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

app/tests/test_server.py

@@ -0,0 +1,378 @@
+"""Tests for the mock server module."""
+
+import json
+import os
+
+import pytest
+
+from api_snapshot.recorder.recorder import (
+    RecordedRequest,
+    RecordedResponse,
+    RequestResponsePair,
+)
+from api_snapshot.server.server import (
+    MockServer,
+    create_app_from_snapshot,
+    parse_path_parameters,
+)
+from api_snapshot.snapshot.manager import (
+    Snapshot,
+    SnapshotManager,
+    SnapshotMetadata,
+)
+
+
+class TestParsePathParameters:
+    """Tests for parse_path_parameters function."""
+
+    def test_exact_path_match(self):
+        """Test with exact path match (no parameters)."""
+        params = parse_path_parameters("/users", "/users")
+
+        assert params == {}
+
+    def test_single_parameter(self):
+        """Test extracting single path parameter."""
+        params = parse_path_parameters("/users/123", "/users/:id")
+
+        assert params == {"id": "123"}
+
+    def test_multiple_parameters(self):
+        """Test extracting multiple path parameters."""
+        params = parse_path_parameters(
+            "/users/123/posts/456",
+            "/users/:userId/posts/:postId",
+        )
+
+        assert params == {"userId": "123", "postId": "456"}
+
+    def test_brace_parameters(self):
+        """Test extracting parameters with braces format."""
+        params = parse_path_parameters("/items/abc", "/items/{id}")
+
+        assert params == {"id": "abc"}
+
+
+class TestMockServer:
+    """Tests for MockServer class."""
+
+    @pytest.fixture
+    def sample_pairs(self):
+        """Create sample request-response pairs."""
+        pairs = []
+
+        get_users = RecordedRequest(
+            method="GET",
+            url="/users",
+            headers={"Accept": "application/json"},
+            body=None,
+        )
+        get_users_resp = RecordedResponse(
+            status_code=200,
+            headers={"Content-Type": "application/json"},
+            body='[{"id": 1, "name": "John"}]',
+            latency_ms=100,
+        )
+        pairs.append(RequestResponsePair(request=get_users,
+                                        response=get_users_resp))
+
+        post_users = RecordedRequest(
+            method="POST",
+            url="/users",
+            headers={"Content-Type": "application/json"},
+            body='{"name": "Jane"}',
+        )
+        post_users_resp = RecordedResponse(
+            status_code=201,
+            headers={"Content-Type": "application/json"},
+            body='{"id": 2, "name": "Jane"}',
+            latency_ms=150,
+        )
+        pairs.append(RequestResponsePair(request=post_users,
+                                        response=post_users_resp))
+
+        return pairs
+
+    def test_init_server(self, sample_pairs):
+        """Test initializing mock server."""
+        metadata = SnapshotMetadata()
+        snapshot = Snapshot(metadata=metadata, requests=sample_pairs)
+
+        server = MockServer(
+            snapshot=snapshot,
+            host="127.0.0.1",
+            port=8080,
+            latency_mode="original",
+        )
+
+        assert server.snapshot == snapshot
+        assert server.host == "127.0.0.1"
+        assert server.port == 8080
+        assert server.latency_mode == "original"
+
+    def test_get_latency_original(self, sample_pairs):
+        """Test latency calculation in original mode."""
+        metadata = SnapshotMetadata()
+        snapshot = Snapshot(metadata=metadata, requests=sample_pairs)
+
+        server = MockServer(snapshot=snapshot, latency_mode="original")
+
+        latency = server._get_latency_ms(100)
+
+        assert latency == 100
+
+    def test_get_latency_fixed(self, sample_pairs):
+        """Test latency calculation in fixed mode."""
+        metadata = SnapshotMetadata()
+        snapshot = Snapshot(metadata=metadata, requests=sample_pairs)
+
+        server = MockServer(
+            snapshot=snapshot,
+            latency_mode="fixed",
+            fixed_latency_ms=200,
+        )
+
+        latency = server._get_latency_ms(50)
+
+        assert latency == 200
+
+    def test_get_latency_none(self, sample_pairs):
+        """Test latency calculation with no latency."""
+        metadata = SnapshotMetadata()
+        snapshot = Snapshot(metadata=metadata, requests=sample_pairs)
+
+        server = MockServer(snapshot=snapshot, latency_mode="none")
+
+        latency = server._get_latency_ms(500)
+
+        assert latency == 0
+
+    def test_parse_query_params(self, sample_pairs):
+        """Test parsing query parameters from URL."""
+        metadata = SnapshotMetadata()
+        snapshot = Snapshot(metadata=metadata, requests=sample_pairs)
+
+        server = MockServer(snapshot=snapshot)
+
+        params = server._parse_query_params(
+            "https://api.example.com/users?page=1&limit=10"
+        )
+
+        assert params["page"] == ["1"]
+        assert params["limit"] == ["10"]
+
+    def test_match_request_exact(self, sample_pairs):
+        """Test matching exact request."""
+        metadata = SnapshotMetadata()
+        snapshot = Snapshot(metadata=metadata, requests=sample_pairs)
+
+        server = MockServer(snapshot=snapshot)
+
+        pair = server._match_request("GET", "/users", {})
+
+        assert pair is not None
+        assert pair.request.method == "GET"
+
+    def test_match_request_method_mismatch(self, sample_pairs):
+        """Test matching with method mismatch."""
+        metadata = SnapshotMetadata()
+        snapshot = Snapshot(metadata=metadata, requests=sample_pairs)
+
+        server = MockServer(snapshot=snapshot)
+
+        pair = server._match_request("DELETE", "/users", {})
+
+        assert pair is None
+
+    def test_match_request_not_found(self, sample_pairs):
+        """Test matching when route not found."""
+        metadata = SnapshotMetadata()
+        snapshot = Snapshot(metadata=metadata, requests=sample_pairs)
+
+        server = MockServer(snapshot=snapshot)
+
+        pair = server._match_request("GET", "/nonexistent", {})
+
+        assert pair is None
+
+    def test_match_request_with_path_params(self, sample_pairs):
+        """Test matching request with path parameters."""
+        pair1 = RecordedRequest(
+            method="GET",
+            url="/users/:id",
+            headers={},
+            body=None,
+        )
+        resp1 = RecordedResponse(
+            status_code=200,
+            headers={"Content-Type": "application/json"},
+            body='{"id": ":id"}',
+            latency_ms=50,
+        )
+        pair = RequestResponsePair(request=pair1, response=resp1)
+
+        metadata = SnapshotMetadata()
+        snapshot = Snapshot(metadata=metadata, requests=[pair])
+
+        server = MockServer(snapshot=snapshot)
+
+        matched = server._match_request("GET", "/users/123", {})
+
+        assert matched is not None
+        assert matched.response.status_code == 200
+
+
+class TestMockServerRoutes:
+    """Tests for mock server route handling."""
+
+    @pytest.fixture
+    def simple_snapshot(self):
+        """Create a simple snapshot for route tests."""
+        req = RecordedRequest(
+            method="GET",
+            url="/hello",
+            headers={},
+            body=None,
+        )
+        resp = RecordedResponse(
+            status_code=200,
+            headers={"Content-Type": "text/plain"},
+            body="Hello, World!",
+            latency_ms=10,
+        )
+        pair = RequestResponsePair(request=req, response=resp)
+
+        metadata = SnapshotMetadata()
+        return Snapshot(metadata=metadata, requests=[pair])
+
+    def test_route_returns_correct_status(self, simple_snapshot):
+        """Test that route returns correct status code."""
+        server = MockServer(snapshot=simple_snapshot)
+
+        with server.app.test_client() as client:
+            response = client.get("/hello")
+
+            assert response.status_code == 200
+
+    def test_route_returns_correct_body(self, simple_snapshot):
+        """Test that route returns correct body."""
+        server = MockServer(snapshot=simple_snapshot)
+
+        with server.app.test_client() as client:
+            response = client.get("/hello")
+
+            assert response.data.decode() == "Hello, World!"
+
+    def test_route_returns_correct_headers(self, simple_snapshot):
+        """Test that route returns correct headers."""
+        server = MockServer(snapshot=simple_snapshot)
+
+        with server.app.test_client() as client:
+            response = client.get("/hello")
+
+            assert "text/plain" in response.content_type
+
+    def test_route_not_found(self, simple_snapshot):
+        """Test 404 for unmatched routes."""
+        server = MockServer(snapshot=simple_snapshot)
+
+        with server.app.test_client() as client:
+            response = client.get("/nonexistent")
+
+            assert response.status_code == 404
+
+            data = json.loads(response.data)
+            assert "error" in data
+            assert "available_routes" in data
+
+    def test_snapshot_info_endpoint(self, simple_snapshot):
+        """Test the __snapshot-info endpoint."""
+        server = MockServer(snapshot=simple_snapshot)
+
+        with server.app.test_client() as client:
+            response = client.get("/__snapshot-info")
+
+            assert response.status_code == 200
+
+            data = json.loads(response.data)
+            assert "endpoints" in data
+            assert "latency_mode" in data
+
+
+class TestMockServerLatency:
+    """Tests for mock server latency simulation."""
+
+    @pytest.fixture
+    def latency_snapshot(self):
+        """Create snapshot for latency tests."""
+        req = RecordedRequest(
+            method="GET",
+            url="/test",
+            headers={},
+            body=None,
+        )
+        resp = RecordedResponse(
+            status_code=200,
+            headers={},
+            body="test",
+            latency_ms=100,
+        )
+        pair = RequestResponsePair(request=req, response=resp)
+
+        metadata = SnapshotMetadata()
+        return Snapshot(metadata=metadata, requests=[pair])
+
+    def test_latency_mode_fixed(self, latency_snapshot):
+        """Test fixed latency mode."""
+        server = MockServer(
+            snapshot=latency_snapshot,
+            latency_mode="fixed",
+            fixed_latency_ms=50,
+        )
+
+        assert server.latency_mode == "fixed"
+        assert server.fixed_latency_ms == 50
+
+    def test_latency_mode_random(self, latency_snapshot):
+        """Test random latency mode."""
+        server = MockServer(
+            snapshot=latency_snapshot,
+            latency_mode="random",
+            random_latency_range=(10, 100),
+        )
+
+        assert server.latency_mode == "random"
+        assert server.random_latency_range == (10, 100)
+
+
+class TestCreateAppFromSnapshot:
+    """Tests for create_app_from_snapshot function."""
+
+    def test_create_app_from_snapshot(self, temp_dir):
+        """Test creating Flask app from snapshot."""
+        manager = SnapshotManager(temp_dir)
+
+        req = RecordedRequest(
+            method="GET",
+            url="/api/test",
+            headers={},
+            body=None,
+        )
+        resp = RecordedResponse(
+            status_code=200,
+            headers={"Content-Type": "application/json"},
+            body='{"success": true}',
+            latency_ms=50,
+        )
+        pair = RequestResponsePair(request=req, response=resp)
+
+        manager.save_snapshot("test", requests=[pair])
+
+        app, server = create_app_from_snapshot(
+            snapshot_path=os.path.join(temp_dir, "test.json"),
+        )
+
+        assert app is not None
+        assert server is not None
+        assert server.host == "127.0.0.1"
+        assert server.port == 8080