Tests for reducers

Author: pbashyal-nmdp

tests/unit/reducers/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

tests/unit/reducers/test_all_reducers.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+from unittest.mock import Mock
+from pyard.reducers import (
+    Reducer,
+    GGroupReducer,
+    PGroupReducer,
+    LGReducer,
+    LGXReducer,
+    WReducer,
+    ExonReducer,
+    U2Reducer,
+    SReducer,
+    DefaultReducer,
+    StrategyFactory,
+)
+
+
+@pytest.fixture
+def mock_ard():
+    """Create comprehensive mock ARD instance"""
+    ard = Mock()
+    ard.ars_mappings = Mock()
+    ard.ars_mappings.g_group = {"A*01:01": "A*01:01:01G"}
+    ard.ars_mappings.p_group = {"A*01:01": "A*01:01P"}
+    ard.ars_mappings.lgx_group = {"A*01:01:01": "A*01:01"}
+    ard.ars_mappings.exon_group = {"A*01:01:01": "A*01:01:01"}
+    ard.ars_mappings.dup_g = {}
+    ard.code_mappings = Mock()
+    ard.code_mappings.who_group = {}
+    ard.db_connection = Mock()
+    ard._config = {"ARS_as_lg": False}
+    ard._is_allele_in_db = Mock(return_value=True)
+    ard._is_who_allele = Mock(return_value=False)
+    ard._redux_allele = Mock()
+    ard.redux = Mock()
+    ard.is_shortnull = Mock(return_value=False)
+    ard.smart_sort_comparator = Mock()
+    return ard
+
+
+def test_all_reducers_inherit_from_base(mock_ard):
+    """Test that all reducer classes inherit from Reducer base class"""
+    reducers = [
+        GGroupReducer(mock_ard),
+        PGroupReducer(mock_ard),
+        LGReducer(mock_ard),
+        LGXReducer(mock_ard),
+        WReducer(mock_ard),
+        ExonReducer(mock_ard),
+        U2Reducer(mock_ard),
+        SReducer(mock_ard),
+        DefaultReducer(mock_ard),
+    ]
+
+    for reducer in reducers:
+        assert isinstance(reducer, Reducer)
+        assert hasattr(reducer, "reduce")
+        assert hasattr(reducer, "ard")
+
+
+def test_strategy_factory_creates_all_reducers(mock_ard):
+    """Test that StrategyFactory can create all reducer types"""
+    factory = StrategyFactory(mock_ard)
+
+    strategies = ["G", "P", "lg", "lgx", "W", "exon", "U2", "S", "default"]
+
+    for strategy_type in strategies:
+        strategy = factory.get_strategy(strategy_type)
+        assert isinstance(strategy, Reducer)
+        assert strategy.ard == mock_ard
+
+
+def test_all_reducers_have_ard_instance(mock_ard):
+    """Test that all reducers store ARD instance correctly"""
+    reducers = [
+        GGroupReducer(mock_ard),
+        PGroupReducer(mock_ard),
+        LGReducer(mock_ard),
+        LGXReducer(mock_ard),
+        WReducer(mock_ard),
+        ExonReducer(mock_ard),
+        U2Reducer(mock_ard),
+        SReducer(mock_ard),
+        DefaultReducer(mock_ard),
+    ]
+
+    for reducer in reducers:
+        assert reducer.ard == mock_ard

tests/unit/reducers/test_base_reducer.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+from unittest.mock import Mock
+from pyard.reducers.base_reducer import Reducer
+
+
+class ConcreteReducer(Reducer):
+    """Concrete implementation for testing abstract base class"""
+
+    def reduce(self, allele: str) -> str:
+        return f"reduced_{allele}"
+
+
+def test_reducer_initialization():
+    """Test that Reducer can be initialized with ARD instance"""
+    mock_ard = Mock()
+    reducer = ConcreteReducer(mock_ard)
+    assert reducer.ard == mock_ard
+
+
+def test_reducer_abstract_method():
+    """Test that reduce method is implemented in concrete class"""
+    mock_ard = Mock()
+    reducer = ConcreteReducer(mock_ard)
+    result = reducer.reduce("A*01:01")
+    assert result == "reduced_A*01:01"
+
+
+def test_reducer_cannot_be_instantiated():
+    """Test that abstract Reducer class cannot be instantiated directly"""
+    mock_ard = Mock()
+    with pytest.raises(TypeError):
+        Reducer(mock_ard)

