Extremities Implants Market

Unable to find the path: ‘/api/v2.0/machines/2/set_owner/’

“””)

@patch(“maasserver.websockets.handlers.machine”, mock_machine_view)
class TestMachineHandler(MAASServerTestCase):
def get_application(self):
self.patch(websockets_module, “validate”, lambda: None)
return make_application()

def test_machine_list_returns_array(self):
get = self.get(‘/api/2.0/machines/’, ‘adam’)
self.assertEqual(
[{“system_id”: “abc123”}],
json_load_bytes(get.body))

def test_machine_get_returns_object(self):
get = self.get(
‘/api/2.0/machines/abc123/?op=get_summary’, ‘adam’)
self.assertEqual(
{“system_id”: “abc123”},
json_load_bytes(get.body))

def test_machine_deployment_status_returns_false(self):
# When the deployment status is requested, if this is done via
# the API 1.0 handler then the deployment status is actually
# returned as a boolean. The API 2.0 handler does not do this,
# so it returns whatever the view returns.
machine_path = ‘/api/2.0/machines/%s/’
get = self.get(machine_path % ‘abc123’, ‘adam’)
self.assertEqual(
{“system_id”: “abc123”},
json_load_bytes(get.body))

def test_machine_custom_method_returns_expected_result(self):
# When a custom HTTP method is executed, the handler returns
# whatever the view returns.
post = self.post(
‘/api/2.0/machines/’, ‘adam’, ‘action=abc123’)
self.assertEqual(
{“system_id”: “abc123”},
json_load_bytes(post.body))

class TestNodeHandler(MAASServerTestCase):
“””Testing of the node handler that does not use the API.”””

def test_node_calls_validate(self):
validate = self.patch(websockets_module, “validate”)
handler = NodeHandler({}, {})
handler.list(handler, {})
validate.assert_called_once_with(handler.request, ‘list’)

validate.reset_mock()
handler.get(handler, {})
validate.assert_called_once_with(handler.request, ‘get’)

def test_node_uses_v2_handler_for_machines(self):
handler = NodeHandler({}, {})
machine_validate = self.patch(machine_handlers, “validate”)
node_machines_handler = handler.node_machines_handler(mock.MagicMock())
node_machines_handler.list({})
self.assertEqual(1, machine_validate.call_count)

@patch(“maasserver.websockets.handlers.machine”, mock_machine_view)
class TestNodeHandlerAPI(MAASServerTestCase):
“””Testing the websockets handler through the API.”””

def get_application(self):
return make_application()

def test_node_list_returns_array(self):
# The node list uses the node_machines_handler to list the machines,
# so it should return the same as the machine handler.
get = self.get(‘/api/2.0/nodes/’, ‘adam’)
self.assertEqual(
[{“system_id”: “abc123”}],
json_load_bytes(get.body))

def test_node_get_returns_object(self):
# The node get uses the node_machines_handler to get the machine,
# so it should return the same as the machine handler.
get = self.get(‘/api/2.0/nodes/abc123/?op=get_summary’, ‘adam’)
self.assertEqual(
{“system_id”: “abc123”},
json_load_bytes(get.body))

class TestVLANsHandler(MAASServerTestCase):
“””Testing of VLAN handler that does not use API.”””

def test_vlan_uses_v2_handler(self):
handler = VLANsHandler({}, {})
validate = self.patch(vlan_module, “validate”)
handler.get_vlans_handler(mock.MagicMock())
self.assertEqual(1, validate.call_count)

class TestControllerHandler(MAASServerTestCase):
“””Testing the websockets ControllerHandler.”””

def test_controller_list_returns_controller_devices(self):
user = factory.make_User()
handler = ControllerHandler({}, {})
handler.request.user = user
rack = factory.make_RackController()
region = factory.make_RegionController()
device = factory.make_Device(owner=user)
factory.make_Machine(owner=user)
self.assertItemsEqual(
[device.system_id, rack.system_id, region.system_id],
[controller[“system_id”]
for controller in handler.list(handler)])

def test_controller_get_returns_controller_device(self):
user = factory.make_User()
handler = ControllerHandler({}, {})
handler.request.user = user
rack = factory.make_RackController()
region = factory.make_RegionController()
device = factory.make_Device(owner=user)
self.assertEqual(
device.system_id,
handler.get(handler,
{“system_id”: device.system_id})[“system_id”])
self.assertEqual(
rack.system_id,
handler.get(handler,
{“system_id”: rack.system_id})[“system_id”])
self.assertEqual(
region.system_id,
handler.get(handler,
{“system_id”: region.system_id})[“system_id”])

