def test_select_for_hardware_scripts_adds_system_mainboard(self):
node = factory.make_Node()
system_vendor = factory.make_NodeMetadata(node=node,
key='system_vendor')
system_product = factory.make_NodeMetadata(node=node,
key='system_product')
system_version = factory.make_NodeMetadata(node=node,
key='system_version')
mainboard_vendor = factory.make_NodeMetadata(node=node,
key='mainboard_vendor')
mainboard_product = factory.make_NodeMetadata(node=node,
key='mainboard_product')
script = factory.make_Script(
script_type=SCRIPT_TYPE.COMMISSIONING,
for_hardware=[
random.choice([
"system_vendor:%s" % system_vendor.value,
"system_product:%s" % system_product.value,
"system_version:%s" % system_version.value,
"mainboard_vendor:%s" % mainboard_vendor.value,
"mainboard_product:%s" % mainboard_product.value,
])
])
script_set = ScriptSet.objects.create_commissioning_script_set(
node, [random.choice(script.tags)])
script_set.select_for_hardware_scripts()
self.assertItemsEqual(
list(NODE_INFO_SCRIPTS) + [script.name],
[script_result.name for script_result in script_set])
def test_multiple_keys_on_node(self):
# We can only ever have one NodeMetadata object for a particular node
# and key.
entry1 = factory.make_NodeMetadata(key="key1", value="value")
entry2 = factory.make_NodeMetadata(node=entry1.node,
key="key2",
value="value")
self.assertNotEqual(entry1, entry2)
def test_list_switches_includes_metadata(self):
owner = factory.make_User()
handler = SwitchHandler(owner, {})
machine = factory.make_Machine(owner=owner)
metadata = {
NODE_METADATA.VENDOR_NAME: "Canonical",
NODE_METADATA.PHYSICAL_MODEL_NAME: "Cloud-in-a-box"
}
for key, value in metadata.items():
factory.make_NodeMetadata(node=machine, key=key, value=value)
factory.make_Switch(node=machine)
self.assertItemsEqual(
[metadata], [result['metadata'] for result in handler.list({})])
def test_create_commissioning_scripts_with_for_hardware_ignores_wo_tag(
self):
node = factory.make_Node()
system_vendor = factory.make_NodeMetadata(node=node,
key='system_vendor')
system_product = factory.make_NodeMetadata(node=node,
key='system_product')
system_version = factory.make_NodeMetadata(node=node,
key='system_version')
mainboard_vendor = factory.make_NodeMetadata(node=node,
key='mainboard_vendor')
mainboard_product = factory.make_NodeMetadata(node=node,
key='mainboard_product')
factory.make_Script(
script_type=SCRIPT_TYPE.COMMISSIONING,
for_hardware=[
random.choice([
"usb:174c:07d1",
"pci:8086:1918",
"modalias:pci:v00001A03d00001150sv000015D9*",
"system_vendor:%s" % system_vendor.value,
"system_product:%s" % system_product.value,
"system_version:%s" % system_version.value,
"mainboard_vendor:%s" % mainboard_vendor.value,
"mainboard_product:%s" % mainboard_product.value,
])
])
to_mock = (node.__module__ + "." + node.__class__.__qualname__ +
".modaliases")
with mock.patch(to_mock, new_callable=PropertyMock) as mods:
mods.return_value = [
'pci:v00008086d00001918sv000015D9sd00000888bc06sc00i00',
'usb:v174Cp07D1d1000dc00dsc00dp00ic08isc06ip50in00',
'pci:v00001A03d00001150sv000015D9sd00000888bc06sc04i00',
]
expected_scripts = list(NODE_INFO_SCRIPTS)
other_script = factory.make_Script(
script_type=SCRIPT_TYPE.COMMISSIONING)
expected_scripts.append(other_script.name)
script_set = ScriptSet.objects.create_commissioning_script_set(
node, [other_script.name])
self.assertItemsEqual(
expected_scripts,
[script_result.name for script_result in script_set])
self.assertEquals(RESULT_TYPE.COMMISSIONING,
script_set.result_type)
self.assertEquals(node.power_state,
script_set.power_state_before_transition)
def test_unique_on_node_and_key(self):
# We can only ever have one NodeMetadata object for a particular node
# and key.
entry = factory.make_NodeMetadata()
self.assertRaises(ValidationError,
factory.make_NodeMetadata,
node=entry.node,
key=entry.key)
def test_hardware_info(self):
self.become_admin()
machine = factory.make_Machine(owner=self.user)
system_vendor = factory.make_NodeMetadata(machine, 'system_vendor')
system_product = factory.make_NodeMetadata(machine, 'system_product')
system_version = factory.make_NodeMetadata(machine, 'system_version')
system_serial = factory.make_NodeMetadata(machine, 'system_serial')
cpu_model = factory.make_NodeMetadata(machine, 'cpu_model')
mainboard_vendor = factory.make_NodeMetadata(
machine, 'mainboard_vendor')
mainboard_product = factory.make_NodeMetadata(
machine, 'mainboard_product')
mainboard_firmware_version = factory.make_NodeMetadata(
machine, 'mainboard_firmware_version')
mainboard_firmware_date = factory.make_NodeMetadata(
machine, 'mainboard_firmware_date')
factory.make_NodeMetadata(machine)
response = self.client.get(self.get_node_uri(machine))
parsed_result = json_load_bytes(response.content)
self.assertThat(response, HasStatusCode(http.client.OK))
self.assertDictEqual({
'system_vendor': system_vendor.value,
'system_product': system_product.value,
'system_version': system_version.value,
'system_serial': system_serial.value,
'cpu_model': cpu_model.value,
'mainboard_vendor': mainboard_vendor.value,
'mainboard_product': mainboard_product.value,
'mainboard_firmware_version': mainboard_firmware_version.value,
'mainboard_firmware_date': mainboard_firmware_date.value,
}, parsed_result['hardware_info'])
def test_hardware_info(self):
self.become_admin()
machine = factory.make_Machine(owner=self.user)
system_vendor = factory.make_NodeMetadata(machine, "system_vendor")
system_product = factory.make_NodeMetadata(machine, "system_product")
system_family = factory.make_NodeMetadata(machine, "system_family")
system_version = factory.make_NodeMetadata(machine, "system_version")
system_serial = factory.make_NodeMetadata(machine, "system_serial")
system_sku = factory.make_NodeMetadata(machine, "system_sku")
cpu_model = factory.make_NodeMetadata(machine, "cpu_model")
mainboard_vendor = factory.make_NodeMetadata(machine,
"mainboard_vendor")
mainboard_product = factory.make_NodeMetadata(machine,
"mainboard_product")
mainboard_serial = factory.make_NodeMetadata(machine,
"mainboard_serial")
mainboard_version = factory.make_NodeMetadata(machine,
"mainboard_version")
mainboard_firmware_vendor = factory.make_NodeMetadata(
machine, "mainboard_firmware_vendor")
mainboard_firmware_version = factory.make_NodeMetadata(
machine, "mainboard_firmware_version")
mainboard_firmware_date = factory.make_NodeMetadata(
machine, "mainboard_firmware_date")
chassis_vendor = factory.make_NodeMetadata(machine, "chassis_vendor")
chassis_type = factory.make_NodeMetadata(machine, "chassis_type")
chassis_serial = factory.make_NodeMetadata(machine, "chassis_serial")
chassis_version = factory.make_NodeMetadata(machine, "chassis_version")
factory.make_NodeMetadata(machine)
response = self.client.get(self.get_node_uri(machine))
parsed_result = json_load_bytes(response.content)
self.assertThat(response, HasStatusCode(http.client.OK))
self.assertDictEqual(
{
"system_vendor": system_vendor.value,
"system_product": system_product.value,
"system_family": system_family.value,
"system_version": system_version.value,
"system_sku": system_sku.value,
"system_serial": system_serial.value,
"cpu_model": cpu_model.value,
"mainboard_vendor": mainboard_vendor.value,
"mainboard_product": mainboard_product.value,
"mainboard_serial": mainboard_serial.value,
"mainboard_version": mainboard_version.value,
"mainboard_firmware_vendor": mainboard_firmware_vendor.value,
"mainboard_firmware_version": mainboard_firmware_version.value,
"mainboard_firmware_date": mainboard_firmware_date.value,
"chassis_vendor": chassis_vendor.value,
"chassis_type": chassis_type.value,
"chassis_serial": chassis_serial.value,
"chassis_version": chassis_version.value,
},
parsed_result["hardware_info"],
)
def test_str(self):
# A NodeMetadata object string representation references the parent
# node hostname.
node = factory.make_Machine(hostname="foobar")
entry = factory.make_NodeMetadata(node=node, key="key")
self.assertEqual("NodeMetadata (foobar/key)", str(entry))
