Add tests

39 tests covering voice code (generate, verify, decode, cross-secret),
CheckResult (from_api_response, day types, activity lookup),
PermissionChecker (normalize_activities 3 formats, cache key),
MemoryCache (TTL, expiry, overwrite). MockHttpClient for test isolation.

Co-Authored-By: claude-flow <ruv@ruv.net>

Author: Allow2CEO

tests/__init__.py

@@ -0,0 +1,77 @@
+"""Mock HTTP client for testing."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Optional, Tuple
+
+from allow2_service.http_response import HttpResponse
+
+
+class MockHttpClient:
+    """Mock HTTP client that returns pre-configured responses.
+
+    Records all requests for later assertions and returns queued responses.
+    """
+
+    def __init__(self) -> None:
+        self.requests: List[Dict[str, Any]] = []
+        self._responses: List[HttpResponse] = []
+
+    def queue_response(
+        self,
+        status_code: int = 200,
+        body: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Queue a response to be returned by the next request.
+
+        Args:
+            status_code: HTTP status code.
+            body: Response body dictionary (JSON-encoded).
+        """
+        self._responses.append(HttpResponse(
+            status_code=status_code,
+            body=json.dumps(body) if body is not None else "{}",
+        ))
+
+    def post(
+        self,
+        url: str,
+        data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> HttpResponse:
+        """Send a mock POST request."""
+        self.requests.append({
+            "method": "POST",
+            "url": url,
+            "data": data or {},
+            "headers": headers or {},
+        })
+        return self._next_response()
+
+    def get(
+        self,
+        url: str,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> HttpResponse:
+        """Send a mock GET request."""
+        self.requests.append({
+            "method": "GET",
+            "url": url,
+            "data": {},
+            "headers": headers or {},
+        })
+        return self._next_response()
+
+    def _next_response(self) -> HttpResponse:
+        """Return the next queued response, or a default 200 OK."""
+        if self._responses:
+            return self._responses.pop(0)
+        return HttpResponse(status_code=200, body="{}")
+
+    @property
+    def last_request(self) -> Optional[Dict[str, Any]]:
+        """Return the most recent request, if any."""
+        if self.requests:
+            return self.requests[-1]
+        return None

tests/mock_http_client.py

@@ -0,0 +1,165 @@
+"""Tests for CheckResult model."""
+
+from __future__ import annotations
+
+from allow2_service.models import CheckResult
+
+
+def test_from_api_response_basic() -> None:
+    response = {
+        "allowed": True,
+        "activities": [
+            {"id": 1, "activity": "Internet", "allowed": True, "remaining": 3600, "banned": False},
+            {"id": 3, "activity": "Gaming", "allowed": False, "remaining": 0, "banned": True},
+        ],
+        "dayType": {"id": 1, "name": "School Day"},
+    }
+
+    result = CheckResult.from_api_response(response)
+
+    # Server says allowed=True, so it should be True
+    assert result.allowed is True
+    assert len(result.activities) == 2
+
+
+def test_from_api_response_all_activities_blocked() -> None:
+    response = {
+        "activities": [
+            {"id": 1, "activity": "Internet", "allowed": False, "remaining": 0},
+            {"id": 3, "activity": "Gaming", "allowed": False, "remaining": 0},
+        ],
+    }
+
+    result = CheckResult.from_api_response(response)
+
+    # No explicit "allowed" key; should be derived from activities
+    assert result.allowed is False
+
+
+def test_from_api_response_all_activities_allowed() -> None:
+    response = {
+        "activities": [
+            {"id": 1, "activity": "Internet", "allowed": True, "remaining": 3600},
+            {"id": 3, "activity": "Gaming", "allowed": True, "remaining": 1800},
+        ],
+    }
+
+    result = CheckResult.from_api_response(response)
+
+    assert result.allowed is True
+
+
+def test_from_api_response_explicit_allowed_overrides() -> None:
+    response = {
+        "allowed": False,
+        "activities": [
+            {"id": 1, "activity": "Internet", "allowed": True, "remaining": 3600},
+        ],
+    }
+
+    result = CheckResult.from_api_response(response)
+
+    # Server says allowed=False even though activity is allowed
+    assert result.allowed is False
+
+
+def test_get_activity_returns_matching() -> None:
+    response = {
+        "activities": [
+            {"id": 1, "activity": "Internet", "allowed": True, "remaining": 3600},
+            {"id": 3, "activity": "Gaming", "allowed": False, "remaining": 0},
+        ],
+    }
+
+    result = CheckResult.from_api_response(response)
+
+    activity = result.get_activity(3)
+    assert activity is not None
+    assert activity.id == 3
+    assert activity.name == "Gaming"
+    assert activity.allowed is False
+
+
+def test_get_activity_returns_none_for_missing() -> None:
+    response = {
+        "activities": [
+            {"id": 1, "activity": "Internet", "allowed": True, "remaining": 3600},
+        ],
+    }
+
+    result = CheckResult.from_api_response(response)
+
+    assert result.get_activity(99) is None
+
+
+def test_is_activity_allowed() -> None:
+    response = {
+        "activities": [
+            {"id": 1, "activity": "Internet", "allowed": True, "remaining": 3600},
+            {"id": 3, "activity": "Gaming", "allowed": False, "remaining": 0},
+        ],
+    }
+
+    result = CheckResult.from_api_response(response)
+
+    assert result.is_activity_allowed(1) is True
+    assert result.is_activity_allowed(3) is False
+    assert result.is_activity_allowed(99) is False
+
+
+def test_get_remaining_seconds() -> None:
+    response = {
+        "activities": [
+            {"id": 1, "activity": "Internet", "allowed": True, "remaining": 3600},
+        ],
+    }
+
+    result = CheckResult.from_api_response(response)
+
+    assert result.get_remaining_seconds(1) == 3600
+    assert result.get_remaining_seconds(99) == 0
+
+
+def test_from_api_response_day_types() -> None:
+    response = {
+        "activities": [],
+        "dayType": {"id": 1, "name": "School Day"},
+        "tomorrowDayType": {"id": 2, "name": "Weekend"},
+    }
+
+    result = CheckResult.from_api_response(response)
+
+    assert result.today_day_type is not None
+    assert result.today_day_type.id == 1
+    assert result.today_day_type.name == "School Day"
+    assert result.tomorrow_day_type is not None
+    assert result.tomorrow_day_type.id == 2
+    assert result.tomorrow_day_type.name == "Weekend"
+
+
+def test_from_api_response_alternate_day_type_keys() -> None:
+    response = {
+        "activities": [],
+        "today": {"id": 3, "name": "Holiday"},
+        "tomorrow": {"id": 1, "name": "School Day"},
+    }
+
+    result = CheckResult.from_api_response(response)
+
+    assert result.today_day_type is not None
+    assert result.today_day_type.id == 3
+    assert result.tomorrow_day_type is not None
+    assert result.tomorrow_day_type.id == 1
+
+
+def test_from_api_response_raw_preserved() -> None:
+    response = {
+        "allowed": True,
+        "activities": [],
+        "custom_field": "custom_value",
+    }
+
+    result = CheckResult.from_api_response(response)
+
+    assert result.raw == response
+    assert result.raw["custom_field"] == "custom_value"

tests/test_check_result.py

@@ -0,0 +1,65 @@
+"""Tests for MemoryCache TTL behavior."""
+
+from __future__ import annotations
+
+import time
+from unittest.mock import patch
+
+from allow2_service.cache import MemoryCache
+
+
+def test_set_and_get() -> None:
+    cache = MemoryCache()
+    cache.set("key1", "value1", ttl=60)
+    assert cache.get("key1") == "value1"
+
+
+def test_get_returns_none_for_missing() -> None:
+    cache = MemoryCache()
+    assert cache.get("nonexistent") is None
+
+
+def test_delete() -> None:
+    cache = MemoryCache()
+    cache.set("key1", "value1")
+    cache.delete("key1")
+    assert cache.get("key1") is None
+
+
+def test_delete_nonexistent_does_not_raise() -> None:
+    cache = MemoryCache()
+    cache.delete("nonexistent")  # should not raise
+
+
+def test_expired_entry_returns_none() -> None:
+    cache = MemoryCache()
+
+    # Store with TTL 1 second
+    cache.set("key1", "value1", ttl=1)
+
+    # Verify it's there initially
+    assert cache.get("key1") == "value1"
+
+    # Mock time to be in the future
+    with patch("allow2_service.cache.memory_cache.time") as mock_time:
+        # First call is for the get check
+        mock_time.time.return_value = time.time() + 10
+        assert cache.get("key1") is None
+
+
+def test_overwrite_existing_key() -> None:
+    cache = MemoryCache()
+    cache.set("key1", "value1")
+    cache.set("key1", "value2")
+    assert cache.get("key1") == "value2"
+
+
+def test_different_ttls() -> None:
+    cache = MemoryCache()
+    cache.set("short", "short-value", ttl=1)
+    cache.set("long", "long-value", ttl=3600)
+
+    with patch("allow2_service.cache.memory_cache.time") as mock_time:
+        mock_time.time.return_value = time.time() + 10
+        assert cache.get("short") is None
+        assert cache.get("long") == "long-value"

tests/test_memory_cache.py

@@ -0,0 +1,72 @@
+"""Tests for PermissionChecker, focusing on activity normalization."""
+
+from __future__ import annotations
+
+from allow2_service.checker import PermissionChecker
+
+
+def test_normalize_activities_list_of_dicts() -> None:
+    """Format 1: list of dicts [{"id": 1, "log": True}, ...] -- pass through."""
+    activities = [{"id": 1, "log": True}, {"id": 3, "log": False}]
+    result = PermissionChecker._normalize_activities(activities)
+    assert result == [{"id": 1, "log": True}, {"id": 3, "log": False}]
+
+
+def test_normalize_activities_simple_list() -> None:
+    """Format 2: simple list of IDs [1, 3, 8] -- expand with log=True."""
+    activities = [1, 3, 8]
+    result = PermissionChecker._normalize_activities(activities)
+    assert result == [
+        {"id": 1, "log": True},
+        {"id": 3, "log": True},
+        {"id": 8, "log": True},
+    ]
+
+
+def test_normalize_activities_legacy_dict() -> None:
+    """Format 3: legacy dict {1: 1, 3: 1} -- convert."""
+    activities = {1: 1, 3: 1, 8: 0}
+    result = PermissionChecker._normalize_activities(activities)
+    assert len(result) == 3
+
+    # Check all are converted properly
+    ids = {a["id"] for a in result}
+    assert ids == {1, 3, 8}
+
+    # Check log values
+    for a in result:
+        if a["id"] == 8:
+            assert a["log"] is False
+        else:
+            assert a["log"] is True
+
+
+def test_normalize_activities_empty_list() -> None:
+    result = PermissionChecker._normalize_activities([])
+    assert result == []
+
+
+def test_normalize_activities_empty_dict() -> None:
+    result = PermissionChecker._normalize_activities({})
+    assert result == []
+
+
+def test_build_cache_key_deterministic() -> None:
+    """Cache key should be the same regardless of activity order."""
+    activities1 = [{"id": 3, "log": True}, {"id": 1, "log": True}]
+    activities2 = [{"id": 1, "log": True}, {"id": 3, "log": True}]
+
+    key1 = PermissionChecker._build_cache_key("user-1", activities1)
+    key2 = PermissionChecker._build_cache_key("user-1", activities2)
+
+    assert key1 == key2
+    assert "allow2_check_user-1_1_3" == key1
+
+
+def test_build_cache_key_different_users() -> None:
+    activities = [{"id": 1, "log": True}]
+
+    key1 = PermissionChecker._build_cache_key("user-1", activities)
+    key2 = PermissionChecker._build_cache_key("user-2", activities)
+
+    assert key1 != key2