tests

Author: Nikita Filonov

conftest.py

@@ -1,6 +1,7 @@
 pytest_plugins = (
     "swagger_coverage_tool.tests.fixtures.http",
     "swagger_coverage_tool.tests.fixtures.config",
+    "swagger_coverage_tool.tests.fixtures.reports",
     "swagger_coverage_tool.tests.fixtures.history",
     "swagger_coverage_tool.tests.fixtures.tracker",
 )

swagger_coverage_tool/tests/fixtures/config.py

@@ -21,11 +21,15 @@ def settings() -> Settings:
 
 
 @pytest.fixture
-def coverage_history_settings(tmp_path: Path) -> Settings:
-    config = Settings(
-        services=[],
-        results_dir=tmp_path / "results",
-    )
-    config.history_file = tmp_path / "history.json"
-    config.history_retention_limit = 3
-    return config
+def coverage_history_settings(tmp_path: Path, settings: Settings) -> Settings:
+    settings.results_dir = tmp_path / "results"
+    settings.history_file = tmp_path / "history.json"
+    settings.history_retention_limit = 3
+    return settings
+
+
+@pytest.fixture
+def reports_settings(tmp_path: Path, coverage_history_settings: Settings) -> Settings:
+    coverage_history_settings.json_report_file = tmp_path / "report.json"
+    coverage_history_settings.html_report_file = tmp_path / "report.html"
+    return coverage_history_settings

swagger_coverage_tool/tests/fixtures/history.py

@@ -3,13 +3,19 @@
 from swagger_coverage_tool.config import Settings
 from swagger_coverage_tool.src.history.builder import SwaggerServiceCoverageHistoryBuilder
 from swagger_coverage_tool.src.history.models import ServiceCoverageHistory
+from swagger_coverage_tool.src.history.storage import SwaggerCoverageHistoryStorage
 
 
 @pytest.fixture
 def service_coverage_history() -> ServiceCoverageHistory:
     return ServiceCoverageHistory()
 
 
