fix: resolve CI/CD test, lint, and type-check failures

app/tests/test_snapshot.py

@@ -0,0 +1,236 @@
+"""Tests for the snapshot module."""
+
+import json
+import os
+
+import pytest
+
+from api_snapshot.snapshot.manager import (
+    SNAPSHOT_VERSION,
+    Snapshot,
+    SnapshotManager,
+    SnapshotMetadata,
+)
+
+
+class TestSnapshotMetadata:
+    """Tests for SnapshotMetadata class."""
+
+    def test_create_metadata(self):
+        """Test creating snapshot metadata."""
+        meta = SnapshotMetadata(
+            version="1.0",
+            description="Test description",
+            source_url="https://api.example.com"
+        )
+
+        assert meta.version == "1.0"
+        assert meta.description == "Test description"
+        assert meta.source_url == "https://api.example.com"
+        assert meta.latency_mode == "original"
+        assert meta.tags == []
+
+    def test_metadata_defaults(self):
+        """Test metadata default values."""
+        meta = SnapshotMetadata()
+
+        assert meta.version == SNAPSHOT_VERSION
+        assert meta.description == ""
+        assert meta.source_url is None
+        assert meta.latency_mode == "original"
+        assert meta.custom_latency_ms is None
+        assert meta.tags == []
+
+    def test_metadata_to_dict(self):
+        """Test converting metadata to dictionary."""
+        meta = SnapshotMetadata(
+            version="1.0",
+            description="Test",
+            tags=["tag1", "tag2"]
+        )
+
+        data = meta.to_dict()
+
+        assert data["version"] == "1.0"
+        assert data["description"] == "Test"
+        assert data["tags"] == ["tag1", "tag2"]
+        assert "timestamp" in data
+
+    def test_metadata_from_dict(self):
+        """Test creating metadata from dictionary."""
+        data = {
+            "version": "1.0",
+            "timestamp": "2024-01-01T00:00:00",
+            "description": "My snapshot",
+            "source_url": "https://api.com",
+            "latency_mode": "fixed",
+            "custom_latency_ms": 100,
+            "tags": ["api", "test"]
+        }
+
+        meta = SnapshotMetadata.from_dict(data)
+
+        assert meta.version == "1.0"
+        assert meta.description == "My snapshot"
+        assert meta.source_url == "https://api.com"
+        assert meta.latency_mode == "fixed"
+        assert meta.custom_latency_ms == 100
+        assert meta.tags == ["api", "test"]
+
+
+class TestSnapshot:
+    """Tests for Snapshot class."""
+
+    def test_create_snapshot(self, sample_pair):
+        """Test creating a snapshot."""
+        meta = SnapshotMetadata(description="Test snapshot")
+        snapshot = Snapshot(metadata=meta, requests=[sample_pair])
+
+        assert snapshot.metadata == meta
+        assert len(snapshot.requests) == 1
+        assert snapshot.requests[0] == sample_pair
+
+    def test_snapshot_to_dict(self, sample_snapshot):
+        """Test converting snapshot to dictionary."""
+        data = sample_snapshot.to_dict()
+
+        assert "metadata" in data
+        assert "requests" in data
+        assert data["metadata"]["description"] == "Test snapshot"
+        assert len(data["requests"]) == 1
+
+    def test_snapshot_from_dict(self, sample_snapshot_dict):
+        """Test creating snapshot from dictionary."""
+        snapshot = Snapshot.from_dict(sample_snapshot_dict)
+
+        assert snapshot.metadata.description == "Test snapshot"
+        assert len(snapshot.requests) == 1
+        assert snapshot.requests[0].request.method == "GET"
+
+
+class TestSnapshotManager:
+    """Tests for SnapshotManager class."""
+
+    def test_init_manager(self, temp_dir):
+        """Test initializing snapshot manager."""
+        manager = SnapshotManager(temp_dir)
+
+        assert manager.snapshot_dir == temp_dir
+        assert os.path.exists(temp_dir)
+
+    def test_save_snapshot(self, snapshot_manager, sample_pair):
+        """Test saving a snapshot."""
+        path = snapshot_manager.save_snapshot(
+            name="test-save",
+            requests=[sample_pair],
+            description="Saved snapshot"
+        )
+
+        assert os.path.exists(path)
+        assert path.endswith("test-save.json")
+
+        with open(path) as f:
+            data = json.load(f)
+
+        assert data["metadata"]["description"] == "Saved snapshot"
+        assert len(data["requests"]) == 1
+
+    def test_save_snapshot_with_tags(self, snapshot_manager, sample_pair):
+        """Test saving snapshot with tags."""
+        snapshot_manager.save_snapshot(
+            name="with-tags",
+            requests=[sample_pair],
+            tags=["tag1", "tag2"]
+        )
+
+        loaded = snapshot_manager.load_snapshot("with-tags")
+
+        assert "tag1" in loaded.metadata.tags
+        assert "tag2" in loaded.metadata.tags
+
+    def test_load_snapshot(self, snapshot_manager, snapshot_file):
+        """Test loading a snapshot."""
+        snapshot = snapshot_manager.load_snapshot("test_snapshot")
+
+        assert snapshot.metadata.description == "Test snapshot"
+        assert len(snapshot.requests) == 2
+
+    def test_load_snapshot_not_found(self, snapshot_manager):
+        """Test loading non-existent snapshot."""
+        with pytest.raises(FileNotFoundError):
+            snapshot_manager.load_snapshot("nonexistent")
+
+    def test_load_invalid_snapshot(self, temp_dir):
+        """Test loading invalid snapshot format."""
+        path = os.path.join(temp_dir, "invalid.json")
+
+        with open(path, "w") as f:
+            json.dump({"invalid": "format"}, f)
+
+        manager = SnapshotManager(temp_dir)
+
+        with pytest.raises(ValueError):
+            manager.load_snapshot("invalid")
+
+    def test_delete_snapshot(self, snapshot_manager, sample_pair):
+        """Test deleting a snapshot."""
+        snapshot_manager.save_snapshot("to-delete", requests=[sample_pair])
+
+        assert snapshot_manager.snapshot_exists("to-delete")
+
+        snapshot_manager.delete_snapshot("to-delete")
+
+        assert not snapshot_manager.snapshot_exists("to-delete")
+
+    def test_delete_nonexistent(self, snapshot_manager):
+        """Test deleting non-existent snapshot."""
+        with pytest.raises(FileNotFoundError):
+            snapshot_manager.delete_snapshot("nonexistent")
+
+    def test_list_snapshots(self, snapshot_manager, sample_pair):
+        """Test listing snapshots."""
+        snapshot_manager.save_snapshot("snap1", requests=[sample_pair])
+        snapshot_manager.save_snapshot("snap2", requests=[sample_pair])
+
+        snapshots = snapshot_manager.list_snapshots()
+
+        assert len(snapshots) == 2
+        names = [s["name"] for s in snapshots]
+        assert "snap1" in names
+        assert "snap2" in names
+
+    def test_list_empty(self, temp_dir):
+        """Test listing with no snapshots."""
+        manager = SnapshotManager(temp_dir)
+
+        snapshots = manager.list_snapshots()
+
+        assert snapshots == []
+
+    def test_snapshot_exists(self, snapshot_manager, sample_pair):
+        """Test checking if snapshot exists."""
+        assert not snapshot_manager.snapshot_exists("test-exists")
+
+        snapshot_manager.save_snapshot("test-exists", requests=[sample_pair])
+
+        assert snapshot_manager.snapshot_exists("test-exists")
+
+    def test_get_path(self, snapshot_manager):
+        """Test getting snapshot path."""
+        path = snapshot_manager._get_path("my-snapshot")
+
+        assert path.endswith("my-snapshot.json")
+
+    def test_get_path_with_extension(self, snapshot_manager):
+        """Test getting path with extension."""
+        path = snapshot_manager._get_path("my-snapshot.json")
+
+        assert path.endswith("my-snapshot.json")
+
+
+class TestSnapshotVersion:
+    """Tests for snapshot versioning."""
+
+    def test_version_constant(self):
+        """Test version constant is defined."""
+        assert SNAPSHOT_VERSION == "1.0"