draft-board 0.1.0-beta.0

package/app/backend/tests/test_sqlite_kv.py

@@ -0,0 +1,290 @@
+"""Tests for sqlite_kv module - low-level SQLite operations for middleware.
+
+Tests cover: KV store, idempotency locking, rate limiting, TTL expiry.
+"""
+
+import sqlite3
+import time
+from unittest.mock import patch
+
+import pytest
+
+# ---------------------------------------------------------------------------
+# Fixture: temp SQLite DB with all required tables
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def sqlite_db(tmp_path):
+    """Create a temporary SQLite DB with required tables and patch _DB_PATH."""
+    db_path = str(tmp_path / "test_kv.db")
+    conn = sqlite3.connect(db_path)
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.executescript("""
+        CREATE TABLE idempotency_cache (
+            cache_key TEXT PRIMARY KEY,
+            lock_value TEXT,
+            result_value TEXT,
+            lock_expires_at TIMESTAMP,
+            result_expires_at TIMESTAMP,
+            created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+        );
+        CREATE TABLE rate_limit_entries (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            client_key TEXT NOT NULL,
+            cost INTEGER NOT NULL DEFAULT 1,
+            recorded_at REAL NOT NULL,
+            expires_at REAL NOT NULL
+        );
+        CREATE INDEX ix_rate_limit_entries_client_key
+            ON rate_limit_entries(client_key);
+        CREATE INDEX ix_rate_limit_entries_expires_at
+            ON rate_limit_entries(expires_at);
+        CREATE TABLE kv_store (
+            key TEXT PRIMARY KEY,
+            value TEXT NOT NULL,
+            expires_at TIMESTAMP,
+            created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+        );
+    """)
+    conn.close()
+
+    with patch("app.sqlite_kv._DB_PATH", db_path):
+        yield db_path
+
+
+# ===========================================================================
+# KV store tests
+# ===========================================================================
+
+
+class TestKVStore:
+    """Tests for kv_set / kv_get / kv_take / kv_delete / kv_exists."""
+
+    def test_set_and_get(self, sqlite_db):
+        from app.sqlite_kv import kv_get, kv_set
+
+        kv_set("hello", "world")
+        assert kv_get("hello") == "world"
+
+    def test_get_missing_key_returns_none(self, sqlite_db):
+        from app.sqlite_kv import kv_get
+
+        assert kv_get("nonexistent") is None
+
+    def test_set_overwrites_existing(self, sqlite_db):
+        from app.sqlite_kv import kv_get, kv_set
+
+        kv_set("key", "v1")
+        kv_set("key", "v2")
+        assert kv_get("key") == "v2"
+
+    def test_delete_existing_key(self, sqlite_db):
+        from app.sqlite_kv import kv_delete, kv_get, kv_set
+
+        kv_set("key", "val")
+        assert kv_delete("key") is True
+        assert kv_get("key") is None
+
+    def test_delete_missing_key_returns_false(self, sqlite_db):
+        from app.sqlite_kv import kv_delete
+
+        assert kv_delete("nope") is False
+
+    def test_exists(self, sqlite_db):
+        from app.sqlite_kv import kv_exists, kv_set
+
+        assert kv_exists("key") is False
+        kv_set("key", "val")
+        assert kv_exists("key") is True
+
+    def test_take_returns_value_and_removes(self, sqlite_db):
+        from app.sqlite_kv import kv_exists, kv_set, kv_take
+
+        kv_set("take-me", "payload")
+        result = kv_take("take-me")
+        assert result == "payload"
+        assert kv_exists("take-me") is False
+
+    def test_take_missing_key_returns_none(self, sqlite_db):
+        from app.sqlite_kv import kv_take
+
+        assert kv_take("gone") is None
+
+    def test_take_is_atomic(self, sqlite_db):
+        """Two consecutive takes: only the first should get the value."""
+        from app.sqlite_kv import kv_set, kv_take
+
+        kv_set("once", "value")
+        first = kv_take("once")
+        second = kv_take("once")
+        assert first == "value"
+        assert second is None
+
+    def test_ttl_expiry(self, sqlite_db):
+        """Expired keys should not be returned by kv_get."""
+        from app.sqlite_kv import kv_get, kv_set
+
+        # Set with 1-second TTL
+        kv_set("ephemeral", "data", ttl_seconds=1)
+        assert kv_get("ephemeral") == "data"
+
+        # Wait for expiry (2s to account for SQLite datetime second resolution)
+        time.sleep(2.0)
+        assert kv_get("ephemeral") is None
+
+    def test_take_expired_key_returns_none(self, sqlite_db):
+        from app.sqlite_kv import kv_set, kv_take
+
+        kv_set("exp", "data", ttl_seconds=1)
+        time.sleep(2.0)
+        assert kv_take("exp") is None
+
+
+# ===========================================================================
+# Idempotency lock tests
+# ===========================================================================
+
+
+class TestIdempotencyLock:
+    """Tests for idempotency_try_acquire / get_lock / store_result / get_result / release_lock."""
+
+    def test_acquire_lock(self, sqlite_db):
+        from app.sqlite_kv import idempotency_try_acquire
+
+        assert idempotency_try_acquire("key1", "lock-a", 60) is True
+
+    def test_double_acquire_fails(self, sqlite_db):
+        from app.sqlite_kv import idempotency_try_acquire
+
+        assert idempotency_try_acquire("key1", "lock-a", 60) is True
+        assert idempotency_try_acquire("key1", "lock-b", 60) is False
+
+    def test_get_lock_value(self, sqlite_db):
+        from app.sqlite_kv import idempotency_get_lock, idempotency_try_acquire
+
+        idempotency_try_acquire("key1", "my-lock", 60)
+        assert idempotency_get_lock("key1") == "my-lock"
+
+    def test_get_lock_missing_returns_none(self, sqlite_db):
+        from app.sqlite_kv import idempotency_get_lock
+
+        assert idempotency_get_lock("missing") is None
+
+    def test_store_and_get_result(self, sqlite_db):
+        from app.sqlite_kv import (
+            idempotency_get_result,
+            idempotency_store_result,
+            idempotency_try_acquire,
+        )
+
+        idempotency_try_acquire("key1", "lock", 60)
+        idempotency_store_result("key1", '{"status": "ok"}', 300)
+        assert idempotency_get_result("key1") == '{"status": "ok"}'
+
+    def test_store_result_clears_lock(self, sqlite_db):
+        from app.sqlite_kv import (
+            idempotency_get_lock,
+            idempotency_store_result,
+            idempotency_try_acquire,
+        )
+
+        idempotency_try_acquire("key1", "lock", 60)
+        idempotency_store_result("key1", "result", 300)
+        assert idempotency_get_lock("key1") is None
+
+    def test_release_lock_deletes_entry(self, sqlite_db):
+        from app.sqlite_kv import (
+            idempotency_get_lock,
+            idempotency_release_lock,
+            idempotency_try_acquire,
+        )
+
+        idempotency_try_acquire("key1", "lock", 60)
+        idempotency_release_lock("key1")
+        assert idempotency_get_lock("key1") is None
+
+    def test_release_lock_preserves_result(self, sqlite_db):
+        """Release should not delete entries that have a stored result."""
+        from app.sqlite_kv import (
+            idempotency_get_result,
+            idempotency_release_lock,
+            idempotency_store_result,
+            idempotency_try_acquire,
+        )
+
+        idempotency_try_acquire("key1", "lock", 60)
+        idempotency_store_result("key1", "cached", 300)
+        idempotency_release_lock("key1")
+        assert idempotency_get_result("key1") == "cached"
+
+    def test_get_result_missing_returns_none(self, sqlite_db):
+        from app.sqlite_kv import idempotency_get_result
+
+        assert idempotency_get_result("nope") is None
+
+
+# ===========================================================================
+# Rate limit tests
+# ===========================================================================
+
+
+class TestRateLimit:
+    """Tests for rate_limit_check_and_record / rate_limit_check_only."""
+
+    def test_first_request_returns_zero_cost(self, sqlite_db):
+        from app.sqlite_kv import rate_limit_check_and_record
+
+        current_cost, _ = rate_limit_check_and_record(
+            "client-1", cost=5, window_seconds=60
+        )
+        assert current_cost == 0
+
+    def test_cost_accumulates(self, sqlite_db):
+        from app.sqlite_kv import rate_limit_check_and_record
+
+        rate_limit_check_and_record("client-1", cost=5, window_seconds=60)
+        current_cost, _ = rate_limit_check_and_record(
+            "client-1", cost=3, window_seconds=60
+        )
+        assert current_cost == 5
+
+    def test_different_clients_isolated(self, sqlite_db):
+        from app.sqlite_kv import rate_limit_check_and_record
+
+        rate_limit_check_and_record("client-a", cost=10, window_seconds=60)
+        current_cost, _ = rate_limit_check_and_record(
+            "client-b", cost=1, window_seconds=60
+        )
+        assert current_cost == 0
+
+    def test_check_only_does_not_record(self, sqlite_db):
+        from app.sqlite_kv import rate_limit_check_and_record, rate_limit_check_only
+
+        rate_limit_check_and_record("client-1", cost=5, window_seconds=60)
+        cost1, _ = rate_limit_check_only("client-1", window_seconds=60)
+        cost2, _ = rate_limit_check_only("client-1", window_seconds=60)
+        assert cost1 == cost2 == 5
+
+    def test_expired_entries_cleaned(self, sqlite_db):
+        from app.sqlite_kv import rate_limit_check_and_record
+
+        # Record with 1-second window (expires quickly)
+        rate_limit_check_and_record("client-1", cost=10, window_seconds=1)
+        time.sleep(1.5)
+
+        # After expiry, cost should be zero
+        current_cost, _ = rate_limit_check_and_record(
+            "client-1", cost=1, window_seconds=60
+        )
+        assert current_cost == 0
+
+    def test_oldest_time_returned(self, sqlite_db):
+        from app.sqlite_kv import rate_limit_check_and_record
+
+        before = time.time()
+        rate_limit_check_and_record("client-1", cost=1, window_seconds=60)
+        _, oldest_time = rate_limit_check_and_record(
+            "client-1", cost=1, window_seconds=60
+        )
+        assert oldest_time >= before

