icsDataValidation 1.0.430__py3-none-any.whl → 1.0.438__py3-none-any.whl

tests/sqlserver_service/test_get_countnulls_statement.py

@@ -0,0 +1,121 @@
+from unittest.mock import MagicMock, Mock
+
+import pytest
+
+from icsDataValidation.core.database_objects import DatabaseObject
+from icsDataValidation.services.database_services.sqlserver_service import SQLServerService
+
+
+@pytest.fixture
+def sqlserver_service():
+    """Create a SQLServerService instance with mocked connection."""
+    connection_params = {
+        'Driver': 'ODBC Driver 18 for SQL Server',
+        'Server': 'localhost',
+        'Port': '1433',
+        'Database': 'testdb',
+        'User': 'sa',
+        'Password': 'password',
+        'Encrypt': True,
+        'TrustServerCertificate': True
+    }
+    service = SQLServerService(connection_params=connection_params)
+    service.sqlserver_connection = MagicMock()
+    return service
+
+
+@pytest.fixture
+def mock_database_object():
+    """Create a mock DatabaseObject."""
+    obj = Mock(spec=DatabaseObject)
+    obj.database = "TestDB"
+    obj.schema = "dbo"
+    obj.name = "TestTable"
+    obj.type = "table"
+    return obj
+
+
+class TestGetCountnullsStatementParametrized:
+    """Parametrized tests for _get_countnulls_statement method."""
+
+    @pytest.mark.parametrize(
+        "columns,exclude_columns,where_clause,expected_contains,expected_not_in",
+        [
+            ( # single column
+                ["Amount"],
+                [],
+                "",
+                ["SUM(CASE WHEN [AMOUNT] IS NULL THEN 1 ELSE 0 END)", "AS [COUNTNULLS_AMOUNT]", "FROM dbo.TestTable"],
+                []
+            ),
+            ( # multiple columns
+                ["Amount", "Name", "IsActive"],
+                [],
+                "",
+                [
+                    "SUM(CASE WHEN [AMOUNT] IS NULL THEN 1 ELSE 0 END)", "AS [COUNTNULLS_AMOUNT]",
+                    "SUM(CASE WHEN [NAME] IS NULL THEN 1 ELSE 0 END)", "AS [COUNTNULLS_NAME]",
+                    "SUM(CASE WHEN [ISACTIVE] IS NULL THEN 1 ELSE 0 END)", "AS [COUNTNULLS_ISACTIVE]"
+                ],
+                []
+            ),
+            ( # with where clause
+                ["Amount"],
+                [],
+                "WHERE Amount > 100",
+                ["SUM(CASE WHEN [AMOUNT] IS NULL THEN 1 ELSE 0 END)", "WHERE Amount > 100"],
+                []
+            ),
+            ( # with exclude columns
+                ["Amount", "Price", "Quantity"],
+                ["Price"],
+                "",
+                ["AMOUNT", "QUANTITY"],
+                ["PRICE"]
+            ),
+            ( # special characters in column names
+                ["/ISDFPS/OBJNR", "MANDT"],
+                [],
+                "",
+                ["[/ISDFPS/OBJNR]", "AS [COUNTNULLS_/ISDFPS/OBJNR]", "[MANDT]", "AS [COUNTNULLS_MANDT]"],
+                []
+            ),
+            ( # empty columns
+                [],
+                [],
+                "",
+                ["SELECT", "FROM dbo.TestTable"],
+                ["COUNTNULLS"]
+            ),
+            ( # all columns excluded
+                ["Amount", "Price"],
+                ["Amount", "Price"],
+                "",
+                ["SELECT", "FROM dbo.TestTable"],
+                ["COUNTNULLS"]
+            ),
+            ( # case insensitive columns
+                ["amount", "Name", "QUANTITY"],
+                [],
+                "",
+                ["[AMOUNT]", "[NAME]", "[QUANTITY]"],
+                []
+            ),
+        ],
+    )
+    def test_get_countnulls_statement(
+        self, sqlserver_service, mock_database_object,
+        columns, exclude_columns, where_clause, expected_contains, expected_not_in
+    ):
+        """Test countnulls statement with various configurations."""
+        result = sqlserver_service._get_countnulls_statement(
+            object=mock_database_object,
+            column_intersections=columns,
+            exclude_columns=exclude_columns,
+            where_clause=where_clause
+        )
+
+        for expected in expected_contains:
+            assert expected in result
+        for expected in expected_not_in:
+            assert expected not in result

