Add comprehensive unit tests for mosaic package

Co-authored-by: raylim <3074310+raylim@users.noreply.github.com>

.gitignore

@@ -12,3 +12,6 @@ tmp*
 .idea/
 .vscode/
 data/
+.pytest_cache/
+.coverage
+htmlcov/

pyproject.toml

@@ -22,7 +22,7 @@ paladin_inference = "mosaic.inference.paladin:main"
 mosaic = "mosaic.gradio_app:main"
 
 [dependency-groups]
-dev = ["black>=25.1.0", "pylint>=3.3.6"]
+dev = ["black>=25.1.0", "pylint>=3.3.6", "pytest>=8.3.0", "pytest-cov>=6.0.0", "pytest-mock>=3.14.0"]
 
 [tool.pylint."messages control"]
 disable = [
@@ -34,3 +34,10 @@ disable = [
 [tool.uv.sources]
 paladin = { git = "ssh://git@github.com/pathology-data-mining/paladin.git", rev = "dev" }
 mussel = { git = "https://github.com/pathology-data-mining/Mussel.git", rev = "ray-dev" }
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = "-v --cov=src/mosaic --cov-report=term-missing"

tests/README.md

@@ -0,0 +1,68 @@
+# Mosaic Unit Tests
+
+This directory contains comprehensive unit tests for the Mosaic package.
+
+## Running Tests
+
+To run all tests:
+
+```bash
+pytest tests/
+```
+
+To run tests with coverage report:
+
+```bash
+pytest tests/ --cov=src/mosaic --cov-report=term-missing
+```
+
+To run a specific test file:
+
+```bash
+pytest tests/inference/test_data.py -v
+```
+
+## Test Structure
+
+- `tests/inference/` - Tests for inference modules
+  - `test_data.py` - Tests for data structures and datasets
+  - `test_aeon.py` - Tests for Aeon inference module
+  - `test_paladin.py` - Tests for Paladin inference module
+- `tests/test_gradio_app.py` - Tests for Gradio application utilities
+- `tests/conftest.py` - Pytest configuration and fixtures
+
+## Test Coverage
+
+Current test coverage includes:
+
+### Data Module (`mosaic.inference.data`)
+- ✅ Cancer type mapping constants
+- ✅ SiteType enum
+- ✅ TileFeatureTensorDataset class
+  - Dataset initialization
+  - Feature padding and truncation
+  - Data type conversions
+  - Site type handling
+
+### Aeon Module (`mosaic.inference.aeon`)
+- ✅ Module constants
+- ✅ Cancer type indices
+
+### Paladin Module (`mosaic.inference.paladin`)
+- ✅ Model map loading
+- ✅ Aeon score loading
+- ✅ Cancer subtype selection
+- ✅ Logits to point estimates conversion
+- ✅ UsageError exception
+
+### Gradio App Module (`mosaic.gradio_app`)
+- ✅ Constants (IHC subtypes, settings columns)
+- ✅ Settings loading and validation
+- ✅ Oncotree code name retrieval
+- ✅ CSV export functionality
+
+## Notes
+
+- Tests use mocking for external dependencies (e.g., mussel models, network requests)
+- Some tests require pytest-mock for mocking functionality
+- Tests are designed to run without requiring full model downloads or GPU access

tests/__init__.py

@@ -0,0 +1 @@
+# Tests module for mosaic package

tests/conftest.py

@@ -0,0 +1,16 @@
+"""Pytest configuration and fixtures."""
+
+import sys
+from unittest.mock import MagicMock
+
+# Mock heavy dependencies before any imports
+# This is necessary to allow tests to run without full environment setup
+mock_modules = [
+    'mussel.models',
+    'mussel.utils',
+    'mussel.utils.segment',
+    'mussel.cli.tessellate',
+]
+
+for module in mock_modules:
+    sys.modules[module] = MagicMock()

tests/inference/__init__.py

@@ -0,0 +1 @@
+# Tests for inference module

tests/inference/test_aeon.py

@@ -0,0 +1,64 @@
+"""Unit tests for mosaic.inference.aeon module."""
+
+import numpy as np
+import pytest
+import torch
+
+from mosaic.inference.aeon import (
+    CANCER_TYPE_TO_INT_MAP,
+    INT_TO_CANCER_TYPE_MAP,
+    col_indices_to_drop,
+)
+
+
+class TestAeonConstants:
+    """Test constants defined in aeon module."""
+
+    def test_col_indices_to_drop_is_list(self):
+        """Test that col_indices_to_drop is a list."""
+        assert isinstance(col_indices_to_drop, list)
+
+    def test_col_indices_to_drop_has_entries(self):
+        """Test that col_indices_to_drop has entries."""
+        assert len(col_indices_to_drop) > 0
+
+    def test_col_indices_to_drop_are_integers(self):
+        """Test that all indices are integers."""
+        for idx in col_indices_to_drop:
+            assert isinstance(idx, int)
+
+    def test_col_indices_to_drop_are_valid(self):
+        """Test that all indices are valid cancer type indices."""
+        max_idx = max(CANCER_TYPE_TO_INT_MAP.values())
+        for idx in col_indices_to_drop:
+            assert 0 <= idx <= max_idx
+
+    def test_col_indices_to_drop_contains_expected_types(self):
+        """Test that specific cancer types are in the drop list."""
+        # Check that some known cancer types to drop are in the list
+        drop_types = ["UDMN", "CUP", "BRCA", "MEL"]
+        for cancer_type in drop_types:
+            if cancer_type in CANCER_TYPE_TO_INT_MAP:
+                idx = CANCER_TYPE_TO_INT_MAP[cancer_type]
+                assert idx in col_indices_to_drop
+
+    def test_cancer_type_maps_available(self):
+        """Test that cancer type maps are available."""
+        assert CANCER_TYPE_TO_INT_MAP is not None
+        assert INT_TO_CANCER_TYPE_MAP is not None
+        assert len(CANCER_TYPE_TO_INT_MAP) > 0
+        assert len(INT_TO_CANCER_TYPE_MAP) > 0
+
+    def test_batch_size_constant(self):
+        """Test that BATCH_SIZE constant is defined."""
+        from mosaic.inference.aeon import BATCH_SIZE
+
+        assert isinstance(BATCH_SIZE, int)
+        assert BATCH_SIZE > 0
+
+    def test_num_workers_constant(self):
+        """Test that NUM_WORKERS constant is defined."""
+        from mosaic.inference.aeon import NUM_WORKERS
+
+        assert isinstance(NUM_WORKERS, int)
+        assert NUM_WORKERS > 0

tests/inference/test_data.py

@@ -0,0 +1,187 @@
+"""Unit tests for mosaic.inference.data module."""
+
+import numpy as np
+import pytest
+import torch
+
+from mosaic.inference.data import (
+    CANCER_TYPE_TO_INT_MAP,
+    INT_TO_CANCER_TYPE_MAP,
+    SiteType,
+    TileFeatureTensorDataset,
+)
+
+
+class TestCancerTypeMaps:
+    """Test cancer type mapping constants."""
+
+    def test_cancer_type_to_int_map_has_entries(self):
+        """Test that CANCER_TYPE_TO_INT_MAP has entries."""
+        assert len(CANCER_TYPE_TO_INT_MAP) > 0
+
+    def test_int_to_cancer_type_map_has_entries(self):
+        """Test that INT_TO_CANCER_TYPE_MAP has entries."""
+        assert len(INT_TO_CANCER_TYPE_MAP) > 0
+
+    def test_maps_are_inverse(self):
+        """Test that the two maps are inverses of each other."""
+        assert len(CANCER_TYPE_TO_INT_MAP) == len(INT_TO_CANCER_TYPE_MAP)
+        for cancer_type, idx in CANCER_TYPE_TO_INT_MAP.items():
+            assert INT_TO_CANCER_TYPE_MAP[idx] == cancer_type
+
+    def test_cancer_type_to_int_map_contains_known_types(self):
+        """Test that the map contains some known cancer types."""
+        known_types = ["LUAD", "BRCA", "PRAD", "COAD"]
+        for cancer_type in known_types:
+            assert cancer_type in CANCER_TYPE_TO_INT_MAP
+
+    def test_indices_are_unique(self):
+        """Test that all indices in CANCER_TYPE_TO_INT_MAP are unique."""
+        indices = list(CANCER_TYPE_TO_INT_MAP.values())
+        assert len(indices) == len(set(indices))
+
+
+class TestSiteType:
+    """Test SiteType enum."""
+
+    def test_site_type_primary_value(self):
+        """Test that PRIMARY has correct value."""
+        assert SiteType.PRIMARY.value == "Primary"
+
+    def test_site_type_metastasis_value(self):
+        """Test that METASTASIS has correct value."""
+        assert SiteType.METASTASIS.value == "Metastasis"
+
+    def test_site_type_has_two_members(self):
+        """Test that SiteType enum has exactly two members."""
+        assert len(list(SiteType)) == 2
+
+
+class TestTileFeatureTensorDataset:
+    """Test TileFeatureTensorDataset class."""
+
+    @pytest.fixture
+    def sample_features(self):
+        """Create sample features for testing."""
+        return np.random.rand(100, 768).astype(np.float32)
+
+    @pytest.fixture
+    def large_features(self):
+        """Create large sample features for testing padding/truncation."""
+        return np.random.rand(25000, 768).astype(np.float32)
+
+    @pytest.fixture
+    def small_features(self):
+        """Create small sample features for testing padding."""
+        return np.random.rand(50, 768).astype(np.float32)
+
+    def test_dataset_initialization(self, sample_features):
+        """Test basic dataset initialization."""
+        dataset = TileFeatureTensorDataset(
+            site_type=SiteType.PRIMARY,
+            tile_features=sample_features,
+            n_max_tiles=20000,
+        )
+        assert dataset.site_type == SiteType.PRIMARY
+        assert dataset.n_max_tiles == 20000
+        assert isinstance(dataset.features, torch.Tensor)
+
+    def test_dataset_length(self, sample_features):
+        """Test that dataset length is always 1."""
+        dataset = TileFeatureTensorDataset(
+            site_type=SiteType.PRIMARY,
+            tile_features=sample_features,
+        )
+        assert len(dataset) == 1
+
+    def test_dataset_getitem_structure(self, sample_features):
+        """Test that __getitem__ returns correct structure."""
+        dataset = TileFeatureTensorDataset(
+            site_type=SiteType.METASTASIS,
+            tile_features=sample_features,
+        )
+        item = dataset[0]
+        assert isinstance(item, dict)
+        assert "site" in item
+        assert "tile_tensor" in item
+        assert item["site"] == "Metastasis"
+        assert isinstance(item["tile_tensor"], torch.Tensor)
+
+    def test_features_are_padded_when_small(self, small_features):
+        """Test that features are padded when fewer than n_max_tiles."""
+        n_max_tiles = 1000
+        dataset = TileFeatureTensorDataset(
+            site_type=SiteType.PRIMARY,
+            tile_features=small_features,
+            n_max_tiles=n_max_tiles,
+        )
+        assert dataset.features.shape[0] == n_max_tiles
+        assert dataset.features.shape[1] == small_features.shape[1]
+
+    def test_features_are_truncated_when_large(self, large_features):
+        """Test that features are truncated when more than n_max_tiles."""
+        n_max_tiles = 20000
+        dataset = TileFeatureTensorDataset(
+            site_type=SiteType.PRIMARY,
+            tile_features=large_features,
+            n_max_tiles=n_max_tiles,
+        )
+        assert dataset.features.shape[0] == n_max_tiles
+        assert dataset.features.shape[1] == large_features.shape[1]
+
+    def test_features_dtype_is_float32(self, sample_features):
+        """Test that features are converted to float32."""
+        dataset = TileFeatureTensorDataset(
+            site_type=SiteType.PRIMARY,
+            tile_features=sample_features,
+        )
+        assert dataset.features.dtype == torch.float32
+
+    def test_site_type_primary(self, sample_features):
+        """Test dataset with PRIMARY site type."""
+        dataset = TileFeatureTensorDataset(
+            site_type=SiteType.PRIMARY,
+            tile_features=sample_features,
+        )
+        item = dataset[0]
+        assert item["site"] == "Primary"
+
+    def test_site_type_metastasis(self, sample_features):
+        """Test dataset with METASTASIS site type."""
+        dataset = TileFeatureTensorDataset(
+            site_type=SiteType.METASTASIS,
+            tile_features=sample_features,
+        )
+        item = dataset[0]
+        assert item["site"] == "Metastasis"
+
+    def test_features_exact_size(self):
+        """Test that features of exactly n_max_tiles are not modified."""
+        n_max_tiles = 100
+        features = np.random.rand(n_max_tiles, 768).astype(np.float32)
+        dataset = TileFeatureTensorDataset(
+            site_type=SiteType.PRIMARY,
+            tile_features=features,
+            n_max_tiles=n_max_tiles,
+        )
+        assert dataset.features.shape[0] == n_max_tiles
+        assert dataset.features.shape[1] == 768
+
+    def test_features_shape_preserved(self, sample_features):
+        """Test that feature dimensionality is preserved."""
+        original_dim = sample_features.shape[1]
+        dataset = TileFeatureTensorDataset(
+            site_type=SiteType.PRIMARY,
+            tile_features=sample_features,
+        )
+        assert dataset.features.shape[1] == original_dim
+
+    def test_different_feature_dimensions(self):
+        """Test dataset with different feature dimensions."""
+        for dim in [256, 512, 768, 1024]:
+            features = np.random.rand(100, dim).astype(np.float32)
+            dataset = TileFeatureTensorDataset(
+                site_type=SiteType.PRIMARY,
+                tile_features=features,
+            )
+            assert dataset.features.shape[1] == dim

tests/inference/test_paladin.py

@@ -0,0 +1,209 @@
+"""Unit tests for mosaic.inference.paladin module."""
+
+import csv
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from mosaic.inference.paladin import (
+    UsageError,
+    load_aeon_scores,
+    load_model_map,
+    select_cancer_subtypes,
+    logits_to_point_estimates,
+)
+import torch
+
+
+class TestLoadModelMap:
+    """Test load_model_map function."""
+
+    @pytest.fixture
+    def temp_model_map_csv(self):
+        """Create a temporary model map CSV file."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".csv") as f:
+            writer = csv.writer(f)
+            writer.writerow(["cancer_subtype", "target_name", "model_path"])
+            writer.writerow(["LUAD", "PD-L1", "/path/to/luad_pdl1.pkl"])
+            writer.writerow(["LUAD", "EGFR", "/path/to/luad_egfr.pkl"])
+            writer.writerow(["BRCA", "HER2", "/path/to/brca_her2.pkl"])
+            writer.writerow(["COAD", "MSI_TYPE", "/path/to/coad_msi.pkl"])
+            temp_path = f.name
+        yield temp_path
+        Path(temp_path).unlink()
+
+    def test_load_model_map_structure(self, temp_model_map_csv):
+        """Test that load_model_map returns correct structure."""
+        model_map = load_model_map(temp_model_map_csv)
+        assert isinstance(model_map, dict)
+        assert "LUAD" in model_map
+        assert "BRCA" in model_map
+        assert "COAD" in model_map
+
+    def test_load_model_map_nested_dict(self, temp_model_map_csv):
+        """Test that model_map contains nested dictionaries."""
+        model_map = load_model_map(temp_model_map_csv)
+        assert isinstance(model_map["LUAD"], dict)
+        assert "PD-L1" in model_map["LUAD"]
+        assert "EGFR" in model_map["LUAD"]
+
+    def test_load_model_map_values(self, temp_model_map_csv):
+        """Test that model_map contains correct values."""
+        model_map = load_model_map(temp_model_map_csv)
+        assert model_map["LUAD"]["PD-L1"] == "/path/to/luad_pdl1.pkl"
+        assert model_map["LUAD"]["EGFR"] == "/path/to/luad_egfr.pkl"
+        assert model_map["BRCA"]["HER2"] == "/path/to/brca_her2.pkl"
+        assert model_map["COAD"]["MSI_TYPE"] == "/path/to/coad_msi.pkl"
+
+    def test_load_model_map_multiple_targets_per_subtype(self, temp_model_map_csv):
+        """Test that cancer subtypes can have multiple targets."""
+        model_map = load_model_map(temp_model_map_csv)
+        assert len(model_map["LUAD"]) == 2
+
+
+class TestLoadAeonScores:
+    """Test load_aeon_scores function."""
+
+    @pytest.fixture
+    def sample_aeon_df(self):
+        """Create a sample Aeon results DataFrame."""
+        return pd.DataFrame(
+            {
+                "Cancer Subtype": ["LUAD", "BRCA", "COAD", "PRAD"],
+                "Confidence": [0.85, 0.10, 0.03, 0.02],
+            }
+        )
+
+    def test_load_aeon_scores_returns_dict(self, sample_aeon_df):
+        """Test that load_aeon_scores returns a dictionary."""
+        scores = load_aeon_scores(sample_aeon_df)
+        assert isinstance(scores, dict)
+
+    def test_load_aeon_scores_correct_mapping(self, sample_aeon_df):
+        """Test that scores are correctly mapped."""
+        scores = load_aeon_scores(sample_aeon_df)
+        assert scores["LUAD"] == 0.85
+        assert scores["BRCA"] == 0.10
+        assert scores["COAD"] == 0.03
+        assert scores["PRAD"] == 0.02
+
+    def test_load_aeon_scores_all_entries(self, sample_aeon_df):
+        """Test that all entries are loaded."""
+        scores = load_aeon_scores(sample_aeon_df)
+        assert len(scores) == 4
+
+    def test_load_aeon_scores_empty_dataframe(self):
+        """Test handling of empty DataFrame."""
+        empty_df = pd.DataFrame({"Cancer Subtype": [], "Confidence": []})
+        scores = load_aeon_scores(empty_df)
+        assert isinstance(scores, dict)
+        assert len(scores) == 0
+
+
+class TestSelectCancerSubtypes:
+    """Test select_cancer_subtypes function."""
+
+    @pytest.fixture
+    def sample_scores(self):
+        """Create sample Aeon scores."""
+        return {
+            "LUAD": 0.85,
+            "BRCA": 0.10,
+            "COAD": 0.03,
+            "PRAD": 0.02,
+        }
+
+    def test_select_top_one_cancer_subtype(self, sample_scores):
+        """Test selecting the top cancer subtype."""
+        result = select_cancer_subtypes(sample_scores, k=1)
+        assert isinstance(result, list)
+        assert len(result) == 1
+        assert result[0] == "LUAD"
+
+    def test_select_top_three_cancer_subtypes(self, sample_scores):
+        """Test selecting the top three cancer subtypes."""
+        result = select_cancer_subtypes(sample_scores, k=3)
+        assert len(result) == 3
+        assert result[0] == "LUAD"
+        assert result[1] == "BRCA"
+        assert result[2] == "COAD"
+
+    def test_select_all_cancer_subtypes(self, sample_scores):
+        """Test selecting all cancer subtypes."""
+        result = select_cancer_subtypes(sample_scores, k=10)
+        assert len(result) == 4
+        assert result[0] == "LUAD"
+        assert result[-1] == "PRAD"
+
+    def test_select_default_k_value(self, sample_scores):
+        """Test that default k=1 is used."""
+        result = select_cancer_subtypes(sample_scores)
+        assert len(result) == 1
+        assert result[0] == "LUAD"
+
+    def test_select_with_empty_scores(self):
+        """Test handling of empty scores dictionary."""
+        result = select_cancer_subtypes({}, k=1)
+        assert isinstance(result, list)
+        assert len(result) == 0
+
+
+class TestLogitsToPointEstimates:
+    """Test logits_to_point_estimates function."""
+
+    def test_logits_to_point_estimates_shape(self):
+        """Test that output shape is correct."""
+        # logits shape: (batch_size, 2 * n_tasks)
+        batch_size = 4
+        n_tasks = 5
+        logits = torch.rand(batch_size, 2 * n_tasks)
+        result = logits_to_point_estimates(logits)
+        assert result.shape == (batch_size, n_tasks)
+
+    def test_logits_to_point_estimates_values_in_range(self):
+        """Test that point estimates are in [0, 1] range."""
+        logits = torch.tensor([[1.0, 2.0, 3.0, 4.0], [0.5, 0.5, 1.0, 1.0]])
+        result = logits_to_point_estimates(logits)
+        assert torch.all(result >= 0.0)
+        assert torch.all(result <= 1.0)
+
+    def test_logits_to_point_estimates_calculation(self):
+        """Test that calculation is correct."""
+        logits = torch.tensor([[2.0, 4.0]])  # alpha=2, beta=4
+        result = logits_to_point_estimates(logits)
+        expected = 2.0 / (2.0 + 4.0)
+        assert torch.isclose(result[0, 0], torch.tensor(expected))
+
+    def test_logits_to_point_estimates_single_batch(self):
+        """Test with single batch."""
+        logits = torch.tensor([[1.0, 1.0, 2.0, 2.0, 3.0, 3.0]])
+        result = logits_to_point_estimates(logits)
+        assert result.shape == (1, 3)
+
+    def test_logits_to_point_estimates_multiple_batches(self):
+        """Test with multiple batches."""
+        logits = torch.rand(10, 8)  # 10 batches, 4 tasks
+        result = logits_to_point_estimates(logits)
+        assert result.shape == (10, 4)
+
+
+class TestUsageError:
+    """Test UsageError exception class."""
+
+    def test_usage_error_is_exception(self):
+        """Test that UsageError is an Exception."""
+        assert issubclass(UsageError, Exception)
+
+    def test_usage_error_can_be_raised(self):
+        """Test that UsageError can be raised."""
+        with pytest.raises(UsageError):
+            raise UsageError("Test error message")
+
+    def test_usage_error_message(self):
+        """Test that UsageError message is preserved."""
+        message = "Test error message"
+        with pytest.raises(UsageError, match=message):
+            raise UsageError(message)

tests/test_gradio_app.py

@@ -0,0 +1,231 @@
+"""Unit tests for mosaic.gradio_app module."""
+
+import tempfile
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+from mosaic.gradio_app import (
+    IHC_SUBTYPES,
+    SETTINGS_COLUMNS,
+    load_settings,
+    validate_settings,
+)
+
+
+class TestConstants:
+    """Test constants in gradio_app."""
+
+    def test_ihc_subtypes_list(self):
+        """Test that IHC_SUBTYPES is a list."""
+        assert isinstance(IHC_SUBTYPES, list)
+
+    def test_ihc_subtypes_has_entries(self):
+        """Test that IHC_SUBTYPES has entries."""
+        assert len(IHC_SUBTYPES) > 0
+
+    def test_ihc_subtypes_contains_expected_values(self):
+        """Test that IHC_SUBTYPES contains expected breast cancer subtypes."""
+        expected_subtypes = ["HR+/HER2+", "HR+/HER2-", "HR-/HER2+", "HR-/HER2-"]
+        for subtype in expected_subtypes:
+            assert subtype in IHC_SUBTYPES
+
+    def test_ihc_subtypes_includes_empty_string(self):
+        """Test that IHC_SUBTYPES includes empty string for non-breast cancers."""
+        assert "" in IHC_SUBTYPES
+
+    def test_settings_columns_list(self):
+        """Test that SETTINGS_COLUMNS is a list."""
+        assert isinstance(SETTINGS_COLUMNS, list)
+
+    def test_settings_columns_required_fields(self):
+        """Test that SETTINGS_COLUMNS contains required fields."""
+        required_fields = [
+            "Slide",
+            "Site Type",
+            "Cancer Subtype",
+            "IHC Subtype",
+            "Segmentation Config",
+        ]
+        for field in required_fields:
+            assert field in SETTINGS_COLUMNS
+
+
+class TestLoadSettings:
+    """Test load_settings function."""
+
+    @pytest.fixture
+    def temp_settings_csv(self):
+        """Create a temporary settings CSV file with all columns."""
+        with tempfile.NamedTemporaryFile(
+            mode="w", delete=False, suffix=".csv"
+        ) as f:
+            f.write("Slide,Site Type,Cancer Subtype,IHC Subtype,Segmentation Config\n")
+            f.write("slide1.svs,Primary,Unknown,,Biopsy\n")
+            f.write("slide2.svs,Metastatic,Unknown,,Resection\n")
+            temp_path = f.name
+        yield temp_path
+        Path(temp_path).unlink()
+
+    @pytest.fixture
+    def temp_minimal_settings_csv(self):
+        """Create a temporary settings CSV file with minimal columns."""
+        with tempfile.NamedTemporaryFile(
+            mode="w", delete=False, suffix=".csv"
+        ) as f:
+            f.write("Slide,Site Type\n")
+            f.write("slide1.svs,Primary\n")
+            f.write("slide2.svs,Metastatic\n")
+            temp_path = f.name
+        yield temp_path
+        Path(temp_path).unlink()
+
+    def test_load_settings_returns_dataframe(self, temp_settings_csv):
+        """Test that load_settings returns a DataFrame."""
+        df = load_settings(temp_settings_csv)
+        assert isinstance(df, pd.DataFrame)
+
+    def test_load_settings_has_all_columns(self, temp_settings_csv):
+        """Test that all required columns are present."""
+        df = load_settings(temp_settings_csv)
+        for col in SETTINGS_COLUMNS:
+            assert col in df.columns
+
+    def test_load_settings_adds_missing_columns(self, temp_minimal_settings_csv):
+        """Test that missing columns are added with defaults."""
+        df = load_settings(temp_minimal_settings_csv)
+        assert "Segmentation Config" in df.columns
+        assert "Cancer Subtype" in df.columns
+        assert "IHC Subtype" in df.columns
+        assert df["Segmentation Config"].iloc[0] == "Biopsy"
+        assert df["Cancer Subtype"].iloc[0] == "Unknown"
+        assert df["IHC Subtype"].iloc[0] == ""
+
+    def test_load_settings_preserves_data(self, temp_settings_csv):
+        """Test that data is preserved correctly."""
+        df = load_settings(temp_settings_csv)
+        assert len(df) == 2
+        assert df["Slide"].iloc[0] == "slide1.svs"
+        assert df["Site Type"].iloc[0] == "Primary"
+
+    def test_load_settings_missing_required_column_raises_error(self):
+        """Test that missing required column raises ValueError."""
+        with tempfile.NamedTemporaryFile(
+            mode="w", delete=False, suffix=".csv"
+        ) as f:
+            f.write("RandomColumn\n")
+            f.write("value\n")
+            temp_path = f.name
+
+        try:
+            with pytest.raises(ValueError, match="Missing required column"):
+                load_settings(temp_path)
+        finally:
+            Path(temp_path).unlink()
+
+    def test_load_settings_filters_to_settings_columns(self, temp_settings_csv):
+        """Test that only SETTINGS_COLUMNS are returned."""
+        df = load_settings(temp_settings_csv)
+        assert list(df.columns) == SETTINGS_COLUMNS
+
+
+class TestGetOncotreeCodeName:
+    """Test get_oncotree_code_name function."""
+
+    def test_oncotree_code_name_caching(self, mocker):
+        """Test that oncotree code names are cached."""
+        from mosaic.gradio_app import get_oncotree_code_name, oncotree_code_map
+
+        # Mock the requests.get call
+        mock_response = mocker.Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = [{"name": "Lung Adenocarcinoma"}]
+        mocker.patch("requests.get", return_value=mock_response)
+
+        # Clear the cache
+        oncotree_code_map.clear()
+
+        # First call should populate cache
+        code = "LUAD"
+        result1 = get_oncotree_code_name(code)
+
+        # Cache should now contain the code
+        assert code in oncotree_code_map
+
+        # Second call should use cache
+        result2 = get_oncotree_code_name(code)
+        assert result1 == result2
+
+    def test_oncotree_code_name_returns_string(self, mocker):
+        """Test that function returns a string."""
+        from mosaic.gradio_app import get_oncotree_code_name, oncotree_code_map
+
+        # Mock the requests.get call
+        mock_response = mocker.Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = [{"name": "Lung Adenocarcinoma"}]
+        mocker.patch("requests.get", return_value=mock_response)
+
+        # Clear cache first
+        oncotree_code_map.clear()
+
+        result = get_oncotree_code_name("LUAD")
+        assert isinstance(result, str)
+
+    def test_oncotree_invalid_code_returns_unknown(self, mocker):
+        """Test that invalid code returns 'Unknown'."""
+        from mosaic.gradio_app import get_oncotree_code_name, oncotree_code_map
+
+        # Mock the requests.get call to return 404
+        mock_response = mocker.Mock()
+        mock_response.status_code = 404
+        mock_response.json.return_value = []
+        mocker.patch("requests.get", return_value=mock_response)
+
+        # Clear cache and use an invalid code
+        oncotree_code_map.clear()
+        result = get_oncotree_code_name("INVALID_CODE_XYZ123")
+        assert result == "Unknown"
+
+
+class TestExportToCsv:
+    """Test export_to_csv function."""
+
+    def test_export_to_csv_returns_path(self):
+        """Test that export_to_csv returns a file path."""
+        from mosaic.gradio_app import export_to_csv
+
+        df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+        result = export_to_csv(df)
+        assert isinstance(result, str)
+        assert result.endswith(".csv")
+        # Clean up
+        Path(result).unlink(missing_ok=True)
+
+    def test_export_to_csv_creates_file(self):
+        """Test that export_to_csv creates a CSV file."""
+        from mosaic.gradio_app import export_to_csv
+
+        df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+        result = export_to_csv(df)
+        assert Path(result).exists()
+        # Clean up
+        Path(result).unlink()
+
+    def test_export_to_csv_with_empty_dataframe_raises_error(self):
+        """Test that exporting empty DataFrame raises error."""
+        from mosaic.gradio_app import export_to_csv
+        import gradio as gr
+
+        df = pd.DataFrame()
+        with pytest.raises(gr.Error):
+            export_to_csv(df)
+
+    def test_export_to_csv_with_none_raises_error(self):
+        """Test that exporting None raises error."""
+        from mosaic.gradio_app import export_to_csv
+        import gradio as gr
+
+        with pytest.raises(gr.Error):
+            export_to_csv(None)