def test__get_client(self, mock_client): driver_info = seamicro._parse_driver_info(self.node) args = {'username': driver_info['username'], 'password': driver_info['password'], 'auth_url': driver_info['api_endpoint']} seamicro._get_client(**driver_info) mock_client.assert_called_once_with(driver_info['api_version'], **args)
def test_set_node_vlan_id_no_input(self): info = seamicro._parse_driver_info(self.node) with task_manager.acquire(self.context, info['uuid'], shared=False) as task: self.assertRaises(exception.InvalidParameterValue, task.driver.vendor.set_node_vlan_id, task, **{})
def test_set_boot_device_no_input(self): info = seamicro._parse_driver_info(self.node) with task_manager.acquire(self.context, info['uuid'], shared=False) as task: self.assertRaises(exception.InvalidParameterValue, task.driver.vendor.vendor_passthru, task, **{'method': 'set_boot_device'})
def test_attach_volume_with_no_input_fail(self): info = seamicro._parse_driver_info(self.node) with task_manager.acquire(self.context, info['uuid'], shared=False) as task: self.assertRaises(exception.InvalidParameterValue, task.driver.vendor.vendor_passthru, task, **{'method': 'attach_volume'})
def test__validate_fail(self, mock_get_volume): info = seamicro._parse_driver_info(self.node) volume_id = "0/p6-6/vol1" volume = self.Volume() volume.id = volume_id mock_get_volume.return_value = volume self.assertRaises(exception.InvalidParameterValue, seamicro._validate_volume, info, volume_id)
def test_set_boot_device_good(self, mock_get_server): info = seamicro._parse_driver_info(self.node) boot_device = "disk" mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, info['uuid'], shared=False) as task: task.driver.management.set_boot_device(task, boot_device) mock_get_server.assert_called_once_with(info)
def test__create_volume_good(self, mock_get_client, mock_get_pools): info = seamicro._parse_driver_info(self.node) pools = [self.Pool(1), self.Pool(6), self.Pool(5)] get_pools_patcher = mock.patch.object(mock_get_client, "volume.create") get_pools_patcher.start() mock_get_pools.return_value = pools seamicro._create_volume(info, 2) get_pools_patcher.stop()
def test_attach_volume_with_no_input_fail(self): info = seamicro._parse_driver_info(self.node) with task_manager.acquire(self.context, [info['uuid']], shared=False) as task: self.assertRaises(exception.InvalidParameterValue, task.resources[0].driver.vendor. vendor_passthru, task, self.node, **{'method': 'attach_volume'})
def test_set_boot_device_no_input(self): info = seamicro._parse_driver_info(self.node) with task_manager.acquire(self.context, [info['uuid']], shared=False) as task: self.assertRaises(exception.InvalidParameterValue, task.resources[0].driver.vendor. vendor_passthru, task, self.node, **{'method': 'set_boot_device'})
def test_set_boot_device_good(self, mock_get_server): info = seamicro._parse_driver_info(self.node) boot_device = "disk" mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task: kwargs = {"device": boot_device, "method": "set_boot_device"} task.resources[0].driver.vendor.vendor_passthru(task, self.node, **kwargs) mock_get_server.assert_called_once_with(info)
def test__parse_driver_info_good(self): # make sure we get back the expected things node = obj_utils.get_test_node(self.context, driver="fake_seamicro", driver_info=INFO_DICT) info = seamicro._parse_driver_info(node) self.assertIsNotNone(info.get("api_endpoint")) self.assertIsNotNone(info.get("username")) self.assertIsNotNone(info.get("password")) self.assertIsNotNone(info.get("server_id")) self.assertIsNotNone(info.get("uuid"))
def test_attach_volume_with_volume_id_good(self, mock_validate_volume, mock_get_server): info = seamicro._parse_driver_info(self.node) volume_id = "0/ironic-p6-1/vol1" mock_validate_volume.return_value = True mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task: kwargs = {"volume_id": volume_id, "method": "attach_volume"} task.resources[0].driver.vendor.vendor_passthru(task, self.node, **kwargs) mock_get_server.assert_called_once_with(info)
def test_set_power_state_off_good(self, mock_power_off): info = seamicro._parse_driver_info(self.node) mock_power_off.return_value = states.POWER_OFF with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task: task.resources[0].driver.power.set_power_state(task, self.node, states.POWER_OFF) mock_power_off.assert_called_once_with(self.node)
def test__get_client(self, mock_client): driver_info = seamicro._parse_driver_info(self.node) args = { 'username': driver_info['username'], 'password': driver_info['password'], 'auth_url': driver_info['api_endpoint'] } seamicro._get_client(**driver_info) mock_client.assert_called_once_with(driver_info['api_version'], **args)
def test_set_boot_device_invalid_device_fail(self, mock_get_server): info = seamicro._parse_driver_info(self.node) boot_device = "invalid_device" mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, info['uuid'], shared=False) as task: self.assertRaises(exception.InvalidParameterValue, task.driver.management.set_boot_device, task, boot_device)
def test_set_boot_device_good(self, mock_get_server): info = seamicro._parse_driver_info(self.node) boot_device = "disk" mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, info['uuid'], shared=False) as task: kwargs = {'device': boot_device, 'method': 'set_boot_device'} task.driver.vendor.vendor_passthru(task, **kwargs) mock_get_server.assert_called_once_with(info)
def test_set_node_vlan_id_good(self, mock_get_server): info = seamicro._parse_driver_info(self.node) vlan_id = "12" mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, info['uuid'], shared=False) as task: kwargs = {'vlan_id': vlan_id, 'method': 'set_node_vlan_id'} task.driver.vendor.vendor_passthru(task, **kwargs) mock_get_server.assert_called_once_with(info)
def test_reboot(self, mock_reboot): info = seamicro._parse_driver_info(self.node) mock_reboot.return_value = states.POWER_ON with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task: task.resources[0].driver.power.reboot(task, self.node) mock_reboot.assert_called_once_with(self.node)
def test_set_power_state_bad_state(self): info = seamicro._parse_driver_info(self.node) self.get_server_mock = self.get_server_patcher.start() self.get_server_mock.return_value = self.Server() with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task: self.assertRaises( exception.IronicException, task.resources[0].driver.power.set_power_state, task, self.node, "BAD_PSTATE" ) self.get_server_patcher.stop()
def test_set_power_state_on_good(self, mock_power_on): info = seamicro._parse_driver_info(self.node) mock_power_on.return_value = states.POWER_ON with task_manager.acquire(self.context, info['uuid'], shared=False) as task: task.driver.power.set_power_state(task, states.POWER_ON) mock_power_on.assert_called_once_with(task.node)
def test__parse_driver_info_good(self): # make sure we get back the expected things node = db_utils.get_test_node(driver='fake_seamicro', driver_info=INFO_DICT) info = seamicro._parse_driver_info(node) self.assertIsNotNone(info.get('api_endpoint')) self.assertIsNotNone(info.get('username')) self.assertIsNotNone(info.get('password')) self.assertIsNotNone(info.get('server_id')) self.assertIsNotNone(info.get('uuid'))
def test_set_boot_device_invalid_device_fail(self, mock_get_server): info = seamicro._parse_driver_info(self.node) boot_device = "invalid_device" mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, info['uuid'], shared=False) as task: kwargs = {'device': boot_device, 'method': 'set_boot_device'} self.assertRaises(exception.InvalidParameterValue, task.driver.vendor.vendor_passthru, task, **kwargs)
def test_attach_volume_with_no_input_fail(self): info = seamicro._parse_driver_info(self.node) with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task: self.assertRaises( exception.InvalidParameterValue, task.resources[0].driver.vendor.vendor_passthru, task, self.node, **{"method": "attach_volume"} )
def test__get_client_fail(self, mock_client): driver_info = seamicro._parse_driver_info(self.node) args = {'username': driver_info['username'], 'password': driver_info['password'], 'auth_url': driver_info['api_endpoint']} mock_client.side_effect = seamicro_client_exception.UnsupportedVersion self.assertRaises(exception.InvalidParameterValue, seamicro._get_client, **driver_info) mock_client.assert_called_once_with(driver_info['api_version'], **args)
def test_set_node_vlan_id_good(self, mock_get_server): info = seamicro._parse_driver_info(self.node) vlan_id = "12" mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, [info['uuid']], shared=False) as task: kwargs = {'vlan_id': vlan_id, 'method': 'set_node_vlan_id'} task.resources[0].driver.vendor.\ vendor_passthru(task, self.node, **kwargs) mock_get_server.assert_called_once_with(info)
def test_reboot(self, mock_reboot): info = seamicro._parse_driver_info(self.node) mock_reboot.return_value = states.POWER_ON with task_manager.acquire(self.context, info['uuid'], shared=False) as task: task.driver.power.reboot(task) mock_reboot.assert_called_once_with(task.node)
def test_set_boot_device_invalid_device_fail(self, mock_get_server): info = seamicro._parse_driver_info(self.node) boot_device = "invalid_device" mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, [info['uuid']], shared=False) as task: kwargs = {'device': boot_device, 'method': 'set_boot_device'} self.assertRaises(exception.InvalidParameterValue, task.resources[0].driver.vendor. vendor_passthru, task, self.node, **kwargs)
def test_set_power_state_off_good(self, mock_power_off): info = seamicro._parse_driver_info(self.node) mock_power_off.return_value = states.POWER_OFF with task_manager.acquire(self.context, info['uuid'], shared=False) as task: task.driver.power.set_power_state(task, states.POWER_OFF) mock_power_off.assert_called_once_with(task.node)
def test_attach_volume_with_volume_id_good(self, mock_validate_volume, mock_get_server): info = seamicro._parse_driver_info(self.node) volume_id = '0/ironic-p6-1/vol1' mock_validate_volume.return_value = True mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, info['uuid'], shared=False) as task: kwargs = {'volume_id': volume_id, 'method': 'attach_volume'} task.driver.vendor.vendor_passthru(task, **kwargs) mock_get_server.assert_called_once_with(info)
def test_set_power_state_bad_state(self): info = seamicro._parse_driver_info(self.node) self.get_server_mock = self.get_server_patcher.start() self.get_server_mock.return_value = self.Server() with task_manager.acquire(self.context, info['uuid'], shared=False) as task: self.assertRaises(exception.IronicException, task.driver.power.set_power_state, task, "BAD_PSTATE") self.get_server_patcher.stop()
def test__parse_driver_info_good(self): # make sure we get back the expected things node = obj_utils.get_test_node(self.context, driver='fake_seamicro', driver_info=INFO_DICT) info = seamicro._parse_driver_info(node) self.assertEqual('http://1.2.3.4', info['api_endpoint']) self.assertEqual('admin', info['username']) self.assertEqual('fake', info['password']) self.assertEqual('0/0', info['server_id']) self.assertEqual('1be26c0b-03f2-4d2e-ae87-c02d7f33c123', info['uuid'])
def test__get_client_fail(self, mock_client): driver_info = seamicro._parse_driver_info(self.node) args = { 'username': driver_info['username'], 'password': driver_info['password'], 'auth_url': driver_info['api_endpoint'] } mock_client.side_effect = seamicro_client_exception.UnsupportedVersion self.assertRaises(exception.InvalidParameterValue, seamicro._get_client, **driver_info) mock_client.assert_called_once_with(driver_info['api_version'], **args)
def setUp(self): super(SeaMicroPrivateMethodsTestCase, self).setUp() n = {'driver': 'fake_seamicro', 'driver_info': INFO_DICT} self.node = obj_utils.create_test_node(self.context, **n) self.Server = Fake_Server self.Volume = Fake_Volume self.Pool = Fake_Pool self.config(action_timeout=0, group='seamicro') self.config(max_retry=2, group='seamicro') self.info = seamicro._parse_driver_info(self.node)
def test_set_power_state_on_good(self, mock_power_on): info = seamicro._parse_driver_info(self.node) mock_power_on.return_value = states.POWER_ON with task_manager.acquire(self.context, [info['uuid']], shared=False) as task: task.resources[0].driver.power.set_power_state(task, self.node, states.POWER_ON) mock_power_on.assert_called_once_with(self.node)
def test_set_power_state_off_fail(self, mock_power_off): info = seamicro._parse_driver_info(self.node) mock_power_off.return_value = states.POWER_ON with task_manager.acquire(self.context, info['uuid'], shared=False) as task: self.assertRaises(exception.PowerStateFailure, task.driver.power.set_power_state, task, states.POWER_OFF) mock_power_off.assert_called_once_with(task.node)
def test_attach_volume_with_invalid_volume_id_fail(self, mock_get_volume, mock_get_server): info = seamicro._parse_driver_info(self.node) volume_id = '0/p6-1/vol1' mock_get_volume.return_value = self.Volume(volume_id) mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, info['uuid'], shared=False) as task: kwargs = {'volume_id': volume_id, 'method': 'attach_volume'} self.assertRaises(exception.InvalidParameterValue, task.driver.vendor.vendor_passthru, task, **kwargs)
def setUp(self): super(SeaMicroDriverTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_seamicro') self.driver = driver_factory.get_driver('fake_seamicro') self.node = obj_utils.create_test_node(self.context, driver='fake_seamicro', driver_info=INFO_DICT) self.get_server_patcher = mock.patch.object(seamicro, '_get_server') self.get_server_mock = None self.Server = Fake_Server self.Volume = Fake_Volume self.info = seamicro._parse_driver_info(self.node)
def test__parse_driver_info_good(self): # make sure we get back the expected things node = obj_utils.get_test_node( self.context, driver='fake_seamicro', driver_info=INFO_DICT) info = seamicro._parse_driver_info(node) self.assertEqual('http://1.2.3.4', info['api_endpoint']) self.assertEqual('admin', info['username']) self.assertEqual('fake', info['password']) self.assertEqual('0/0', info['server_id']) self.assertEqual('1be26c0b-03f2-4d2e-ae87-c02d7f33c123', info['uuid'])
def test_attach_volume_with_invalid_volume_id_fail(self, mock_get_volume, mock_get_server): info = seamicro._parse_driver_info(self.node) volume_id = '0/p6-1/vol1' mock_get_volume.return_value = self.Volume(volume_id) mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, [info['uuid']], shared=False) as task: kwargs = {'volume_id': volume_id, 'method': 'attach_volume'} self.assertRaises(exception.InvalidParameterValue, task.resources[0].driver.vendor. vendor_passthru, task, **kwargs)
def setUp(self): super(SeaMicroPrivateMethodsTestCase, self).setUp() n = { 'driver': 'fake_seamicro', 'driver_info': INFO_DICT } self.node = obj_utils.create_test_node(self.context, **n) self.Server = Fake_Server self.Volume = Fake_Volume self.Pool = Fake_Pool self.config(action_timeout=0, group='seamicro') self.config(max_retry=2, group='seamicro') self.info = seamicro._parse_driver_info(self.node)
def test_set_power_state_on_fail(self, mock_power_on): info = seamicro._parse_driver_info(self.node) mock_power_on.return_value = states.POWER_OFF with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task: self.assertRaises( exception.PowerStateFailure, task.resources[0].driver.power.set_power_state, task, self.node, states.POWER_ON, ) mock_power_on.assert_called_once_with(self.node)
def test_attach_volume_with_volume_size_good(self, mock_create_volume, mock_validate_volume, mock_get_server): info = seamicro._parse_driver_info(self.node) volume_id = '0/ironic-p6-1/vol1' volume_size = 2 mock_create_volume.return_value = volume_id mock_validate_volume.return_value = True mock_get_server.return_value = self.Server(active="true") with task_manager.acquire(self.context, [info['uuid']], shared=False) as task: kwargs = {'volume_size': volume_size, 'method': "attach_volume"} task.resources[0].driver.vendor.\ vendor_passthru(task, self.node, **kwargs) mock_get_server.assert_called_once_with(info) mock_create_volume.assert_called_once_with(info, volume_size)
def test_set_boot_device_fail(self, mock_get_server): def fake_set_boot_order(self, **kwargs): raise seamicro_client_exception.ClientException(500) info = seamicro._parse_driver_info(self.node) boot_device = "pxe" server = self.Server(active="true") server.set_boot_order = fake_set_boot_order mock_get_server.return_value = server with task_manager.acquire(self.context, info['uuid'], shared=False) as task: self.assertRaises(exception.IronicException, task.driver.management.set_boot_device, task, boot_device) mock_get_server.assert_called_once_with(info)
def test_set_boot_device_fail(self, mock_get_server): def fake_set_boot_order(self, **kwargs): raise seamicro_client_exception.ClientException(500) info = seamicro._parse_driver_info(self.node) boot_device = "pxe" server = self.Server(active="true") server.set_boot_order = fake_set_boot_order mock_get_server.return_value = server with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task: kwargs = {"device": boot_device, "method": "set_boot_device"} self.assertRaises( exception.IronicException, task.resources[0].driver.vendor.vendor_passthru, task, self.node, **kwargs ) mock_get_server.assert_called_once_with(info)
def test_set_boot_device_fail(self, mock_get_server): def fake_set_boot_order(self, **kwargs): raise seamicro_client_exception.ClientException(500) info = seamicro._parse_driver_info(self.node) boot_device = "pxe" server = self.Server(active="true") server.set_boot_order = fake_set_boot_order mock_get_server.return_value = server with task_manager.acquire(self.context, [info['uuid']], shared=False) as task: kwargs = {'device': boot_device, 'method': 'set_boot_device'} self.assertRaises(exception.IronicException, task.resources[0].driver.vendor. vendor_passthru, task, self.node, **kwargs) mock_get_server.assert_called_once_with(info)
def test_set_node_vlan_id_fail(self, mock_get_server): def fake_set_untagged_vlan(self, **kwargs): raise seamicro_client_exception.ClientException(500) info = seamicro._parse_driver_info(self.node) vlan_id = "12" server = self.Server(active="true") server.set_untagged_vlan = fake_set_untagged_vlan mock_get_server.return_value = server with task_manager.acquire(self.context, info['uuid'], shared=False) as task: kwargs = {'vlan_id': vlan_id, 'method': 'set_node_vlan_id'} self.assertRaises(exception.IronicException, task.driver.vendor.vendor_passthru, task, **kwargs) mock_get_server.assert_called_once_with(info)
def test_attach_volume_fail(self, mock_validate_volume, mock_get_server): def fake_attach_volume(self, **kwargs): raise seamicro_client_exception.ClientException(500) info = seamicro._parse_driver_info(self.node) volume_id = '0/p6-1/vol1' mock_validate_volume.return_value = True server = self.Server(active="true") server.attach_volume = fake_attach_volume mock_get_server.return_value = server with task_manager.acquire(self.context, info['uuid'], shared=False) as task: kwargs = {'volume_id': volume_id, 'method': 'attach_volume'} self.assertRaises(exception.IronicException, task.driver.vendor.vendor_passthru, task, **kwargs) mock_get_server.assert_called_once_with(info)
def test__validate_good(self, mock_get_volume): info = seamicro._parse_driver_info(self.node) volume = self.Volume() mock_get_volume.return_value = volume valid = seamicro._validate_volume(info, volume.id) self.assertEqual(valid, True)
def test__create_volume_fail(self, mock_get_pools): info = seamicro._parse_driver_info(self.node) mock_get_pools.return_value = None self.assertRaises(exception.IronicException, seamicro._create_volume, info, 2)