def test__node_resource_malformed_capabilities(self): props = _get_properties() props['capabilities'] = 'test:capability,:no_key,no_val:' node = ironic_utils.get_test_node(properties=props) result = self.driver._node_resource(node) stats = jsonutils.loads(result['stats']) self.assertEqual('capability', stats.get('test'))
def test_rebuild_failures(self, mock_save, mock_get, mock_driver_fields, mock_fg_bid, mock_set_pstate): node_uuid = uuidutils.generate_uuid() instance_uuid = uuidutils.generate_uuid() node = ironic_utils.get_test_node(uuid=node_uuid, instance_uuid=instance_uuid, instance_type_id=5) mock_get.return_value = node image_meta = ironic_utils.get_test_image_meta() flavor_id = 5 flavor = {'id': flavor_id, 'name': 'baremetal'} mock_fg_bid.return_value = flavor instance = fake_instance.fake_instance_obj(self.ctx, uuid=instance_uuid, node=node_uuid, instance_type_id=flavor_id) exceptions = [ exception.NovaException(), ironic_exception.BadRequest(), ironic_exception.InternalServerError(), ] for e in exceptions: mock_set_pstate.side_effect = e self.assertRaises(exception.InstanceDeployFailure, self.driver.rebuild, context=self.ctx, instance=instance, image_meta=image_meta, injected_files=None, admin_password=None, bdms=None, detach_block_devices=None, attach_block_devices=None)
def test_reboot(self, mock_val_inst, mock_set_power): node = ironic_utils.get_test_node() mock_val_inst.return_value = node instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.driver.reboot(self.ctx, instance, None, None) mock_set_power.assert_called_once_with(node.uuid, 'reboot')
def test_show_ironic_no_properties(self, mock_get, mock_list_ports): CONF.set_override('compute_driver', 'nova.virt.ironic.driver') properties = {} node = ironic_utils.get_test_node(properties=properties) port = ironic_utils.get_test_port() mock_get.return_value = node mock_list_ports.return_value = [port] res_dict = self.controller.show(self.request, node.uuid) expected_output = { 'node': { 'memory_mb': 0, 'instance_uuid': None, 'host': 'IRONIC MANAGED', 'disk_gb': 0, 'interfaces': [{ 'address': port.address }], 'task_state': None, 'id': node.uuid, 'cpus': 0 } } self.assertEqual(expected_output, res_dict) mock_get.assert_called_once_with(node.uuid) mock_list_ports.assert_called_once_with(node.uuid)
def test_show_ironic(self, mock_get, mock_list_ports): properties = {'cpus': 1, 'memory_mb': 512, 'local_gb': 10} node = ironic_utils.get_test_node(properties=properties) port = ironic_utils.get_test_port() mock_get.return_value = node mock_list_ports.return_value = [port] res_dict = self.controller.show(self.request, node.uuid) expected_output = { 'node': { 'memory_mb': properties['memory_mb'], 'instance_uuid': None, 'host': 'IRONIC MANAGED', 'disk_gb': properties['local_gb'], 'interfaces': [{ 'address': port.address }], 'task_state': None, 'id': node.uuid, 'cpus': properties['cpus'] } } self.assertEqual(expected_output, res_dict) mock_get.assert_called_once_with(node.uuid) mock_list_ports.assert_called_once_with(node.uuid)
def test_pxe_get_cleanup_patch_no_flavor_kernel_ramdisk_ids(self): self.flavor = ironic_utils.get_test_flavor(extra_specs={}) node = ironic_utils.get_test_node(driver='pxe_fake') patch = patcher.create(node).get_cleanup_patch(self.instance, None, self.flavor) # If there's no extra_specs patch should be exactly like a # generic patch self.assertEqual(self._expected_cleanup_patch, patch)
def test__add_driver_fields_good(self, mock_update): node = ironic_utils.get_test_node(driver='fake') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.driver._add_driver_fields(node, instance, None, None) expected_patch = [{'path': '/instance_uuid', 'op': 'add', 'value': instance['uuid']}] mock_update.assert_called_once_with(node.uuid, expected_patch)
def test_pxe_get_deploy_patch_no_flavor_kernel_ramdisk_ids(self): flavor = ironic_utils.get_test_flavor(extra_specs={}) node = ironic_utils.get_test_node(driver='pxe_fake') patch = patcher.create(node).get_deploy_patch( self.instance, self.image_meta, flavor) # If there's no extra_specs patch should be exactly like a # generic patch self.assertEqual(sorted(self._expected_deploy_patch), sorted(patch))
def test__node_resource_exposes_capabilities(self): props = _get_properties() props['capabilities'] = 'test:capability' node = ironic_utils.get_test_node(properties=props) result = self.driver._node_resource(node) stats = jsonutils.loads(result['stats']) self.assertIsNone(stats.get('capabilities')) self.assertEqual('capability', stats.get('test'))
def test_get_available_resource(self, mock_nr, mock_get): node = ironic_utils.get_test_node() fake_resource = 'fake-resource' mock_get.return_value = node mock_nr.return_value = fake_resource result = self.driver.get_available_resource(node.uuid) self.assertEqual(fake_resource, result) mock_nr.assert_called_once_with(node)
def test_pxe_get_deploy_patch_no_flavor_kernel_ramdisk_ids(self): flavor = ironic_utils.get_test_flavor(extra_specs={}) node = ironic_utils.get_test_node(driver='pxe_fake') patch = patcher.create(node).get_deploy_patch(self.instance, self.image_meta, flavor) # If there's no extra_specs patch should be exactly like a # generic patch self.assertEqual(sorted(self._expected_deploy_patch), sorted(patch))
def test__add_driver_fields_fail(self, mock_update): mock_update.side_effect = ironic_exception.BadRequest() node = ironic_utils.get_test_node(driver='fake') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.assertRaises(exception.InstanceDeployFailure, self.driver._add_driver_fields, node, instance, None, None)
def test_pxe_get_cleanup_patch_no_flavor_kernel_ramdisk_ids(self): self.flavor = ironic_utils.get_test_flavor(extra_specs={}) node = ironic_utils.get_test_node(driver='pxe_fake') patch = patcher.create(node).get_cleanup_patch(self.instance, None, self.flavor) # If there's no extra_specs patch should be exactly like a # generic patch self.assertEqual(self._expected_cleanup_patch, patch)
def test_node_is_available(self, mock_get): node = ironic_utils.get_test_node() mock_get.return_value = node self.assertTrue(self.driver.node_is_available(node.uuid)) mock_get.assert_called_with(node.uuid) mock_get.side_effect = ironic_exception.NotFound self.assertFalse(self.driver.node_is_available(node.uuid))
def test__cleanup_deploy_good(self, mock_update, mock_flavor): mock_flavor.return_value = ironic_utils.get_test_flavor(extra_specs={}) node = ironic_utils.get_test_node(driver='fake', instance_uuid='fake-id') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.driver._cleanup_deploy(node, instance, None) expected_patch = [{'path': '/instance_uuid', 'op': 'remove'}] mock_update.assert_called_once_with(node.uuid, expected_patch)
def test_show_ironic_no_interfaces(self, mock_get, mock_list_ports): properties = {'cpus': 1, 'memory_mb': 512, 'local_gb': 10} node = ironic_utils.get_test_node(properties=properties) mock_get.return_value = node mock_list_ports.return_value = [] res_dict = self.controller.show(self.request, node.uuid) self.assertEqual([], res_dict['node']['interfaces']) mock_get.assert_called_once_with(node.uuid) mock_list_ports.assert_called_once_with(node.uuid)
def test_show_ironic_no_interfaces(self, mock_get, mock_list_ports): properties = {'cpus': 1, 'memory_mb': 512, 'local_gb': 10} node = ironic_utils.get_test_node(properties=properties) mock_get.return_value = node mock_list_ports.return_value = [] res_dict = self.controller.show(self.request, node.uuid) self.assertEqual([], res_dict['node']['interfaces']) mock_get.assert_called_once_with(node.uuid) mock_list_ports.assert_called_once_with(node.uuid)
def test_generic_get_deploy_patch_preserve_ephemeral(self): node = ironic_utils.get_test_node(driver='fake') for preserve in [True, False]: patch = patcher.create(node).get_deploy_patch( self.instance, self.image_meta, self.flavor, preserve_ephemeral=preserve) expected = [{'path': '/instance_info/preserve_ephemeral', 'value': str(preserve), 'op': 'add', }] expected += self._expected_deploy_patch self.assertEqual(sorted(expected), sorted(patch))
def test_generic_get_deploy_patch_preserve_ephemeral(self): node = ironic_utils.get_test_node(driver='fake') for preserve in [True, False]: patch = patcher.create(node).get_deploy_patch( self.instance, self.image_meta, self.flavor, preserve_ephemeral=preserve) expected = [{'path': '/instance_info/preserve_ephemeral', 'value': str(preserve), 'op': 'add', }] expected += self._expected_deploy_patch self.assertEqual(sorted(expected), sorted(patch))
def test__cleanup_deploy_fail(self, mock_update, mock_flavor): mock_flavor.return_value = ironic_utils.get_test_flavor(extra_specs={}) mock_update.side_effect = ironic_exception.BadRequest() node = ironic_utils.get_test_node(driver='fake', instance_uuid='fake-id') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.assertRaises(exception.InstanceTerminationFailure, self.driver._cleanup_deploy, node, instance, None)
def test_pxe_get_cleanup_patch_no_flavor_kernel_ramdisk_ids(self): self.flavor = ironic_utils.get_test_flavor(extra_specs={}) driver_info = {'pxe_deploy_kernel': 'fake-kernel-id', 'pxe_deploy_ramdisk': 'fake-ramdisk-id'} node = ironic_utils.get_test_node(driver='pxe_fake', driver_info=driver_info) instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) patch = patcher.create(node).get_cleanup_patch(instance, None, self.flavor) self.assertEqual([], patch)
def test_macs_for_instance(self, mock_node): node = ironic_utils.get_test_node() port = ironic_utils.get_test_port() mock_node.get.return_value = node mock_node.list_ports.return_value = [port] instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) result = self.driver.macs_for_instance(instance) self.assertEqual([port.address], result) mock_node.list_ports.assert_called_once_with(node.uuid)
def test_pxe_get_deploy_patch_no_preserve_ephemeral(self): node = ironic_utils.get_test_node(driver='pxe_fake') instance = fake_instance.fake_instance_obj( self.ctx, node=node.uuid, ephemeral_gb=10) patch = patcher.create(node).get_deploy_patch( instance, self.image_meta, self.flavor) for preserve in [True, False]: unexpected = {'path': '/instance_info/preserve_ephemeral', 'value': str(preserve), 'op': 'add', } self.assertNotIn(unexpected, patch)
def test_destroy_trigger_undeploy_fail(self, fake_validate, mock_sps): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid, provision_state=ironic_states.ACTIVE) fake_validate.return_value = node instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) mock_sps.side_effect = exception.NovaException() self.assertRaises(exception.NovaException, self.driver.destroy, self.ctx, instance, None, None)
def test_power_off(self, mock_sp, fake_validate): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid) fake_validate.return_value = node instance_uuid = uuidutils.generate_uuid() instance = fake_instance.fake_instance_obj(self.ctx, node=instance_uuid) self.driver.power_off(instance) mock_sp.assert_called_once_with(node_uuid, 'off')
def test_pxe_get_cleanup_patch(self): driver_info = {'pxe_deploy_kernel': 'fake-kernel-id', 'pxe_deploy_ramdisk': 'fake-ramdisk-id'} node = ironic_utils.get_test_node(driver='pxe_fake', driver_info=driver_info) patch = patcher.create(node).get_cleanup_patch(self.instance, None, self.flavor) expected = [{'path': '/driver_info/pxe_deploy_kernel', 'op': 'remove'}, {'path': '/driver_info/pxe_deploy_ramdisk', 'op': 'remove'}] self.assertEqual(sorted(expected), sorted(patch))
def test_validate_instance_and_node(self, mock_gbiui): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' instance_uuid = uuidutils.generate_uuid() node = ironic_utils.get_test_node(uuid=node_uuid, instance_uuid=instance_uuid) instance = fake_instance.fake_instance_obj(self.ctx, uuid=instance_uuid) icli = cw.IronicClientWrapper() mock_gbiui.return_value = node result = ironic_driver.validate_instance_and_node(icli, instance) self.assertEqual(result.uuid, node_uuid)
def test_pxe_get_cleanup_patch(self): driver_info = {'pxe_deploy_kernel': 'fake-kernel-id', 'pxe_deploy_ramdisk': 'fake-ramdisk-id'} node = ironic_utils.get_test_node(driver='pxe_fake', driver_info=driver_info) patch = patcher.create(node).get_cleanup_patch(self.instance, None, self.flavor) expected = [{'path': '/driver_info/pxe_deploy_kernel', 'op': 'remove'}, {'path': '/driver_info/pxe_deploy_ramdisk', 'op': 'remove'}] self.assertEqual(sorted(expected), sorted(patch))
def test_list_instance_uuids(self, mock_call): num_nodes = 2 nodes = [] for n in range(num_nodes): nodes.append(ironic_utils.get_test_node( instance_uuid=uuidutils.generate_uuid())) mock_call.return_value = nodes uuids = self.driver.list_instance_uuids() mock_call.assert_called_with('node.list', associated=True) expected = [n.instance_uuid for n in nodes] self.assertEqual(sorted(expected), sorted(uuids))
def test_plug_vifs(self, mock__plug_vifs, mock_get): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(uuid=node_uuid) mock_get.return_value = node instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) network_info = utils.get_test_network_info() self.driver.plug_vifs(instance, network_info) mock_get.assert_called_once_with(node_uuid) mock__plug_vifs.assert_called_once_with(node, instance, network_info)
def test__node_resources_unavailable(self): node_dicts = [ # a node in maintenance /w no instance and power OFF {'uuid': uuidutils.generate_uuid(), 'maintenance': True, 'power_state': ironic_states.POWER_OFF}, # a node in maintenance /w no instance and ERROR power state {'uuid': uuidutils.generate_uuid(), 'maintenance': True, 'power_state': ironic_states.ERROR}, # a node not in maintenance /w no instance and bad power state {'uuid': uuidutils.generate_uuid(), 'power_state': ironic_states.NOSTATE}, ] for n in node_dicts: node = ironic_utils.get_test_node(**n) self.assertTrue(self.driver._node_resources_unavailable(node)) avail_node = ironic_utils.get_test_node( power_state=ironic_states.POWER_OFF) self.assertFalse(self.driver._node_resources_unavailable(avail_node))
def test_pxe_get_deploy_patch(self): node = ironic_utils.get_test_node(driver='pxe_fake') extra_specs = self.flavor['extra_specs'] expected = [{'path': '/driver_info/pxe_deploy_kernel', 'value': extra_specs['baremetal:deploy_kernel_id'], 'op': 'add'}, {'path': '/driver_info/pxe_deploy_ramdisk', 'value': extra_specs['baremetal:deploy_ramdisk_id'], 'op': 'add'}] expected += self._expected_deploy_patch patch = patcher.create(node).get_deploy_patch( self.instance, self.image_meta, self.flavor) self.assertEqual(sorted(expected), sorted(patch))
def test_pxe_get_deploy_patch_with_ephemeral(self): node = ironic_utils.get_test_node(driver='pxe_fake') instance = fake_instance.fake_instance_obj( self.ctx, node=node.uuid, ephemeral_gb=10) CONF.set_override('default_ephemeral_format', 'testfmt') patch = patcher.create(node).get_deploy_patch( instance, self.image_meta, self.flavor) expected1 = {'path': '/instance_info/ephemeral_gb', 'value': '10', 'op': 'add'} expected2 = {'path': '/instance_info/ephemeral_format', 'value': 'testfmt', 'op': 'add'} self.assertIn(expected1, patch) self.assertIn(expected2, patch)
def test_pxe_get_deploy_patch(self): node = ironic_utils.get_test_node(driver='pxe_fake') extra_specs = self.flavor['extra_specs'] expected = [{'path': '/driver_info/pxe_deploy_kernel', 'value': extra_specs['baremetal:deploy_kernel_id'], 'op': 'add'}, {'path': '/driver_info/pxe_deploy_ramdisk', 'value': extra_specs['baremetal:deploy_ramdisk_id'], 'op': 'add'}] expected += self._expected_deploy_patch patch = patcher.create(node).get_deploy_patch( self.instance, self.image_meta, self.flavor) self.assertEqual(sorted(expected), sorted(patch))
def test_destroy_unassociate_fail(self, mock_node): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid, provision_state=ironic_states.ACTIVE) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) mock_node.get_by_instance_uuid.return_value = node mock_node.update.side_effect = exception.NovaException() self.assertRaises(exception.NovaException, self.driver.destroy, self.ctx, instance, None, None) mock_node.set_provision_state.assert_called_once_with(node_uuid, 'deleted') mock_node.get_by_instance_uuid.assert_called_with(instance.uuid)
def test_destroy_ignore_unexpected_state(self, mock_cleanup_deploy, mock_node): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' network_info = 'foo' node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid, provision_state=ironic_states.DELETING) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) mock_node.get_by_instance_uuid.return_value = node self.driver.destroy(self.ctx, instance, network_info, None) self.assertFalse(mock_node.set_provision_state.called) mock_node.get_by_instance_uuid.assert_called_with(instance.uuid) mock_cleanup_deploy.assert_called_with(node, instance, network_info)
def test_spawn_node_driver_validation_fail(self, mock_flavor, mock_node): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) fake_flavor = {'ephemeral_gb': 0} mock_node.validate.return_value = ironic_utils.get_test_validation( power=False, deploy=False) mock_node.get.return_value = node mock_flavor.return_value = fake_flavor self.assertRaises(exception.ValidationError, self.driver.spawn, self.ctx, instance, None, [], None) mock_node.get.assert_called_once_with(node_uuid) mock_node.validate.assert_called_once_with(node_uuid) mock_flavor.assert_called_with(mock.ANY, instance['instance_type_id'])
def test_generic_get_deploy_patch_ephemeral(self): CONF.set_override('default_ephemeral_format', 'testfmt') node = ironic_utils.get_test_node(driver='fake') instance = fake_instance.fake_instance_obj(self.ctx, ephemeral_gb=10) patch = patcher.create(node).get_deploy_patch( instance, self.image_meta, self.flavor) expected = [{'path': '/instance_info/ephemeral_gb', 'value': str(instance.ephemeral_gb), 'op': 'add'}, {'path': '/instance_info/ephemeral_format', 'value': 'testfmt', 'op': 'add'}] expected += self._expected_deploy_patch self.assertEqual(sorted(expected), sorted(patch))
def test_generic_get_deploy_patch_ephemeral(self): CONF.set_override('default_ephemeral_format', 'testfmt') node = ironic_utils.get_test_node(driver='fake') instance = fake_instance.fake_instance_obj(self.ctx, ephemeral_gb=10) patch = patcher.create(node).get_deploy_patch( instance, self.image_meta, self.flavor) expected = [{'path': '/instance_info/ephemeral_gb', 'value': str(instance.ephemeral_gb), 'op': 'add'}, {'path': '/instance_info/ephemeral_format', 'value': 'testfmt', 'op': 'add'}] expected += self._expected_deploy_patch self.assertEqual(sorted(expected), sorted(patch))
def test_index_ironic(self, mock_list): properties = {'cpus': 2, 'memory_mb': 1024, 'local_gb': 20} node = ironic_utils.get_test_node(properties=properties) mock_list.return_value = [node] res_dict = self.controller.index(self.request) expected_output = { 'nodes': [{ 'memory_mb': properties['memory_mb'], 'host': 'IRONIC MANAGED', 'disk_gb': properties['local_gb'], 'interfaces': [], 'task_state': None, 'id': node.uuid, 'cpus': properties['cpus'] }] } self.assertEqual(expected_output, res_dict) mock_list.assert_called_once_with(detail=True)
def test_index_ironic_missing_properties(self, mock_list): CONF.set_override('compute_driver', 'nova.virt.ironic.driver') properties = {'cpus': 2} node = ironic_utils.get_test_node(properties=properties) mock_list.return_value = [node] res_dict = self.controller.index(self.request) expected_output = { 'nodes': [{ 'memory_mb': 0, 'host': 'IRONIC MANAGED', 'disk_gb': 0, 'interfaces': [], 'task_state': None, 'id': node.uuid, 'cpus': properties['cpus'] }] } self.assertEqual(expected_output, res_dict) mock_list.assert_called_once_with(detail=True)
def test_generic_get_deploy_patch(self): node = ironic_utils.get_test_node(driver='fake') patch = patcher.create(node).get_deploy_patch(self.instance, self.image_meta, self.flavor) self.assertEqual(sorted(self._expected_deploy_patch), sorted(patch))
def test_create_pxe(self): node = ironic_utils.get_test_node(driver='pxe_fake') patcher_obj = patcher.create(node) self.assertIsInstance(patcher_obj, patcher.PXEDriverFields)
def test_create_generic(self): node = ironic_utils.get_test_node(driver='fake') patcher_obj = patcher.create(node) self.assertIsInstance(patcher_obj, patcher.GenericDriverFields)
def test_generic_get_cleanup_patch(self): node = ironic_utils.get_test_node(driver='fake') patch = patcher.create(node).get_cleanup_patch(self.instance, None, self.flavor) self.assertEqual(self._expected_cleanup_patch, patch)