async def test_backend_closed_cmds(running_backend):
async with apiv1_backend_administration_cmds_factory(
running_backend.addr, running_backend.backend.config.administration_token
) as cmds:
pass
with pytest.raises(trio.ClosedResourceError):
await cmds.ping()
async def _stats_organization(name, backend_addr, administration_token):
async with apiv1_backend_administration_cmds_factory(
backend_addr, administration_token
) as cmds:
stats = await cmds.organization_stats(name)
for key, value in stats.items():
click.echo(f"{key}: {value}")
async def test_administration_cmds_has_right_methods(running_backend):
async with apiv1_backend_administration_cmds_factory(
running_backend.addr, running_backend.backend.config.administration_token
) as cmds:
for method_name in APIV1_ADMINISTRATION_CMDS:
assert hasattr(cmds, method_name)
for method_name in ALL_CMDS - APIV1_ADMINISTRATION_CMDS:
assert not hasattr(cmds, method_name)
async def test_backend_switch_offline(running_backend):
async with apiv1_backend_administration_cmds_factory(
running_backend.addr, running_backend.backend.config.administration_token
) as cmds:
await cmds.ping()
with running_backend.offline():
with pytest.raises(BackendNotAvailable):
await cmds.ping()
async def _create_organization(debug, name, backend_addr, administration_token, expiration_date):
async with spinner("Creating organization in backend"):
async with apiv1_backend_administration_cmds_factory(
backend_addr, administration_token
) as cmds:
rep = await cmds.organization_create(name, expiration_date)
if rep["status"] != "ok":
raise RuntimeError(f"Backend refused to create organization: {rep}")
bootstrap_token = rep["bootstrap_token"]
organization_addr = BackendOrganizationBootstrapAddr.build(backend_addr, name, bootstrap_token)
organization_addr_display = click.style(organization_addr.to_url(), fg="yellow")
click.echo(f"Bootstrap organization url: {organization_addr_display}")
def _cmds_factory(keepalive):
return apiv1_backend_administration_cmds_factory(
backend_addr,
backend.config.administration_token,
keepalive=keepalive)
async def test_handshake_invalid_token(running_backend):
with pytest.raises(BackendConnectionRefused) as exc:
async with apiv1_backend_administration_cmds_factory(running_backend.addr, "dummy") as cmds:
await cmds.ping()
assert str(exc.value) == "Invalid administration token"
async def test_ping(running_backend):
async with apiv1_backend_administration_cmds_factory(
running_backend.addr, running_backend.backend.config.administration_token
) as cmds:
rep = await cmds.ping("Hello World !")
assert rep == {"status": "ok", "pong": "Hello World !"}
async def initialize_test_organization(
config_dir: Path,
backend_address: BackendAddr,
password: str,
administration_token: str,
force: bool,
) -> Tuple[LocalDevice, LocalDevice, LocalDevice]:
configure_logging("WARNING")
organization_id = OrganizationID("Org")
# Create organization
async with apiv1_backend_administration_cmds_factory(
backend_address, administration_token
) as administration_cmds:
rep = await administration_cmds.organization_create(organization_id)
assert rep["status"] == "ok"
bootstrap_token = rep["bootstrap_token"]
organization_bootstrap_addr = BackendOrganizationBootstrapAddr.build(
backend_address, organization_id, bootstrap_token
)
# Bootstrap organization and Alice user
async with apiv1_backend_anonymous_cmds_factory(organization_bootstrap_addr) as anonymous_cmds:
alice_device = await bootstrap_organization(
cmds=anonymous_cmds,
human_handle=HumanHandle(label="Alice", email="*****@*****.**"),
device_label="laptop",
)
save_device_with_password(config_dir, alice_device, password, force=force)
# Create a workspace for Alice
config = load_config(config_dir, debug="DEBUG" in os.environ)
async with logged_core_factory(config, alice_device) as core:
alice_ws_id = await core.user_fs.workspace_create("alice_workspace")
await core.user_fs.sync()
# Register a new device for Alice
other_alice_device = None
async with backend_authenticated_cmds_factory(
addr=alice_device.organization_addr,
device_id=alice_device.device_id,
signing_key=alice_device.signing_key,
) as alice_cmds:
rep = await alice_cmds.invite_new(type=InvitationType.DEVICE)
assert rep["status"] == "ok"
invitation_addr = BackendInvitationAddr.build(
backend_addr=alice_device.organization_addr,
organization_id=alice_device.organization_id,
invitation_type=InvitationType.DEVICE,
token=rep["token"],
)
async with backend_invited_cmds_factory(addr=invitation_addr) as invited_cmds:
async def invite_task():
initial_ctx = DeviceGreetInitialCtx(cmds=alice_cmds, token=invitation_addr.token)
in_progress_ctx = await initial_ctx.do_wait_peer()
in_progress_ctx = await in_progress_ctx.do_wait_peer_trust()
in_progress_ctx = await in_progress_ctx.do_signify_trust()
in_progress_ctx = await in_progress_ctx.do_get_claim_requests()
await in_progress_ctx.do_create_new_device(
author=alice_device, device_label=in_progress_ctx.requested_device_label
)
async def claim_task():
nonlocal other_alice_device
initial_ctx = await claimer_retrieve_info(cmds=invited_cmds)
in_progress_ctx = await initial_ctx.do_wait_peer()
in_progress_ctx = await in_progress_ctx.do_signify_trust()
in_progress_ctx = await in_progress_ctx.do_wait_peer_trust()
other_alice_device = await in_progress_ctx.do_claim_device(
requested_device_label="pc"
)
async with trio.open_service_nursery() as nursery:
nursery.start_soon(invite_task)
nursery.start_soon(claim_task)
save_device_with_password(config_dir, other_alice_device, password, force=force)
# Invite Bob in
bob_device = None
rep = await alice_cmds.invite_new(type=InvitationType.USER, claimer_email="*****@*****.**")
assert rep["status"] == "ok"
invitation_addr = BackendInvitationAddr.build(
backend_addr=alice_device.organization_addr,
organization_id=alice_device.organization_id,
invitation_type=InvitationType.USER,
token=rep["token"],
)
async with backend_invited_cmds_factory(addr=invitation_addr) as invited_cmds:
async def invite_task():
initial_ctx = UserGreetInitialCtx(cmds=alice_cmds, token=invitation_addr.token)
in_progress_ctx = await initial_ctx.do_wait_peer()
in_progress_ctx = await in_progress_ctx.do_wait_peer_trust()
in_progress_ctx = await in_progress_ctx.do_signify_trust()
in_progress_ctx = await in_progress_ctx.do_get_claim_requests()
await in_progress_ctx.do_create_new_user(
author=alice_device,
human_handle=in_progress_ctx.requested_human_handle,
device_label=in_progress_ctx.requested_device_label,
profile=UserProfile.STANDARD,
)
async def claim_task():
nonlocal bob_device
initial_ctx = await claimer_retrieve_info(cmds=invited_cmds)
in_progress_ctx = await initial_ctx.do_wait_peer()
in_progress_ctx = await in_progress_ctx.do_signify_trust()
in_progress_ctx = await in_progress_ctx.do_wait_peer_trust()
bob_device = await in_progress_ctx.do_claim_user(
requested_human_handle=HumanHandle(label="Bob", email="*****@*****.**"),
requested_device_label="laptop",
)
async with trio.open_service_nursery() as nursery:
nursery.start_soon(invite_task)
nursery.start_soon(claim_task)
save_device_with_password(config_dir, bob_device, password, force=force)
# Create bob workspace and share with Alice
async with logged_core_factory(config, bob_device) as core:
bob_ws_id = await core.user_fs.workspace_create("bob_workspace")
await core.user_fs.workspace_share(bob_ws_id, alice_device.user_id, WorkspaceRole.MANAGER)
# Share Alice workspace with bob
async with logged_core_factory(config, alice_device) as core:
await core.user_fs.workspace_share(alice_ws_id, bob_device.user_id, WorkspaceRole.MANAGER)
# Synchronize every device
for device in (alice_device, other_alice_device, bob_device):
async with logged_core_factory(config, device) as core:
await core.user_fs.process_last_messages()
await core.user_fs.sync()
return (alice_device, other_alice_device, bob_device)
async def initialize_test_organization(
config_dir: Path,
backend_address: BackendAddr,
password: str,
administration_token: str,
additional_users_number: int,
additional_devices_number: int,
) -> Tuple[LocalDevice, LocalDevice, LocalDevice]:
configure_logging(log_level="WARNING")
organization_id = OrganizationID("Org")
# Create organization
async with apiv1_backend_administration_cmds_factory(
backend_address, administration_token) as administration_cmds:
rep = await administration_cmds.organization_create(organization_id)
assert rep["status"] == "ok", rep
bootstrap_token = rep["bootstrap_token"]
organization_bootstrap_addr = BackendOrganizationBootstrapAddr.build(
backend_address, organization_id, bootstrap_token)
# Bootstrap organization and Alice user and create device "laptop" for Alice
async with apiv1_backend_anonymous_cmds_factory(
organization_bootstrap_addr) as anonymous_cmds:
alice_device = await bootstrap_organization(
cmds=anonymous_cmds,
human_handle=HumanHandle(label="Alice", email="*****@*****.**"),
device_label="laptop",
)
save_device_with_password(config_dir=config_dir,
device=alice_device,
password=password)
config = load_config(config_dir, debug="DEBUG" in os.environ)
# Create context manager, alice_core will be needed for the rest of the script
async with logged_core_factory(config, alice_device) as alice_core:
async with backend_authenticated_cmds_factory(
addr=alice_device.organization_addr,
device_id=alice_device.device_id,
signing_key=alice_device.signing_key,
) as alice_cmds:
# Create new device "pc" for Alice
other_alice_device = await _register_new_device(
cmds=alice_cmds, author=alice_device, device_label="pc")
save_device_with_password(config_dir=config_dir,
device=other_alice_device,
password=password)
# Invite Bob in organization
bob_device = await _register_new_user(
cmds=alice_cmds,
author=alice_device,
device_label="laptop",
human_handle=HumanHandle(email="*****@*****.**", label="Bob"),
profile=UserProfile.STANDARD,
)
save_device_with_password(config_dir=config_dir,
device=bob_device,
password=password)
# Invite Toto in organization
toto_device = await _register_new_user(
cmds=alice_cmds,
author=alice_device,
device_label="laptop",
human_handle=HumanHandle(email="*****@*****.**",
label="Toto"),
profile=UserProfile.OUTSIDER,
)
save_device_with_password(config_dir=config_dir,
device=toto_device,
password=password)
# Create Alice workspace
alice_ws_id = await alice_core.user_fs.workspace_create(
"alice_workspace")
# Create context manager
async with logged_core_factory(config, bob_device) as bob_core:
# Create Bob workspace
bob_ws_id = await bob_core.user_fs.workspace_create(
"bob_workspace")
# Bob share workspace with Alice
await bob_core.user_fs.workspace_share(bob_ws_id,
alice_device.user_id,
WorkspaceRole.MANAGER)
# Alice share workspace with Bob
await alice_core.user_fs.workspace_share(
alice_ws_id, bob_device.user_id, WorkspaceRole.MANAGER)
# Add additional random users
await _add_random_users(
cmds=alice_cmds,
author=alice_device,
alice_core=alice_core,
bob_core=bob_core,
alice_ws_id=alice_ws_id,
bob_ws_id=bob_ws_id,
additional_users_number=additional_users_number,
)
# Add additional random device for alice
await _add_random_device(
cmds=alice_cmds,
device=alice_device,
additional_devices_number=additional_devices_number,
)
# Synchronize every device
for device in (alice_device, other_alice_device, bob_device):
async with logged_core_factory(config, device) as core:
await core.user_fs.process_last_messages()
await core.user_fs.sync()
return (alice_device, other_alice_device, bob_device)