def test_controller_get_checks_permission(self):
user = factory.make_User()
handler = ControllerHandler({}, {})
handler.request.user = user
rack = factory.make_RackController()
user2 = factory.make_User()
device = factory.make_Device(owner=user2)
self.assertEqual(
rack.system_id,
handler.get(handler,
{“system_id”: rack.system_id})[“system_id”])
self.assertRaises(
PermissionDenied,
handler.get, handler, {“system_id”: device.system_id})

class TestDevicesHandler(MAASServerTestCase):
“””Testing the websockets DevicesHandler.”””

def test_devices_list_returns_devices_belonging_to_user(self):
user = factory.make_User()
handler = DeviceHandler({}, {})
handler.request.user = user
device = factory.make_Device(owner=user)
# Make other devices that shouldn’t be visible.
factory.make_Device(owner=factory.make_User())
devices = handler.list(handler)
self.assertEqual([device.system_id], [dev[“system_id”]
for dev in devices])

def test_devices_get_returns_device_belonging_to_user(self):
user = factory.make_User()
handler = DeviceHandler({}, {})
handler.request.user = user
device = factory.make_Device(owner=user)
self.assertEqual(
device.system_id,
handler.get(handler, {“system_id”: device.system_id})[“system_id”])

def test_devices_get_checks_permission(self):
user = factory.make_User()
handler = DeviceHandler({}, {})
handler.request.user = user
device = factory.make_Device(owner=factory.make_User())
self.assertRaises(
PermissionDenied,
handler.get, handler, {“system_id”: device.system_id})

def test_devices_create_calls_create_device(self):
# This isn’t a very thorough test because the actual behavior is tested
# in the tests for create_device. But it ensures that the call gets
# through the websockets handler.
user = factory.make_User()
handler = DeviceHandler({}, {})
handler.request.user = user
device = factory.make_Device(owner=user)
create_device = self.patch(device_module, “create”)
create_device.return_value = device
params = {
“hostname”: factory.make_name(“host”),
“domain”: factory.make_Domain().name,
“parent”: factory.make_Node().system_id,
}
handler.create(handler, params)
create_device.assert_called_once_with(
hostname=params[“hostname”], domain=params[“domain”],
parent=params[“parent”])

class TestEventHandler(MAASServerTestCase):

def test_event_list_filters_by_type(self):
handler = EventHandler({}, {})
events = [
factory.make_Event(type__level=AUDIT, node=factory.make_Node()),
factory.make_Event(type__level=DEBUG, node=factory.make_Node()),
factory.make_Event(type__level=INFO, node=factory.make_Node()),
factory.make_Event(type__level=WARNING, node=factory.make_Node()),
factory.make_Event(type__level=ERROR, node=factory.make_Node()),
factory.make_Event(type__level=CRITICAL, node=factory.make_Node()),
]
handler.request.user = factory.make_admin()

def get_result(level):
result_ids = [event.id for event in handler.list(
handler, {‘level’: level})]
expected_ids = [
event.id for event in events
if event.type.level >= EventType.LEVEL_CHOICES_DICT[level]]
self.assertItemsEqual(expected_ids, result_ids)
get_result(‘AUDIT’)
get_result(‘DEBUG’)
get_result(‘INFO’)
get_result(‘WARNING’)
get_result(‘ERROR’)
get_result(‘CRITICAL’)

def test_event_list_works_with_invalid_level(self):
handler = EventHandler({}, {})
factory.make_Event(type__level=AUDIT, node=factory.make_Node())
factory.make_Event(type__level=DEBUG, node=factory.make_Node())

handler.request.user = factory.make_admin()
result = handler.list(handler, {‘level’: ‘INVALID’})
self.assertItemsEqual([], result)

def test_event_list_works_without_level(self):
handler = EventHandler({}, {})
events = [
factory.make_Event(type__level=AUDIT, node=factory.make_Node()),
factory.make_Event(type__level=DEBUG, node=factory.make_Node()),
factory.make_Event(type__level=INFO, node=factory.make_Node()),
]
handler.request.user = factory.make_admin()
result_ids = [event.id for event in handler.list(handler, {})]
self.assertItemsEqual([event.id for event in events], result_ids)