def test__model__device__check_access__device_owner(self):
device = Device.create("the-user", True)
actual_result = device.check_access("the-user")
self.assertEqual(True, actual_result)
mock.m.contact_microservice.assert_not_called()
def test__model__device__create(self):
actual_result = Device.create("the user", False)
self.assertEqual("the user", actual_result.owner)
self.assertEqual(False, actual_result.powered_on)
self.assertRegex(actual_result.uuid,
r"[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}")
self.assertRegex(actual_result.name, r"[a-zA-Z0-9]{1,15}")
mock.wrapper.session.add.assert_called_with(actual_result)
mock.wrapper.session.commit.assert_called_with()
def test__model__device__check_access__part_owner(self):
device = Device.create("the-user", True)
expected_result = mock.m.contact_microservice()["ok"]
actual_result = device.check_access("other-user")
self.assertEqual(expected_result, actual_result)
mock.m.contact_microservice.assert_called_with(
"service", ["check_part_owner"], {
"user_uuid": "other-user",
"device_uuid": device.uuid
})
def post(self):
if not current_user.is_admin:
abort(401)
data = request.get_json()
serial_number = data.get("serial_number")
if serial_number is None:
abort(400)
device = DeviceModel.create(serial_number)
device.put()
return jsonify(device.to_json())
def create(data: dict, user: str) -> dict:
"""
Create a device.
:param data: The given data.
:param user: The user uuid.
:return: The response
"""
device_count = wrapper.session.query(Device).filter_by(owner=user).first()
if device_count:
return already_have_device
device: Device = Device.create(user, 1, True)
return device.serialize
def handle_update_device(socket, message):
j_device = message['device']
device = Device.create(
code=j_device['code'],
model=j_device['model'],
name=j_device['name'],
system=j_device['system'],
distribution_cabinet=j_device['distribution_cabinet'],
local_control_panel=j_device['local_control_panel'],
dcs_cabinet=j_device['dcs_cabinet'],
forward_device=j_device['forward_device'],
backward_device=j_device['backward_device'],
legend=j_device['legend'],
workshop=Workshop.select().where(Device.code == j_device['workshop']))
device.save()
return 0, 'succeed'
def create_device(data: dict, user: str) -> dict:
"""
Create a device.
:param data: The given data.
:param user: The user uuid.
:return: The response
"""
count: int = wrapper.session.query(func.count(
Device.uuid)).filter_by(owner=user).scalar()
if count >= 3:
return maximum_devices_reached
comp, message = check_compatible(data)
if not comp:
return message
comp, message = check_exists(user, data)
if not comp:
return message
performance: tuple = calculate_power(data)
device: Device = Device.create(user, True)
Workload.create(device.uuid, performance)
create_hardware(data, device.uuid)
delete_items(user, data)
m.contact_microservice("service", ["device_init"], {
"device_uuid": device.uuid,
"user": device.owner
})
return device.serialize
def test__model__device__create__different_uuid(self):
first_element = Device.create("user", True).uuid
second_element = Device.create("user", True).uuid
self.assertNotEqual(first_element, second_element)
