def test__user_endpoint__miner_list(self, device_online_patch): miners = self.query_miner.filter_by.return_value = [ mock.MagicMock() for _ in range(5) ] services = [mock.MagicMock() for _ in range(5)] results = services.copy() expected_arguments = [m.uuid for m in miners] self.query_service.get.side_effect = lambda a: self.assertEqual( expected_arguments.pop(0), a) or results.pop(0) online_results = [True, False, True, True, False] expected_online_arguments = [s.device for s in services] device_online_patch.side_effect = lambda a: self.assertEqual( expected_online_arguments.pop(0), a) or online_results.pop(0) online_results_copy = online_results.copy() expected_result = { "miners": [{ "miner": m.serialize, "service": s.serialize } for m, s, e in zip(miners, services, online_results_copy) if e] } actual_result = miner.list_miners({"wallet_uuid": "some-wallet"}, "") self.assertEqual(expected_result, actual_result) self.query_miner.filter_by.assert_called_with(wallet="some-wallet") self.assertFalse(results) self.assertFalse(online_results)
def test__user_endpoint__file_move__parent_directory_not_found(self): mock_device = mock.MagicMock() mock_file = mock.MagicMock() self.query_device.get.return_value = mock_device query_results = [None, None] expected_query_params = [ {"device": mock_device.uuid, "filename": "new-name", "parent_dir_uuid": "0"}, {"device": mock_device.uuid, "uuid": "0", "is_directory": True}, ] def handle_file_query(**kwargs): self.assertEqual(expected_query_params.pop(0), kwargs) out = mock.MagicMock() out.first.return_value = query_results.pop(0) return out self.query_file.filter_by.side_effect = handle_file_query expected_result = parent_directory_not_found actual_result = file.move( { "device_uuid": mock_device.uuid, "file_uuid": "my-file", "new_filename": "new-name", "new_parent_dir_uuid": "0", }, "user", mock_device, mock_file, ) self.assertEqual(expected_result, actual_result) self.assertFalse(query_results)
def test__change_miner_power__successful(self, stop_service_patch, dict_patch): needs = {"cpu": 2, "ram": 3, "gpu": 5, "disk": 7, "network": 11} mock.m.contact_microservice.return_value = mock.MagicMock() given_per = mock.MagicMock() expected_per = mock.MagicMock() expected_arguments = [mock.m.contact_microservice(), needs] results = [given_per, expected_per] dict_patch.side_effect = lambda e: self.assertEqual( expected_arguments.pop(0), e) or results.pop(0) expected_result = (expected_per, given_per), {} actual_result = essentials.change_miner_power(0.8, "the-miner", "my-device", "user") self.assertEqual(expected_result, actual_result) stop_service_patch.assert_called_with("my-device", "the-miner", "user") mock.m.contact_microservice.assert_called_with( "device", ["hardware", "register"], { "user": "******", "service_uuid": "the-miner", "device_uuid": "my-device", "cpu": 2 * 0.8, "ram": 3 * 0.8, "gpu": 5 * 0.8, "disk": 7 * 0.8, "network": 11 * 0.8, }, )
def test__user_endpoint__miner_power__successful_started( self, exists_wallet_patch, update_miner_patch, change_miner_power_patch, time_patch, owner_patch): mock_miner = self.query_miner.get.return_value = mock.MagicMock() mock_service = mock.MagicMock() exists_wallet_patch.return_value = True time_patch.return_value = 1337 expected_result = mock_miner.serialize actual_result = miner.set_power({"power": 42}, "", mock_service) self.assertEqual(expected_result, actual_result) self.query_miner.get.assert_called_with(mock_service.uuid) exists_wallet_patch.assert_called_with(mock_miner.wallet) update_miner_patch.assert_called_with(mock_miner) change_miner_power_patch.assert_called_with(42, mock_service.uuid, mock_service.device, mock_service.owner) self.assertEqual(change_miner_power_patch(), mock_service.speed) self.assertEqual(True, mock_service.running) self.assertEqual(42, mock_miner.power) self.assertEqual(1337000, mock_miner.started) owner_patch.assert_called_with(mock_miner.wallet) mock.m.contact_user.assert_called_with( owner_patch(), { "notify-id": "miner-rate-changed", "origin": "miner/power", "wallet_uuid": mock_miner.wallet }, ) mock.wrapper.session.commit.assert_called_with()
def test__ms_endpoint__delete_user(self): devices = [mock.MagicMock() for _ in range(5)] files = {} hardware_elements = {} workloads = {} services = {} to_delete = devices.copy() for i in range(5): uuid = devices[i].uuid files[uuid] = [mock.MagicMock() for _ in range(5)] hardware_elements[uuid] = [mock.MagicMock() for _ in range(5)] workloads[uuid] = [mock.MagicMock() for _ in range(5)] services[uuid] = [mock.MagicMock() for _ in range(5)] to_delete += files[uuid] + hardware_elements[uuid] + workloads[ uuid] + services[uuid] self.query_device.filter_by.return_value = devices.copy() mock.wrapper.session.delete.side_effect = to_delete.remove self.query_file.filter_by.side_effect = lambda device: files[device] self.query_hardware.filter_by.side_effect = lambda device_uuid: hardware_elements[ device_uuid] self.query_workload.filter_by.side_effect = lambda uuid: workloads[uuid ] self.query_service.filter_by.side_effect = lambda device_uuid: services[ device_uuid] self.assertEqual( success, device.delete_user({"user_uuid": "the-user"}, "server")) self.assertFalse(to_delete) self.query_device.filter_by.assert_called_with(owner="the-user") mock.wrapper.session.commit.assert_called_with()
def test__stop_services(self, update_patch): def create_service(name): s = mock.MagicMock() s.name = name return s services = [ create_service("ssh"), create_service("bruteforce"), create_service("miner") ] self.query_miner.get.return_value = miner = mock.MagicMock() self.query_bruteforce.get.return_value = bruteforce = mock.MagicMock() self.query_service.filter_by.return_value = services essentials.stop_services("the-device") self.query_service.filter_by.assert_called_with(device="the-device") self.query_bruteforce.get.assert_called_with(services[1].uuid) self.assertEqual(None, bruteforce.target_device) self.assertEqual(None, bruteforce.target_service) self.assertEqual(None, bruteforce.started) self.query_miner.get.assert_called_with(services[2].uuid) update_patch.assert_called_with(miner) self.assertEqual(None, miner.started) for service in services: self.assertEqual(False, service.running) mock.wrapper.session.commit.assert_called_with()
def test__ms_endpoint__hardware_scale(self, dict_patch): mock_service = self.query_service.filter_by( ).first.return_value = mock.MagicMock() mock_service.name = "bruteforce" old_speed = mock_service.speed data = {"service_uuid": mock_service.uuid} needs = {"foo": "bar"} given_per = mock.MagicMock() expected_per = mock.MagicMock() expected_params = [data, needs] results = [given_per, expected_per] dict_patch.side_effect = lambda x: self.assertEqual( expected_params.pop(0), x) or results.pop(0) bruteforce = self.query_bruteforce.get.return_value = mock.MagicMock() expected_result = success_scheme actual_result = service.hardware_scale(data, "user") self.assertEqual(expected_result, actual_result) self.query_service.filter_by.assert_called_with(uuid=mock_service.uuid) self.query_bruteforce.get.assert_called_with(mock_service.uuid) bruteforce.update_progress.assert_called_with(old_speed) self.assertEqual( { "from": "speedm", "expected": expected_per, "given": given_per }, mock_service.speed) mock.wrapper.session.commit.assert_called_with()
def test__ms_endpoint__delete_user(self): normal_service = mock.MagicMock() bruteforce_service = mock.MagicMock() bruteforce_info = mock.MagicMock() miner_service = mock.MagicMock() miner_info = mock.MagicMock() self.query_service.filter_by.return_value = [ normal_service, bruteforce_service, miner_service ] to_delete = [ normal_service, bruteforce_service, bruteforce_info, miner_service, miner_info ] def handle_query_bruteforce(uuid): out = mock.MagicMock() out.first.return_value = bruteforce_info if uuid == bruteforce_service.uuid else None return out self.query_bruteforce.filter_by.side_effect = handle_query_bruteforce def handle_query_miner(uuid): out = mock.MagicMock() out.first.return_value = miner_info if uuid == miner_service.uuid else None return out self.query_miner.filter_by.side_effect = handle_query_miner mock.wrapper.session.delete.side_effect = to_delete.remove self.assertEqual(success_scheme, service.delete_user({"user_uuid": "user"}, "server")) self.query_service.filter_by.assert_called_with(owner="user") mock.wrapper.session.commit.assert_called_with() self.assertFalse(to_delete)
def test__generate_scale(self): data = 2, 3, 5, 7, 11 workload = mock.MagicMock() workload.performance_cpu = 29 workload.performance_ram = 23 workload.performance_gpu = 19 workload.performance_disk = 17 workload.performance_network = 13 workload.usage_cpu = 20 workload.usage_ram = 30 workload.usage_gpu = 40 workload.usage_disk = 0 workload.usage_network = 50 expected_result = 1, 23 / 33, 19 / 45, 1, 13 / 61 actual_result = game_content.generate_scale(data, workload) self.assertEqual(expected_result, actual_result) workload = mock.MagicMock() workload.performance_cpu = 20 workload.performance_ram = 30 workload.performance_gpu = 40 workload.performance_disk = 1 workload.performance_network = 50 workload.usage_cpu = 29 workload.usage_ram = 23 workload.usage_gpu = 19 workload.usage_disk = 17 workload.usage_network = 13 expected_result = 20 / 31, 1, 1, 1 / 24, 1 actual_result = game_content.generate_scale(data, workload) self.assertEqual(expected_result, actual_result)
def test__calculate_real_use(self, gen_scal): workload = mock.MagicMock() service = mock.MagicMock() service.allocated_cpu = 1 service.allocated_ram = 1 service.allocated_gpu = 1 service.allocated_disk = 1 service.allocated_network = 1 self.query_workload.get.return_value = workload self.query_service.get.return_value = service gen_scal.return_value = 1, 2, 3, 4, 5 expected_result = { "cpu": 1, "ram": 2, "gpu": 3, "disk": 4, "network": 5 } result = game_content.calculate_real_use("service-uuid") self.assertEqual(expected_result, result) self.query_service.get.assert_called_with("service-uuid") self.query_workload.get.assert_called_with(service.device_uuid) gen_scal.assert_called_with(workload)
def test__ms_endpoint__hardware_stop__successful(self, turn_patch, generate_patch, scale_patch): mock_service = mock.MagicMock() mock_workload = mock.MagicMock() other_services = [mock.MagicMock() for _ in range(5)] self.query_service.get.return_value = mock_service self.query_workload.get.return_value = mock_workload self.query_service.filter_by().all.return_value = other_services data = { "device_uuid": "the-device", "service_uuid": "my-service", "user": "******" } expected_result = success actual_result = hardware.hardware_stop(data, "ms") self.assertEqual(expected_result, actual_result) self.query_service.get.assert_called_with("my-service") self.query_workload.get.assert_called_with("the-device") mock_service.export.assert_called_with() turn_patch.assert_called_with(mock_service.export()) mock.wrapper.session.delete.assert_called_with(mock_service) mock.wrapper.session.commit.assert_called_with() mock_workload.service.assert_called_with(turn_patch()) generate_patch.assert_called_with(turn_patch(), mock_workload) self.query_service.filter_by.assert_called_with( device_uuid="the-device") scale_patch.assert_called_with(other_services, generate_patch()) mock_workload.workload_notification.assert_called_with( "device-hardware-stop") mock.m.contact_user.assert_called_with( "user", mock_workload.workload_notification())
def test__user_endpoint__file_update__successful(self): mock_device = mock.MagicMock() mock_file = mock.MagicMock() mock_file.is_directory = False expected_result = mock_file.serialize actual_result = file.update( {"device_uuid": mock_device.uuid, "file_uuid": mock_file.uuid, "content": "test"}, "user", mock_device, mock_file, ) self.assertEqual(expected_result, actual_result) self.assertEqual("test", mock_file.content) mock.wrapper.session.commit.assert_called_with() mock.m.contact_user.assert_called_with( "user", { "notify-id": "file-update", "origin": "update", "device_uuid": mock_device.uuid, "data": {"created": [], "deleted": [], "changed": [mock_file.uuid]}, }, )
def setUp(self): mock.reset_mocks() self.query_miner = mock.MagicMock() self.query_service = mock.MagicMock() mock.wrapper.session.query.side_effect = { Miner: self.query_miner, Service: self.query_service }.__getitem__
def test__user_endpoint__miner_power__wallet_not_found( self, exists_wallet_patch): mock_miner = self.query_miner.get.return_value = mock.MagicMock() mock_service = mock.MagicMock() exists_wallet_patch.return_value = False self.assertEqual(wallet_not_found, miner.set_power({}, "", mock_service)) self.query_miner.get.assert_called_with(mock_service.uuid) exists_wallet_patch.assert_called_with(mock_miner.wallet)
def setUp(self): mock.reset_mocks() self.query_device = mock.MagicMock() self.query_file = mock.MagicMock() mock.wrapper.session.query.side_effect = { Device: self.query_device, File: self.query_file }.__getitem__
def test__check_compatible__not_existing(self, cee_patch): elements = mock.MagicMock() cee_patch.return_value = False, mock.MagicMock() expected_result = cee_patch() actual_result = game_content.check_compatible(elements) self.assertEqual(expected_result, actual_result) cee_patch.assert_called_with(elements)
def setUp(self): mock.reset_mocks() self.query_service = mock.MagicMock() self.query_workload = mock.MagicMock() mock.wrapper.session.query.side_effect = { Service: self.query_service, Workload: self.query_workload, }.__getitem__
def test__exists_device(self): device = mock.MagicMock() expected_result = mock.MagicMock() mock.m.contact_microservice.return_value = {"exist": expected_result} actual_result = essentials.exists_device(device) self.assertEqual(expected_result, actual_result) mock.m.contact_microservice.assert_called_with("device", ["exist"], {"device_uuid": device})
def test__file_exists__successful(self): mock_file = self.query_file.filter_by( ).first.return_value = mock.MagicMock() mock_device = mock.MagicMock() self.assertEqual((mock_device, mock_file), errors.file_exists({"file_uuid": "my-file"}, "", mock_device)) self.query_file.filter_by.assert_called_with(device=mock_device.uuid, uuid="my-file")
def test__user_endpoint__file_all(self): mock_device = mock.MagicMock() files = [mock.MagicMock() for _ in range(5)] self.query_file.filter_by().all.return_value = files expected_result = {"files": [f.serialize for f in files]} actual_result = file.list_files({"device_uuid": mock_device.uuid, "parent_dir_uuid": "0"}, "user", mock_device) self.assertEqual(expected_result, actual_result) self.query_file.filter_by.assert_called_with(device=mock_device.uuid, parent_dir_uuid="0")
def test__user_endpoint__file_update__directories_can_not_be_updated(self): mock_device = mock.MagicMock() mock_file = mock.MagicMock() mock_file.is_directory = True expected_result = directories_can_not_be_updated actual_result = file.update( {"device_uuid": mock_device.uuid, "file_uuid": "my-file", "content": "test"}, "user", mock_device, mock_file ) self.assertEqual(expected_result, actual_result)
def test__ms_endpoint__hardware_scale__successful(self, turn_patch, dict_patch, generate_patch, scale_patch): data = { "device_uuid": "the-device", "service_uuid": "my-service", "user": "******" } mock_service = mock.MagicMock() mock_service.allocated_cpu = 21 mock_service.allocated_ram = 13 mock_service.allocated_gpu = 8 mock_service.allocated_disk = 5 mock_service.allocated_network = 3 mock_workload = mock.MagicMock() other_services = [mock.MagicMock() for _ in range(5)] self.query_service.get.return_value = mock_service self.query_workload.get.return_value = mock_workload self.query_service.filter_by().all.return_value = other_services scales = generate_patch.return_value = 2, 3, 5, 7, 11 expected_calls = [turn_patch(), dict_patch()] mock_workload.service.side_effect = lambda a: self.assertEqual( expected_calls.pop(0), a) expected_result = { "service_uuid": mock_service.service_uuid, "cpu": mock_service.allocated_cpu * scales[0], "ram": mock_service.allocated_ram * scales[1], "gpu": mock_service.allocated_gpu * scales[2], "disk": mock_service.allocated_disk * scales[3], "network": mock_service.allocated_network * scales[4], } actual_result = hardware.hardware_scale(data, "ms") self.assertEqual(expected_result, actual_result) self.query_service.get.assert_called_with("my-service") self.query_workload.get.assert_called_with("the-device") self.query_service.filter_by.assert_called_with( device_uuid="the-device") mock_service.export.assert_called_with() turn_patch.assert_called_with(mock_service.export()) dict_patch.assert_called_with(data) generate_patch.assert_called_with(dict_patch(), mock_workload) mock_service.overwrite.assert_called_with(dict_patch()) scale_patch.assert_called_with(other_services, generate_patch()) mock_workload.workload_notification.assert_called_with( "device-hardware-scale") mock.m.contact_user.assert_called_with( "user", mock_workload.workload_notification())
def setUp(self): mock.reset_mocks() self.query_device = mock.MagicMock() self.query_file = mock.MagicMock() file.func = self.sqlalchemy_func = mock.MagicMock() self.query_func_count = mock.MagicMock() mock.wrapper.session.query.side_effect = { Device: self.query_device, File: self.query_file, self.sqlalchemy_func.count(): self.query_func_count, }.__getitem__
def test__user_endpoint__file_move__successful(self): mock_device = mock.MagicMock() mock_file = mock.MagicMock() mock_file.is_directory = True mock_file.uuid = "3" dir_mock = mock.MagicMock() dir_mock.parent_dir_uuid = None dir_mock.uuid = "0" filesystem = {"0": dir_mock, None: None} self.query_device.get.return_value = mock_device def handle_file_query(**kwargs): out = mock.MagicMock() if "filename" in kwargs: self.assertEqual({"device": mock_device.uuid, "filename": "new-name", "parent_dir_uuid": "0"}, kwargs) out.first.return_value = None elif "uuid" in kwargs and kwargs["uuid"] == "my-file": self.assertEqual({"device": mock_device.uuid, "uuid": "my-file"}, kwargs) out.first.return_value = mock_file else: self.assertEqual(mock_device.uuid, kwargs["device"]) self.assertIn(kwargs["uuid"], filesystem) out.first.return_value = filesystem[kwargs["uuid"]] return out self.query_file.filter_by.side_effect = handle_file_query expected_result = mock_file.serialize actual_result = file.move( { "device_uuid": mock_device.uuid, "file_uuid": "my-file", "new_filename": "new-name", "new_parent_dir_uuid": "0", }, "user", mock_device, mock_file, ) self.assertEqual(expected_result, actual_result) self.assertEqual("new-name", mock_file.filename) mock.wrapper.session.commit.assert_called_with() mock.m.contact_user.assert_called_with( "user", { "notify-id": "file-update", "origin": "update", "device_uuid": mock_device.uuid, "data": {"created": [], "deleted": [], "changed": [mock_file.uuid]}, }, )
def test__user_endpoint__normal_file_delete__successful(self): mock_device = mock.MagicMock() mock_file = mock.MagicMock() mock_file.is_directory = False expected_result = success actual_result = file.delete_file( {"device_uuid": mock_device.uuid, "file_uuid": mock_file.uuid}, "user", mock_device, mock_file ) self.assertEqual(expected_result, actual_result) mock.wrapper.session.delete.assert_called_with(mock_file) mock.wrapper.session.commit.assert_called_with()
def setUp(self): mock.reset_mocks() self.query_service = mock.MagicMock() service.func = self.sqlalchemy_func = mock.MagicMock() self.query_func_count = mock.MagicMock() self.query_bruteforce = mock.MagicMock() self.query_miner = mock.MagicMock() mock.wrapper.session.query.side_effect = { Service: self.query_service, Bruteforce: self.query_bruteforce, Miner: self.query_miner, self.sqlalchemy_func.count(): self.query_func_count, }.__getitem__
def test__user_endpoint__miner_wallet__successful(self, exists_wallet_patch, update_miner_patch, owner_patch): mock_miner = self.query_miner.get.return_value = mock.MagicMock() mock_service = mock.MagicMock() exists_wallet_patch.return_value = True owners = [mock.MagicMock(), mock.MagicMock()] orig_owner = owners.copy() def owner_handler(wallet): self.assertEqual(mock_miner.wallet, wallet) return owners.pop() owner_patch.side_effect = owner_handler def notification_handler(user, data): self.assertEqual(orig_owner.pop(), user) if orig_owner: self.assertEqual( { "notify-id": "miner-disconnected", "origin": "miner/wallet", "wallet_uuid": mock_miner.wallet }, data, ) else: self.assertEqual( { "notify-id": "miner-connected", "origin": "miner/wallet", "wallet_uuid": mock_miner.wallet }, data) mock.m.contact_user.side_effect = notification_handler expected_result = mock_miner.serialize actual_result = miner.set_wallet({"wallet_uuid": "wallet"}, "", mock_service) self.assertEqual(expected_result, actual_result) self.query_miner.get.assert_called_with(mock_service.uuid) exists_wallet_patch.assert_called_with("wallet") update_miner_patch.assert_called_with(mock_miner) self.assertEqual("wallet", mock_miner.wallet) mock.wrapper.session.commit.assert_called_with() self.assertFalse(owners) self.assertFalse(orig_owner)
def test__ms_endpoint__hardware_register__service_already_running(self): mock_workload = mock.MagicMock() self.query_workload.get.return_value = mock_workload self.query_service.get.return_value = mock.MagicMock() expected_result = service_already_running actual_result = hardware.hardware_register( { "device_uuid": "the-device", "service_uuid": "my-service" }, "ms") self.assertEqual(expected_result, actual_result) self.query_workload.get.assert_called_with("the-device") self.query_service.get.assert_called_with("my-service")
def test__ms_endpoint__hardware_register__successful( self, dict_patch, generate_scale_patch, scale_patch, service_create_patch): mock_workload = mock.MagicMock() other_services = [mock.MagicMock() for _ in range(5)] self.query_workload.get.return_value = mock_workload self.query_service.get.return_value = None self.query_service.filter_by().all.return_value = other_services dict_patch.return_value = 1, 2, 3, 4, 5 scales = generate_scale_patch.return_value = 2, 3, 5, 7, 11 ser = mock.MagicMock() ser.allocated_cpu = 21 ser.allocated_ram = 13 ser.allocated_gpu = 8 ser.allocated_disk = 5 ser.allocated_network = 3 service_create_patch.return_value = ser data = { "device_uuid": "the-device", "service_uuid": "my-service", "user": "******" } expected_result = { "service_uuid": ser.service_uuid, "cpu": ser.allocated_cpu * scales[0], "ram": ser.allocated_ram * scales[1], "gpu": ser.allocated_gpu * scales[2], "disk": ser.allocated_disk * scales[3], "network": ser.allocated_network * scales[4], } actual_result = hardware.hardware_register(data, "ms") self.assertEqual(expected_result, actual_result) self.query_service.filter_by.assert_called_with( device_uuid="the-device") dict_patch.assert_called_with(data) generate_scale_patch.assert_called_with(dict_patch(), mock_workload) scale_patch.assert_called_with(other_services, generate_scale_patch()) mock_workload.service.assert_called_with(dict_patch()) service_create_patch.assert_called_with("the-device", "my-service", dict_patch()) mock_workload.workload_notification.assert_called_with( "device-hardware-register") mock.m.contact_user.assert_called_with( "user", mock_workload.workload_notification())
def test__user_endpoint__file_create__no_parent_dir(self, file_create_patch): mock_device = mock.MagicMock() mock_device.check_access.return_value = True self.query_file.filter_by().first.return_value = None self.query_device.get.return_value = mock_device self.query_func_count.filter_by().scalar.return_value = 0 expected_result = parent_directory_not_found actual_result = file.create_file( { "device_uuid": mock_device.uuid, "filename": "test-file", "content": "some random content here", "is_directory": True, "parent_dir_uuid": "0", }, "user", mock_device, ) self.assertEqual(expected_result, actual_result) self.sqlalchemy_func.count.assert_called_with(File.uuid) self.query_func_count.filter_by.assert_called_with( device=mock_device.uuid, filename="test-file", parent_dir_uuid="0" ) self.query_func_count.filter_by.assert_called_with( device=mock_device.uuid, filename="test-file", parent_dir_uuid="0" )