agent-portal-2 0.1.0

package/python/tests/test_config.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from agent_portal.config import load_config, save_default_config
+
+
+class ConfigTests(unittest.TestCase):
+    def test_default_config_can_be_created_and_loaded(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            config_path = save_default_config(root)
+            config = load_config(root)
+            self.assertTrue(config_path.exists())
+            self.assertEqual(config.runtime_port, 8765)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/tests/test_doctor.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import unittest
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from agent_portal.doctor import run_doctor
+
+
+class DoctorTests(unittest.TestCase):
+    def test_doctor_returns_checks(self) -> None:
+        report = run_doctor()
+        self.assertGreater(len(report.checks), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/tests/test_metrics.py

@@ -0,0 +1,180 @@
+"""Tests for metrics and telemetry module."""
+
+from __future__ import annotations
+
+import time
+import unittest
+import tempfile
+from pathlib import Path
+
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from agent_portal.metrics import (
+    MetricsCollector,
+    TimerContext,
+    MetricType,
+    get_metrics,
+    reset_metrics,
+)
+
+
+class MetricsCollectorTests(unittest.TestCase):
+    """Test cases for the MetricsCollector class."""
+
+    def setUp(self) -> None:
+        """Reset metrics before each test."""
+        reset_metrics()
+        self.metrics = MetricsCollector()
+
+    def test_increment_counter(self) -> None:
+        self.metrics.increment("test.counter", 5.0)
+        self.assertEqual(self.metrics.get_counter("test.counter"), 5.0)
+        
+        self.metrics.increment("test.counter", 3.0)
+        self.assertEqual(self.metrics.get_counter("test.counter"), 8.0)
+
+    def test_set_gauge(self) -> None:
+        self.metrics.set_gauge("test.gauge", 42.0)
+        self.assertEqual(self.metrics.get_gauge("test.gauge"), 42.0)
+        
+        self.metrics.set_gauge("test.gauge", 99.0)
+        self.assertEqual(self.metrics.get_gauge("test.gauge"), 99.0)
+
+    def test_record_histogram(self) -> None:
+        values = [1.0, 2.0, 3.0, 4.0, 5.0]
+        for value in values:
+            self.metrics.record_histogram("test.histogram", value)
+        
+        stats = self.metrics.get_histogram("test.histogram")
+        self.assertEqual(stats["count"], 5)
+        self.assertEqual(stats["sum"], 15.0)
+        self.assertEqual(stats["min"], 1.0)
+        self.assertEqual(stats["max"], 5.0)
+        self.assertEqual(stats["avg"], 3.0)
+
+    def test_record_timer(self) -> None:
+        durations = [0.1, 0.2, 0.3, 0.4, 0.5]
+        for duration in durations:
+            self.metrics.record_timer("test.timer", duration)
+        
+        stats = self.metrics.get_timer_stats("test.timer")
+        self.assertEqual(stats["count"], 5)
+        self.assertEqual(stats["min"], 0.1)
+        self.assertEqual(stats["max"], 0.5)
+        self.assertAlmostEqual(stats["avg"], 0.3, places=2)
+
+    def test_timer_context(self) -> None:
+        with self.metrics.start_timer("test.context"):
+            time.sleep(0.05)
+        
+        stats = self.metrics.get_timer_stats("test.context")
+        self.assertEqual(stats["count"], 1)
+        self.assertGreater(stats["min"], 0.04)
+        self.assertLess(stats["max"], 0.15)
+
+    def test_percentiles(self) -> None:
+        durations = list(range(100))  # 0 to 99
+        for duration in durations:
+            self.metrics.record_timer("test.percentiles", float(duration))
+        
+        stats = self.metrics.get_timer_stats("test.percentiles")
+        self.assertEqual(stats["count"], 100)
+        self.assertAlmostEqual(stats["p50"], 49.0, places=0)
+        self.assertAlmostEqual(stats["p95"], 94.0, places=0)
+        self.assertAlmostEqual(stats["p99"], 98.0, places=0)
+
+    def test_get_all_metrics(self) -> None:
+        self.metrics.increment("test.counter", 1.0)
+        self.metrics.set_gauge("test.gauge", 42.0)
+        self.metrics.record_histogram("test.histogram", 5.0)
+        
+        all_metrics = self.metrics.get_all_metrics()
+        self.assertIn("counters", all_metrics)
+        self.assertIn("gauges", all_metrics)
+        self.assertIn("histograms", all_metrics)
+        self.assertIn("timers", all_metrics)
+        
+        self.assertEqual(all_metrics["counters"]["test.counter"], 1.0)
+        self.assertEqual(all_metrics["gauges"]["test.gauge"], 42.0)
+
+    def test_reset(self) -> None:
+        self.metrics.increment("test.counter", 100.0)
+        self.assertEqual(self.metrics.get_counter("test.counter"), 100.0)
+        
+        self.metrics.reset()
+        self.assertEqual(self.metrics.get_counter("test.counter"), 0.0)
+
+    def test_export_to_file(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            self.metrics.increment("test.counter", 42.0)
+            
+            export_path = Path(temp_dir) / "metrics.json"
+            self.metrics.export_to_file(export_path)
+            
+            self.assertTrue(export_path.exists())
+            
+            import json
+            content = json.loads(export_path.read_text(encoding="utf8"))
+            self.assertIn("counters", content)
+            self.assertIn("exported_at", content)
+
+    def test_get_recent_samples(self) -> None:
+        self.metrics.increment("test.counter", 1.0)
+        self.metrics.set_gauge("test.gauge", 42.0)
+        
+        samples = self.metrics.get_recent_samples(limit=10)
+        self.assertEqual(len(samples), 2)
+        self.assertEqual(samples[0]["name"], "test.counter")
+        self.assertEqual(samples[1]["name"], "test.gauge")
+
+    def test_builtin_metrics(self) -> None:
+        """Check that built-in metrics are initialized."""
+        self.assertIsNotNone(self.metrics.get_counter("actions.total"))
+        self.assertIsNotNone(self.metrics.get_counter("actions.completed"))
+        self.assertIsNotNone(self.metrics.get_gauge("runtime.uptime_seconds"))
+
+    def test_histogram_empty(self) -> None:
+        stats = self.metrics.get_histogram("nonexistent")
+        self.assertEqual(stats["count"], 0)
+        self.assertEqual(stats["sum"], 0.0)
+
+    def test_timer_empty(self) -> None:
+        stats = self.metrics.get_timer_stats("nonexistent")
+        self.assertEqual(stats["count"], 0)
+
+    def test_max_samples_limit(self) -> None:
+        """Test that samples don't grow beyond max_samples."""
+        small_metrics = MetricsCollector(max_samples=100)
+        
+        for i in range(200):
+            small_metrics.increment("test", 1.0)
+        
+        samples = small_metrics.get_recent_samples(limit=1000)
+        self.assertLessEqual(len(samples), 100)
+
+
+class GlobalMetricsTests(unittest.TestCase):
+    """Test cases for global metrics functions."""
+
+    def test_get_metrics_singleton(self) -> None:
+        reset_metrics()
+        m1 = get_metrics()
+        m2 = get_metrics()
+        self.assertIs(m1, m2)
+
+    def test_reset_metrics(self) -> None:
+        reset_metrics()
+        metrics = get_metrics()
+        
+        metrics.increment("test", 100.0)
+        self.assertEqual(metrics.get_counter("test"), 100.0)
+        
+        reset_metrics()
+        new_metrics = get_metrics()
+        self.assertEqual(new_metrics.get_counter("test"), 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/tests/test_rate_limit.py

@@ -0,0 +1,237 @@
+"""Tests for rate limiting module."""
+
+from __future__ import annotations
+
+import time
+import unittest
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from agent_portal.rate_limit import (
+    RateLimiter,
+    RateLimitConfig,
+    ActionThrottler,
+    ClientInfo,
+)
+
+
+class RateLimiterTests(unittest.TestCase):
+    """Test cases for the RateLimiter class."""
+
+    def test_basic_request_allowed(self) -> None:
+        limiter = RateLimiter()
+        allowed, error = limiter.check_rate_limit("client1")
+        self.assertTrue(allowed)
+        self.assertIsNone(error)
+
+    def test_request_within_limits(self) -> None:
+        config = RateLimitConfig(requests_per_minute=10, burst_limit=5)
+        limiter = RateLimiter(config)
+        
+        # Should allow up to burst limit
+        for i in range(5):
+            allowed, error = limiter.check_rate_limit("client1")
+            self.assertTrue(allowed, f"Request {i} should be allowed")
+            self.assertIsNone(error)
+
+    def test_burst_limit_exceeded(self) -> None:
+        config = RateLimitConfig(requests_per_minute=100, burst_limit=3)
+        limiter = RateLimiter(config)
+        
+        # Exhaust burst limit
+        for i in range(3):
+            allowed, _ = limiter.check_rate_limit("client1")
+            self.assertTrue(allowed)
+        
+        # Next request should be blocked
+        allowed, error = limiter.check_rate_limit("client1")
+        self.assertFalse(allowed)
+        self.assertIn("Burst limit exceeded", error or "")
+
+    def test_per_minute_limit(self) -> None:
+        config = RateLimitConfig(requests_per_minute=5, burst_limit=10)
+        limiter = RateLimiter(config)
+        
+        # This should be within burst but hit per-minute limit
+        for i in range(6):
+            allowed, _ = limiter.check_rate_limit("client1")
+        
+        # Should be blocked due to per-minute limit
+        allowed, error = limiter.check_rate_limit("client1")
+        self.assertFalse(allowed)
+        self.assertIn("per minute", error or "")
+
+    def test_different_clients_independent(self) -> None:
+        config = RateLimitConfig(requests_per_minute=2, burst_limit=2)
+        limiter = RateLimiter(config)
+        
+        # Client 1 makes 2 requests
+        for _ in range(2):
+            limiter.check_rate_limit("client1")
+        
+        # Client 1 should be blocked on third request
+        allowed, _ = limiter.check_rate_limit("client1")
+        self.assertFalse(allowed)
+        
+        # Client 2 should still be allowed
+        allowed, _ = limiter.check_rate_limit("client2")
+        self.assertTrue(allowed)
+
+    def test_block_timeout(self) -> None:
+        config = RateLimitConfig(
+            requests_per_minute=10,
+            burst_limit=2,
+            burst_window_seconds=0.5
+        )
+        limiter = RateLimiter(config)
+        
+        # Exhaust burst limit
+        for _ in range(2):
+            limiter.check_rate_limit("client1")
+        
+        # Should be blocked
+        allowed, _ = limiter.check_rate_limit("client1")
+        self.assertFalse(allowed)
+        
+        # Wait for block to expire
+        time.sleep(1.1)
+        
+        # Should be allowed again
+        allowed, _ = limiter.check_rate_limit("client1")
+        self.assertTrue(allowed)
+
+    def test_reset_client(self) -> None:
+        config = RateLimitConfig(requests_per_minute=2, burst_limit=2)
+        limiter = RateLimiter(config)
+        
+        # Exhaust limits
+        for _ in range(2):
+            limiter.check_rate_limit("client1")
+        
+        # Should be blocked
+        allowed, _ = limiter.check_rate_limit("client1")
+        self.assertFalse(allowed)
+        
+        # Reset client
+        limiter.reset_client("client1")
+        
+        # Should be allowed again
+        allowed, _ = limiter.check_rate_limit("client1")
+        self.assertTrue(allowed)
+
+    def test_cleanup_old_clients(self) -> None:
+        limiter = RateLimiter()
+        
+        # Add some clients
+        limiter.check_rate_limit("client1")
+        limiter.check_rate_limit("client2")
+        
+        # They should exist
+        self.assertIn("client1", limiter.clients)
+        self.assertIn("client2", limiter.clients)
+        
+        # Cleanup with max age of 0 hours (should remove all)
+        removed = limiter.cleanup_old_clients(max_age_hours=0)
+        self.assertGreater(removed, 0)
+        
+        # Clients should be removed
+        self.assertNotIn("client1", limiter.clients)
+
+    def test_default_config(self) -> None:
+        limiter = RateLimiter()
+        config = limiter.config
+        
+        self.assertEqual(config.requests_per_minute, 60)
+        self.assertEqual(config.requests_per_hour, 1000)
+        self.assertEqual(config.burst_limit, 10)
+        self.assertEqual(config.burst_window_seconds, 1.0)
+
+
+class ActionThrottlerTests(unittest.TestCase):
+    """Test cases for the ActionThrottler class."""
+
+    def setUp(self) -> None:
+        self.throttler = ActionThrottler()
+
+    def test_click_action_allowed(self) -> None:
+        allowed, error = self.throttler.check_action_allowed("click")
+        self.assertTrue(allowed)
+        self.assertIsNone(error)
+
+    def test_execute_action_stricter_limits(self) -> None:
+        # Execute action has stricter limits (5 per minute)
+        for _ in range(5):
+            allowed, _ = self.throttler.check_action_allowed("execute")
+            self.assertTrue(allowed)
+        
+        # 6th request should be blocked
+        allowed, error = self.throttler.check_action_allowed("execute")
+        self.assertFalse(allowed)
+        self.assertIn("execute", error or "")
+
+    def test_different_actions_independent(self) -> None:
+        # Exhaust execute limit
+        for _ in range(6):
+            self.throttler.check_action_allowed("execute")
+        
+        # Execute should be blocked
+        allowed, _ = self.throttler.check_action_allowed("execute")
+        self.assertFalse(allowed)
+        
+        # Click should still be allowed
+        allowed, _ = self.throttler.check_action_allowed("click")
+        self.assertTrue(allowed)
+
+    def test_per_client_throttling(self) -> None:
+        # Exhaust execute for client1
+        for _ in range(6):
+            self.throttler.check_action_allowed("execute", "client1")
+        
+        # Client1 should be blocked
+        allowed, _ = self.throttler.check_action_allowed("execute", "client1")
+        self.assertFalse(allowed)
+        
+        # Client2 should still be allowed
+        allowed, _ = self.throttler.check_action_allowed("execute", "client2")
+        self.assertTrue(allowed)
+
+    def test_cleanup_old_entries(self) -> None:
+        self.throttler.check_action_allowed("click", "client1")
+        self.throttler.check_action_allowed("type", "client1")
+        
+        # Should have entries
+        self.assertGreater(len(self.throttler._action_counts), 0)
+        
+        # Cleanup with max age 0
+        removed = self.throttler.cleanup_old_entries(max_age_hours=0)
+        
+        # Entries should be removed
+        self.assertEqual(removed, 2)
+
+    def test_unknown_action_type_defaults(self) -> None:
+        # Unknown actions should get default limits
+        for _ in range(70):
+            allowed, _ = self.throttler.check_action_allowed("unknown_action")
+        
+        # Should be blocked at default 60/min limit
+        allowed, _ = self.throttler.check_action_allowed("unknown_action")
+        self.assertFalse(allowed)
+
+    def test_screenshot_stricter_than_click(self) -> None:
+        # Screenshot has limit of 10 per minute, click has 60
+        for _ in range(11):
+            self.throttler.check_action_allowed("screenshot")
+        
+        allowed, _ = self.throttler.check_action_allowed("screenshot")
+        self.assertFalse(allowed)
+        
+        # Click should still be allowed
+        allowed, _ = self.throttler.check_action_allowed("click")
+        self.assertTrue(allowed)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/tests/test_runtime.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from agent_portal.models import ActionRequest, RuntimeConfigModel
+from agent_portal.runtime import PortalRuntime
+
+
+class StubBrowser:
+    def __init__(self) -> None:
+        self.connected = False
+        self.url: str | None = None
+        self.console_errors: list[str] = []
+        self.network_errors: list[str] = []
+
+    def available(self) -> bool:
+        return True
+
+    def start(self) -> None:
+        self.connected = True
+
+    def stop(self) -> None:
+        self.connected = False
+
+    def open_url(self, url: str) -> None:
+        self.url = url
+
+    def screenshot(self, label: str) -> str:
+        return f"{label}.png"
+
+    def click(self, selector: str) -> None:
+        self.url = self.url or "http://localhost/test"
+
+    def type_text(self, selector: str, value: str) -> None:
+        return None
+
+    def scroll(self, selector: str | None = None) -> None:
+        return None
+
+    def hover(self, selector: str) -> None:
+        return None
+
+    def wait(self, selector: str) -> None:
+        return None
+
+    def inspect(self) -> dict[str, object]:
+        return {
+            "url": self.url,
+            "title": "Fixture",
+            "dom": "<html></html>",
+            "consoleErrors": self.console_errors,
+            "networkErrors": self.network_errors,
+        }
+
+    def current_url(self) -> str | None:
+        return self.url
+
+    def current_title(self) -> str | None:
+        return "Fixture" if self.url else None
+
+    def read_console(self) -> list[str]:
+        return list(self.console_errors)
+
+    def read_network(self) -> list[str]:
+        return list(self.network_errors)
+
+
+class RuntimeTests(unittest.TestCase):
+    def build_runtime(self, root: Path) -> PortalRuntime:
+        config = RuntimeConfigModel(
+            screenshot_directory="shots",
+            report_directory="reports",
+            sensitive_screenshots_enabled=True,
+            safe_mode=False,
+        )
+        runtime = PortalRuntime(root, config)
+        runtime.browser = StubBrowser()  # type: ignore[assignment]
+        return runtime
+
+    def test_runtime_proposes_and_rejects_action(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            runtime = self.build_runtime(Path(temp_dir))
+            action = runtime.propose_action(
+                ActionRequest("click", "Click a safe element", target="#ok")
+            )
+            rejected = runtime.reject_action(action.action_id, "Rejected for test")
+            self.assertEqual(rejected.status, "rejected")
+            self.assertEqual(runtime.session.runtime_status, "blocked")
+
+    def test_runtime_blocks_password_typing(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            runtime = self.build_runtime(Path(temp_dir))
+            action = runtime.propose_action(
+                ActionRequest("type", "Enter password", target="#password", payload="secret")
+            )
+            self.assertEqual(action.status, "blocked")
+
+    def test_runtime_open_and_report_generation(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            runtime = self.build_runtime(root)
+            runtime.start()
+            runtime.ensure_browser()
+            result = runtime.open_url("http://localhost:3000")
+            report_path = runtime.generate_report()
+
+            self.assertEqual(result.status, "completed")
+            self.assertTrue(report_path.exists())
+
+            report = json.loads(report_path.read_text(encoding="utf8"))
+            self.assertEqual(report["current_url"], "http://localhost:3000")
+            self.assertGreaterEqual(len(report["actions_completed"]), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/tests/test_server.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import json
+import socket
+import tempfile
+import threading
+import time
+import unittest
+from pathlib import Path
+import sys
+from urllib.request import Request, urlopen
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from agent_portal.models import RuntimeConfigModel
+from agent_portal.runtime import PortalRuntime
+from agent_portal.server import build_server
+
+
+class ServerTests(unittest.TestCase):
+    def test_status_endpoint_responds(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            with socket.socket() as probe:
+                probe.bind(("127.0.0.1", 0))
+                port = probe.getsockname()[1]
+
+            config = RuntimeConfigModel(runtime_host="127.0.0.1", runtime_port=port)
+            runtime = PortalRuntime(root, config)
+            runtime.start()
+            server = build_server(runtime)
+            thread = threading.Thread(target=server.serve_forever, daemon=True)
+            thread.start()
+
+            try:
+                time.sleep(0.1)
+                with urlopen(f"http://127.0.0.1:{port}/status") as response:
+                    payload = json.loads(response.read().decode("utf8"))
+                self.assertEqual(payload["session"]["runtime_status"], "idle")
+            finally:
+                request = Request(
+                    f"http://127.0.0.1:{port}/control/stop",
+                    data=b"{}",
+                    headers={"Content-Type": "application/json"},
+                )
+                with urlopen(request):
+                    pass
+                thread.join(timeout=2)
+                server.server_close()
+
+
+if __name__ == "__main__":
+    unittest.main()