test: add 24 tests and improve test infrastructure

Add 19 fast tests (signature defaults, device fallback, batch parsing
edge cases, output writing, guard clauses, UI component config) and
5 slow tests (beam search, temperature, max tokens, empty input,
beam+temperature conflict). Total: 25 → 49 tests.

Refactor existing tests to use pytest tmp_path fixture for automatic
cleanup, add shared demo fixture for UI tests, suppress uncaptured
UserWarning in device test, and modernize pytest.raises usage.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

tests/test_app.py

@@ -1,6 +1,6 @@
 import csv
-import tempfile
 from pathlib import Path
+from unittest.mock import patch
 
 import pytest
 import torch
@@ -37,69 +37,158 @@ def test_translate_accepts_generation_params():
     assert "temperature" in params
 
 
+# --- Task 1: Signature default + device tests ---
+
+
+def test_translate_signature_defaults():
+    """translate() should have correct default values for generation parameters."""
+    import inspect
+
+    import app
+
+    sig = inspect.signature(app.translate)
+    assert sig.parameters["max_new_tokens"].default == 512
+    assert sig.parameters["num_beams"].default == 1
+    assert sig.parameters["temperature"].default == 1.0
+
+
+def test_translate_batch_signature_defaults():
+    """translate_batch() should have correct default values for generation parameters."""
+    import inspect
+
+    import app
+
+    sig = inspect.signature(app.translate_batch)
+    assert sig.parameters["max_new_tokens"].default == 512
+    assert sig.parameters["num_beams"].default == 1
+    assert sig.parameters["temperature"].default == 1.0
+
+
+def test_get_device_returns_cpu_when_no_cuda():
+    """_get_device() should return CPU when CUDA is not available."""
+    import app
+
+    with patch("app.torch.cuda.is_available", return_value=False):
+        with pytest.warns(UserWarning):
+            device = app._get_device()
+    assert device.type == "cpu"
+
+
+def test_get_device_warns_on_cpu():
+    """_get_device() should emit a UserWarning when falling back to CPU."""
+    import app
+
+    with patch("app.torch.cuda.is_available", return_value=False):
+        with pytest.warns(UserWarning, match="No GPU available"):
+            app._get_device()
+
+
 # --- Batch file parsing helper tests ---
 
 
-def _make_txt_file(lines: list[str]) -> str:
-    """Create a temp .txt file and return its path."""
-    f = tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False)
-    f.write("\n".join(lines))
-    f.close()
-    return f.name
+def _make_txt_file(tmp_dir: Path, lines: list[str]) -> str:
+    """Create a .txt file in tmp_dir and return its path."""
+    path = tmp_dir / "input.txt"
+    path.write_text("\n".join(lines))
+    return str(path)
 
 
-def _make_csv_file(rows: list[dict]) -> str:
-    """Create a temp .csv file and return its path."""
-    f = tempfile.NamedTemporaryFile(mode="w", suffix=".csv", delete=False, newline="")
-    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
-    writer.writeheader()
-    writer.writerows(rows)
-    f.close()
-    return f.name
+def _make_csv_file(tmp_dir: Path, rows: list[dict]) -> str:
+    """Create a .csv file in tmp_dir and return its path."""
+    path = tmp_dir / "input.csv"
+    with open(path, "w", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=rows[0].keys())
+        writer.writeheader()
+        writer.writerows(rows)
+    return str(path)
 
 
-def test_parse_txt_file():
+def test_parse_txt_file(tmp_path):
     import app
 
-    path = _make_txt_file(["Hello", "World", "Test"])
+    path = _make_txt_file(tmp_path, ["Hello", "World", "Test"])
     texts, original_data = app._parse_input_file(path)
     assert texts == ["Hello", "World", "Test"]
     assert original_data is None
-    Path(path).unlink()
 
 
-def test_parse_csv_file():
+def test_parse_csv_file(tmp_path):
     import app
 
