Open-source AI teammates in Slack, Teams, Discord, Telegram and Mattermost. Self-host it, with any agent harness and any model.
Python agent-orchestrationaiai-agentschatopsdiscordlangchainmcpmicrosoft-teamsmulti-agentopen-sourceopenaiself-hostedslack
import json
from datetime import UTC, datetime
from unittest.mock import Mock, patch
from uuid import NAMESPACE_URL, uuid5
import pytest
from test_controller import (
CORE_FIXTURES,
MACHINE_ID,
config,
fixture_config,
insert_machine,
)
from switch_hosted_controller.config import ConfigError
from switch_hosted_controller.gateway import (
CoreMachine,
Gateway,
GatewayConfig,
GatewayError,
bundle_token,
)
from switch_hosted_controller.model import DesiredState, ObservedState
from switch_hosted_controller.store import CapacityError, MachineStore
VOLUME_ID = "vol-0123456789abcdef0"
CODE = "swce_SyntheticEnrollmentCode0000"
SEAT = "5e1c2b4a-0000-4000-8000-0000000000a1"
OTHER_MACHINE_ID = "3f1c2b4a-0000-4000-8000-000000000002"
def core_machine(**overrides) -> dict:
return {
"machine_id": MACHINE_ID,
"state": "provisioning",
"desired_state": "running",
"revision": 1,
"data_volume_id": None,
"retain_until": None,
"bundle_revision": None,
**overrides,
}
def prepared_machine(**overrides) -> dict:
return {
"machine_id": MACHINE_ID,
"revision": 1,
"bundle_revision": 1,
"api_endpoint": "https://switch.example.test/agent-api",
"controllers": [{"key": SEAT, "id": None, "enrollment_code": CODE}],
**overrides,
}
def make_gateway(cfg, store, instance_type="m6i.large") -> Gateway:
return Gateway(
GatewayConfig("https://switch.example.test", "SYNTHETIC-CONTROLLER", instance_type),
cfg,
store,
)
def open_store(cfg) -> MachineStore:
return MachineStore(cfg.state_db_path, cfg.fingerprint())
def routed(machines: list[dict], prepared: dict | None = None) -> Mock:
def request(path, body=None):
if path == "/machines":
return {"machines": machines}
if path.endswith("/prepare"):
return prepared
return {}
return Mock(side_effect=request)
def at_rest(store: MachineStore, machine_id: str, desired: DesiredState, observed: ObservedState):
claim = store.set_desired(machine_id, desired, None)
return store.set_observed(claim, observed, None)
def delete_fully(store: MachineStore, machine_id: str) -> None:
at_rest(store, machine_id, DesiredState.STOPPED, ObservedState.STOPPED)
claim = store.set_desired(machine_id, DesiredState.DELETED, None)
store.set_observed(claim, ObservedState.DELETED, None)
def test_launch_retry_reuses_the_row_and_prepares_once(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
gateway.request = routed([core_machine()], prepared_machine())
gateway.sync_machines(gateway.machines())
machine = store.get(MACHINE_ID)
assert (machine.instance_type, machine.image_id) == ("m6i.large", cfg.image_id)
assert (machine.bundle_token, machine.bundle) == (None, None)
assert not any(call.args[0].endswith("/prepare") for call in gateway.request.call_args_list)
store.record_volume(MACHINE_ID, VOLUME_ID, cfg.availability_zone)
for _ in range(3):
gateway.sync_machines(gateway.machines())
assert len(store.list()) == 1
assert sum(call.args[0].endswith("/prepare") for call in gateway.request.call_args_list) == 1
machine = store.get(MACHINE_ID)
assert machine.bundle_token == str(uuid5(NAMESPACE_URL, f"{MACHINE_ID}:1"))
assert machine.bundle == json.dumps(
{
"version": 5,
"installationId": cfg.installation_id,
"machineId": MACHINE_ID,
"dataVolumeId": VOLUME_ID,
"apiEndpoint": "https://switch.example.test/agent-api",
"controllers": [{"key": SEAT, "id": None, "enrollmentCode": CODE}],
},
separators=(",", ":"),
)
store.close()
@pytest.mark.parametrize("endpoint", [None, "http://switch.example.test/agent-api", "https://"])
def test_bundle_refuses_an_invalid_api_endpoint(tmp_path, endpoint):
cfg = config(tmp_path)
store = open_store(cfg)
machine = insert_machine(store, cfg, MACHINE_ID)
with pytest.raises(ConfigError, match="API endpoint"):
make_gateway(cfg, store).bundle(prepared_machine(api_endpoint=endpoint), machine)
store.close()
def test_machine_without_a_controller_writes_no_bundle(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
prepared = prepared_machine()
del prepared["controllers"]
gateway.request = Mock(return_value=prepared)
core = CoreMachine.parse(core_machine())
gateway.sync_machine(core)
store.record_volume(MACHINE_ID, VOLUME_ID, cfg.availability_zone)
with pytest.raises(ConfigError):
gateway.sync_machine(core)
machine = store.get(MACHINE_ID)
assert (machine.bundle_token, machine.bundle) == (None, None)
store.close()
@pytest.mark.parametrize(
"prepared",
[
prepared_machine(machine_id=OTHER_MACHINE_ID),
prepared_machine(bundle_revision=0),
],
)
def test_prepare_for_a_different_machine_or_revision_fails_loud(tmp_path, prepared):
cfg = config(tmp_path)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
gateway.request = Mock(return_value=prepared)
with pytest.raises(ConfigError):
gateway.sync_machine(CoreMachine.parse(core_machine(data_volume_id=VOLUME_ID)))
machine = store.get(MACHINE_ID)
assert (machine.bundle_token, machine.bundle) == (None, None)
store.close()
@pytest.mark.parametrize("failure", [GatewayError(500), RuntimeError("Bundle write failed")])
def test_one_failed_machine_does_not_block_other_machines(tmp_path, failure):
cfg = config(tmp_path, max_machines=2)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
gateway.request = routed([core_machine(), core_machine(machine_id=OTHER_MACHINE_ID)])
gateway.sync_machine = Mock(side_effect=[failure, None])
gateway.sync_machines(gateway.machines())
assert gateway.sync_machine.call_count == 2
assert gateway.request.call_count == 1
gateway.sync_machine.side_effect = [failure, None]
with patch(
"switch_hosted_controller.gateway.monotonic",
return_value=gateway.prepare_failures[MACHINE_ID] + 301,
):
gateway.sync_machines(gateway.machines())
assert gateway.request.call_args_list[-1].args == (
f"/machines/{MACHINE_ID}/observation",
{
"state": "error",
"revision": 1,
"error": "Cloud machine setup failed. Retry; if it still fails, contact your administrator.",
"error_code": None,
"data_volume_id": None,
"instance_id": None,
"instance_type": None,
},
)
store.close()
def test_conflict_during_prepare_is_retried_without_reporting(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
gateway.request = routed([core_machine()])
gateway.sync_machine = Mock(side_effect=GatewayError(409))
for _ in range(2):
with patch("switch_hosted_controller.gateway.monotonic", return_value=10_000):
gateway.sync_machines(gateway.machines())
assert gateway.prepare_failures == {}
assert [call.args[0] for call in gateway.request.call_args_list] == ["/machines", "/machines"]
store.close()
def test_rejected_prepare_stops_the_machine_and_reports_the_detail(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
insert_machine(store, cfg, MACHINE_ID)
store.record_volume(MACHINE_ID, VOLUME_ID, cfg.availability_zone)
def request(path, body=None):
if path == "/machines":
return {"machines": [core_machine()]}
if path.endswith("/prepare"):
raise GatewayError(422, "Owner is no longer a member.")
return {}
gateway.request = Mock(side_effect=request)
gateway.sync_machines(gateway.machines())
assert store.get(MACHINE_ID).desired_state is DesiredState.STOPPED
assert gateway.request.call_args_list[-1].args == (
f"/machines/{MACHINE_ID}/observation",
{
"state": "error",
"revision": 1,
"error": "Owner is no longer a member.",
"error_code": None,
"data_volume_id": VOLUME_ID,
"instance_id": None,
"instance_type": "m6i.large",
},
)
store.close()
def test_error_machine_being_deleted_is_still_reported(tmp_path):
cfg = config(tmp_path, max_machines=2)
store = open_store(cfg)
insert_machine(store, cfg, MACHINE_ID)
delete_fully(store, MACHINE_ID)
insert_machine(store, cfg, OTHER_MACHINE_ID)
gateway = make_gateway(cfg, store)
gateway.request = routed(
[
core_machine(state="error", desired_state="deleted", revision=4),
core_machine(machine_id=OTHER_MACHINE_ID, state="error", revision=4),
]
)
gateway.report_observations(gateway.machines())
reports = [call.args for call in gateway.request.call_args_list if call.args[0] != "/machines"]
assert reports == [
(
f"/machines/{MACHINE_ID}/observation",
{
"state": "deleted",
"revision": 1,
"error": None,
"error_code": None,
"data_volume_id": None,
"instance_id": None,
"instance_type": "m6i.large",
},
)
]
store.close()
def core_fixture(name: str) -> dict:
return json.loads((CORE_FIXTURES / name).read_text())
def synced_from_core(tmp_path) -> tuple[MachineStore, Gateway, dict]:
[listed] = core_fixture("machines_response.json")["machines"]
cfg = fixture_config(tmp_path, "c7i.2xlarge")
store = open_store(cfg)
gateway = make_gateway(cfg, store, instance_type="c7i.2xlarge")
gateway.request = routed([listed], core_fixture("prepare_controller_response.json"))
gateway.sync_machines(gateway.machines())
return store, gateway, listed
def test_core_machine_list_and_prepare_produce_the_bundle(tmp_path):
store, gateway, listed = synced_from_core(tmp_path)
prepared = core_fixture("prepare_controller_response.json")
core = CoreMachine.parse(listed)
assert (core.machine_id, core.desired_state) == (listed["machine_id"], "running")
machine = store.get(listed["machine_id"])
assert (machine.core_revision, machine.data_volume_id) == (
listed["revision"],
listed["data_volume_id"],
)
assert machine.bundle_token == bundle_token(listed["machine_id"], listed["revision"])
assert json.loads(machine.bundle) == {
"version": 5,
"installationId": "inst-test",
"machineId": prepared["machine_id"],
"dataVolumeId": listed["data_volume_id"],
"apiEndpoint": prepared["api_endpoint"],
"controllers": [
{"key": entry["key"], "id": entry["id"], "enrollmentCode": entry["enrollment_code"]}
for entry in prepared["controllers"]
],
}
assert prepared["controllers"]
store.close()
def test_running_observation_matches_the_core_fixture(tmp_path):
store, gateway, listed = synced_from_core(tmp_path)
machine = store.get(listed["machine_id"])
store.record_instance(machine.machine_id, "i-0123456789abcdef0", machine.bundle)
store.set_observed(store.get(listed["machine_id"]), ObservedState.RUNNING, None)
gateway.report_observations(gateway.machines())
path, body = gateway.request.call_args_list[-1].args
assert path == f"/machines/{listed['machine_id']}/observation"
assert body == core_fixture("controller_observation.json")
store.close()
@pytest.mark.parametrize(
("observed", "state"),
[
(ObservedState.PENDING, "provisioning"),
(ObservedState.PROVISIONING, "provisioning"),
(ObservedState.RUNNING, "running"),
(ObservedState.STOPPING, "stopping"),
(ObservedState.STOPPED, "stopped"),
(ObservedState.RETAINED, "retained"),
(ObservedState.DELETING, "deleting"),
(ObservedState.DELETED, "deleted"),
(ObservedState.NEEDS_ATTENTION, "error"),
],
)
def test_observed_states_map_onto_core_states(tmp_path, observed, state):
cfg = config(tmp_path)
store = open_store(cfg)
machine = insert_machine(store, cfg, MACHINE_ID)
store.set_observed(machine, observed, "internal detail")
gateway = make_gateway(cfg, store)
gateway.request = routed([core_machine()])
gateway.report_observations(gateway.machines())
body = gateway.request.call_args_list[-1].args[1]
assert body["state"] == state
if state == "error":
assert body["error"] == (
"The cloud machine needs repair. Contact your server administrator."
)
assert body["error_code"] == "machine_needs_attention"
else:
assert body["error"] is None
assert body["error_code"] is None
store.close()
@pytest.mark.parametrize(
("desired", "core_desired", "state"),
[
(DesiredState.RUNNING, "running", "provisioning"),
(DesiredState.STOPPED, "stopped", "stopping"),
(DesiredState.RETAINED, "retained", "stopping"),
(DesiredState.RETAINED, "deleted", "deleting"),
(DesiredState.DELETED, "deleted", "deleting"),
],
)
def test_pending_is_reported_by_desired_state(tmp_path, desired, core_desired, state):
cfg = config(tmp_path)
store = open_store(cfg)
insert_machine(store, cfg, MACHINE_ID)
if desired is DesiredState.DELETED:
at_rest(store, MACHINE_ID, DesiredState.STOPPED, ObservedState.STOPPED)
store.set_desired(MACHINE_ID, desired, None)
assert store.get(MACHINE_ID).observed_state is ObservedState.PENDING
gateway = make_gateway(cfg, store)
gateway.request = routed([core_machine(desired_state=core_desired)])
gateway.report_observations(gateway.machines())
assert gateway.request.call_args_list[-1].args[1]["state"] == state
store.close()
def test_retained_on_the_way_to_deletion_is_reported_as_deleting(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
machine = insert_machine(store, cfg, MACHINE_ID)
store.set_observed(machine, ObservedState.RETAINED, None)
gateway = make_gateway(cfg, store)
gateway.request = routed([core_machine(desired_state="deleted")])
gateway.report_observations(gateway.machines())
assert gateway.request.call_args_list[-1].args[1]["state"] == "deleting"
store.close()
def test_core_desired_states_map_onto_the_row(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
gateway.sync_machine(CoreMachine.parse(core_machine()))
assert store.get(MACHINE_ID).desired_state is DesiredState.RUNNING
gateway.sync_machine(CoreMachine.parse(core_machine(desired_state="stopped", revision=2)))
assert store.get(MACHINE_ID).desired_state is DesiredState.STOPPED
retain_until = "2026-01-08T00:00:00+00:00"
gateway.sync_machine(
CoreMachine.parse(
core_machine(desired_state="retained", revision=3, retain_until=retain_until)
)
)
retained = store.get(MACHINE_ID)
assert retained.desired_state is DesiredState.RETAINED
assert retained.retain_until == datetime(2026, 1, 8, tzinfo=UTC)
assert retained.core_revision == 3
deleted = CoreMachine.parse(
core_machine(desired_state="deleted", revision=4, retain_until=retain_until)
)
gateway.sync_machine(deleted)
assert store.get(MACHINE_ID).desired_state is DesiredState.RETAINED
store.set_observed(store.get(MACHINE_ID), ObservedState.RETAINED, None)
gateway.sync_machine(deleted)
machine = store.get(MACHINE_ID)
assert machine.desired_state is DesiredState.DELETED
assert machine.retain_until == datetime(2026, 1, 8, tzinfo=UTC)
gateway.sync_machine(CoreMachine.parse(core_machine(revision=5)))
assert store.get(MACHINE_ID).desired_state is DesiredState.DELETED
store.close()
def test_deleting_a_running_machine_retains_it_first(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
insert_machine(store, cfg, MACHINE_ID)
gateway = make_gateway(cfg, store)
gateway.sync_machine(CoreMachine.parse(core_machine(desired_state="deleted", revision=2)))
machine = store.get(MACHINE_ID)
assert machine.desired_state is DesiredState.RETAINED
assert machine.retain_until is None
store.close()
def test_running_machine_in_error_is_stopped(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
gateway.sync_machine(CoreMachine.parse(core_machine(state="error")))
assert store.list() == []
insert_machine(store, cfg, MACHINE_ID)
gateway.sync_machine(CoreMachine.parse(core_machine(state="error", revision=2)))
assert store.get(MACHINE_ID).desired_state is DesiredState.STOPPED
store.close()
def test_stale_core_revision_changes_nothing(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
gateway.sync_machine(CoreMachine.parse(core_machine(desired_state="stopped", revision=3)))
gateway.sync_machine(CoreMachine.parse(core_machine(revision=2)))
machine = store.get(MACHINE_ID)
assert machine.desired_state is DesiredState.STOPPED
assert machine.core_revision == 3
store.close()
def test_a_new_machine_takes_the_capacity_a_deleted_one_released(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
insert_machine(store, cfg, MACHINE_ID)
other = CoreMachine.parse(core_machine(machine_id=OTHER_MACHINE_ID))
with pytest.raises(CapacityError):
gateway.sync_machine(other)
at_rest(store, MACHINE_ID, DesiredState.STOPPED, ObservedState.STOPPED)
store.set_desired(MACHINE_ID, DesiredState.DELETED, None)
gateway.sync_machine(other)
assert [machine.machine_id for machine in store.list()] == [MACHINE_ID, OTHER_MACHINE_ID]
assert store.get(OTHER_MACHINE_ID).desired_state is DesiredState.RUNNING
assert store.get(MACHINE_ID).desired_state is DesiredState.DELETED
store.close()
def test_core_data_volume_is_adopted_and_then_cross_checked(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
gateway.request = Mock(return_value=prepared_machine())
gateway.sync_machine(CoreMachine.parse(core_machine(data_volume_id=VOLUME_ID)))
machine = store.get(MACHINE_ID)
assert machine.data_volume_id == VOLUME_ID
assert machine.volume_az == cfg.availability_zone
other = CoreMachine.parse(core_machine(data_volume_id="vol-0fedcba9876543210"))
with pytest.raises(ConfigError, match="different data volume"):
gateway.sync_machine(other)
store.close()
def test_capacity_counts_machines_before_inserting(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
gateway.sync_machine(CoreMachine.parse(core_machine(desired_state="stopped")))
second = CoreMachine.parse(core_machine(machine_id=OTHER_MACHINE_ID))
with pytest.raises(CapacityError):
gateway.sync_machine(second)
store.close()
def test_instance_type_outside_the_allowed_list_is_rejected(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
with pytest.raises(ConfigError, match="instance type"):
make_gateway(cfg, store, instance_type="m6i.xlarge")
store.close()
@pytest.mark.parametrize(
"overrides",
[
{"machine_id": "not-a-uuid"},
{"revision": 0},
{"revision": True},
{"desired_state": "restart"},
{"retain_until": "2026-01-08T00:00:00"},
{"data_volume_id": "volume"},
],
)
def test_invalid_core_machines_are_refused(overrides):
with pytest.raises((ConfigError, ValueError)):
CoreMachine.parse(core_machine(**overrides))
def test_invalid_core_machine_does_not_block_the_others(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
gateway = make_gateway(cfg, store)
gateway.request = routed([core_machine(revision=0), core_machine(desired_state="stopped")])
gateway.sync_machines(gateway.machines())
assert store.get(MACHINE_ID).desired_state is DesiredState.STOPPED
store.close()
SEAT_B = "5e1c2b4a-0000-4000-8000-0000000000b1"
SEAT_C = "5e1c2b4a-0000-4000-8000-0000000000c1"
CONTROLLER_ID = "9a1c2b4a-0000-4000-8000-0000000000aa"
def seat(key: str, *, controller_id: str | None = None, code: str | None = CODE) -> dict:
return {"key": key, "id": controller_id, "enrollment_code": None if controller_id else code}
def test_a_bundle_carries_one_controller_per_workspace_in_cores_order(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
machine = store.record_volume(
insert_machine(store, cfg, MACHINE_ID).machine_id, VOLUME_ID, cfg.availability_zone
)
other_code = "swce_SyntheticEnrollmentCode0001"
prepared = prepared_machine(
controllers=[
seat(SEAT_C, code=other_code),
seat(SEAT, controller_id=CONTROLLER_ID),
{**seat(SEAT_B), "key": SEAT_B.upper()},
]
)
assert make_gateway(cfg, store).bundle(prepared, machine) == {
"version": 5,
"installationId": cfg.installation_id,
"machineId": MACHINE_ID,
"dataVolumeId": VOLUME_ID,
"apiEndpoint": "https://switch.example.test/agent-api",
"controllers": [
{"key": SEAT_C, "id": None, "enrollmentCode": other_code},
{"key": SEAT, "id": CONTROLLER_ID, "enrollmentCode": None},
{"key": SEAT_B, "id": None, "enrollmentCode": CODE},
],
}
store.close()
def test_a_bundle_takes_up_to_eight_controllers(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
machine = insert_machine(store, cfg, MACHINE_ID)
keys = [f"5e1c2b4a-0000-4000-8000-00000000000{index}" for index in range(8)]
prepared = prepared_machine(controllers=[seat(key) for key in keys])
bundle = make_gateway(cfg, store).bundle(prepared, machine)
assert [entry["key"] for entry in bundle["controllers"]] == keys
store.close()
@pytest.mark.parametrize(
"controllers",
[
None,
{"key": SEAT, "id": None, "enrollment_code": CODE},
[],
[seat(f"5e1c2b4a-0000-4000-8000-00000000000{index}") for index in range(9)],
[seat(SEAT), seat(SEAT, controller_id=CONTROLLER_ID)],
[seat(SEAT), seat(SEAT.upper())],
[None],
["not-a-controller"],
[{"id": None, "enrollment_code": CODE}],
[{"key": None, "id": None, "enrollment_code": CODE}],
[{"key": "not-a-uuid", "id": None, "enrollment_code": CODE}],
[{"key": 7, "id": None, "enrollment_code": CODE}],
[{"key": SEAT, "id": None, "enrollment_code": None}],
[{"key": SEAT}],
[{"key": SEAT, "id": None, "enrollment_code": "swcc_not-a-code-at-all-0000"}],
[{"key": SEAT, "id": "not-a-uuid", "enrollment_code": None}],
[{"key": SEAT, "id": 7, "enrollment_code": None}],
[{"key": SEAT, "id": CONTROLLER_ID, "enrollment_code": CODE}],
[seat(SEAT_B), {"key": SEAT, "id": CONTROLLER_ID, "enrollment_code": CODE}],
],
)
def test_a_controller_bundle_refuses_what_is_not_one(tmp_path, controllers):
cfg = config(tmp_path)
store = open_store(cfg)
machine = insert_machine(store, cfg, MACHINE_ID)
prepared = prepared_machine(controllers=controllers)
with pytest.raises(ConfigError):
make_gateway(cfg, store).bundle(prepared, machine)
store.close()
def test_a_prepare_with_the_former_single_controller_is_refused(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
machine = insert_machine(store, cfg, MACHINE_ID)
prepared = prepared_machine(controller={"id": None, "enrollment_code": CODE})
del prepared["controllers"]
with pytest.raises(ConfigError):
make_gateway(cfg, store).bundle(prepared, machine)
store.close()
def test_an_enrolled_controller_gets_its_controller_and_no_code(tmp_path):
cfg = config(tmp_path)
store = open_store(cfg)
machine = insert_machine(store, cfg, MACHINE_ID)
prepared = prepared_machine(controllers=[seat(SEAT, controller_id=CONTROLLER_ID)])
bundle = make_gateway(cfg, store).bundle(prepared, machine)
assert bundle["controllers"] == [{"key": SEAT, "id": CONTROLLER_ID, "enrollmentCode": None}]
store.close()