package/app/backend/tests/test_sqlite_worker.py

@@ -0,0 +1,353 @@
+"""Tests for sqlite_worker module - in-process job runner backed by SQLite."""
+
+import json
+import sqlite3
+import threading
+import time
+from unittest.mock import patch
+
+import pytest
+
+# ---------------------------------------------------------------------------
+# Fixture: temp SQLite DB with job_queue table + patched _DB_PATH
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def sqlite_db(tmp_path):
+    """Create a temporary SQLite DB with job_queue table."""
+    db_path = str(tmp_path / "test_worker.db")
+    conn = sqlite3.connect(db_path)
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("""
+        CREATE TABLE job_queue (
+            id TEXT PRIMARY KEY,
+            task_name TEXT NOT NULL,
+            args_json TEXT NOT NULL DEFAULT '[]',
+            status TEXT NOT NULL DEFAULT 'pending',
+            claimed_by TEXT,
+            claimed_at TIMESTAMP,
+            completed_at TIMESTAMP,
+            result_json TEXT,
+            priority INTEGER NOT NULL DEFAULT 0,
+            created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    conn.execute("""
+        CREATE INDEX ix_job_queue_status ON job_queue(status)
+    """)
+    conn.execute("""
+        CREATE INDEX ix_job_queue_claim_order
+            ON job_queue(status, priority, created_at)
+    """)
+    conn.commit()
+    conn.close()
+
+    with (
+        patch("app.sqlite_kv._DB_PATH", db_path),
+        patch("app.services.sqlite_worker._DB_PATH", db_path),
+    ):
+        yield db_path
+
+
+def _insert_task(
+    db_path: str, task_id: str, task_name: str, args: list, priority: int = 0
+):
+    """Helper to insert a pending task."""
+    conn = sqlite3.connect(db_path)
+    conn.execute(
+        "INSERT INTO job_queue (id, task_name, args_json, status, priority, created_at) "
+        "VALUES (?, ?, ?, 'pending', ?, datetime('now'))",
+        (task_id, task_name, json.dumps(args), priority),
+    )
+    conn.commit()
+    conn.close()
+
+
+def _get_task_status(db_path: str, task_id: str) -> str | None:
+    """Helper to read task status."""
+    conn = sqlite3.connect(db_path)
+    row = conn.execute(
+        "SELECT status FROM job_queue WHERE id = ?", (task_id,)
+    ).fetchone()
+    conn.close()
+    return row[0] if row else None
+
+
+# ===========================================================================
+# SQLiteWorker unit tests (no background threads)
+# ===========================================================================
+
+
+class TestWorkerClaimTask:
+    """Test atomic task claiming without starting the poll loop."""
+
+    def test_claim_pending_task(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        _insert_task(sqlite_db, "t1", "execute_ticket", ["job-1"])
+
+        worker = SQLiteWorker()
+        claimed = worker._claim_next_task()
+        assert claimed is not None
+        task_id, task_name, args_json = claimed
+        assert task_id == "t1"
+        assert task_name == "execute_ticket"
+        assert json.loads(args_json) == ["job-1"]
+
+    def test_claim_returns_none_when_empty(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        worker = SQLiteWorker()
+        assert worker._claim_next_task() is None
+
+    def test_claim_skips_already_claimed(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        _insert_task(sqlite_db, "t1", "execute_ticket", ["j1"])
+
+        worker = SQLiteWorker()
+        first = worker._claim_next_task()
+        assert first is not None
+
+        second = worker._claim_next_task()
+        assert second is None
+
+    def test_claim_respects_priority(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        _insert_task(sqlite_db, "low", "execute_ticket", ["j-low"], priority=0)
+        _insert_task(sqlite_db, "high", "execute_ticket", ["j-high"], priority=10)
+
+        worker = SQLiteWorker()
+        claimed = worker._claim_next_task()
+        assert claimed[0] == "high"
+
+    def test_claim_marks_status_as_claimed(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        _insert_task(sqlite_db, "t1", "execute_ticket", ["j1"])
+        worker = SQLiteWorker()
+        worker._claim_next_task()
+
+        assert _get_task_status(sqlite_db, "t1") == "claimed"
+
+
+class TestWorkerMarkResults:
+    """Test _mark_completed and _mark_failed."""
+
+    def test_mark_completed(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        _insert_task(sqlite_db, "t1", "execute_ticket", ["j1"])
+
+        worker = SQLiteWorker()
+        worker._mark_completed("t1", {"status": "ok"})
+
+        conn = sqlite3.connect(sqlite_db)
+        row = conn.execute(
+            "SELECT status, result_json, completed_at FROM job_queue WHERE id = 't1'"
+        ).fetchone()
+        conn.close()
+
+        assert row[0] == "completed"
+        assert json.loads(row[1]) == {"status": "ok"}
+        assert row[2] is not None
+
+    def test_mark_completed_none_result(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        _insert_task(sqlite_db, "t1", "execute_ticket", ["j1"])
+        worker = SQLiteWorker()
+        worker._mark_completed("t1", None)
+
+        conn = sqlite3.connect(sqlite_db)
+        row = conn.execute(
+            "SELECT status, result_json FROM job_queue WHERE id = 't1'"
+        ).fetchone()
+        conn.close()
+
+        assert row[0] == "completed"
+        assert row[1] is None
+
+    def test_mark_failed(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        _insert_task(sqlite_db, "t1", "execute_ticket", ["j1"])
+        worker = SQLiteWorker()
+        worker._mark_failed("t1", "Something went wrong")
+
+        conn = sqlite3.connect(sqlite_db)
+        row = conn.execute(
+            "SELECT status, result_json FROM job_queue WHERE id = 't1'"
+        ).fetchone()
+        conn.close()
+
+        assert row[0] == "failed"
+        result = json.loads(row[1])
+        assert "Something went wrong" in result["error"]
+
+
+class TestWorkerTaskRegistration:
+    """Test register_task and register_periodic."""
+
+    def test_register_task(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        worker = SQLiteWorker()
+        worker.register_task("my_task", lambda x: x)
+        assert "my_task" in worker._tasks
+
+    def test_register_periodic(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        worker = SQLiteWorker()
+        worker.register_periodic("heartbeat", 10.0, lambda: None)
+        assert len(worker._periodic_tasks) == 1
+        assert worker._periodic_tasks[0][0] == "heartbeat"
+
+
+# ===========================================================================
+# SQLiteWorker integration tests (with background threads)
+# ===========================================================================
+
+
+class TestWorkerExecution:
+    """Test full task execution with worker start/stop."""
+
+    def test_worker_executes_task(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        results = []
+
+        def my_task(job_id):
+            results.append(job_id)
+            return {"done": True}
+
+        worker = SQLiteWorker(poll_interval=0.1)
+        worker.register_task("test_task", my_task)
+
+        _insert_task(sqlite_db, "t1", "test_task", ["job-abc"])
+
+        worker.start()
+        try:
+            # Wait for task execution (up to 3 seconds)
+            for _ in range(30):
+                if _get_task_status(sqlite_db, "t1") == "completed":
+                    break
+                time.sleep(0.1)
+
+            assert _get_task_status(sqlite_db, "t1") == "completed"
+            assert results == ["job-abc"]
+        finally:
+            worker.stop()
+
+    def test_worker_handles_task_failure(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        def failing_task(job_id):
+            raise ValueError("boom")
+
+        worker = SQLiteWorker(poll_interval=0.1)
+        worker.register_task("bad_task", failing_task)
+
+        _insert_task(sqlite_db, "t1", "bad_task", ["j1"])
+
+        worker.start()
+        try:
+            for _ in range(30):
+                status = _get_task_status(sqlite_db, "t1")
+                if status == "failed":
+                    break
+                time.sleep(0.1)
+
+            assert _get_task_status(sqlite_db, "t1") == "failed"
+        finally:
+            worker.stop()
+
+    def test_worker_handles_unknown_task(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        worker = SQLiteWorker(poll_interval=0.1)
+        # Don't register any tasks
+
+        _insert_task(sqlite_db, "t1", "unknown_task", ["j1"])
+
+        worker.start()
+        try:
+            for _ in range(30):
+                status = _get_task_status(sqlite_db, "t1")
+                if status == "failed":
+                    break
+                time.sleep(0.1)
+
+            assert _get_task_status(sqlite_db, "t1") == "failed"
+        finally:
+            worker.stop()
+
+    def test_worker_executes_multiple_tasks_in_order(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        order = []
+
+        def tracking_task(job_id):
+            order.append(job_id)
+            return {"ok": True}
+
+        worker = SQLiteWorker(poll_interval=0.1)
+        worker.register_task("track", tracking_task)
+
+        # Insert tasks with increasing time
+        for i in range(3):
+            _insert_task(sqlite_db, f"t{i}", "track", [f"job-{i}"])
+
+        worker.start()
+        try:
+            for _ in range(60):
+                conn = sqlite3.connect(sqlite_db)
+                completed = conn.execute(
+                    "SELECT COUNT(*) FROM job_queue WHERE status = 'completed'"
+                ).fetchone()[0]
+                conn.close()
+                if completed == 3:
+                    break
+                time.sleep(0.1)
+
+            assert len(order) == 3
+        finally:
+            worker.stop()
+
+    def test_worker_start_stop_idempotent(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        worker = SQLiteWorker(poll_interval=0.1)
+        worker.register_task("noop", lambda: None)
+
+        # Double start
+        worker.start()
+        worker.start()
+
+        # Double stop
+        worker.stop()
+        worker.stop()
+
+    def test_periodic_task_runs(self, sqlite_db):
+        from app.services.sqlite_worker import SQLiteWorker
+
+        call_count = {"n": 0}
+        lock = threading.Lock()
+
+        def periodic_fn():
+            with lock:
+                call_count["n"] += 1
+
+        worker = SQLiteWorker(poll_interval=0.1)
+        worker.register_periodic("ticker", 0.2, periodic_fn)
+
+        worker.start()
+        try:
+            time.sleep(1.0)
+            with lock:
+                assert call_count["n"] >= 2, f"Periodic ran {call_count['n']} times"
+        finally:
+            worker.stop()