def test_bruteforce_attack_successful(self):
random_owner = uuid()
device_uuid = setup_device()[0]
setup_workload(device_uuid, clear_device=False)
target_device = setup_device(owner=random_owner, clear_device=False)[0]
service_uuid = create_service(device_uuid,
name="bruteforce",
n=2,
speed=1.0)[1]
target_service = create_service(target_device,
clear_service=False,
speed=1.0)[0]
create_bruteforce_service(service_uuid, target_device, target_service,
True)
expected = {"ok": True}
actual = self.client.ms(
"service",
["bruteforce", "attack"],
device_uuid=device_uuid,
service_uuid=service_uuid,
target_device=target_device,
target_service=target_service,
)
self.assertEqual(expected, actual)
def test_bruteforce_stop_service_not_running(self):
device_uuid = setup_device()[0]
target_device = setup_device(owner=uuid(), clear_device=False)
service_uuid = create_service(device_uuid, "bruteforce", speed=1.0)[0]
target_service = create_service(target_device,
n=2,
clear_service=False)[1]
create_bruteforce_service(service_uuid, target_device, target_service)
with self.assertRaises(ServiceNotRunningException):
self.client.ms("service", ["bruteforce", "stop"],
device_uuid=device_uuid,
service_uuid=service_uuid)
def test_create_service_not_supported(self):
device_uuid = setup_device()[0]
with self.assertRaises(ServiceNotSupportedException):
self.client.ms("service", ["create"],
device_uuid=device_uuid,
name="nothing here")
def test_create_permission_denied(self):
device_uuid = setup_device(owner=uuid())[0]
with self.assertRaises(PermissionDeniedException):
self.client.ms("service", ["create"],
device_uuid=device_uuid,
name="ssh")
def test_create_invalid_request(self):
device_uuid = setup_device()[0]
with self.assertRaises(InvalidRequestException):
self.client.ms("service", ["create"],
device_uuid=device_uuid,
name="miner")
def test_miner_get_device_powered_off(self):
device_uuid = setup_device(2)[1]
service_uuid = create_service(device_uuid, "miner")[0]
with self.assertRaises(DeviceNotOnlineException):
self.client.ms("service", ["miner", "get"],
service_uuid=service_uuid)
def test_miner_list_successful(self):
device_uuid = setup_device()[0]
service_uuid = create_service(device_uuid, "miner")[0]
wallet_uuid = create_wallet()[0]
create_miner_service(service_uuid, wallet_uuid)
expected = {
"miners": [{
"service": {
"running": True,
"owner": super_uuid,
"running_port": 1337,
"name": "miner",
"uuid": service_uuid,
"device": device_uuid,
"part_owner": None,
"speed": None,
},
"miner": {
"wallet": wallet_uuid,
"started": 0,
"power": 0.0,
"uuid": service_uuid
},
}]
}
actual = self.client.ms("service", ["miner", "list"],
wallet_uuid=wallet_uuid)
self.assertEqual(expected, actual)
def test_revoke_device_powered_off(self):
device_uuid = setup_device(2)[1]
network_uuid = create_network(device_uuid)[0]
invitation_uuid = create_invitation(uuid(), network_uuid)
with self.assertRaises(DeviceNotOnlineException):
self.client.ms("network", ["revoke"], uuid=invitation_uuid)
def test_miner_get_permission_denied(self):
device_uuid = setup_device(owner=uuid())[0]
service_uuid = create_service(device_uuid, "miner")[0]
with self.assertRaises(PermissionDeniedException):
self.client.ms("service", ["miner", "get"],
service_uuid=service_uuid)
def test_invite_network_not_found(self):
device_uuid = setup_device()[0]
with self.assertRaises(NetworkNotFoundException):
self.client.ms("network", ["invite"],
uuid=uuid(),
device=device_uuid)
def test_create_device_powered_off(self):
device_uuid = setup_device(2)[1]
with self.assertRaises(DeviceNotOnlineException):
self.client.ms("network", ["create"],
device=device_uuid,
name="test_network#1",
hidden=False)
def test_create_invalid_name(self):
device_uuid = setup_device()[0]
with self.assertRaises(InvalidNameException):
self.client.ms("network", ["create"],
device=device_uuid,
name="space go brr",
hidden=False)
def test_create_device_powered_off(self):
device_uuid = setup_device(2)[1]
with self.assertRaises(DeviceNotOnlineException):
self.client.ms("service", ["create"],
device_uuid=device_uuid,
name="ssh")
def test_deny_successful(self):
device_uuid = setup_device()[0]
invitation_uuid = create_invitation(device_uuid, uuid())
expected = {"result": True}
actual = self.client.ms("network", ["deny"], uuid=invitation_uuid)
self.assertEqual(actual, expected)
def test_invite_already_member(self):
device_uuid = setup_device()[0]
network_uuid = create_network(device_uuid)[0]
with self.assertRaises(AlreadyMemberOfNetworkException):
self.client.ms("network", ["invite"],
uuid=network_uuid,
device=device_uuid)
def test_public_info_device_powered_off(self):
device_uuid = setup_device(2)[1]
service_uuid = create_service(device_uuid)[0]
with self.assertRaises(DeviceNotOnlineException):
self.client.ms("service", ["public_info"],
device_uuid=device_uuid,
service_uuid=service_uuid)
def test_miner_wallet_not_found(self):
device_uuid = setup_device()[0]
service_uuid = create_service(device_uuid, "miner")[0]
with self.assertRaises(WalletNotFoundException):
self.client.ms("service", ["miner", "wallet"],
service_uuid=service_uuid,
wallet_uuid=uuid())
def test_create_service_already_exists(self):
device_uuid = setup_device()[0]
create_service(device_uuid, "ssh")
with self.assertRaises(AlreadyOwnThisServiceException):
self.client.ms("service", ["create"],
device_uuid=device_uuid,
name="ssh")
def test_request_device_powered_off(self):
device_uuid = setup_device(2)[1]
network_uuid = create_network(uuid())[0]
with self.assertRaises(DeviceNotOnlineException):
self.client.ms("network", ["request"],
uuid=network_uuid,
device=device_uuid)
def test_create_name_already_used(self):
device_uuid = setup_device()[0]
create_network(device_uuid)
with self.assertRaises(NameAlreadyInUseException):
self.client.ms("network", ["create"],
device=device_uuid,
name="test_network#1",
hidden=False)
def test_create_max_network(self):
device_uuid = setup_device()[0]
create_network(device_uuid, 2)
with self.assertRaises(MaximumNetworksReachedException):
self.client.ms("network", ["create"],
device=device_uuid,
name="new_network",
hidden=False)
def test_bruteforce_status_permission_denied(self):
device_uuid = setup_device(owner=uuid())[0]
service_uuid = create_service(device_uuid, "bruteforce", speed=0.0)[0]
with self.assertRaises(PermissionDeniedException):
self.client.ms("service", ["bruteforce", "status"],
device_uuid=device_uuid,
service_uuid=service_uuid)
def test_create_wallet_not_found(self):
device_uuid = setup_device()[0]
with self.assertRaises(WalletNotFoundException):
self.client.ms("service", ["create"],
device_uuid=device_uuid,
name="miner",
wallet_uuid=uuid())
def test_delete_successful(self):
device_uuid = setup_device()[0]
network_uuid = create_network(device_uuid)[0]
expected = {"result": True}
actual = self.client.ms("network", ["delete"], uuid=network_uuid)
self.assertEqual(actual, expected)
def test_miner_wallet_device_not_online(self):
device_uuid = setup_device(2)[1]
service_uuid = create_service(device_uuid, "miner")[0]
with self.assertRaises(DeviceNotOnlineException):
self.client.ms("service", ["miner", "wallet"],
service_uuid=service_uuid,
wallet_uuid=uuid())
def test_kick_cannot_kick_owner(self):
device_uuid = setup_device()[0]
network_uuid = create_network(device_uuid)[0]
with self.assertRaises(CannotKickOwnerException):
self.client.ms("network", ["kick"],
uuid=network_uuid,
device=device_uuid)
def test_leave_owner_cannot_leave_network(self):
device_uuid = setup_device()[0]
network_uuid = create_network(device_uuid)[0]
with self.assertRaises(CannotLeaveOwnNetworkException):
self.client.ms("network", ["leave"],
uuid=network_uuid,
device=device_uuid)
def test_part_owner_no_access(self):
device_uuid = setup_device(owner=uuid())[0]
create_service(device_uuid)
expected = {"ok": False}
actual = self.client.ms("service", ["part_owner"],
device_uuid=device_uuid)
self.assertEqual(expected, actual)
def test_leave_device_not_online(self):
device_uuid = setup_device(2)[1]
network_uuid = create_network(uuid())[0]
with self.assertRaises(DeviceNotOnlineException):
self.client.ms("network", ["leave"],
uuid=network_uuid,
device=device_uuid)
def test_delete_permission_denied(self):
device_uuid = setup_device(owner=uuid())[0]
service_uuid = create_service(device_uuid)[0]
with self.assertRaises(PermissionDeniedException):
self.client.ms("service", ["delete"],
device_uuid=device_uuid,
service_uuid=service_uuid)