tests/unit/reducers/test_default_reducer.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+from unittest.mock import Mock
+from pyard.reducers.default_reducer import DefaultReducer
+from pyard.exceptions import InvalidAlleleError
+
+
+@pytest.fixture
+def mock_ard():
+    """Create mock ARD instance"""
+    ard = Mock()
+    ard.ars_mappings = Mock()
+    ard.ars_mappings.p_group = Mock()
+    ard.ars_mappings.g_group = Mock()
+    ard.is_valid_allele = Mock()
+    return ard
+
+
+def test_reduce_p_group_allele(mock_ard):
+    """Test reduction of P group allele"""
+    mock_ard.ars_mappings.p_group.values.return_value = ["A*01:01P"]
+
+    reducer = DefaultReducer(mock_ard)
+    result = reducer.reduce("A*01:01P")
+
+    assert result == "A*01:01P"
+
+
+def test_reduce_g_group_allele(mock_ard):
+    """Test reduction of G group allele"""
+    mock_ard.ars_mappings.g_group.values.return_value = ["A*01:01G"]
+
+    reducer = DefaultReducer(mock_ard)
+    result = reducer.reduce("A*01:01G")
+
+    assert result == "A*01:01G"
+
+
+def test_reduce_valid_allele_in_db(mock_ard):
+    """Test reduction of valid allele in database"""
+    mock_ard.is_valid_allele.return_value = True
+
+    reducer = DefaultReducer(mock_ard)
+    result = reducer.reduce("A*01:01")
+
+    assert result == "A*01:01"
+    mock_ard.is_valid_allele.assert_called_once_with("A*01:01")
+
+
+def test_reduce_invalid_allele_raises_error(mock_ard):
+    """Test that invalid allele raises InvalidAlleleError"""
+    mock_ard.ars_mappings.p_group.values.return_value = []
+    mock_ard.ars_mappings.g_group.values.return_value = []
+    mock_ard.is_valid_allele.return_value = False
+
+    reducer = DefaultReducer(mock_ard)
+
+    with pytest.raises(InvalidAlleleError, match="INVALID is an invalid allele"):
+        reducer.reduce("INVALID")

tests/unit/reducers/test_exon_reducer.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+from unittest.mock import Mock, patch
+from pyard.reducers.exon_reducer import ExonReducer
+
+
+@pytest.fixture
+def mock_ard():
+    """Create mock ARD instance"""
+    ard = Mock()
+    ard.ars_mappings = Mock()
+    ard.ars_mappings.exon_group = {"A*01:01:01": "A*01:01:01"}
+    ard.is_shortnull = Mock()
+    ard.redux = Mock()
+    return ard
+
+
+def test_reduce_allele_in_exon_group(mock_ard):
+    """Test reduction of allele in exon group mapping"""
+    reducer = ExonReducer(mock_ard)
+    result = reducer.reduce("A*01:01:01")
+
+    assert result == "A*01:01:01"
+
+
+def test_reduce_allele_with_expression_char_shortnull(mock_ard):
+    """Test reduction of allele with expression character that is shortnull"""
+    mock_ard.ars_mappings.exon_group = {"A*01:01:01N": "A*01:01:01"}
+    mock_ard.is_shortnull.return_value = True
+
+    with patch("pyard.reducers.exon_reducer.expression_chars", "N"):
+        reducer = ExonReducer(mock_ard)
+        result = reducer.reduce("A*01:01:01N")
+
+    assert result == "A*01:01:01N"
+    mock_ard.is_shortnull.assert_called_once_with("A*01:01:01N")
+
+
+def test_reduce_allele_with_expression_char_not_shortnull(mock_ard):
+    """Test reduction of allele with expression character that is not shortnull"""
+    mock_ard.ars_mappings.exon_group = {"A*01:01:01Q": "A*01:01:01"}
+    mock_ard.is_shortnull.return_value = False
+
+    with patch("pyard.reducers.exon_reducer.expression_chars", "Q"):
+        reducer = ExonReducer(mock_ard)
+        result = reducer.reduce("A*01:01:01Q")
+
+    assert result == "A*01:01:01"
+
+
+def test_reduce_allele_not_in_exon_group_w_redux_same(mock_ard):
+    """Test reduction when W redux returns same allele"""
+    mock_ard.redux.return_value = "B*07:02"
+
+    reducer = ExonReducer(mock_ard)
+    result = reducer.reduce("B*07:02")
+
+    assert result == "B*07:02"
+    mock_ard.redux.assert_called_once_with("B*07:02", "W")
+
+
+def test_reduce_allele_not_in_exon_group_w_redux_two_field(mock_ard):
+    """Test reduction when W redux returns 2-field allele"""
+    mock_ard.redux.return_value = "B*07:02"
+
+    reducer = ExonReducer(mock_ard)
+    result = reducer.reduce("B*07:02:01")
+
+    assert result == "B*07:02:01"
+
+
+def test_reduce_allele_not_in_exon_group_recursive(mock_ard):
+    """Test recursive reduction when W redux returns different allele"""
+    mock_ard.redux.side_effect = ["B*07:02:01:01", "B*07:02:01"]
+
+    reducer = ExonReducer(mock_ard)
+    result = reducer.reduce("B*07:02:XX")
+
+    assert result == "B*07:02:01"
+    assert mock_ard.redux.call_count == 2

