def test_delete_chassis_with_node(self): chassis = obj_utils.create_test_chassis(self.context) obj_utils.create_test_node(self.context, chassis_id=chassis.id) response = self.delete('/chassis/%s' % chassis.uuid, expect_errors=True) self.assertEqual(400, response.status_int) self.assertEqual('application/json', response.content_type) self.assertTrue(response.json['error_message'])
def test_node_by_instance_uuid_wrong_uuid(self): obj_utils.create_test_node(self.context, uuid=utils.generate_uuid(), instance_uuid=utils.generate_uuid()) wrong_uuid = utils.generate_uuid() data = self.get_json('/nodes?instance_uuid=%s' % wrong_uuid) self.assertThat(data['nodes'], HasLength(0))
def test_delete_chassis_with_node(self): cdict = dbutils.get_test_chassis() self.dbapi.create_chassis(cdict) obj_utils.create_test_node(self.context, chassis_id=cdict['id']) response = self.delete('/chassis/%s' % cdict['uuid'], expect_errors=True) self.assertEqual(400, response.status_int) self.assertEqual('application/json', response.content_type) self.assertTrue(response.json['error_message'])
def test_links(self): uuid = utils.generate_uuid() obj_utils.create_test_node(self.context, id=1, uuid=uuid) data = self.get_json('/nodes/%s' % uuid) self.assertIn('links', data.keys()) self.assertEqual(2, len(data['links'])) self.assertIn(uuid, data['links'][0]['href']) for l in data['links']: bookmark = l['rel'] == 'bookmark' self.assertTrue(self.validate_link(l['href'], bookmark=bookmark))
def test_parse_driver_info_missing_password(self): node = obj_utils.create_test_node(self.context, driver='ilo', driver_info=INFO_DICT) del node.driver_info['ilo_password'] self.assertRaises(exception.InvalidParameterValue, ilo_common.parse_driver_info, node)
def setUp(self): super(AMTPowerTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_amt') self.info = INFO_DICT self.node = obj_utils.create_test_node(self.context, driver='fake_amt', driver_info=self.info)
def test_parse_driver_info_invalid_port(self): node = obj_utils.create_test_node(self.context, driver='fake_drac', driver_info=INFO_DICT) node.driver_info['drac_port'] = 'foo' self.assertRaises(exception.InvalidParameterValue, drac_common.parse_driver_info, node)
def test_parse_instance_info_invalid_root_gb(self): info = dict(INST_INFO_DICT) info['root_gb'] = 'foobar' node = obj_utils.create_test_node(self.context, instance_info=info) self.assertRaises(exception.InvalidParameterValue, iscsi_deploy.parse_instance_info, node)
def test_parse_driver_info_invalid_port(self): node = obj_utils.create_test_node(self.context, driver='ilo', driver_info=INFO_DICT) node.driver_info['client_port'] = 'qwe' self.assertRaises(exception.InvalidParameterValue, ilo_common.parse_driver_info, node)
def test_node_power_action_set_power_failure(self): """Test if an exception is thrown when the set_power call fails.""" node = obj_utils.create_test_node(self.context, uuid=cmn_utils.generate_uuid(), driver='fake', power_state=states.POWER_OFF) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') as get_power_mock: with mock.patch.object(self.driver.power, 'set_power_state') as set_power_mock: get_power_mock.return_value = states.POWER_OFF set_power_mock.side_effect = exception.IronicException() self.assertRaises( exception.IronicException, conductor_utils.node_power_action, task, states.POWER_ON) node.refresh() get_power_mock.assert_called_once_with(mock.ANY) set_power_mock.assert_called_once_with(mock.ANY, states.POWER_ON) self.assertEqual(states.POWER_OFF, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNotNone(node['last_error'])
def setUp(self): super(TestPXEUtils, self).setUp() mgr_utils.mock_the_extension_manager(driver="fake") self.dbapi = dbapi.get_instance() self.context = context.get_admin_context() self.pxe_options = { 'deployment_key': '0123456789ABCDEFGHIJKLMNOPQRSTUV', 'ari_path': u'/tftpboot/1be26c0b-03f2-4d2e-ae87-c02d7f33c123/' u'ramdisk', 'iscsi_target_iqn': u'iqn-1be26c0b-03f2-4d2e-ae87-c02d7f33' u'c123', 'deployment_ari_path': u'/tftpboot/1be26c0b-03f2-4d2e-ae87-c02d7' u'f33c123/deploy_ramdisk', 'pxe_append_params': 'test_param', 'aki_path': u'/tftpboot/1be26c0b-03f2-4d2e-ae87-c02d7f33c123/' u'kernel', 'deployment_id': u'1be26c0b-03f2-4d2e-ae87-c02d7f33c123', 'ironic_api_url': 'http://192.168.122.184:6385', 'deployment_aki_path': u'/tftpboot/1be26c0b-03f2-4d2e-ae87-' u'c02d7f33c123/deploy_kernel', 'disk': 'cciss/c0d0,sda,hda,vda' } self.agent_pxe_options = { 'deployment_ari_path': u'/tftpboot/1be26c0b-03f2-4d2e-ae87-c02d7' u'f33c123/deploy_ramdisk', 'pxe_append_params': 'test_param', 'aki_path': u'/tftpboot/1be26c0b-03f2-4d2e-ae87-c02d7f33c123/' u'kernel', 'ipa-api-url': 'http://192.168.122.184:6385', 'deployment_aki_path': u'/tftpboot/1be26c0b-03f2-4d2e-ae87-' u'c02d7f33c123/deploy_kernel', } self.node = object_utils.create_test_node(self.context)
def test_parse_driver_info_missing_username(self): node = obj_utils.create_test_node(self.context, driver='fake_drac', driver_info=INFO_DICT) del node.driver_info['drac_username'] self.assertRaises(exception.InvalidParameterValue, drac_common.parse_driver_info, node)
def test_node_power_action_invalid_state(self): """Test for exception when changing to an invalid power state.""" node = obj_utils.create_test_node(self.context, uuid=cmn_utils.generate_uuid(), driver='fake', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') as get_power_mock: get_power_mock.return_value = states.POWER_ON self.assertRaises(exception.InvalidParameterValue, conductor_utils.node_power_action, task, "INVALID_POWER_STATE") node.refresh() get_power_mock.assert_called_once_with(mock.ANY) self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNotNone(node['last_error']) # last_error is cleared when a new transaction happens conductor_utils.node_power_action(task, states.POWER_OFF) node.refresh() self.assertEqual(states.POWER_OFF, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error'])
def test__parse_driver_info_invalid_preserve_ephemeral(self): info = dict(INFO_DICT) info['pxe_preserve_ephemeral'] = 'foobar' node = obj_utils.create_test_node(self.context, driver_info=info) self.assertRaises(exception.InvalidParameterValue, pxe._parse_driver_info, node)
def test__parse_driver_info_valid_preserve_ephemeral_false(self): info = dict(INFO_DICT) for _id, opt in enumerate(["false", "FALSE", "False", "f", "off", "no", "n", "0"]): info["pxe_preserve_ephemeral"] = opt node = obj_utils.create_test_node(self.context, id=_id, uuid=utils.generate_uuid(), driver_info=info) data = pxe._parse_driver_info(node) self.assertFalse(data.get("preserve_ephemeral"))
def setUp(self): super(PXEPrivateMethodsTestCase, self).setUp() n = {"driver": "fake_pxe", "driver_info": INFO_DICT} mgr_utils.mock_the_extension_manager(driver="fake_pxe") self.dbapi = dbapi.get_instance() self.context = context.get_admin_context() self.node = obj_utils.create_test_node(self.context, **n)
def test__parse_driver_info_valid_preserve_ephemeral_true(self): info = dict(INFO_DICT) for _id, opt in enumerate(["true", "TRUE", "True", "t", "on", "yes", "y", "1"]): info["pxe_preserve_ephemeral"] = opt node = obj_utils.create_test_node(self.context, id=_id, uuid=utils.generate_uuid(), driver_info=info) data = pxe._parse_driver_info(node) self.assertTrue(data.get("preserve_ephemeral"))
def test_node_power_action_in_same_state(self): """Test setting node state to its present state. Test that we don't try to set the power state if the requested state is the same as the current state. """ node = obj_utils.create_test_node(self.context, uuid=cmn_utils.generate_uuid(), driver='fake', last_error='anything but None', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') as get_power_mock: get_power_mock.return_value = states.POWER_ON with mock.patch.object(self.driver.power, 'set_power_state') as set_power_mock: conductor_utils.node_power_action(task, states.POWER_ON) node.refresh() get_power_mock.assert_called_once_with(mock.ANY) self.assertFalse(set_power_mock.called, "set_power_state unexpectedly called") self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error'])
def setUp(self): super(VirtualBoxMethodsTestCase, self).setUp() driver_info = INFO_DICT.copy() mgr_utils.mock_the_extension_manager(driver="fake_vbox") self.node = obj_utils.create_test_node(self.context, driver='fake_vbox', driver_info=driver_info)
def setUp(self): super(IRMCPowerTestCase, self).setUp() driver_info = INFO_DICT mgr_utils.mock_the_extension_manager(driver="fake_irmc") self.node = obj_utils.create_test_node(self.context, driver='fake_irmc', driver_info=driver_info)
def _test_update_raid_info(self, current_config, capabilities=None): node = obj_utils.create_test_node(self.context, driver='fake') if capabilities: properties = node.properties properties['capabilities'] = capabilities del properties['local_gb'] node.properties = properties node.save() raid.update_raid_info(node, current_config) properties = node.properties current = node.raid_config target = node.target_raid_config self.assertIsNotNone(current['last_updated']) self.assertIsInstance(current['logical_disks'][0], dict) if current_config['logical_disks'][0].get('is_root_volume'): self.assertEqual({'wwn': '600508B100'}, properties['root_device']) self.assertEqual(100, properties['local_gb']) self.assertIn('raid_level:1', properties['capabilities']) if capabilities: self.assertIn(capabilities, properties['capabilities']) else: self.assertNotIn('local_gb', properties) self.assertNotIn('root_device', properties) if capabilities: self.assertNotIn('raid_level:1', properties['capabilities']) self.assertEqual({}, target)
def test_node_power_action_in_same_state_db_not_in_sync(self): """Test setting node state to its present state if DB is out of sync. Under rare conditions (see bug #1403106) database might contain stale information, make sure we fix it. """ node = obj_utils.create_test_node(self.context, uuid=cmn_utils.generate_uuid(), driver='fake', last_error='anything but None', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') as get_power_mock: get_power_mock.return_value = states.POWER_OFF with mock.patch.object(self.driver.power, 'set_power_state') as set_power_mock: conductor_utils.node_power_action(task, states.POWER_OFF) node.refresh() get_power_mock.assert_called_once_with(mock.ANY) self.assertFalse(set_power_mock.called, "set_power_state unexpectedly called") self.assertEqual(states.POWER_OFF, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error'])
def test_node_power_action_failed_getting_state(self): """Test if an exception is thrown when we can't get the current power state. """ node = obj_utils.create_test_node(self.context, uuid=cmn_utils.generate_uuid(), driver='fake', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') \ as get_power_state_mock: get_power_state_mock.side_effect = \ exception.InvalidParameterValue('failed getting power state') self.assertRaises(exception.InvalidParameterValue, conductor_utils.node_power_action, task, states.POWER_ON) node.refresh() get_power_state_mock.assert_called_once_with(mock.ANY) self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNotNone(node['last_error'])
def test_nodes_subresource(self): chassis = obj_utils.create_test_chassis(self.context) for id_ in range(2): obj_utils.create_test_node(self.context, chassis_id=chassis.id, uuid=uuidutils.generate_uuid()) data = self.get_json('/chassis/%s/nodes' % chassis.uuid) self.assertEqual(2, len(data['nodes'])) self.assertNotIn('next', data.keys()) # Test collection pagination data = self.get_json('/chassis/%s/nodes?limit=1' % chassis.uuid) self.assertEqual(1, len(data['nodes'])) self.assertIn('next', data.keys())
def setUp(self): super(UtilsTestCase, self).setUp() self.context = context.get_admin_context() self.dbapi = db_api.get_instance() mgr_utils.mock_the_extension_manager() self.driver = driver_factory.get_driver("fake") self.node = obj_utils.create_test_node(self.context)
def setUp(self): super(TestNeutron, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake') self.config( cleaning_network_uuid='00000000-0000-0000-0000-000000000000', group='neutron') self.config(enabled_drivers=['fake']) self.config(dhcp_provider='neutron', group='dhcp') self.config(url='test-url', url_timeout=30, retries=2, group='neutron') self.config(insecure=False, certfile='test-file', admin_user='******', admin_tenant_name='test-admin-tenant', admin_password='******', auth_uri='test-auth-uri', group='keystone_authtoken') self.node = object_utils.create_test_node(self.context) self.ports = [ object_utils.create_test_port( self.context, node_id=self.node.id, id=2, uuid='1be26c0b-03f2-4d2e-ae87-c02d7f33c782', address='52:54:00:cf:2d:32')] # Very simple neutron port representation self.neutron_port = {'id': '132f871f-eaec-4fed-9475-0d54465e0f00', 'mac_address': '52:54:00:cf:2d:32'} dhcp_factory.DHCPFactory._dhcp_provider = None
def test_create_port_using_node_name(self, mock_utcnow, mock_anln): mock_anln.return_value = True pdict = apiutils.port_post_data() ndict = dbutils.get_test_node() del pdict['node_id'] ndict['name'] = 'nodenaaame' ndict['created_at'] = datetime.datetime(2000, 1, 1, 0, 0) ndict['uuid'] = '1ab23c4d-03f2-4d2e-ae87-c02d7f33c126' node = obj_utils.create_test_node(self.context, **ndict) pdict['node'] = node.name test_time = datetime.datetime(2000, 1, 1, 0, 0) mock_utcnow.return_value = test_time response = self.post_json('/ports', pdict) self.assertEqual(201, response.status_int) result = self.get_json('/ports/%s' % pdict['uuid']) self.assertEqual(pdict['uuid'], result['uuid']) self.assertFalse(result['updated_at']) return_created_at = timeutils.parse_isotime( result['created_at']).replace(tzinfo=None) self.assertEqual(test_time, return_created_at) # Check location header self.assertIsNotNone(response.location) expected_location = '/v1/ports/%s' % pdict['uuid'] self.assertEqual(urlparse.urlparse(response.location).path, expected_location) data = self.get_json("/ports?node=%s" % pdict['node'], headers={api_controller.Version.string: '1.5'}) data = self.get_json('/ports/%s' % pdict['uuid']) self.assertEqual(pdict['uuid'], data['uuid']) self.assertIn('extra', data) self.assertIn('node', data)
def setUp(self): super(TaskManagerTestCase, self).setUp() self.host = 'test-host' self.config(host=self.host) self.config(node_locked_retry_attempts=1, group='conductor') self.config(node_locked_retry_interval=0, group='conductor') self.node = obj_utils.create_test_node(self.context)
def setUp(self): super(IloCommonMethodsTestCase, self).setUp() self.dbapi = dbapi.get_instance() self.context = context.get_admin_context() mgr_utils.mock_the_extension_manager(driver="fake_ilo") self.node = obj_utils.create_test_node(self.context, driver='fake_ilo', driver_info=INFO_DICT)
def setUp(self): super(IPMINativePrivateMethodTestCase, self).setUp() self.node = obj_utils.create_test_node(self.context, driver='fake_ipminative', driver_info=INFO_DICT) self.dbapi = db_api.get_instance() self.info = ipminative._parse_driver_info(self.node)
def setUp(self): super(CleanUpFullFlowTestCase, self).setUp() self.config(image_cache_size=0, group='pxe') # Configure node mgr_utils.mock_the_extension_manager(driver="fake_pxe") instance_info = INST_INFO_DICT instance_info['deploy_key'] = 'fake-56789' self.node = obj_utils.create_test_node(self.context, driver='fake_pxe', instance_info=instance_info, driver_info=DRV_INFO_DICT) self.port = obj_utils.create_test_port(self.context, node_id=self.node.id) # Configure temporary directories pxe_temp_dir = tempfile.mkdtemp() self.config(tftp_root=pxe_temp_dir, group='pxe') tftp_master_dir = os.path.join(CONF.pxe.tftp_root, 'tftp_master') self.config(tftp_master_path=tftp_master_dir, group='pxe') os.makedirs(tftp_master_dir) instance_temp_dir = tempfile.mkdtemp() self.config(images_path=instance_temp_dir, group='pxe') instance_master_dir = os.path.join(CONF.pxe.images_path, 'instance_master') self.config(instance_master_path=instance_master_dir, group='pxe') os.makedirs(instance_master_dir) self.pxe_config_dir = os.path.join(CONF.pxe.tftp_root, 'pxelinux.cfg') os.makedirs(self.pxe_config_dir) # Populate some file names self.master_kernel_path = os.path.join(CONF.pxe.tftp_master_path, 'kernel') self.master_instance_path = os.path.join(CONF.pxe.instance_master_path, 'image_uuid') self.node_tftp_dir = os.path.join(CONF.pxe.tftp_root, self.node.uuid) os.makedirs(self.node_tftp_dir) self.kernel_path = os.path.join(self.node_tftp_dir, 'kernel') self.node_image_dir = iscsi_deploy._get_image_dir_path(self.node.uuid) os.makedirs(self.node_image_dir) self.image_path = iscsi_deploy._get_image_file_path(self.node.uuid) self.config_path = pxe_utils.get_pxe_config_file_path(self.node.uuid) self.mac_path = pxe_utils._get_pxe_mac_path(self.port.address) self.token_path = pxe._get_token_file_path(self.node.uuid) # Create files self.files = [ self.config_path, self.master_kernel_path, self.master_instance_path, self.token_path ] for fname in self.files: # NOTE(dtantsur): files with 0 size won't be cleaned up with open(fname, 'w') as fp: fp.write('test') os.link(self.config_path, self.mac_path) os.link(self.master_kernel_path, self.kernel_path) os.link(self.master_instance_path, self.image_path)
def test__parse_instance_info_invalid_ephemeral_gb(self): info = dict(INST_INFO_DICT) info['ephemeral_gb'] = 'foobar' info['ephemeral_format'] = 'exttest' node = obj_utils.create_test_node(self.context, instance_info=info) self.assertRaises(exception.InvalidParameterValue, pxe._parse_instance_info, node)
def test_nodes_subresource(self): cdict = dbutils.get_test_chassis() self.dbapi.create_chassis(cdict) for id in range(2): obj_utils.create_test_node(self.context, id=id, chassis_id=cdict['id'], uuid=utils.generate_uuid()) data = self.get_json('/chassis/%s/nodes' % cdict['uuid']) self.assertEqual(2, len(data['nodes'])) self.assertNotIn('next', data.keys()) # Test collection pagination data = self.get_json('/chassis/%s/nodes?limit=1' % cdict['uuid']) self.assertEqual(1, len(data['nodes'])) self.assertIn('next', data.keys())
def setUp(self): super(IBootDriverTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_iboot') self.driver = driver_factory.get_driver('fake_iboot') self.node = obj_utils.create_test_node(self.context, driver='fake_iboot', driver_info=INFO_DICT) self.info = iboot._parse_driver_info(self.node)
def test__parse_driver_info_bad_relay_id(self): info = dict(INFO_DICT) info['iboot_relay_id'] = 'not-integer' node = obj_utils.create_test_node(self.context, driver='fake_iboot', driver_info=info) self.assertRaises(exception.InvalidParameterValue, iboot._parse_driver_info, node)
def setUp(self): super(IPMINativePrivateMethodTestCase, self).setUp() self.context = context.get_admin_context() self.node = obj_utils.create_test_node(self.context, driver='fake_ipminative', driver_info=INFO_DICT) self.dbapi = db_api.get_instance() self.info = ipminative._parse_driver_info(self.node)
def test__parse_driver_info_good_with_explicit_relay_id(self): info = dict(INFO_DICT) info['iboot_relay_id'] = '2' node = obj_utils.create_test_node(self.context, driver='fake_iboot', driver_info=info) info = iboot._parse_driver_info(node) self.assertEqual(2, info.get('relay_id'))
def test_parse_driver_info_missing_protocol(self): node = obj_utils.create_test_node(self.context, driver='fake_drac', driver_info=INFO_DICT) del node.driver_info['drac_protocol'] info = drac_common.parse_driver_info(node) self.assertEqual('https', info.get('drac_protocol'))
def test__parse_driver_info_good_with_explicit_port(self): info = dict(INFO_DICT) info['iboot_port'] = '1234' node = obj_utils.create_test_node(self.context, driver='fake_iboot', driver_info=info) info = iboot._parse_driver_info(node) self.assertEqual(1234, info.get('port'))
def test__parse_driver_info_missing_password(self): info = dict(INFO_DICT) del info['iboot_password'] node = obj_utils.create_test_node(self.context, driver='fake_iboot', driver_info=info) self.assertRaises(exception.MissingParameterValue, iboot._parse_driver_info, node)
def setUp(self): super(TaskManagerTestCase, self).setUp() self.host = 'test-host' self.config(host=self.host) self.config(node_locked_retry_attempts=1, group='conductor') self.config(node_locked_retry_interval=0, group='conductor') self.context = mock.sentinel.context self.node = obj_utils.create_test_node(self.context)
def test_management_interface_validate_fail(self): # Missing SEAMICRO driver_info information node = obj_utils.create_test_node(self.context, uuid=utils.generate_uuid(), driver='fake_seamicro') with task_manager.acquire(self.context, node.uuid) as task: self.assertRaises(exception.MissingParameterValue, task.driver.management.validate, task)
def setUp(self): super(IloPowerTestCase, self).setUp() driver_info = INFO_DICT mgr_utils.mock_the_extension_manager(driver="fake_ilo") self.dbapi = dbapi.get_instance() self.node = obj_utils.create_test_node(self.context, driver='fake_ilo', driver_info=driver_info)
def test_power_interface_validate_fail(self): node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), id=999, driver='fake_oneview') with task_manager.acquire(self.context, node.uuid) as task: self.assertRaises(exception.MissingParameterValue, task.driver.power.validate, task)
def test__parse_parameters_no_ports_fail(self): node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), driver='fake_wol') with task_manager.acquire(self.context, node.uuid, shared=True) as task: self.assertRaises(exception.InvalidParameterValue, wol._parse_parameters, task)
def test__parse_instance_info_missing_root_gb(self): # make sure error is raised when info is missing info = dict(INST_INFO_DICT) del info['root_gb'] node = obj_utils.create_test_node(self.context, instance_info=info) self.assertRaises(exception.InvalidParameterValue, pxe._parse_instance_info, node)
def test_nodes_subresource(self): chassis = obj_utils.create_test_chassis(self.context) for id_ in range(2): obj_utils.create_test_node(self.context, id=id_, chassis_id=chassis.id, uuid=utils.generate_uuid()) data = self.get_json('/chassis/%s/nodes' % chassis.uuid) self.assertEqual(2, len(data['nodes'])) self.assertNotIn('next', data.keys()) # Test collection pagination data = self.get_json('/chassis/%s/nodes?limit=1' % chassis.uuid) self.assertEqual(1, len(data['nodes'])) self.assertIn('next', data.keys())
def test__parse_driver_info_good(self): # make sure we get back the expected things node = obj_utils.create_test_node(self.context, driver='fake_pxe', driver_info=DRV_INFO_DICT) info = pxe._parse_driver_info(node) self.assertIsNotNone(info.get('deploy_ramdisk')) self.assertIsNotNone(info.get('deploy_kernel'))
def test__parse_driver_info_missing_deploy_ramdisk(self): # make sure error is raised when info is missing info = dict(DRV_INFO_DICT) del info['pxe_deploy_ramdisk'] node = obj_utils.create_test_node(self.context, driver_info=info) self.assertRaises(exception.MissingParameterValue, pxe._parse_driver_info, node)
def setUp(self): super(UcsValidateParametersTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="fake_ucs") self.node = obj_utils.create_test_node(self.context, driver='fake_ucs', driver_info=INFO_DICT) with task_manager.acquire(self.context, self.node.uuid, shared=True) as task: self.helper = ucs_helper.CiscoUcsHelper(task)
def setUp(self): super(UcsManagementTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_ucs') self.node = obj_utils.create_test_node(self.context, driver='fake_ucs', driver_info=INFO_DICT) self.interface = ucs_mgmt.UcsManagement() self.task = mock.Mock() self.task.node = self.node
def test_parse_instance_info_good(self): # make sure we get back the expected things node = obj_utils.create_test_node(self.context, driver='fake_pxe', instance_info=INST_INFO_DICT) info = iscsi_deploy.parse_instance_info(node) self.assertIsNotNone(info.get('image_source')) self.assertIsNotNone(info.get('root_gb')) self.assertEqual(0, info.get('ephemeral_gb'))
def test_parse_instance_info_valid_preserve_ephemeral_true(self): info = dict(INST_INFO_DICT) for opt in ['true', 'TRUE', 'True', 't', 'on', 'yes', 'y', '1']: info['preserve_ephemeral'] = opt node = obj_utils.create_test_node(self.context, uuid=utils.generate_uuid(), instance_info=info) data = iscsi_deploy.parse_instance_info(node) self.assertTrue(data.get('preserve_ephemeral'))
def test_parse_instance_info_valid_preserve_ephemeral_false(self): info = dict(INST_INFO_DICT) for opt in ['false', 'FALSE', 'False', 'f', 'off', 'no', 'n', '0']: info['preserve_ephemeral'] = opt node = obj_utils.create_test_node(self.context, uuid=utils.generate_uuid(), instance_info=info) data = iscsi_deploy.parse_instance_info(node) self.assertFalse(data.get('preserve_ephemeral'))
def setUp(self): super(TestPatch, self).setUp() self.node = obj_utils.create_test_node(context.get_admin_context()) self.port = obj_utils.create_test_port(self.context) p = mock.patch.object(rpcapi.ConductorAPI, 'get_topic_for') self.mock_gtf = p.start() self.mock_gtf.return_value = 'test-topic' self.addCleanup(p.stop)
def setUp(self): super(PXEPrivateMethodsTestCase, self).setUp() n = { 'driver': 'fake_pxe', 'instance_info': INST_INFO_DICT, 'driver_info': DRV_INFO_DICT, } mgr_utils.mock_the_extension_manager(driver="fake_pxe") self.node = obj_utils.create_test_node(self.context, **n)
def setUp(self): super(DracManagementTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_drac') self.node = obj_utils.create_test_node(self.context, driver='fake_drac', driver_info=INFO_DICT) self.driver = drac_mgmt.DracManagement() self.task = mock.Mock() self.task.node = self.node
def setUp(self): super(CleanUpTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="fake_pxe") instance_info = INST_INFO_DICT instance_info['deploy_key'] = 'fake-56789' self.node = obj_utils.create_test_node(self.context, driver='fake_pxe', instance_info=instance_info, driver_info=DRV_INFO_DICT)
def test_parse_instance_info_configdrive(self): info = dict(INST_INFO_DICT) info['configdrive'] = 'http://1.2.3.4/cd' node = obj_utils.create_test_node( self.context, instance_info=info, driver_internal_info=DRV_INTERNAL_INFO_DICT, ) instance_info = iscsi_deploy.parse_instance_info(node) self.assertEqual('http://1.2.3.4/cd', instance_info['configdrive'])