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"
)