tests/sqlserver_service/test_get_in_clause.py

@@ -0,0 +1,87 @@
+import pytest
+
+from icsDataValidation.services.database_services.sqlserver_service import SQLServerService
+
+
+class TestInClauseVariations:
+    """Test various IN clause generation scenarios using parametrization."""
+
+    @pytest.mark.parametrize(
+        "key_filters,numeric_columns,numeric_scale,expected_contains",
+        [
+            ( # basic single row
+                {"col1": ["value1"], "col2": ["value2"]},
+                [],
+                2,
+                [" AND (CONCAT(", "CONCAT([col1], '|' ,[col2], '|')", "('value1|value2|')"],
+            ),
+            ( # basic single row with one column
+                {"col1": ["value1"]},
+                [],
+                2,
+                [" AND (CONCAT(", "CONCAT([col1], '|')", "('value1|')"],
+            ),
+            ( # multiple rows
+                {"id": [1, 2, 3], "name": ["a", "b", "c"]},
+                [],
+                2,
+                ["(CONCAT([id], '|' ,[name], '|')", "('1|a|','2|b|','3|c|')"],
+            ),
+            ( # numeric columns with rounding
+                {"price": [10.5, 20.3], "quantity": [5, 10]},
+                ["price"],
+                2,
+                ["ROUND([price], 2)", "numeric(38, 2)", "quantity", "('10.5|5|','20.3|10|')"],
+            ),
+            ( # quotes in column names (should be removed)
+                {"'col1'": ["value1"], "'col2'": ["value2"]},
+                [],
+                2,
+                ["col1", "col2"],
+            ),
+            ( # empty filters
+                {},
+                [],
+                2,
+                [""],
+            ),
+            ( # numeric with specific scale
+                {"Price": [100.123, 200.456], "Count": [1, 2]},
+                ["Price"],
+                3,
+                ["ROUND([Price], 3)", "numeric(38, 3)", "Count"],
+            ),
+            ( # all numeric columns
+                {"col1": [1.1, 2.2], "col2": [3.3, 4.4]},
+                ["col1", "col2"],
+                2,
+                ["ROUND([col1], 2)", "ROUND([col2], 2)", "numeric(38, 2)"],
+            ),
+            ( # mixed data types
+                {"amount": [100, 200], "category": ["A", "B"], "quantity": [10, 20]},
+                ["amount", "quantity"],
+                0,
+                ["ROUND([amount], 0)", "ROUND([quantity], 0)", "category"],
+            ),
+            ( # values order check
+                {"id": [1, 2], "name": ["alice", "bob"]},
+                [],
+                2,
+                ["('1|alice|','2|bob|')"],
+            ),
+            ( # special character column names
+                {"/ABC": ["value1", "value2"], "Normal": ["val1", "val2"]},
+                [],
+                2,
+                ["[/ABC]", "[Normal]", "CONCAT([/ABC], '|' ,[Normal], '|')"],
+            ),
+        ],
+    )
+    def test_in_clause_contains(
+        self, key_filters, numeric_columns, numeric_scale, expected_contains
+    ):
+        """Test that result contains expected substrings."""
+        result = SQLServerService._get_in_clause(key_filters, numeric_columns, numeric_scale)
+
+        for expected in expected_contains:
+            assert expected in result