Zo doen wijdat in oost

2026-10-16 07:20:44 +02:00
parent 25d9cb1c7d
commit 6f80a820da
229 changed files with 23894 additions and 74 deletions
@@ -225,3 +225,170 @@ def test_ip_is_only_ever_stored_hashed():
    assert "203" not in digest and len(digest) == 32
    assert store.hash_ip("203.0.113.9") == digest
    assert store.hash_ip("") == ""
+
+
+def queue_one(url="https://reddit.com/r/x", caller="c1"):
+    return store.enqueue_request("user", caller, url, "GET", "reddit", "any")
+
+
+def test_the_queue_is_bounded(local_db):
+    get_table("node_requests").delete()
+    for _ in range(LIMITS.max_queue_depth):
+        queue_one()
+    with pytest.raises(store.QueueFull):
+        queue_one()
+    assert store.count_open_requests() == LIMITS.max_queue_depth
+    first = store.list_queued(1)[0]
+    store.fail_request(first["uid"], "x")
+    queue_one()
+    get_table("node_requests").delete()
+
+
+def test_a_request_is_claimed_by_exactly_one_assignment(local_db):
+    get_table("node_requests").delete()
+    uid = queue_one()
+    assert store.claim_request(uid, "device-a") is True
+    assert store.claim_request(uid, "device-b") is False
+    assert store.get_request(uid)["device_uid"] == "device-a"
+    get_table("node_requests").delete()
+
+
+def test_a_result_can_only_land_on_an_assigned_request(local_db):
+    get_table("node_requests").delete()
+    uid = queue_one()
+    done = dict(result_status=200, result_headers="{}", result_body="eA==", result_bytes=1, truncated=False)
+    assert store.finish_request(uid, **done) is False
+    store.claim_request(uid, "d")
+    assert store.finish_request(uid, **done) is True
+    assert store.finish_request(uid, **done) is False
+    assert store.fail_request(uid, "late") is False
+    assert store.get_request(uid)["status"] == "done"
+    get_table("node_requests").delete()
+
+
+def test_expiry_separates_waiting_from_stuck_requests(local_db):
+    get_table("node_requests").delete()
+    waiting, stuck, fresh = queue_one(), queue_one(), queue_one()
+    store.claim_request(stuck, "d")
+    later = datetime.now(timezone.utc) + timedelta(
+        seconds=LIMITS.job_timeout_seconds + LIMITS.job_grace_seconds + LIMITS.queue_max_wait_seconds + 1
+    )
+    counts = store.expire_requests(later)
+    assert counts == {"queued": 2, "assigned": 1}
+    assert store.get_request(waiting)["status"] == "expired"
+    assert store.get_request(stuck)["error"] == "timeout"
+    assert store.get_request(fresh)["status"] == "expired"
+    assert store.expire_requests(later) == {"queued": 0, "assigned": 0}
+    get_table("node_requests").delete()
+
+
+def test_requests_are_listed_oldest_first_and_limited(local_db):
+    get_table("node_requests").delete()
+    uids = [queue_one() for _ in range(5)]
+    assert [row["uid"] for row in store.list_queued(3)] == uids[:3]
+    get_table("node_requests").delete()
+
+
+def test_request_garbage_collection_leaves_recent_rows(local_db):
+    get_table("node_requests").delete()
+    queue_one()
+    assert store.prune_requests() == 0
+    far = datetime.now(timezone.utc) + timedelta(seconds=LIMITS.request_retention_seconds + 5)
+    assert store.prune_requests(dry_run=True, moment=far) == 1
+    assert store.prune_requests(moment=far) == 1
+
+
+def test_caller_quota_counts_exactly_to_the_limit(local_db):
+    caller = generate_uid()
+    results = [store.reserve_caller_request("user", caller, 5) for _ in range(9)]
+    assert results.count(True) == 5
+    assert store.caller_requests_today("user", caller) == 5
+
+
+def test_a_zero_quota_or_anonymous_caller_never_reserves(local_db):
+    assert not store.reserve_caller_request("guest", "someone", 0)
+    assert not store.reserve_caller_request("user", "", 10)
+    assert store.caller_requests_today("guest", "someone") == 0
+
+
+def test_caller_quota_is_per_caller_and_per_day(local_db):
+    a, b = generate_uid(), generate_uid()
+    for _ in range(3):
+        assert store.reserve_caller_request("user", a, 3)
+    assert not store.reserve_caller_request("user", a, 3)
+    assert store.reserve_caller_request("user", b, 3)
+    tomorrow = datetime.now(timezone.utc) + timedelta(days=1)
+    assert store.reserve_caller_request("user", a, 3, moment=tomorrow)
+    assert store.reserve_caller_request("guest", a, 3)
+
+
+def test_caller_counters_are_pruned_with_the_usage_buckets(local_db):
+    caller = generate_uid()
+    store.reserve_caller_request("user", caller, 5)
+    far = datetime.now(timezone.utc) + timedelta(days=LIMITS.usage_daily_retention_days + 2)
+    assert store.prune_usage_daily(dry_run=True, moment=far) >= 1
+    assert store.caller_requests_today("user", caller) == 1
+    store.prune_usage_daily(moment=far)
+    assert store.caller_requests_today("user", caller) == 0
+
+
+def test_batch_helpers_match_the_single_lookups(local_db):
+    owner = generate_uid()
+    row, _ = store.create_device(owner, "a", "native")
+    store.save_node_settings(owner, {"enabled": True, "bandwidth_mb_day": 7})
+    assert store.get_devices_by_uids([row["uid"], "missing", ""])[row["uid"]]["user_uid"] == owner
+    assert store.get_enabled_by_users([owner, "nobody"]) == {owner: True}
+    assert store.get_settings_by_users([owner])[owner]["bandwidth_mb_day"] == 7
+    assert store.get_devices_by_uids([]) == {}
+
+
+def test_batch_helpers_ignore_revoked_devices(local_db):
+    owner = generate_uid()
+    row, _ = store.create_device(owner, "a", "native")
+    store.revoke_device(row["uid"], owner)
+    assert store.get_devices_by_uids([row["uid"]]) == {}
+
+
+def test_device_breakdown_buckets_blank_values_as_unknown(local_db):
+    owner = generate_uid()
+    store.create_device(owner, "a", "native")
+    store.create_device(owner, "b", "extension")
+    kinds = store.device_breakdown("kind")
+    assert kinds["native"] >= 1 and kinds["extension"] >= 1
+    assert "unknown" in store.device_breakdown("country")
+    with pytest.raises(ValueError):
+        store.device_breakdown("secret_hash")
+
+
+def test_device_breakdown_ignores_revoked_devices(local_db):
+    owner = generate_uid()
+    row, _ = store.create_device(owner, "a", "native")
+    before = store.device_breakdown("status").get("active", 0)
+    store.revoke_device(row["uid"], owner)
+    assert store.device_breakdown("status").get("active", 0) == before - 1
+
+
+def test_request_status_counts_always_lists_every_status(local_db):
+    counts = store.request_status_counts()
+    assert set(store.REQUEST_STATUSES) <= set(counts)
+    assert all(value >= 0 for value in counts.values())
+
+
+def test_usage_day_totals_sums_the_day(local_db):
+    owner = generate_uid()
+    row, _ = store.create_device(owner, "a", "native")
+    before = store.usage_day_totals()
+    store.record_job(row["uid"], owner, ok=True, bytes_up=10, bytes_down=90)
+    after = store.usage_day_totals()
+    assert after["requests_ok"] == before["requests_ok"] + 1
+    assert after["bytes_down"] == before["bytes_down"] + 90
+
+
+def test_recent_devices_is_capped_and_excludes_deleted(local_db):
+    owner = generate_uid()
+    row, _ = store.create_device(owner, "a", "native")
+    assert row["uid"] in {item["uid"] for item in store.recent_devices(store.ADMIN_LIST_LIMIT)}
+    assert len(store.recent_devices(1)) == 1
+    assert len(store.recent_devices(10_000)) <= store.ADMIN_LIST_LIMIT
+    store.revoke_device(row["uid"], owner)
+    assert row["uid"] not in {item["uid"] for item in store.recent_devices(store.ADMIN_LIST_LIMIT)}