Handler Tests

 - Add tests for all handlers

Author: pbashyal-nmdp

tests/unit/handlers/__init__.py

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

tests/unit/handlers/test_allele_handler.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+from unittest.mock import Mock, MagicMock
+
+from pyard.handlers.allele_handler import AlleleHandler
+
+
+class TestAlleleHandler:
+    """Test cases for AlleleHandler class"""
+
+    @pytest.fixture
+    def mock_ard(self):
+        """Create mock ARD instance"""
+        ard = Mock()
+        ard._config = {"ARS_as_lg": False}
+        return ard
+
+    @pytest.fixture
+    def mock_strategy_factory(self):
+        """Create mock strategy factory"""
+        factory = Mock()
+        mock_strategy = Mock()
+        mock_strategy.reduce.return_value = "A*01:01G"
+        factory.get_strategy.return_value = mock_strategy
+        return factory
+
+    @pytest.fixture
+    def allele_handler(self, mock_ard, mock_strategy_factory):
+        """Create AlleleHandler instance with mocked dependencies"""
+        handler = AlleleHandler(mock_ard)
+        handler.strategy_factory = mock_strategy_factory
+        return handler
+
+    def test_init(self, mock_ard):
+        """Test AlleleHandler initialization"""
+        handler = AlleleHandler(mock_ard)
+        assert handler.ard == mock_ard
+        assert handler.strategy_factory is not None
+
+    def test_reduce_allele(self, allele_handler, mock_strategy_factory):
+        """Test reduce_allele method"""
+        result = allele_handler.reduce_allele("A*01:01:01", "G")
+
+        mock_strategy_factory.get_strategy.assert_called_once_with("G")
+        mock_strategy_factory.get_strategy.return_value.reduce.assert_called_once_with(
+            "A*01:01:01"
+        )
+        assert result == "A*01:01G"
+
+    def test_add_lg_suffix_single_allele_default(self, allele_handler):
+        """Test add_lg_suffix with single allele using default 'g' suffix"""
+        result = allele_handler.add_lg_suffix("A*01:01")
+        assert result == "A*01:01g"
+
+    def test_add_lg_suffix_single_allele_ars(self, mock_ard):
+        """Test add_lg_suffix with single allele using ARS suffix"""
+        mock_ard._config = {"ARS_as_lg": True}
+        handler = AlleleHandler(mock_ard)
+        result = handler.add_lg_suffix("A*01:01")
+        assert result == "A*01:01ARS"
+
+    def test_add_lg_suffix_multiple_alleles(self, allele_handler):
+        """Test add_lg_suffix with multiple alleles separated by '/'"""
+        result = allele_handler.add_lg_suffix("A*01:01/A*01:02")
+        assert result == "A*01:01g/A*01:02g"
+
+    def test_add_lg_suffix_multiple_alleles_ars(self, mock_ard):
+        """Test add_lg_suffix with multiple alleles using ARS suffix"""
+        mock_ard._config = {"ARS_as_lg": True}
+        handler = AlleleHandler(mock_ard)
+        result = handler.add_lg_suffix("A*01:01/A*01:02")
+        assert result == "A*01:01ARS/A*01:02ARS"

tests/unit/handlers/test_gl_string_handler.py

