def test_GET_returns_empty_if_no_networks(self):
self.become_admin()
response = self.client.get(reverse("license_keys_handler"))
self.assertEqual(http.client.OK, response.status_code,
response.content)
self.assertEqual([], json_load_bytes(response.content))
def test_PUT_include_output(self):
self.become_admin()
script_set = self.make_scriptset()
script_results = {}
for _ in range(3):
script_result = factory.make_ScriptResult(script_set=script_set)
script_results[script_result.name] = script_result
response = self.client.put(self.get_script_result_uri(script_set),
{"include_output": True})
self.assertThat(response, HasStatusCode(http.client.OK))
parsed_result = json_load_bytes(response.content)
results = parsed_result.pop("results")
self.assertDictEqual(
{
"id":
script_set.id,
"system_id":
script_set.node.system_id,
"type":
script_set.result_type,
"type_name":
script_set.result_type_name,
"last_ping":
fmt_time(script_set.last_ping),
"status":
script_set.status,
"status_name":
script_set.status_name,
"started":
fmt_time(script_set.started),
"ended":
fmt_time(script_set.ended),
"runtime":
script_set.runtime,
"resource_uri":
"/MAAS/api/2.0/nodes/%s/results/%d/" %
(script_set.node.system_id, script_set.id),
},
parsed_result,
)
for result in results:
script_result = script_results[result["name"]]
self.assertDictEqual(
{
"id": script_result.id,
"name": script_result.name,
"created": fmt_time(script_result.created),
"updated": fmt_time(script_result.updated),
"status": script_result.status,
"status_name": script_result.status_name,
"exit_status": script_result.exit_status,
"started": fmt_time(script_result.started),
"ended": fmt_time(script_result.ended),
"runtime": script_result.runtime,
"starttime": script_result.starttime,
"endtime": script_result.endtime,
"estimated_runtime": script_result.estimated_runtime,
"parameters": script_result.parameters,
"script_id": script_result.script_id,
"script_revision_id": script_result.script_version_id,
"suppressed": script_result.suppressed,
"output": b64encode(script_result.output).decode(),
"stdout": b64encode(script_result.stdout).decode(),
"stderr": b64encode(script_result.stderr).decode(),
"result": b64encode(script_result.result).decode(),
},
result,
)
def test_describe(self):
response = self.client.get(reverse("describe"))
description = json_load_bytes(response.content)
self.assertSetEqual({"doc", "handlers", "resources", "hash"},
set(description))
self.assertIsInstance(description["handlers"], list)
def test_describe_hash_is_the_api_hash(self):
response = self.client.get(reverse("describe"))
description = json_load_bytes(response.content)
self.assertThat(description["hash"],
Equals(get_api_description_hash()))
def test_read(self):
node = factory.make_Node(with_boot_disk=False)
# Add three physical block devices
physical_block_devices = [
factory.make_PhysicalBlockDevice(node=node, size=10 * 1000**3)
for _ in range(3)
]
# Partition and add a LVM_PV filesystem to the last two physical block
# devices. Leave the first partition alone.
lvm_pv_filesystems = [
factory.make_Filesystem(block_device=device,
fstype=FILESYSTEM_TYPE.LVM_PV)
for device in physical_block_devices[1:]
]
# Make a filesystem_group (analogous to a volume group) on top of our
# two lvm-pm filesystems.
filesystem_group = factory.make_FilesystemGroup(
group_type=FILESYSTEM_GROUP_TYPE.LVM_VG,
filesystems=lvm_pv_filesystems,
)
# Make a VirtualBlockDevice on top of the filesystem group we just
# made.
virtual_block_device = factory.make_VirtualBlockDevice(
filesystem_group=filesystem_group, size=10 * 1000**3)
# Add some iSCSI block devices.
iscsi_block_devices = [
factory.make_ISCSIBlockDevice(node=node, size=10 * 1000**3)
for _ in range(3)
]
uri = get_blockdevices_uri(node)
response = self.client.get(uri)
self.assertEqual(http.client.OK, response.status_code,
response.content)
devices = json_load_bytes(response.content)
# We should have seven devices, three physical, one virtual, and
# three iscsi.
self.assertEqual(len(devices), 7)
self.assertEqual(len([d for d in devices if d["type"] == "physical"]),
3)
self.assertEqual(len([d for d in devices if d["type"] == "virtual"]),
1)
self.assertEqual(len([d for d in devices if d["type"] == "iscsi"]), 3)
# The IDs we expect and the IDs we got through the API should match.
expected_device_ids = [
d.id for d in (physical_block_devices + [virtual_block_device] +
iscsi_block_devices)
]
result_device_ids = [d["id"] for d in devices]
self.assertItemsEqual(expected_device_ids, result_device_ids)
# Validate that every one has a resource_uri.
for d in devices:
self.expectThat(
d,
Contains("resource_uri"),
"Device(%s:%s) is missing a resource_uri." %
(d["type"], d["id"]),
)
def test_POST_reserve_rejects_invalid_ip(self):
response = self.post_reservation_request(ip_address="1690.254.0.1")
self.assertEqual(http.client.BAD_REQUEST, response.status_code)
self.assertEqual(
dict(ip_address=["Enter a valid IPv4 or IPv6 address."]),
json_load_bytes(response.content))
def test_health_status(self):
self.become_admin()
machine = factory.make_Machine(owner=self.user)
commissioning_script_set = factory.make_ScriptSet(
result_type=RESULT_TYPE.COMMISSIONING, node=machine)
testing_script_set = factory.make_ScriptSet(
result_type=RESULT_TYPE.TESTING, node=machine)
make_script_result = partial(
factory.make_ScriptResult,
script_set=testing_script_set,
status=factory.pick_choice(SCRIPT_STATUS_CHOICES,
but_not=[SCRIPT_STATUS.ABORTED]),
)
commissioning_script_result = make_script_result(
script_set=commissioning_script_set,
script=factory.make_Script(script_type=SCRIPT_TYPE.COMMISSIONING),
)
cpu_script_result = make_script_result(script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.CPU,
))
memory_script_result = make_script_result(script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.MEMORY,
))
network_script_result = make_script_result(script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.NETWORK,
))
storage_script_result = make_script_result(script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.STORAGE,
))
node_script_result = make_script_result(script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.NODE,
))
interface_script_result = make_script_result(
script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.NETWORK,
))
testing_script_results = (
machine.get_latest_testing_script_results.exclude(
status=SCRIPT_STATUS.ABORTED))
testing_status = get_status_from_qs(testing_script_results)
response = self.client.get(self.get_node_uri(machine))
parsed_result = json_load_bytes(response.content)
def status(s):
return get_status_from_qs([s])
def status_name(s):
return SCRIPT_STATUS_CHOICES[status(s)][1]
self.assertThat(response, HasStatusCode(http.client.OK))
self.assertEqual(
status(commissioning_script_result),
parsed_result["commissioning_status"],
)
self.assertEqual(
status_name(commissioning_script_result),
parsed_result["commissioning_status_name"],
)
self.assertEqual(testing_status, parsed_result["testing_status"])
self.assertEqual(
SCRIPT_STATUS_CHOICES[testing_status][1],
parsed_result["testing_status_name"],
)
self.assertEqual(status(cpu_script_result),
parsed_result["cpu_test_status"])
self.assertEqual(
status_name(cpu_script_result),
parsed_result["cpu_test_status_name"],
)
self.assertEqual(status(memory_script_result),
parsed_result["memory_test_status"])
self.assertEqual(
status_name(memory_script_result),
parsed_result["memory_test_status_name"],
)
self.assertEqual(status(network_script_result),
parsed_result["network_test_status"])
self.assertEqual(
status_name(network_script_result),
parsed_result["network_test_status_name"],
)
self.assertEqual(status(storage_script_result),
parsed_result["storage_test_status"])
self.assertEqual(
status_name(storage_script_result),
parsed_result["storage_test_status_name"],
)
self.assertEqual(status(node_script_result),
parsed_result["other_test_status"])
self.assertEqual(
status_name(node_script_result),
parsed_result["other_test_status_name"],
)
self.assertEqual(
status(interface_script_result),
parsed_result["interface_test_status"],
)
self.assertEqual(
status_name(interface_script_result),
parsed_result["interface_test_status_name"],
)
def test_GET_query_prev_next_URIs_preserve_query_params(self):
expected_uri_path = reverse("events_handler")
# Build a query dict for the given combination of params.
request_params = {
param: self.factories[param]()
for param in self.params
}
# Ensure that op is always included.
request_params["op"] = "query"
response = self.client.get(reverse("events_handler"), request_params)
self.assertEqual(
http.client.OK,
response.status_code,
response.content.decode(settings.DEFAULT_CHARSET),
)
parsed_result = json_load_bytes(response.content)
# next_uri is always set because new matching events may be
# logged at a later date.
next_uri = urlparse(parsed_result["next_uri"])
self.assertThat(
next_uri,
MatchesStructure.byEquality(
scheme="",
netloc="",
params="",
path=expected_uri_path,
fragment="",
),
)
next_uri_params = dict(
parse_qsl(next_uri.query, keep_blank_values=True))
if "before" in request_params:
# The window was limited in the request by the presence of a
# `before` argument, so the next_uri omits the `before` argument
# and substitutes a related `after` argument.
expected_params = request_params.copy()
before = expected_params.pop("before")
expected_params["after"] = str(int(before) - 1)
self.assertDictEqual(expected_params, next_uri_params)
else:
# Because we have not created any actual events in the database,
# the next_uri has the same parameters as we already requested.
self.assertDictEqual(request_params, next_uri_params)
# prev_uri is set when there MAY be older matching events, but
# sometimes we can know there aren't any.
if "after" in request_params:
prev_uri = urlparse(parsed_result["prev_uri"])
self.assertThat(
prev_uri,
MatchesStructure.byEquality(
scheme="",
netloc="",
params="",
path=expected_uri_path,
fragment="",
),
)
prev_uri_params = dict(
parse_qsl(prev_uri.query, keep_blank_values=True))
if "after" in request_params:
# The window was limited in the request by the presence of an
# `after` argument, so the prev_uri omits the `after` argument
# and substitutes a related `before` argument.
expected_params = request_params.copy()
after = expected_params.pop("after")
expected_params["before"] = str(int(after) + 1)
self.assertDictEqual(expected_params, prev_uri_params)
else:
# Because we have not created any actual test events, the
# prev_uri has the same parameters as we already requested.
self.assertDictEqual(request_params, prev_uri_params)
else:
# Because we have not created any actual test events AND the
# search window was not limited by `after`, we can be certain that
# no older matching events exist, hence prev_uri is not provided.
self.assertThat(parsed_result["prev_uri"], Is(None))
def test_POST_returns_limited_fields(self):
response = self.client.post(
reverse('machines_handler'), {
'hostname': factory.make_string(),
'architecture': make_usable_architecture(self),
'power_type': 'manual',
'mac_addresses': ['aa:bb:cc:dd:ee:ff', '22:bb:cc:dd:ee:ff'],
})
parsed_result = json_load_bytes(response.content)
self.assertItemsEqual([
'hostname',
'hardware_uuid',
'default_gateways',
'domain',
'fqdn',
'owner',
'owner_data',
'system_id',
'architecture',
'min_hwe_kernel',
'hwe_kernel',
'status',
'locked',
'osystem',
'distro_series',
'netboot',
'node_type',
'node_type_name',
'pod',
'power_type',
'power_state',
'resource_uri',
'tag_names',
'ip_addresses',
'interface_set',
'cpu_count',
'cpu_speed',
'storage',
'memory',
'swap_size',
'zone',
'pool',
'disable_ipv4',
'address_ttl',
'boot_disk',
'boot_interface',
'blockdevice_set',
'iscsiblockdevice_set',
'physicalblockdevice_set',
'virtualblockdevice_set',
'volume_groups',
'raids',
'cache_sets',
'bcaches',
'status_name',
'status_message',
'status_action',
'special_filesystems',
'current_commissioning_result_id',
'current_testing_result_id',
'current_installation_result_id',
'commissioning_status',
'commissioning_status_name',
'testing_status',
'testing_status_name',
'cpu_test_status',
'cpu_test_status_name',
'memory_test_status',
'memory_test_status_name',
'storage_test_status',
'storage_test_status_name',
'other_test_status',
'other_test_status_name',
'hardware_info',
], list(parsed_result))
def test_read_returns_limited_fields(self):
pod = factory.make_Pod(capabilities=[])
for _ in range(3):
factory.make_PodStoragePool(pod=pod)
response = self.client.get(reverse("pods_handler"))
parsed_result = json_load_bytes(response.content)
self.assertItemsEqual(
[
"id",
"name",
"tags",
"type",
"resource_uri",
"capabilities",
"architectures",
"total",
"used",
"zone",
"available",
"cpu_over_commit_ratio",
"memory_over_commit_ratio",
"storage_pools",
"pool",
"host",
"default_macvlan_mode",
"version",
],
list(parsed_result[0]),
)
self.assertItemsEqual(
[
"cores",
"memory",
"local_storage",
],
list(parsed_result[0]["total"]),
)
self.assertItemsEqual(
[
"cores",
"memory",
"local_storage",
],
list(parsed_result[0]["used"]),
)
self.assertItemsEqual(
[
"cores",
"memory",
"local_storage",
],
list(parsed_result[0]["available"]),
)
self.assertItemsEqual(
[
"id",
"name",
"type",
"path",
"total",
"used",
"available",
"default",
],
list(parsed_result[0]["storage_pools"][0]),
)
def test_GET_with_machine(self):
machine = factory.make_Machine()
vm = factory.make_VirtualMachine(machine=machine)
response = self.client.get(get_vm_uri(vm.id))
details = json_load_bytes(response.content)
self.assertEqual(details["machine_id"], machine.id)
def test_read_returns_limited_fields(self):
pod = factory.make_Pod(capabilities=[
Capabilities.FIXED_LOCAL_STORAGE, Capabilities.ISCSI_STORAGE])
for _ in range(3):
factory.make_PodStoragePool(pod=pod)
response = self.client.get(reverse('pods_handler'))
parsed_result = json_load_bytes(response.content)
self.assertItemsEqual(
[
'id',
'name',
'tags',
'type',
'resource_uri',
'capabilities',
'architectures',
'total',
'used',
'zone',
'available',
'cpu_over_commit_ratio',
'memory_over_commit_ratio',
'storage_pools',
'pool',
],
list(parsed_result[0]))
self.assertItemsEqual(
[
'cores',
'memory',
'local_storage',
'local_disks',
'iscsi_storage',
],
list(parsed_result[0]['total']))
self.assertItemsEqual(
[
'cores',
'memory',
'local_storage',
'local_disks',
'iscsi_storage',
],
list(parsed_result[0]['used']))
self.assertItemsEqual(
[
'cores',
'memory',
'local_storage',
'local_disks',
'iscsi_storage',
],
list(parsed_result[0]['available']))
self.assertItemsEqual(
[
'id',
'name',
'type',
'path',
'total',
'used',
'available',
'default',
],
list(parsed_result[0]['storage_pools'][0]))
def test_GET_returns_empty_if_no_ipaddresses(self):
response = self.client.get(reverse('ipaddresses_handler'))
self.assertEqual(http.client.OK, response.status_code,
response.content)
self.assertEqual([], json_load_bytes(response.content))
def test_PUT_filters(self):
self.become_admin()
scripts = [factory.make_Script() for _ in range(10)]
script_set = self.make_scriptset()
script_results = {}
for script in scripts:
script_result = factory.make_ScriptResult(script_set=script_set,
script=script)
script_results[script_result.name] = script_result
results_list = list(script_results.values())
filtered_results = [random.choice(results_list) for _ in range(3)]
response = self.client.get(
self.get_script_result_uri(script_set),
{
"filters":
"%s,%s,%d" % (
filtered_results[0].name,
random.choice([
tag for tag in filtered_results[1].script.tags
if "tag" in tag
]),
filtered_results[2].id,
)
},
)
self.assertThat(response, HasStatusCode(http.client.OK))
parsed_result = json_load_bytes(response.content)
results = parsed_result.pop("results")
self.assertDictEqual(
{
"id":
script_set.id,
"system_id":
script_set.node.system_id,
"type":
script_set.result_type,
"type_name":
script_set.result_type_name,
"last_ping":
fmt_time(script_set.last_ping),
"status":
script_set.status,
"status_name":
script_set.status_name,
"started":
fmt_time(script_set.started),
"ended":
fmt_time(script_set.ended),
"runtime":
script_set.runtime,
"resource_uri":
"/MAAS/api/2.0/nodes/%s/results/%d/" %
(script_set.node.system_id, script_set.id),
},
parsed_result,
)
for result in results:
self.assertIn(
result["name"],
[script_result.name for script_result in filtered_results],
)
script_result = script_results[result["name"]]
self.assertDictEqual(
{
"id": script_result.id,
"name": script_result.name,
"created": fmt_time(script_result.created),
"updated": fmt_time(script_result.updated),
"status": script_result.status,
"status_name": script_result.status_name,
"exit_status": script_result.exit_status,
"started": fmt_time(script_result.started),
"ended": fmt_time(script_result.ended),
"runtime": script_result.runtime,
"starttime": script_result.starttime,
"endtime": script_result.endtime,
"estimated_runtime": script_result.estimated_runtime,
"parameters": script_result.parameters,
"script_id": script_result.script_id,
"script_revision_id": script_result.script_version_id,
"suppressed": script_result.suppressed,
},
result,
)
def test_list_files_filters_by_owner(self):
factory.make_FileStorage(owner=factory.make_User())
response = self.make_API_GET_request()
self.assertEqual(http.client.OK, response.status_code)
parsed_results = json_load_bytes(response.content)
self.assertEqual([], parsed_results)
def test_POST_returns_limited_fields(self):
response = self.client.post(
reverse("machines_handler"),
{
"hostname": factory.make_string(),
"architecture": make_usable_architecture(self),
"power_type": "manual",
"mac_addresses": ["aa:bb:cc:dd:ee:ff", "22:bb:cc:dd:ee:ff"],
},
)
parsed_result = json_load_bytes(response.content)
self.assertItemsEqual(
[
"hostname",
"description",
"hardware_uuid",
"default_gateways",
"domain",
"fqdn",
"owner",
"owner_data",
"system_id",
"architecture",
"min_hwe_kernel",
"hwe_kernel",
"status",
"locked",
"osystem",
"distro_series",
"netboot",
"node_type",
"node_type_name",
"pod",
"power_type",
"power_state",
"resource_uri",
"tag_names",
"ip_addresses",
"interface_set",
"cpu_count",
"cpu_speed",
"storage",
"memory",
"swap_size",
"zone",
"pool",
"disable_ipv4",
"address_ttl",
"boot_disk",
"bios_boot_method",
"boot_interface",
"blockdevice_set",
"iscsiblockdevice_set",
"numanode_set",
"physicalblockdevice_set",
"virtualblockdevice_set",
"volume_groups",
"raids",
"cache_sets",
"bcaches",
"status_name",
"status_message",
"status_action",
"special_filesystems",
"current_commissioning_result_id",
"current_testing_result_id",
"current_installation_result_id",
"commissioning_status",
"commissioning_status_name",
"testing_status",
"testing_status_name",
"cpu_test_status",
"cpu_test_status_name",
"memory_test_status",
"memory_test_status_name",
"network_test_status",
"network_test_status_name",
"storage_test_status",
"storage_test_status_name",
"other_test_status",
"other_test_status_name",
"hardware_info",
"interface_test_status",
"interface_test_status_name",
"virtualmachine_id",
],
list(parsed_result),
)
def test_GET_include_output(self):
script_set = self.make_scriptset()
script_results = {}
for _ in range(3):
script_result = factory.make_ScriptResult(script_set=script_set)
script_results[script_result.name] = script_result
response = self.client.get(self.get_script_result_uri(script_set),
{'include_output': True})
self.assertThat(response, HasStatusCode(http.client.OK))
parsed_result = json_load_bytes(response.content)
results = parsed_result.pop('results')
self.assertDictEqual(
{
'id':
script_set.id,
'system_id':
script_set.node.system_id,
'type':
script_set.result_type,
'type_name':
script_set.result_type_name,
'last_ping':
fmt_time(script_set.last_ping),
'status':
script_set.status,
'status_name':
script_set.status_name,
'started':
fmt_time(script_set.started),
'ended':
fmt_time(script_set.ended),
'runtime':
script_set.runtime,
'resource_uri':
'/MAAS/api/2.0/nodes/%s/results/%d/' %
(script_set.node.system_id, script_set.id),
}, parsed_result)
for result in results:
script_result = script_results[result['name']]
self.assertDictEqual(
{
'id': script_result.id,
'name': script_result.name,
'created': fmt_time(script_result.created),
'updated': fmt_time(script_result.updated),
'status': script_result.status,
'status_name': script_result.status_name,
'exit_status': script_result.exit_status,
'started': fmt_time(script_result.started),
'ended': fmt_time(script_result.ended),
'runtime': script_result.runtime,
'starttime': script_result.starttime,
'endtime': script_result.endtime,
'estimated_runtime': script_result.estimated_runtime,
'parameters': script_result.parameters,
'script_id': script_result.script_id,
'script_revision_id': script_result.script_version_id,
'output': b64encode(script_result.output).decode(),
'stdout': b64encode(script_result.stdout).decode(),
'stderr': b64encode(script_result.stderr).decode(),
'result': b64encode(script_result.result).decode(),
}, result)
def test_GET_returns_empty_if_no_subnets(self):
response = self.client.get(reverse("networks_handler"))
self.assertEqual(http.client.OK, response.status_code,
response.content)
self.assertEqual([], json_load_bytes(response.content))
def test_GET_filters(self):
scripts = [factory.make_Script() for _ in range(10)]
script_set = self.make_scriptset()
script_results = {}
for script in scripts:
script_result = factory.make_ScriptResult(script_set=script_set,
script=script)
script_results[script_result.name] = script_result
results_list = list(script_results.values())
filtered_results = [random.choice(results_list) for _ in range(3)]
response = self.client.get(
self.get_script_result_uri(script_set), {
'filters':
'%s,%s,%d' %
(filtered_results[0].name,
random.choice([
tag
for tag in filtered_results[1].script.tags if 'tag' in tag
]), filtered_results[2].id)
})
self.assertThat(response, HasStatusCode(http.client.OK))
parsed_result = json_load_bytes(response.content)
results = parsed_result.pop('results')
self.assertDictEqual(
{
'id':
script_set.id,
'system_id':
script_set.node.system_id,
'type':
script_set.result_type,
'type_name':
script_set.result_type_name,
'last_ping':
fmt_time(script_set.last_ping),
'status':
script_set.status,
'status_name':
script_set.status_name,
'started':
fmt_time(script_set.started),
'ended':
fmt_time(script_set.ended),
'runtime':
script_set.runtime,
'resource_uri':
'/MAAS/api/2.0/nodes/%s/results/%d/' %
(script_set.node.system_id, script_set.id),
}, parsed_result)
for result in results:
self.assertIn(
result['name'],
[script_result.name for script_result in filtered_results])
script_result = script_results[result['name']]
self.assertDictEqual(
{
'id': script_result.id,
'name': script_result.name,
'created': fmt_time(script_result.created),
'updated': fmt_time(script_result.updated),
'status': script_result.status,
'status_name': script_result.status_name,
'exit_status': script_result.exit_status,
'started': fmt_time(script_result.started),
'ended': fmt_time(script_result.ended),
'runtime': script_result.runtime,
'starttime': script_result.starttime,
'endtime': script_result.endtime,
'estimated_runtime': script_result.estimated_runtime,
'parameters': script_result.parameters,
'script_id': script_result.script_id,
'script_revision_id': script_result.script_version_id,
}, result)
def test_health_status(self):
self.become_admin()
machine = factory.make_Machine(owner=self.user)
commissioning_script_set = factory.make_ScriptSet(
result_type=RESULT_TYPE.COMMISSIONING, node=machine)
testing_script_set = factory.make_ScriptSet(
result_type=RESULT_TYPE.TESTING, node=machine)
make_script_result = partial(
factory.make_ScriptResult, script_set=testing_script_set,
status=factory.pick_choice(
SCRIPT_STATUS_CHOICES, but_not=[SCRIPT_STATUS.ABORTED]))
commissioning_script_result = make_script_result(
script_set=commissioning_script_set, script=factory.make_Script(
script_type=SCRIPT_TYPE.COMMISSIONING))
cpu_script_result = make_script_result(
script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.CPU))
memory_script_result = make_script_result(
script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.MEMORY))
storage_script_result = make_script_result(
script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.STORAGE))
node_script_result = make_script_result(
script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.NODE))
testing_script_results = (
machine.get_latest_testing_script_results.exclude(
status=SCRIPT_STATUS.ABORTED))
testing_status = get_status_from_qs(testing_script_results)
response = self.client.get(self.get_node_uri(machine))
parsed_result = json_load_bytes(response.content)
status = lambda s: get_status_from_qs([s])
status_name = lambda s: SCRIPT_STATUS_CHOICES[status(s)][1]
self.assertThat(response, HasStatusCode(http.client.OK))
self.assertEquals(
status(commissioning_script_result),
parsed_result['commissioning_status'])
self.assertEquals(
status_name(commissioning_script_result),
parsed_result['commissioning_status_name'])
self.assertEquals(testing_status, parsed_result['testing_status'])
self.assertEquals(
SCRIPT_STATUS_CHOICES[testing_status][1],
parsed_result['testing_status_name'])
self.assertEquals(
status(cpu_script_result), parsed_result['cpu_test_status'])
self.assertEquals(
status_name(cpu_script_result),
parsed_result['cpu_test_status_name'])
self.assertEquals(
status(memory_script_result), parsed_result['memory_test_status'])
self.assertEquals(
status_name(memory_script_result),
parsed_result['memory_test_status_name'])
self.assertEquals(
status(storage_script_result),
parsed_result['storage_test_status'])
self.assertEquals(
status_name(storage_script_result),
parsed_result['storage_test_status_name'])
self.assertEquals(
status(node_script_result),
parsed_result['other_test_status'])
self.assertEquals(
status_name(node_script_result),
parsed_result['other_test_status_name'])
def test_adding_returns_badrequest_when_key_not_in_form(self):
response = self.client.post(reverse('sshkeys_handler'))
self.assertEqual(http.client.BAD_REQUEST, response.status_code,
response)
self.assertEqual(dict(key=["This field is required."]),
json_load_bytes(response.content))