tests/unit/reducers/test_g_reducer.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+from unittest.mock import Mock
+from pyard.reducers.g_reducer import GGroupReducer
+
+
+@pytest.fixture
+def mock_ard():
+    """Create mock ARD instance"""
+    ard = Mock()
+    ard.ars_mappings = Mock()
+    ard.ars_mappings.g_group = {"A*01:01": "A*01:01:01G", "A*02:01": "A*02:01:02G"}
+    ard.ars_mappings.dup_g = {"A*02:01": "A*02:01:01G/A*02:01:02G"}
+    ard.ars_mappings.p_group = Mock()
+    ard.is_valid_allele = Mock(return_value=True)
+    return ard
+
+
+def test_reduce_allele_in_g_group(mock_ard):
+    """Test reduction of allele in G group mapping"""
+    reducer = GGroupReducer(mock_ard)
+    result = reducer.reduce("A*01:01")
+
+    assert result == "A*01:01:01G"
+
+
+def test_reduce_allele_in_dup_g(mock_ard):
+    """Test reduction of allele in duplicate G group mapping"""
+    reducer = GGroupReducer(mock_ard)
+    result = reducer.reduce("A*02:01")
+
+    assert result == "A*02:01:01G/A*02:01:02G"
+
+
+def test_reduce_allele_not_in_g_group_calls_super(mock_ard):
+    """Test that allele not in G group calls parent reduce method"""
+    reducer = GGroupReducer(mock_ard)
+    result = reducer.reduce("B*07:02")
+
+    assert result == "B*07:02"
+    mock_ard.is_valid_allele.assert_called_once_with("B*07:02")

tests/unit/reducers/test_lg_reducer.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+from unittest.mock import Mock
+from pyard.reducers.lg_reducer import LGXReducer, LGReducer
+
+
+@pytest.fixture
+def mock_ard():
+    """Create mock ARD instance"""
+    ard = Mock()
+    ard.ars_mappings = Mock()
+    ard.ars_mappings.lgx_group = {"A*01:01:01": "A*01:01"}
+    ard._config = {"ARS_as_lg": False}
+    return ard
+
+
+class TestLGXReducer:
+    def test_reduce_allele_in_lgx_group(self, mock_ard):
+        """Test reduction of allele in LGX group mapping"""
+        reducer = LGXReducer(mock_ard)
+        result = reducer.reduce("A*01:01:01")
+
+        assert result == "A*01:01"
+
+    def test_reduce_allele_not_in_lgx_group(self, mock_ard):
+        """Test reduction of allele not in LGX group returns first 2 fields"""
+        reducer = LGXReducer(mock_ard)
+        result = reducer.reduce("B*07:02:01:03")
+
+        assert result == "B*07:02"
+
+    def test_reduce_two_field_allele(self, mock_ard):
+        """Test reduction of already 2-field allele"""
+        reducer = LGXReducer(mock_ard)
+        result = reducer.reduce("C*01:02")
+
+        assert result == "C*01:02"
+
+
+class TestLGReducer:
+    def test_reduce_single_allele_with_g_suffix(self, mock_ard):
+        """Test reduction adds 'g' suffix to single allele"""
+        reducer = LGReducer(mock_ard)
+        result = reducer.reduce("A*01:01:01")
+
+        assert result == "A*01:01g"
+
+    def test_reduce_single_allele_with_ars_suffix(self, mock_ard):
+        """Test reduction adds 'ARS' suffix when configured"""
+        mock_ard._config = {"ARS_as_lg": True}
+        reducer = LGReducer(mock_ard)
+        result = reducer.reduce("A*01:01:01")
+
+        assert result == "A*01:01ARS"
+
+    def test_reduce_multiple_alleles_with_g_suffix(self, mock_ard):
+        """Test reduction adds 'g' suffix to multiple alleles"""
+        mock_ard.ars_mappings.lgx_group = {"A*01:01:01": "A*01:01/A*01:02"}
+        reducer = LGReducer(mock_ard)
+        result = reducer.reduce("A*01:01:01")
+
+        assert result == "A*01:01g/A*01:02g"