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_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_miner_power_device_not_found(self):
service_uuid = create_service(uuid(), "miner")[0]
with self.assertRaises(DeviceNotFoundException):
self.client.ms("service", ["miner", "power"],
service_uuid=service_uuid,
power=0.5)
def test_miner_wallet_device_not_found(self):
service_uuid = create_service(uuid(), "miner")[0]
with self.assertRaises(DeviceNotFoundException):
self.client.ms("service", ["miner", "wallet"],
service_uuid=service_uuid,
wallet_uuid=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_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_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_bruteforce_status_device_not_found(self):
device_uuid = uuid()
service_uuid = create_service(device_uuid, "bruteforce", speed=0.0)[0]
with self.assertRaises(DeviceNotFoundException):
self.client.ms("service", ["bruteforce", "status"],
device_uuid=device_uuid,
service_uuid=service_uuid)
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_bruteforce_attack_could_not_start_service(self):
device_uuid = setup_device()[0]
target_device = setup_device(owner=uuid(), 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)[0]
with self.assertRaises(CouldNotStartService):
self.client.ms(
"service",
["bruteforce", "attack"],
device_uuid=device_uuid,
service_uuid=service_uuid,
target_device=target_device,
target_service=target_service,
)
def test_miner_power_wallet_not_found(self):
device_uuid = setup_device()[0]
service_uuid = create_service(device_uuid, "miner")[0]
create_miner_service(service_uuid, uuid())
with self.assertRaises(WalletNotFoundException):
self.client.ms("service", ["miner", "power"],
service_uuid=service_uuid,
power=0.5)
def test_bruteforce_stop_successful(self):
device_uuid = setup_device()[0]
target_device = setup_device(owner=uuid(), clear_device=False)[0]
target_service = create_service(target_device)[0]
service_uuid = create_service(device_uuid,
"bruteforce",
speed=2.0,
clear_service=False)[0]
create_bruteforce_service(service_uuid, target_device, target_service,
True)
actual = self.client.ms("service", ["bruteforce", "stop"],
device_uuid=device_uuid,
service_uuid=service_uuid)
self.assertEqual(True, actual["ok"])
self.assertEqual(target_device, actual["target_device"])
self.assertIsInstance(actual["access"], bool)
self.assertIsInstance(actual["progress"], float)
def test_bruteforce_status_device_powered_off(self):
device_uuid = setup_device(2)[1]
service_uuid = create_service(device_uuid, "bruteforce", speed=0.0)[0]
create_bruteforce_service(service_uuid, uuid(), uuid())
with self.assertRaises(DeviceNotOnlineException):
self.client.ms("service", ["bruteforce", "status"],
device_uuid=device_uuid,
service_uuid=service_uuid)
def test_miner_power_could_not_start_service(self):
device_uuid = setup_device()[0]
service_uuid = create_service(device_uuid, "miner", speed=1)[0]
wallet_uuid = create_wallet()[0]
create_miner_service(service_uuid, wallet_uuid)
with self.assertRaises(CouldNotStartService):
self.client.ms("service", ["miner", "power"],
service_uuid=service_uuid,
power=0.5)
def test_bruteforce_stop_attack_not_running(self):
device_uuid = setup_device()[0]
service_uuid = create_service(device_uuid,
"bruteforce",
speed=1.0,
n=2)[1]
with self.assertRaises(AttackNotRunningException):
self.client.ms("service", ["bruteforce", "stop"],
device_uuid=device_uuid,
service_uuid=service_uuid)
def test_bruteforce_stop_device_powered_off(self):
device_uuid = setup_device(2)[1]
service_uuid = create_service(device_uuid,
"bruteforce",
speed=2.0,
clear_service=False)[0]
with self.assertRaises(DeviceNotOnlineException):
self.client.ms("service", ["bruteforce", "stop"],
device_uuid=device_uuid,
service_uuid=service_uuid)
def test_bruteforce_stop_device_not_found(self):
device_uuid = uuid()
service_uuid = create_service(device_uuid,
"bruteforce",
speed=2.0,
clear_service=False)[0]
with self.assertRaises(DeviceNotFoundException):
self.client.ms("service", ["bruteforce", "stop"],
device_uuid=device_uuid,
service_uuid=service_uuid)
def test_bruteforce_attack_service_not_running(self):
device_uuid = setup_device()[0]
target_device = setup_device(owner=uuid(), clear_device=False)[0]
service_uuid = create_service(device_uuid,
name="bruteforce",
n=2,
speed=1.0)[1]
target_service = create_service(target_device,
n=2,
clear_service=False)[1]
with self.assertRaises(ServiceNotRunningException):
self.client.ms(
"service",
["bruteforce", "attack"],
device_uuid=device_uuid,
service_uuid=service_uuid,
target_device=target_device,
target_service=target_service,
)
def test_miner_wallet(self):
device_uuid = setup_device()[0]
service_uuid = create_service(device_uuid, "miner", speed=1.0)[0]
create_miner_service(service_uuid)
wallet_uuid = create_wallet()[0]
actual = self.client.ms("service", ["miner", "wallet"],
service_uuid=service_uuid,
wallet_uuid=wallet_uuid)
self.assertEqual(wallet_uuid, actual["wallet"])
self.assertEqual(0.0, actual["power"])
self.assertEqual(service_uuid, actual["uuid"])
self.assertIsInstance(actual["started"], int)
def test_miner_get_successful(self):
device_uuid = setup_device()[0]
service_uuid = create_service(device_uuid, "miner")[0]
create_miner_service(service_uuid)
expected = {
"wallet": None,
"started": 0,
"power": 0.0,
"uuid": service_uuid
}
actual = self.client.ms("service", ["miner", "get"],
service_uuid=service_uuid)
self.assertEqual(expected, actual)
def test_miner_power_successful(self):
device_uuid = setup_device()[0]
setup_workload(device_uuid, False)
service_uuid = create_service(device_uuid, "miner", n=2)[1]
wallet_uuid = create_wallet()[0]
create_miner_service(service_uuid, wallet_uuid, False, 1)
actual = self.client.ms("service", ["miner", "power"],
service_uuid=service_uuid,
power=1.0)
self.assertEqual(service_uuid, actual["uuid"])
self.assertEqual(wallet_uuid, actual["wallet"])
self.assertEqual(1.0, actual["power"])
self.assertIsInstance(actual["started"], int)
def test_bruteforce_attack_device_not_found(self):
device_uuid = uuid()
service_uuid = create_service(device_uuid,
name="bruteforce",
n=2,
speed=0.0)[1]
with self.assertRaises(DeviceNotFoundException):
self.client.ms(
"service",
["bruteforce", "attack"],
device_uuid=device_uuid,
service_uuid=service_uuid,
target_device=uuid(),
target_service=uuid(),
)
def test_bruteforce_status_successful(self):
device_uuid = setup_device()[0]
service_uuid = create_service(device_uuid, "bruteforce", speed=0.0)[0]
create_bruteforce_service(service_uuid, uuid(), uuid(), True)
actual = self.client.ms("service", ["bruteforce", "status"],
device_uuid=device_uuid,
service_uuid=service_uuid)
self.assert_dict_with_keys(
actual,
["uuid", "started", "target_device", "target_service", "progress"])
self.assertEqual(service_uuid, actual["uuid"])
self.assertEqual(1.0, actual["progress"])
self.assert_valid_uuid(actual["target_device"])
self.assert_valid_uuid(actual["target_service"])
self.assertIsInstance(actual["started"], int)
def test_bruteforce_attack_permission_denied(self):
device_uuid = setup_device(owner=uuid())[0]
service_uuid = create_service(device_uuid,
name="bruteforce",
n=2,
speed=0.0)[1]
with self.assertRaises(PermissionDeniedException):
self.client.ms(
"service",
["bruteforce", "attack"],
device_uuid=device_uuid,
service_uuid=service_uuid,
target_device=uuid(),
target_service=uuid(),
)
def test_bruteforce_attack_device_powered_off(self):
device_uuid = setup_device(2)[1]
service_uuid = create_service(device_uuid,
name="bruteforce",
n=2,
speed=0.0)[1]
with self.assertRaises(DeviceNotOnlineException):
self.client.ms(
"service",
["bruteforce", "attack"],
device_uuid=device_uuid,
service_uuid=service_uuid,
target_device=uuid(),
target_service=uuid(),
)
def test_bruteforce_attack_already_running(self):
device_uuid = setup_device()[0]
service_uuid = create_service(device_uuid,
name="bruteforce",
n=1,
speed=1.0)[0]
with self.assertRaises(AttackAlreadyRunning):
self.client.ms(
"service",
["bruteforce", "attack"],
device_uuid=device_uuid,
service_uuid=service_uuid,
target_device=uuid(),
target_service=uuid(),
)