-    path = _make_csv_file([{"id": "1", "text": "Hello"}, {"id": "2", "text": "World"}])
+    path = _make_csv_file(tmp_path, [{"id": "1", "text": "Hello"}, {"id": "2", "text": "World"}])
     texts, original_data = app._parse_input_file(path)
     assert texts == ["Hello", "World"]
     assert original_data is not None
     assert len(original_data) == 2
     assert original_data[0]["id"] == "1"
-    Path(path).unlink()
 
 
-def test_parse_csv_missing_text_column():
+def test_parse_csv_missing_text_column(tmp_path):
     import app
 
-    path = _make_csv_file([{"id": "1", "content": "Hello"}])
-    try:
+    path = _make_csv_file(tmp_path, [{"id": "1", "content": "Hello"}])
+    with pytest.raises(ValueError, match="text"):
         app._parse_input_file(path)
-        assert False, "Should have raised ValueError"
-    except ValueError as e:
-        assert "text" in str(e).lower()
-    finally:
-        Path(path).unlink()
+
+
+# --- Task 2: Batch parsing edge cases ---
+
+
+def test_parse_empty_txt_file(tmp_path):
+    """Empty .txt file should return ([], None)."""
+    import app
+
+    path = tmp_path / "empty.txt"
+    path.write_text("")
+    texts, original_data = app._parse_input_file(str(path))
+    assert texts == []
+    assert original_data is None
+
+
+def test_parse_unsupported_extension(tmp_path):
+    """Unsupported file extension should raise ValueError."""
+    import app
+
+    path = tmp_path / "data.json"
+    path.write_text("{}")
+    with pytest.raises(ValueError, match="Unsupported file type"):
+        app._parse_input_file(str(path))
+
+
+def test_parse_single_line_txt(tmp_path):
+    """Single-line .txt file should return one-element list."""
+    import app
+
+    path = _make_txt_file(tmp_path, ["Only one line"])
+    texts, original_data = app._parse_input_file(path)
+    assert texts == ["Only one line"]
+    assert original_data is None
+
+
+def test_parse_single_row_csv(tmp_path):
+    """Single-row .csv file should return one-element list with metadata."""
+    import app
+
+    path = _make_csv_file(tmp_path, [{"id": "1", "text": "Single row"}])
+    texts, original_data = app._parse_input_file(path)
+    assert texts == ["Single row"]
+    assert original_data is not None
+    assert len(original_data) == 1
+    assert original_data[0]["id"] == "1"
+
+
+# --- Write output tests ---
 
 
 def test_write_txt_output():
     import app
 
     output_path = app._write_output_file(["Bonjour", "Monde"], None, ".txt")
-    content = Path(output_path).read_text()
-    assert content == "Bonjour\nMonde"
-    Path(output_path).unlink()
+    try:
+        content = Path(output_path).read_text()
+        assert content == "Bonjour\nMonde"
+    finally:
+        Path(output_path).unlink(missing_ok=True)
 
 
 def test_write_csv_output():
@@ -107,13 +196,34 @@ def test_write_csv_output():
 
     original_data = [{"id": "1", "text": "Hello"}, {"id": "2", "text": "World"}]
     output_path = app._write_output_file(["Bonjour", "Monde"], original_data, ".csv")
-    with open(output_path, newline="") as f:
-        reader = list(csv.DictReader(f))
-    assert len(reader) == 2
-    assert reader[0]["translation"] == "Bonjour"
-    assert reader[0]["id"] == "1"
-    assert reader[1]["translation"] == "Monde"
-    Path(output_path).unlink()
+    try:
+        with open(output_path, newline="") as f:
+            reader = list(csv.DictReader(f))
+        assert len(reader) == 2
+        assert reader[0]["translation"] == "Bonjour"
+        assert reader[0]["id"] == "1"
+        assert reader[1]["translation"] == "Monde"
+    finally:
+        Path(output_path).unlink(missing_ok=True)
+
+
+# --- Task 3: Write output edge case ---
+
+
+def test_write_single_txt_output():
+    """Single translation output should have no extraneous newlines."""
+    import app
+
+    output_path = app._write_output_file(["Bonjour"], None, ".txt")
+    try:
+        content = Path(output_path).read_text()
+        assert content == "Bonjour"
+        assert "\n" not in content
+    finally:
+        Path(output_path).unlink(missing_ok=True)
+
+
+# --- Batch function tests ---
 
 
 def test_translate_batch_exists():