+@pytest.fixture
+def coverage_history_storage(coverage_history_settings: Settings) -> SwaggerCoverageHistoryStorage:
+    return SwaggerCoverageHistoryStorage(coverage_history_settings)
+
+
 @pytest.fixture
 def service_coverage_history_builder(
         service_coverage_history: ServiceCoverageHistory,

swagger_coverage_tool/tests/fixtures/reports.py

@@ -0,0 +1,49 @@
+from datetime import datetime
+
+import pytest
+
+from swagger_coverage_tool.config import Settings
+from swagger_coverage_tool.src.coverage.models import ServiceCoverage, ServiceEndpointCoverage
+from swagger_coverage_tool.src.coverage.status import ServiceEndpointCoverageStatus
+from swagger_coverage_tool.src.history.models import CoverageHistory
+from swagger_coverage_tool.src.reports.models import CoverageReportState
+from swagger_coverage_tool.src.reports.storage import SwaggerReportsStorage
+from swagger_coverage_tool.src.tools.http import HTTPMethod
+from swagger_coverage_tool.src.tools.types import ServiceKey, CoveragePercent, EndpointName
+
+
+@pytest.fixture
+def coverage_report_state(coverage_history_settings: Settings) -> CoverageReportState:
+    service_key = ServiceKey("test-service")
+
+    fake_service_coverage = ServiceCoverage(
+        total_coverage_history=[
+            CoverageHistory(created_at=datetime.now(), total_coverage=CoveragePercent(88.0))
+        ],
+        endpoints=[
+            ServiceEndpointCoverage(
+                name=EndpointName("get_users"),
+                method=HTTPMethod.GET,
+                coverage=ServiceEndpointCoverageStatus.COVERED,
+                total_cases=1,
+                status_codes=[],
+                query_parameters=[],
+                request_coverage=ServiceEndpointCoverageStatus.COVERED,
+                total_coverage_history=[
+                    CoverageHistory(
+                        created_at=datetime.now(),
+                        total_coverage=CoveragePercent(55.0),
+                    )
+                ],
+            )
+        ],
+    )
+
+    report = CoverageReportState.init(coverage_history_settings)
+    report.services_coverage = {service_key: fake_service_coverage}
+    return report
+
+
+@pytest.fixture
+def reports_storage(reports_settings: Settings) -> SwaggerReportsStorage:
+    return SwaggerReportsStorage(reports_settings)

swagger_coverage_tool/tests/suites/src/history/test_storage.py

@@ -0,0 +1,146 @@
+import json
+from datetime import datetime
+from pathlib import Path
+
+import pytest
+
+from swagger_coverage_tool.config import Settings
+from swagger_coverage_tool.src.history.endpoint import build_endpoint_key
+from swagger_coverage_tool.src.history.models import CoverageHistoryState, ServiceCoverageHistory, CoverageHistory
+from swagger_coverage_tool.src.history.storage import SwaggerCoverageHistoryStorage
+from swagger_coverage_tool.src.reports.models import CoverageReportState
+from swagger_coverage_tool.src.tools.http import HTTPMethod
+from swagger_coverage_tool.src.tools.types import ServiceKey, CoveragePercent, EndpointName
+
+
+# -------------------------------
+# TEST: load
+# -------------------------------
+
+def test_load_returns_empty_if_no_history_file(
+        coverage_history_storage: SwaggerCoverageHistoryStorage,
+        coverage_history_settings: Settings,
+):
+    coverage_history_settings.history_file = None
+
+    result = coverage_history_storage.load()
+    assert isinstance(result, CoverageHistoryState)
+    assert result.services == {}
+
+
+def test_load_returns_empty_if_file_not_exists(
+        coverage_history_storage: SwaggerCoverageHistoryStorage,
+        coverage_history_settings: Settings,
+):
+    assert not coverage_history_settings.history_file.exists()
+
+    result = coverage_history_storage.load()
+    assert isinstance(result, CoverageHistoryState)
+    assert result.services == {}
+
+
+def test_load_reads_and_parses_valid_json(
+        coverage_history_storage: SwaggerCoverageHistoryStorage,
+        coverage_history_settings: Settings,
+):
+    state = CoverageHistoryState(
+        services={
+            ServiceKey("test-service"): ServiceCoverageHistory(
+                total_coverage_history=[
+                    CoverageHistory(created_at=datetime.now(), total_coverage=CoveragePercent(90.0))
+                ]
+            )
+        }
+    )
+    coverage_history_settings.history_file.write_text(state.model_dump_json(by_alias=True))
+
+    result = coverage_history_storage.load()
+    assert isinstance(result, CoverageHistoryState)
+    assert "test-service" in result.services
+
+
+def test_load_handles_invalid_json(
+        coverage_history_storage: SwaggerCoverageHistoryStorage,
+        coverage_history_settings: Settings,
+):
+    coverage_history_settings.history_file.write_text("{ invalid json }")
+
+    result = coverage_history_storage.load()
+    assert isinstance(result, CoverageHistoryState)
+    assert result.services == {}
+
+
+# -------------------------------
+# TEST: save
+# -------------------------------
+
+def test_save_creates_and_writes_file(
+        coverage_history_storage: SwaggerCoverageHistoryStorage,
+        coverage_history_settings: Settings,
+):
+    state = CoverageHistoryState(
+        services={
+            ServiceKey("test-service"): ServiceCoverageHistory(
+                total_coverage_history=[
+                    CoverageHistory(created_at=datetime.now(), total_coverage=CoveragePercent(75.0))
+                ]
+            )
+        }
+    )
+
+    coverage_history_storage.save(state)
+
+    assert coverage_history_settings.history_file.exists()
+    content = json.loads(coverage_history_settings.history_file.read_text())
+    assert "services" in content
+
+
+def test_save_logs_error(
+        caplog,
+        monkeypatch: pytest.MonkeyPatch,
+        coverage_history_storage: SwaggerCoverageHistoryStorage,
+):
+    state = CoverageHistoryState()
+
+    def mock_write_text(_):
+        raise OSError("disk full")
+
+    monkeypatch.setattr(Path, "write_text", mock_write_text)
+    coverage_history_storage.save(state)
+
+    assert any("Error saving history" in message for message in caplog.messages)
+
+
+# -------------------------------
+# TEST: save_from_report
+# -------------------------------
+
+def test_save_from_report_builds_correct_state(
+        monkeypatch: pytest.MonkeyPatch,
+        coverage_report_state: CoverageReportState,
+        coverage_history_storage: SwaggerCoverageHistoryStorage,
+):
+    called = {}
+
+    def mock_save(state: CoverageHistoryState):
+        called["state"] = state
+
+    monkeypatch.setattr(coverage_history_storage, "save", mock_save)
+
+    coverage_history_storage.save_from_report(coverage_report_state)
+
+    assert "state" in called
+    state = called["state"]
+
+    assert isinstance(state, CoverageHistoryState)
+
+    service_key = ServiceKey("test-service")
+    assert service_key in state.services
+
+    service_state = state.services[service_key]
+    assert isinstance(service_state, ServiceCoverageHistory)
+    assert service_state.total_coverage_history[0].total_coverage == 88.0
+
+    key = build_endpoint_key(EndpointName("get_users"), HTTPMethod.GET)
+    assert key in service_state.endpoints_total_coverage_history
+    assert service_state.endpoints_total_coverage_history[key][0].total_coverage == 55.0

swagger_coverage_tool/tests/suites/src/reports/__init__.py

@@ -0,0 +1,45 @@
+from datetime import datetime
+
+from swagger_coverage_tool.config import Settings
+from swagger_coverage_tool.src.reports.models import (
+    CoverageReportState,
+    CoverageReportConfig,
+    CoverageReportServiceConfig,
+)
+
+
+def test_init_creates_valid_report_state(settings: Settings):
+    state = CoverageReportState.init(settings)
+
+    assert isinstance(state, CoverageReportState)
+    assert isinstance(state.config, CoverageReportConfig)
+    assert isinstance(state.created_at, datetime)
+    assert isinstance(state.services_coverage, dict)
+    assert state.services_coverage == {}
+
+    assert len(state.config.services) == len(settings.services)
+    first_service = state.config.services[0]
+    assert isinstance(first_service, CoverageReportServiceConfig)
+    assert first_service.key == settings.services[0].key
+    assert first_service.name == settings.services[0].name
+    assert str(first_service.swagger_url) == str(settings.services[0].swagger_url)
+
+
+def test_init_with_empty_settings():
+    empty_settings = Settings(services=[])
+    state = CoverageReportState.init(empty_settings)
+
+    assert isinstance(state, CoverageReportState)
+    assert state.config.services == []
+    assert state.services_coverage == {}
+    assert isinstance(state.created_at, datetime)
+
+
+def test_init_creates_distinct_instances(settings: Settings):
+    state1 = CoverageReportState.init(settings)
+    state2 = CoverageReportState.init(settings)
+
+    assert state1 is not state2
+    assert state1.created_at != state2.created_at
+    assert state1.config.services[0].key == state2.config.services[0].key
+    assert isinstance(state1.config.services[0], CoverageReportServiceConfig)