| """Registering without an account must create something that can do nothing. |
| |
| Pairing runs the other way round now: a worker invents a code, prints it, and |
| registers here, and somebody signed in enters that code to claim it. That makes |
| ``register_unclaimed`` the only entry point on this server that needs no |
| account, so every test below is about the same question -- what can a caller do |
| with a record nobody has claimed? The answer has to be "nothing". |
| """ |
|
|
| from __future__ import annotations |
|
|
| import pytest |
|
|
| from distinct_server.control_plane import UNASSIGNED_AGENT, ControlPlane |
| from distinct_server.models import ( |
| AgentCapabilities, |
| AuthenticationError, |
| CapacityError, |
| ConflictError, |
| ) |
| from distinct_server.security import new_access_code, new_pairing_code |
|
|
|
|
| def _caps(name: str = "worker") -> AgentCapabilities: |
| return AgentCapabilities( |
| agent_id="", |
| name=name, |
| os="linux", |
| arch="x64", |
| cpu="test", |
| ram_gb=8.0, |
| models=("m1",), |
| tools=(), |
| energy_provider="test meter", |
| ) |
|
|
|
|
| @pytest.fixture() |
| def plane() -> ControlPlane: |
| return ControlPlane() |
|
|
|
|
| def test_an_unclaimed_worker_is_invisible_to_everyone(plane: ControlPlane) -> None: |
| plane.register_unclaimed(_caps(), new_pairing_code()) |
| assert plane.list_agents() == () |
| assert plane.list_agents(viewer_id="user:alice") == () |
| assert plane.list_agents(viewer_id="user:mallory") == () |
|
|
|
|
| def test_an_unclaimed_workers_access_code_grants_nothing(plane: ControlPlane) -> None: |
| """Otherwise a stranger takes a share of a machine still being set up.""" |
|
|
| access = new_access_code() |
| plane.register_unclaimed(_caps(), new_pairing_code(), access_code=access) |
| with pytest.raises(AuthenticationError): |
| plane.redeem_access_code(access, "user:mallory") |
|
|
|
|
| def test_claiming_requires_an_account(plane: ControlPlane) -> None: |
| code = new_pairing_code() |
| plane.register_unclaimed(_caps(), code) |
| with pytest.raises(AuthenticationError): |
| plane.claim_agent(code, "") |
| with pytest.raises(AuthenticationError): |
| plane.claim_agent(code, " ") |
|
|
|
|
| def test_a_wrong_code_says_nothing_about_why(plane: ControlPlane) -> None: |
| plane.register_unclaimed(_caps(), new_pairing_code()) |
| with pytest.raises(AuthenticationError) as caught: |
| plane.claim_agent(new_pairing_code(), "user:alice") |
| assert str(caught.value) == "that code is not valid" |
|
|
|
|
| def test_claiming_makes_the_worker_real(plane: ControlPlane) -> None: |
| code = new_pairing_code() |
| access = new_access_code() |
| credential = plane.register_unclaimed(_caps(), code, access_code=access) |
| assert plane.claim_state(credential.agent_id) == "waiting" |
|
|
| assert plane.claim_agent(code, "user:alice") == credential.agent_id |
| assert plane.claim_state(credential.agent_id) == "claimed" |
| assert len(plane.list_agents()) == 1 |
| |
| assert plane.redeem_access_code(access, "user:bob") == credential.agent_id |
|
|
|
|
| def test_a_claim_code_is_used_once(plane: ControlPlane) -> None: |
| code = new_pairing_code() |
| plane.register_unclaimed(_caps(), code) |
| plane.claim_agent(code, "user:alice") |
| with pytest.raises(AuthenticationError): |
| plane.claim_agent(code, "user:bob") |
|
|
|
|
| def test_two_workers_cannot_wait_on_one_code(plane: ControlPlane) -> None: |
| """An ambiguous claim is worse than a refused registration.""" |
|
|
| code = new_pairing_code() |
| plane.register_unclaimed(_caps("first"), code) |
| with pytest.raises(ConflictError): |
| plane.register_unclaimed(_caps("second"), code) |
|
|
|
|
| def test_an_unclaimed_worker_expires(plane: ControlPlane) -> None: |
| code = new_pairing_code() |
| credential = plane.register_unclaimed(_caps(), code, now=1000.0) |
| later = 1000.0 + plane.limits.claim_ttl_seconds + 1 |
| assert plane.claim_state(credential.agent_id, now=later) == "gone" |
| with pytest.raises(AuthenticationError): |
| plane.claim_agent(code, "user:alice", now=later) |
|
|
|
|
| def test_the_unclaimed_pool_is_bounded(plane: ControlPlane) -> None: |
| """The one unauthenticated write on this server cannot be accumulated.""" |
|
|
| for _ in range(plane.limits.max_unclaimed_agents * 3): |
| plane.register_unclaimed(_caps(), new_pairing_code()) |
| waiting = sum(1 for r in plane._agents.values() if r.claim_digest) |
| assert waiting <= plane.limits.max_unclaimed_agents |
|
|
|
|
| def test_a_flood_never_locks_a_real_volunteer_out(plane: ControlPlane) -> None: |
| """A full pool evicts its oldest waiter rather than refusing everybody. |
| |
| Refusing is what an attacker filling the pool is trying to buy: the feature |
| turned off for real users. The oldest waiter loses its slot instead, and a |
| flood mostly evicts its own earlier entries. |
| """ |
|
|
| for index in range(plane.limits.max_unclaimed_agents): |
| plane.register_unclaimed(_caps(f"flood{index}"), new_pairing_code(), now=1000.0 + index) |
|
|
| mine = new_pairing_code() |
| credential = plane.register_unclaimed(_caps("volunteer"), mine, now=2000.0) |
| assert plane.claim_state(credential.agent_id, now=2000.0) == "waiting" |
| assert plane.claim_agent(mine, "user:alice", now=2000.0) == credential.agent_id |
|
|
|
|
| def test_the_registry_itself_still_has_a_hard_ceiling(plane: ControlPlane) -> None: |
| """Eviction bounds the unclaimed pool; claimed agents are still capped.""" |
|
|
| codes = [new_pairing_code() for _ in range(plane.limits.max_unclaimed_agents)] |
| for index, code in enumerate(codes): |
| plane.register_unclaimed(_caps(f"w{index}"), code) |
| for index, code in enumerate(codes): |
| plane.claim_agent(code, f"user:{index}") |
| made = len(codes) |
| with pytest.raises(CapacityError): |
| while made < plane.limits.max_agents + 10: |
| code = new_pairing_code() |
| plane.register_unclaimed(_caps(), code) |
| plane.claim_agent(code, "user:alice") |
| made += 1 |
| assert made == plane.limits.max_agents |
|
|
|
|
| def test_expiry_frees_the_ceiling(plane: ControlPlane) -> None: |
| for _ in range(plane.limits.max_unclaimed_agents): |
| plane.register_unclaimed(_caps(), new_pairing_code(), now=1000.0) |
| later = 1000.0 + plane.limits.claim_ttl_seconds + 1 |
| plane.register_unclaimed(_caps(), new_pairing_code(), now=later) |
|
|
|
|
| def test_no_job_can_be_sent_to_an_unclaimed_worker(plane: ControlPlane) -> None: |
| """The visibility gate is what dispatch consults, so this is the proof.""" |
|
|
| credential = plane.register_unclaimed(_caps(), new_pairing_code()) |
| session = plane.create_session() |
| conversation = plane.create_conversation(session.session_id) |
| job = plane.submit_job( |
| session.session_id, |
| conversation.conversation_id, |
| "hello", |
| "m1", |
| viewer_id="user:alice", |
| ) |
| |
| |
| assert job.spec.target_agent_id != credential.agent_id |
| assert job.spec.target_agent_id == UNASSIGNED_AGENT |
|
|