@@ -122,39 +232,155 @@ def test_translate_batch_exists():
     assert callable(app.translate_batch)
 
 
-def test_demo_has_sidebar_and_tabs():
-    """Verify the demo contains the expected layout components."""
+# --- Task 4: Batch function guard clauses ---
+
+
+def test_translate_batch_none_file_raises_error():
+    """translate_batch() should raise gr.Error when file is None."""
+    import gradio as gr
+
+    import app
+
+    with pytest.raises(gr.Error, match="upload a file"):
+        app.translate_batch(None, "French")
+
+
+def test_translate_batch_empty_file_raises_error(tmp_path):
+    """translate_batch() should raise gr.Error for an empty file."""
+    import gradio as gr
+
     import app
 
-    demo = app._build_demo()
-    # Flatten all blocks in the demo
-    blocks = demo.blocks
+    class FakeFile:
+        def __init__(self, name):
+            self.name = name
 
-    # Check for key component types by looking at block values
-    component_types = {type(b).__name__ for b in blocks.values()}
+    path = tmp_path / "empty.txt"
+    path.write_text("")
+    fake_file = FakeFile(str(path))
+    with pytest.raises(gr.Error, match="empty"):
+        app.translate_batch(fake_file, "French")
+
+
+def test_translate_batch_accepts_generation_params():
+    """translate_batch() signature must accept generation parameters and progress."""
+    import inspect
+
+    import app
+
+    sig = inspect.signature(app.translate_batch)
+    params = list(sig.parameters.keys())
+    assert "max_new_tokens" in params
+    assert "num_beams" in params
+    assert "temperature" in params
+    assert "progress" in params
+
+
+# --- UI component tests ---
+
+
+@pytest.fixture
+def demo():
+    import app
+
+    return app._build_demo()
+
+
+def _find_slider_by_label(demo, label: str):
+    """Find a slider in the demo by its label."""
+    sliders = [b for b in demo.blocks.values() if type(b).__name__ == "Slider" and b.label == label]
+    assert len(sliders) == 1, f"Expected 1 slider with label '{label}', found {len(sliders)}"
+    return sliders[0]
+
+
+def test_demo_has_sidebar_and_tabs(demo):
+    """Verify the demo contains the expected layout components."""
+    component_types = {type(b).__name__ for b in demo.blocks.values()}
     assert "Tab" in component_types, f"Expected Tab component, found: {component_types}"
     assert "Slider" in component_types, f"Expected Slider component, found: {component_types}"
     assert "Dropdown" in component_types, f"Expected Dropdown component, found: {component_types}"
 
 
-def test_demo_has_three_sliders():
+def test_demo_has_three_sliders(demo):
     """Three sliders: max_new_tokens, num_beams, temperature."""
-    import app
-
-    demo = app._build_demo()
     sliders = [b for b in demo.blocks.values() if type(b).__name__ == "Slider"]
     assert len(sliders) == 3, f"Expected 3 sliders, found {len(sliders)}"
 
 
-def test_demo_has_two_tabs():
+def test_demo_has_two_tabs(demo):
     """Two tabs: Single and Batch."""
-    import app
-
-    demo = app._build_demo()
     tabs = [b for b in demo.blocks.values() if type(b).__name__ == "Tab"]
     assert len(tabs) == 2, f"Expected 2 tabs, found {len(tabs)}"
 
 
