test(units): add test suite for QUDT units integration

- Add unit tests
- Add E2E CLI tests
- Add fixtures for units sync functionality.
- Includes mocking for external QUDT API calls.

Signed-off-by: Mustafa Kaptan <[email protected]>

Author: mfkaptan-motius

tests/conftest.py

@@ -1,6 +1,6 @@
-from collections import UserDict
 from collections.abc import Callable
 from dataclasses import dataclass, field
+from pathlib import Path
 from typing import Any
 
 import pytest
@@ -17,22 +17,11 @@
 from s2dm.exporters.utils.extraction import get_all_named_types
 from s2dm.exporters.utils.schema_loader import ensure_query
 from s2dm.idgen.models import IDGenerationSpec
+from s2dm.units.sync import UnitRow, _uri_to_enum_symbol
 
 SCALAR_TYPES = ["String", "Int", "Float", "Boolean"]
 
 
-class EchoDict(UserDict[str, str]):
-    """A dictionary that echoes the key as the value."""
-
-    def __missing__(self, key: str) -> str:
-        return key
-
-
-@pytest.fixture(scope="session")
-def mock_unit_lookup() -> EchoDict:
-    return EchoDict()
-
-
 @dataclass
 class MockFieldData:
     name: str
@@ -58,7 +47,7 @@ def enum_name(self) -> str:
     def enum_schema_str(self) -> str:
         return f"""
             enum {self.enum_name if self.is_enum_field else self.unit_enum_name} {{
-                {' '.join(self.allowed or self.unit_allowed_values)}
+                {" ".join(self.allowed or self.unit_allowed_values)}
             }}
         """
 
@@ -143,10 +132,10 @@ def mock_graphql_schema_strategy(
             vehicle: Vehicle
         }}
 
