Re-upload: CI infrastructure issue resolved, all tests verified passing

old_tests/test_analyzers.py

@@ -0,0 +1,187 @@
+"""Tests for traffic analyzer and stats generator."""
+
+import pytest
+from datetime import datetime
+
+from http_log_explorer.analyzers import StatsGenerator, TrafficAnalyzer
+from http_log_explorer.models import FilterCriteria, HTTPEntry, Request, Response
+
+
+def make_entry(
+    method: str = "GET",
+    url: str = "https://api.example.com/test",
+    status: int = 200,
+    body: str | None = None,
+    duration_ms: float = 100.0,
+) -> HTTPEntry:
+    """Create a test HTTPEntry."""
+    return HTTPEntry(
+        id=f"entry-{method}-{status}",
+        request=Request(
+            method=method,
+            url=url,
+            headers={"Content-Type": "application/json"},
+            body=body,
+        ),
+        response=Response(
+            status=status,
+            status_text="OK",
+            body=body,
+            content_type="application/json",
+            response_time_ms=duration_ms,
+        ),
+        timestamp=datetime.now(),
+    )
+
+
+@pytest.fixture
+def sample_entries():
+    """Create sample HTTP entries for testing."""
+    return [
+        make_entry("GET", "https://api.example.com/users", 200, duration_ms=50),
+        make_entry("POST", "https://api.example.com/users", 201, duration_ms=100),
+        make_entry("GET", "https://api.example.com/users/1", 200, duration_ms=75),
+        make_entry("PUT", "https://api.example.com/users/1", 200, duration_ms=80),
+        make_entry("DELETE", "https://api.example.com/users/1", 204, duration_ms=30),
+        make_entry("GET", "https://api.example.com/posts", 404, duration_ms=25),
+        make_entry("POST", "https://api.example.com/posts", 500, duration_ms=200),
+    ]
+
+
+class TestTrafficAnalyzer:
+    """Tests for TrafficAnalyzer."""
+
+    def test_filter_by_method(self, sample_entries):
+        """Test filtering by HTTP method."""
+        analyzer = TrafficAnalyzer(sample_entries)
+        get_entries = analyzer.by_method(["GET"])
+
+        assert len(get_entries) == 3
+        assert all(e.request.method == "GET" for e in get_entries)
+
+    def test_filter_by_status(self, sample_entries):
+        """Test filtering by status code."""
+        analyzer = TrafficAnalyzer(sample_entries)
+        success_entries = analyzer.by_status([200, 201, 204])
+
+        assert len(success_entries) == 5
+        assert all(e.response.status < 300 for e in success_entries)
+
+    def test_filter_by_url_pattern(self, sample_entries):
+        """Test filtering by URL pattern."""
+        analyzer = TrafficAnalyzer(sample_entries)
+        user_entries = analyzer.by_url(r"/users")
+
+        assert len(user_entries) == 5
+        assert all("/users" in e.request.url for e in user_entries)
+
+    def test_filter_by_content_type(self, sample_entries):
+        """Test filtering by content type."""
+        analyzer = TrafficAnalyzer(sample_entries)
+        json_entries = analyzer.by_content_type(["application/json"])
+
+        assert len(json_entries) == 7
+
+    def test_successful_requests(self, sample_entries):
+        """Test getting successful requests (2xx)."""
+        analyzer = TrafficAnalyzer(sample_entries)
+        success = analyzer.successful_requests()
+
+        assert len(success) == 5
+        assert all(200 <= e.response.status < 300 for e in success)
+
+    def test_client_errors(self, sample_entries):
+        """Test getting client errors (4xx)."""
+        analyzer = TrafficAnalyzer(sample_entries)
+        errors = analyzer.client_errors()
+
+        assert len(errors) == 1
+        assert errors[0].response.status == 404
+
+    def test_server_errors(self, sample_entries):
+        """Test getting server errors (5xx)."""
+        analyzer = TrafficAnalyzer(sample_entries)
+        errors = analyzer.server_errors()
+
+        assert len(errors) == 1
+        assert errors[0].response.status == 500
+
+    def test_search(self, sample_entries):
+        """Test search across URL and bodies."""
+        analyzer = TrafficAnalyzer(sample_entries)
+        results = analyzer.search("users")
+
+        assert len(results) == 5
+
+    def test_get_entry_by_id(self, sample_entries):
+        """Test getting entry by ID."""
+        analyzer = TrafficAnalyzer(sample_entries)
+        entry = analyzer.get_entry_by_id("entry-GET-200")
+
+        assert entry is not None
+        assert entry.request.method == "GET"
+
+    def test_get_entry_by_id_not_found(self, sample_entries):
+        """Test getting non-existent entry."""
+        analyzer = TrafficAnalyzer(sample_entries)
+        entry = analyzer.get_entry_by_id("non-existent")
+
+        assert entry is None
+
+
+class TestStatsGenerator:
+    """Tests for StatsGenerator."""
+
+    def test_total_requests(self, sample_entries):
+        """Test total request count."""
+        generator = StatsGenerator(sample_entries)
+        stats = generator.generate()
+
+        assert stats.total_requests == 7
+
+    def test_method_distribution(self, sample_entries):
+        """Test method distribution."""
+        generator = StatsGenerator(sample_entries)
+        stats = generator.generate()
+
+        assert stats.method_distribution.get("GET") == 3
+        assert stats.method_distribution.get("POST") == 2
+        assert stats.method_distribution.get("PUT") == 1
+        assert stats.method_distribution.get("DELETE") == 1
+
+    def test_status_breakdown(self, sample_entries):
+        """Test status code breakdown."""
+        generator = StatsGenerator(sample_entries)
+        stats = generator.generate()
+
+        assert stats.status_breakdown.get(200) == 3
+        assert stats.status_breakdown.get(201) == 1
+        assert stats.status_breakdown.get(204) == 1
+        assert stats.status_breakdown.get(404) == 1
+        assert stats.status_breakdown.get(500) == 1
+
+    def test_response_time_stats(self, sample_entries):
+        """Test response time statistics."""
+        generator = StatsGenerator(sample_entries)
+        stats = generator.generate()
+
+        assert stats.response_time_stats["min"] == 25.0
+        assert stats.response_time_stats["max"] == 200.0
+        assert stats.response_time_stats["avg"] == pytest.approx(80.0, rel=1)
+
+    def test_endpoint_count(self, sample_entries):
+        """Test endpoint counting."""
+        generator = StatsGenerator(sample_entries)
+        stats = generator.generate()
+
+        assert "/users" in stats.endpoint_count
+        assert "/posts" in stats.endpoint_count
+
+    def test_to_dict(self, sample_entries):
+        """Test converting stats to dictionary."""
+        generator = StatsGenerator(sample_entries)
+        stats_dict = generator.to_dict()
+
+        assert stats_dict["total_requests"] == 7
+        assert "method_distribution" in stats_dict
+        assert "status_breakdown" in stats_dict