+# --- Task 5: UI component detail tests ---
+
+
+def test_slider_max_new_tokens_config(demo):
+    """Max new tokens slider should have correct config."""
+    slider = _find_slider_by_label(demo, "Max new tokens")
+    assert slider.minimum == 1
+    assert slider.maximum == 1024
+    assert slider.value == 512
+    assert slider.step == 1
+
+
+def test_slider_num_beams_config(demo):
+    """Num beams slider should have correct config."""
+    slider = _find_slider_by_label(demo, "Num beams")
+    assert slider.minimum == 1
+    assert slider.maximum == 10
+    assert slider.value == 1
+    assert slider.step == 1
+
+
+def test_slider_temperature_config(demo):
+    """Temperature slider should have correct config."""
+    slider = _find_slider_by_label(demo, "Temperature")
+    assert slider.minimum == 0.1
+    assert slider.maximum == 2.0
+    assert slider.value == 1.0
+    assert slider.step == 0.1
+
+
+def test_dropdown_default_is_french(demo):
+    """Default dropdown value should be French."""
+    dropdowns = [b for b in demo.blocks.values() if type(b).__name__ == "Dropdown"]
+    assert len(dropdowns) >= 1
+    assert dropdowns[0].value == "French"
+
+
+def test_file_upload_accepts_txt_and_csv(demo):
+    """File upload component should accept .txt and .csv files."""
+    file_components = [b for b in demo.blocks.values() if type(b).__name__ == "File"]
+    upload_files = [f for f in file_components if f.file_types is not None]
+    assert len(upload_files) >= 1
+    assert set(upload_files[0].file_types) == {".txt", ".csv"}
+
+
+def test_batch_output_is_non_interactive(demo):
+    """Batch output file component should be non-interactive."""
+    file_components = [b for b in demo.blocks.values() if type(b).__name__ == "File"]
+    output_files = [f for f in file_components if f.interactive is False]
+    assert len(output_files) >= 1, "Expected at least one non-interactive File component"
+
+
+def test_examples_use_tier1_languages(demo):
+    """All example languages should be in the tier 1 language mapping."""
+    from langmap.langid_mapping import langid_to_language
+
+    tier1_languages = set(langid_to_language.values())
+
+    # gr.Examples creates a Dataset component internally
+    datasets = [b for b in demo.blocks.values() if type(b).__name__ == "Dataset"]
+    assert len(datasets) >= 1, "Expected at least one Dataset (Examples) component"
+
+    for dataset in datasets:
+        for sample in dataset.samples:
+            language = sample[1]  # [text, language]
+            assert language in tier1_languages, f"Example language '{language}' not in tier 1 mapping"
+
+
 # --- Slow tests (require CUDA + model download) ---
 
 gpu_available = torch.cuda.is_available()
@@ -205,3 +431,50 @@ def test_translate_returns_string(loaded_app):
     result = loaded_app.translate("Hello", "French")
     assert isinstance(result, str)
     assert len(result) > 0
+
+
+# --- Task 6: Slow tests for non-default params ---
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(not gpu_available, reason="Requires CUDA")
+def test_translate_with_beam_search(loaded_app):
+    """Translation with beam search (num_beams=4) should return a string."""
+    result = loaded_app.translate("Hello", "French", num_beams=4)
+    assert isinstance(result, str)
+    assert len(result) > 0
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(not gpu_available, reason="Requires CUDA")
+def test_translate_with_custom_temperature(loaded_app):
+    """Translation with custom temperature should return a string."""
+    result = loaded_app.translate("Hello", "French", temperature=0.5)
+    assert isinstance(result, str)
+    assert len(result) > 0
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(not gpu_available, reason="Requires CUDA")
+def test_translate_with_custom_max_tokens(loaded_app):
+    """Translation with low max_new_tokens should return a short string."""
+    result = loaded_app.translate("Hello", "French", max_new_tokens=10)
+    assert isinstance(result, str)
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(not gpu_available, reason="Requires CUDA")
+def test_translate_empty_string(loaded_app):
+    """Translating an empty string should not crash."""
+    result = loaded_app.translate("", "French")
+    assert isinstance(result, str)
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(not gpu_available, reason="Requires CUDA")
+def test_translate_beam_search_ignores_temperature(loaded_app):
+    """When beam search is active with non-default temperature, gr.Info should be called."""
+    with patch("app.gr.Info") as mock_info:
+        result = loaded_app.translate("Hello", "French", num_beams=4, temperature=0.5)
+        mock_info.assert_called_once()
+    assert isinstance(result, str)