-        {' '.join(enums)}
+        {" ".join(enums)}
 
         type Vehicle {{
-            {' '.join(map(lambda f: f.to_field_str(), fields))}
+            {" ".join(map(lambda f: f.to_field_str(), fields))}
         }}
         """
     )
@@ -160,3 +149,96 @@ def mock_named_types_strategy(
 ) -> tuple[list[GraphQLNamedType], list[MockFieldData]]:
     schema, fields = draw(mock_graphql_schema_strategy())
     return get_all_named_types(schema), fields
+
+
+# Constants for common test values
+MOCK_QUDT_VERSION = "3.1.5"
+MOCK_ENUM_CONTENT = "enum TestEnum { TEST }"
+
+# QUDT constants for unit testing
+QUDT_UNIT_BASE = "http://qudt.org/vocab/unit"
+QUDT_QK_BASE = "http://qudt.org/vocab/quantitykind"
+
+# Standard test paths for units sync
+STANDARD_UNIT_PATHS = [
+    "velocity/VelocityUnitEnum.graphql",
+    "mass/MassUnitEnum.graphql",
+    "length/LengthUnitEnum.graphql",
+]
+
+
+@pytest.fixture
+def mock_qudt_version() -> str:
+    """Standard QUDT version for testing."""
+    return MOCK_QUDT_VERSION
+
+
+@pytest.fixture
+def mock_check_latest_qudt_version(mock_qudt_version: str) -> Callable[[], str]:
+    """Mock function for checking latest QUDT version."""
+
+    def _mock() -> str:
+        return mock_qudt_version
+
+    return _mock
+
+
+@pytest.fixture
+def mock_sync_qudt_units() -> Callable[..., list[Path]]:
+    """Mock function for sync_qudt_units with configurable behavior."""
+
+    def _mock(
+        units_root: Path,
+        version: str | None = None,
+        *,
+        dry_run: bool = False,
+        num_paths: int = 3,
+        create_files: bool = True,
+    ) -> list[Path]:
+        # Generate test paths based on the number requested
+        test_paths = [units_root / path for path in STANDARD_UNIT_PATHS[:num_paths]]
+
+        # Simulate creating files only when not in dry-run mode and create_files is True
+        if not dry_run and create_files:
+            for path in test_paths:
+                path.parent.mkdir(parents=True, exist_ok=True)
+                path.write_text(MOCK_ENUM_CONTENT)
+
+        return test_paths
+
+    return _mock
+
+
+@pytest.fixture
+def units_sync_mocks(
+    monkeypatch: pytest.MonkeyPatch,
+    mock_sync_qudt_units: Callable[..., list[Path]],
+    mock_check_latest_qudt_version: Callable[[], str],
+) -> tuple[Callable[..., list[Path]], Callable[[], str]]:
+    """Fixture that applies all units sync mocks at once."""
+    monkeypatch.setattr("s2dm.cli.sync_qudt_units", mock_sync_qudt_units)
+    monkeypatch.setattr("s2dm.cli.check_latest_qudt_version", mock_check_latest_qudt_version)
+    return mock_sync_qudt_units, mock_check_latest_qudt_version
+
+
+def create_test_unit_row(
+    unit_segment: str,
+    qk_segment: str,
+    label: str | None = None,
+    ucum: str | None = None,
+) -> "UnitRow":
+    """Create a test UnitRow with minimal required data.
+
+    Note: This imports UnitRow and _uri_to_enum_symbol locally to avoid circular imports.
+    """
+    unit_label = label or unit_segment.lower().replace("-", " ")
+    symbol = _uri_to_enum_symbol(f"{QUDT_UNIT_BASE}/{unit_segment}")
+
+    return UnitRow(
+        unit_iri=f"{QUDT_UNIT_BASE}/{unit_segment}",
+        unit_label=unit_label,
+        quantity_kind_iri=f"{QUDT_QK_BASE}/{qk_segment}",
+        quantity_kind_label=qk_segment,
+        symbol=symbol,
+        ucum_code=ucum or unit_segment.lower(),
+    )

tests/test_e2e_cli.py

@@ -1,4 +1,5 @@
 import json
+from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
@@ -11,7 +12,6 @@
 SAMPLE1 = TESTS_DATA / "schema1.graphql"
 SAMPLE2 = TESTS_DATA / "schema2.graphql"
 SAMPLE3 = TESTS_DATA / "schema3.graphql"
-UNITS = TESTS_DATA / "test_units.yaml"
 
 # Version bump test schemas
 BASE_SCHEMA = TESTS_DATA / "base.graphql"
@@ -192,19 +192,7 @@ def test_registry_export_concept_uri(runner: CliRunner, tmp_outputs: Path) -> No
 
 def test_registry_export_id(runner: CliRunner, tmp_outputs: Path) -> None:
     out = tmp_outputs / "ids.json"
-    result = runner.invoke(
-        cli,
-        [
-            "registry",
-            "id",
-            "-s",
-            str(SAMPLE1),
-            "-u",
-            str(UNITS),
-            "-o",
-            str(out),
-        ],
-    )
+    result = runner.invoke(cli, ["registry", "id", "-s", str(SAMPLE1), "-o", str(out)])
     assert result.exit_code == 0, result.output
     assert out.exists()
     with open(out) as f:
@@ -215,7 +203,7 @@ def test_registry_export_id(runner: CliRunner, tmp_outputs: Path) -> None:
 
 def test_registry_init(runner: CliRunner, tmp_outputs: Path) -> None:
     out = tmp_outputs / "spec_history.json"
-    result = runner.invoke(cli, ["registry", "init", "-s", str(SAMPLE1), "-u", str(UNITS), "-o", str(out)])
+    result = runner.invoke(cli, ["registry", "init", "-s", str(SAMPLE1), "-o", str(out)])
     assert result.exit_code == 0, result.output
     assert out.exists()
     with open(out) as f:
@@ -230,21 +218,19 @@ def test_registry_init(runner: CliRunner, tmp_outputs: Path) -> None:
                 spec_history
                 and isinstance(spec_history, list)
                 and isinstance(spec_history[0], dict)
-                and spec_history[0].get("@id") == "0xEC20D822"
+                and spec_history[0].get("@id") == "0x32E14E88"
             ):
                 found = True
                 break
-    assert found, 'Expected entry with "@id": "ns:Vehicle.averageSpeed" and specHistory id "0xEC20D822" not found.'
+    assert found, 'Expected entry with "@id": "ns:Vehicle.averageSpeed" and specHistory id "0x32E14E88" not found.'
 
 
 def test_registry_update(runner: CliRunner, tmp_outputs: Path) -> None:
     out = tmp_outputs / "spec_history_update.json"
     # First, create a spec history file
     init_out = tmp_outputs / "spec_history.json"
-    runner.invoke(cli, ["registry", "init", "-s", str(SAMPLE1), "-u", str(UNITS), "-o", str(init_out)])
-    runner.invoke(
-        cli, ["registry", "update", "-s", str(SAMPLE2), "-u", str(UNITS), "-sh", str(init_out), "-o", str(out)]
-    )
+    runner.invoke(cli, ["registry", "init", "-s", str(SAMPLE1), "-o", str(init_out)])
+    runner.invoke(cli, ["registry", "update", "-s", str(SAMPLE2), "-sh", str(init_out), "-o", str(out)])
     assert out.exists()
     with open(out) as f:
         data = json.load(f)
@@ -256,13 +242,13 @@ def test_registry_update(runner: CliRunner, tmp_outputs: Path) -> None:
         if isinstance(entry, dict) and entry.get("@id") == "ns:Vehicle.averageSpeed":
             spec_history = entry.get("specHistory", [])
             ids = [h.get("@id") for h in spec_history if isinstance(h, dict)]
-            if "0xEC20D822" in ids:
+            if "0x32E14E88" in ids:
                 found_old = True
-            if "0xB86BF561" in ids:
+            if "0xE47AA673" in ids:
                 found_new = True
             break
-    assert found_old, 'Expected old specHistory id "0xEC20D822" not found.'
-    assert found_new, 'Expected new specHistory id "0xB86BF561" not found.'
+    assert found_old, 'Expected old specHistory id "0x32E14E88" not found.'
+    assert found_new, 'Expected new specHistory id "0xE47AA673" not found.'
 
 
 @pytest.mark.parametrize(
@@ -397,3 +383,33 @@ def test_stats_graphql(runner: CliRunner) -> None:
     print(f"{result.output=}")
     assert result.exit_code == 0, result.output
     assert "'UInt32': 1" in result.output
+
+
+def test_units_sync_cli(
+    runner: CliRunner,
+    tmp_outputs: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    mock_sync_qudt_units: Callable[..., list[Path]],
+    mock_check_latest_qudt_version: Callable[[], str],
+) -> None:
+    """Test that the units sync CLI command works end-to-end."""
+
+    # Simple mock that just returns a few paths
+    def simple_mock(units_root: Path, version: str | None = None, *, dry_run: bool = False) -> list[Path]:
+        return mock_sync_qudt_units(units_root, version, dry_run=dry_run, num_paths=2)
+
+    # Apply mocks to avoid network calls
+    monkeypatch.setattr("s2dm.cli.sync_qudt_units", simple_mock)
+    monkeypatch.setattr("s2dm.cli.check_latest_qudt_version", mock_check_latest_qudt_version)
+
+    output_dir = tmp_outputs / "units_cli_test"
+
+    # Test basic CLI functionality
+    result = runner.invoke(cli, ["units", "sync", "--output-dir", str(output_dir)])
+    assert result.exit_code == 0, result.output
+    assert "Generated" in result.output or "enum files" in result.output
+
+    # Test that --dry-run flag is accepted (detailed behavior tested in unit tests)
+    result = runner.invoke(cli, ["units", "sync", "--output-dir", str(output_dir), "--dry-run"])
+    assert result.exit_code == 0, result.output
+    assert "Would generate" in result.output or "dry" in result.output.lower()

tests/test_idgen.py

@@ -10,7 +10,6 @@
 from s2dm.idgen.idgen import fnv1_32_wrapper
 from s2dm.idgen.models import IDGenerationSpec
 from tests.conftest import (
-    EchoDict,
     MockFieldData,
     mock_named_types_strategy,
 )
@@ -19,14 +18,13 @@
 @given(named_types_and_fields=mock_named_types_strategy())
 def test_id_spec_generation_of_all_fields_from_graphql_schema(
     named_types_and_fields: tuple[list[GraphQLNamedType], list[MockFieldData]],
-    mock_unit_lookup: EchoDict,
 ) -> None:
     """Test that ID generation spec can be generated from a GraphQL schema."""
     named_types, fields = named_types_and_fields
     expected_id_specs = {field.expected_id_spec() for field in fields}
 
-    exporter = IDExporter(schema=None, units_file=None, output=None, strict_mode=False, dry_run=True)  # type: ignore [arg-type]
-    all_id_specs = set(exporter.iter_all_id_specs(named_types, mock_unit_lookup))  # type: ignore [arg-type]
+    exporter = IDExporter(schema=None, output=None, strict_mode=False, dry_run=True)  # type: ignore [arg-type]
+    all_id_specs = set(exporter.iter_all_id_specs(named_types))
 
     for expected_id_spec in expected_id_specs:
         assert expected_id_spec in all_id_specs
@@ -35,16 +33,14 @@ def test_id_spec_generation_of_all_fields_from_graphql_schema(
 @given(named_types_and_fields=mock_named_types_strategy())
 @pytest.mark.parametrize("strict_mode", [True, False])
 def test_id_generation_is_deterministic_across_iterations(
-    named_types_and_fields: tuple[list[GraphQLNamedType], list[MockFieldData]],
-    strict_mode: bool,
-    mock_unit_lookup: EchoDict,
+    named_types_and_fields: tuple[list[GraphQLNamedType], list[MockFieldData]], strict_mode: bool
 ) -> None:
     """Test that ID generation is deterministic across iterations."""
 
     named_types, _ = named_types_and_fields
 
-    exporter = IDExporter(schema=None, units_file=None, output=None, strict_mode=strict_mode, dry_run=True)  # type: ignore [arg-type]
-    all_id_specs = set(exporter.iter_all_id_specs(named_types, mock_unit_lookup))  # type: ignore [arg-type]
+    exporter = IDExporter(schema=None, output=None, strict_mode=strict_mode, dry_run=True)  # type: ignore [arg-type]
+    all_id_specs = set(exporter.iter_all_id_specs(named_types))
 
     first_iteration_ids = {}
     for id_spec in all_id_specs:
@@ -62,17 +58,15 @@ def test_id_generation_is_deterministic_across_iterations(
 @given(named_types_and_fields=mock_named_types_strategy())
 @pytest.mark.parametrize("strict_mode", [True, False])
 def test_id_generation_is_unique_accros_schema(
-    named_types_and_fields: tuple[list[GraphQLNamedType], list[MockFieldData]],
-    strict_mode: bool,
-    mock_unit_lookup: EchoDict,
+    named_types_and_fields: tuple[list[GraphQLNamedType], list[MockFieldData]], strict_mode: bool
 ) -> None:
     """Test that ID generation produces unique IDs across the schema fields."""
 
     named_types, _ = named_types_and_fields
 
-    exporter = IDExporter(schema=None, units_file=None, output=None, strict_mode=strict_mode, dry_run=True)  # type: ignore [arg-type]
+    exporter = IDExporter(schema=None, output=None, strict_mode=strict_mode, dry_run=True)  # type: ignore [arg-type]
     ids = {}
-    for id_spec in exporter.iter_all_id_specs(named_types, mock_unit_lookup):  # type: ignore [arg-type]
+    for id_spec in exporter.iter_all_id_specs(named_types):
         field_id = fnv1_32_wrapper(id_spec, strict_mode=strict_mode)
         ids[id_spec.name] = field_id