@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+from unittest.mock import Mock
+
+from pyard.handlers.gl_string_processor import GLStringHandler
+from pyard.exceptions import InvalidAlleleError
+
+
+class TestGLStringHandler:
+    """Test cases for GLStringHandler class"""
+
+    @pytest.fixture
+    def mock_ard(self):
+        """Create mock ARD instance"""
+
+        def redux_side_effect(x, y):
+            # Mock the redux method to return the input string
+            return x
+
+        def sort_comparator(a, b, ignore_suffixes=()):
+            # Simple lexicographic comparison for consistent sorting
+            if a < b:
+                return -1
+            elif a > b:
+                return 1
+            else:
+                return 0
+
+        ard = Mock()
+        ard._config = {"strict": False, "ignore_allele_with_suffixes": ()}
+        ard.redux.side_effect = redux_side_effect
+        ard.smart_sort_comparator.side_effect = sort_comparator
+        ard._is_valid.return_value = True
+        return ard
+
+    @pytest.fixture
+    def gl_handler(self, mock_ard):
+        """Create GLStringHandler instance"""
+        return GLStringHandler(mock_ard)
+
+    def test_init(self, mock_ard):
+        """Test GLStringHandler initialization"""
+        handler = GLStringHandler(mock_ard)
+        assert handler.ard == mock_ard
+
+    def test_process_gl_string_single_allele(self, gl_handler):
+        """Test processing single allele (no delimiters)"""
+        result = gl_handler.process_gl_string("A*01:01", "G")
+        assert result == "A*01:01"
+
+    def test_process_gl_string_caret_delimiter(self, gl_handler):
+        """Test processing GL string with ^ delimiter"""
+        result = gl_handler.process_gl_string("A*01:01^B*07:02", "G")
+        # Results are sorted - check that both components are present
+        assert "A*01:01" in result and "B*07:02" in result and "^" in result
+
+    def test_process_gl_string_pipe_delimiter(self, gl_handler):
+        """Test processing GL string with | delimiter"""
+        result = gl_handler.process_gl_string("A*01:01|B*07:02", "G")
+        # Results are sorted - check that both components are present
+        assert "A*01:01" in result and "B*07:02" in result and "|" in result
+
+    def test_process_gl_string_plus_delimiter(self, gl_handler):
+        """Test processing GL string with + delimiter"""
+        result = gl_handler.process_gl_string("A*01:01+A*02:01", "G")
+        assert result == "A*01:01+A*02:01"
+
+    def test_process_gl_string_tilde_delimiter(self, gl_handler):
+        """Test processing GL string with ~ delimiter"""
+        result = gl_handler.process_gl_string("A*01:01~A*02:01", "G")
+        assert result == "A*01:01~A*02:01"
+
+    def test_process_gl_string_slash_delimiter(self, gl_handler):
+        """Test processing GL string with / delimiter"""
+        result = gl_handler.process_gl_string("A*01:01/A*02:01", "lgx")
+        # Results are sorted - the actual sorting puts A*01:01 before A*02:01
+        assert result == "A*01:01/A*02:01"
+
+    def test_process_gl_string_strict_mode_valid(self, mock_ard):
+        """Test processing with strict mode enabled and valid alleles"""
+        mock_ard._config["strict"] = True
+        handler = GLStringHandler(mock_ard)
+        result = handler.process_gl_string("A*01:01", "G")
+        assert result == "A*01:01"
+        mock_ard._is_valid.assert_called_once_with("A*01:01")
+
+    def test_process_gl_string_strict_mode_invalid(self, mock_ard):
+        """Test processing with strict mode enabled and invalid alleles"""
+        mock_ard._config["strict"] = True
+        mock_ard._is_valid.return_value = False
+        handler = GLStringHandler(mock_ard)
+
+        with pytest.raises(InvalidAlleleError):
+            handler.process_gl_string("INVALID", "G")
+
+    def test_sorted_unique_gl_tilde_preserves_order(self, gl_handler):
+        """Test that ~ delimiter preserves original order"""
+        result = gl_handler._sorted_unique_gl(["B*07:02", "A*01:01"], "~")
+        assert result == "B*07:02~A*01:01"
+
+    def test_sorted_unique_gl_plus_sorts(self, gl_handler):
+        """Test that + delimiter sorts components"""
+        result = gl_handler._sorted_unique_gl(["B*07:02", "A*01:01"], "+")
+        assert "+" in result
+
+    def test_sorted_unique_gl_other_delimiters_flatten(self, gl_handler):
+        """Test that other delimiters flatten and deduplicate"""
+        result = gl_handler._sorted_unique_gl(["A*01:01/A*02:01", "A*01:01"], "/")
+        # Should flatten and deduplicate
+        assert "/" in result
+
+    def test_validate_gl_string_single_valid_allele(self, gl_handler):
+        """Test validation of single valid allele"""
+        result = gl_handler.validate_gl_string("A*01:01")
+        assert result is True
+
+    def test_validate_gl_string_single_invalid_allele(self, mock_ard):
+        """Test validation of single invalid allele"""
+        mock_ard._is_valid.return_value = False
+        handler = GLStringHandler(mock_ard)
+
+        with pytest.raises(InvalidAlleleError):
+            handler.validate_gl_string("INVALID")
+
+    def test_validate_gl_string_with_delimiters(self, gl_handler):
+        """Test validation of GL string with delimiters"""
+        result = gl_handler.validate_gl_string("A*01:01^B*07:02")
+        assert result is True
+
+    def test_validate_gl_string_mixed_valid_invalid(self, mock_ard):
+        """Test validation with mix of valid and invalid alleles"""
+        mock_ard._is_valid.side_effect = lambda x: x != "INVALID"
+        handler = GLStringHandler(mock_ard)
+
+        with pytest.raises(InvalidAlleleError):
+            handler.validate_gl_string("A*01:01^INVALID")
+
+    @pytest.mark.parametrize(
+        "redux_type", ["G", "P", "lg", "lgx", "W", "exon", "U2", "S"]
+    )
+    def test_process_gl_string_valid_redux_types(self, gl_handler, redux_type):
+        """Test processing with all valid reduction types"""
+        result = gl_handler.process_gl_string("A*01:01", redux_type)
+        assert result == "A*01:01"
+
+    def test_process_gl_string_invalid_redux_type(self, gl_handler):
+        """Test processing with invalid reduction type"""
+        with pytest.raises(ValueError):
+            gl_handler.process_gl_string("A*01:01", "INVALID")