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