diff --git a/.testr.conf b/.testr.conf index 6c1541ea72..1a61078d7e 100644 --- a/.testr.conf +++ b/.testr.conf @@ -1,4 +1,4 @@ [DEFAULT] -test_command=OS_STDOUT_CAPTURE=1 OS_STDERR_CAPTURE=1 OS_TEST_TIMEOUT=60 ${PYTHON:-python} -m subunit.run discover -t ./ ./ $LISTOPT $IDOPTION +test_command=OS_STDOUT_CAPTURE=1 OS_STDERR_CAPTURE=1 OS_TEST_TIMEOUT=60 ${PYTHON:-python} -m subunit.run discover -t ./ ${TESTS_DIR:-./ironic/tests/} $LISTOPT $IDOPTION test_id_option=--load-list $IDFILE test_list_option=--list diff --git a/ironic/nova/tests/__init__.py b/ironic/nova/tests/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/ironic/nova/tests/scheduler/__init__.py b/ironic/nova/tests/scheduler/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/ironic/nova/tests/scheduler/test_ironic_host_manager.py b/ironic/nova/tests/scheduler/test_ironic_host_manager.py index c79b0998fb..176eba565f 100644 --- a/ironic/nova/tests/scheduler/test_ironic_host_manager.py +++ b/ironic/nova/tests/scheduler/test_ironic_host_manager.py @@ -17,12 +17,13 @@ Tests For IronicHostManager """ +from ironic.nova.scheduler import ironic_host_manager +from ironic.nova.tests.scheduler import ironic_fakes + from nova import db from nova import exception from nova.scheduler import filters -from nova.scheduler import ironic_host_manager from nova import test -from nova.tests.scheduler import ironic_fakes class FakeFilterClass1(filters.BaseHostFilter): diff --git a/ironic/nova/tests/virt/__init__.py b/ironic/nova/tests/virt/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/ironic/nova/tests/virt/ironic/test_driver.py b/ironic/nova/tests/virt/ironic/test_driver.py index 5a6042ad4d..870962c08c 100644 --- a/ironic/nova/tests/virt/ironic/test_driver.py +++ b/ironic/nova/tests/virt/ironic/test_driver.py @@ -22,16 +22,18 @@ from ironicclient import exc as ironic_exception import mock from oslo.config import cfg +from ironic.nova.virt.ironic import driver as ironic_driver +from ironic.nova.virt.ironic import ironic_states + from nova.compute import power_state as nova_states from nova import context as nova_context from nova import exception +from nova.objects.flavor import Flavor as flavor_obj from nova.openstack.common import uuidutils from nova import test from nova.tests import fake_instance from nova.tests import utils from nova.virt import fake -from nova.virt.ironic import driver as ironic_driver -from nova.virt.ironic import ironic_states CONF = cfg.CONF @@ -189,21 +191,35 @@ class IronicDriverTestCase(test.NoDBTestCase): mock_ctx.return_value = self.ctx with mock.patch.object(ironic_client, 'get_client') as mock_ir_cli: self.driver._get_client() - expected = {'os_auth_token': self.ctx.auth_token, + expected = {'os_auth_token': 'fake-token', 'ironic_url': CONF.ironic.api_endpoint} mock_ir_cli.assert_called_once_with(CONF.ironic.api_version, **expected) - def test__require_node(self): + def test_validate_instance_and_node(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' - test_instance = fake_instance.fake_instance_obj(self.ctx, - node=node_uuid) - self.assertEqual(node_uuid, self.driver._require_node(test_instance)) + instance_uuid = uuidutils.generate_uuid() + node = get_test_node(uuid=node_uuid, instance_uuid=instance_uuid) + instance = fake_instance.fake_instance_obj(self.ctx, + uuid=instance_uuid) - def test__require_node_fail(self): - test_instance = fake_instance.fake_instance_obj(self.ctx, node=None) - self.assertRaises(exception.NovaException, - self.driver._require_node, test_instance) + with mock.patch.object(FAKE_CLIENT.node, 'get_by_instance_uuid') \ + as mock_gbiui: + mock_gbiui.return_value = node + result = ironic_driver.validate_instance_and_node(FAKE_CLIENT, + instance) + self.assertEqual(result.uuid, node_uuid) + + def test_validate_instance_and_node_failed(self): + with mock.patch.object(FAKE_CLIENT.node, 'get_by_instance_uuid') \ + as mock_gbiui: + mock_gbiui.side_effect = ironic_exception.HTTPNotFound() + instance_uuid = uuidutils.generate_uuid(), + instance = fake_instance.fake_instance_obj(self.ctx, + uuid=instance_uuid) + self.assertRaises(exception.InstanceNotFound, + ironic_driver.validate_instance_and_node, + FAKE_CLIENT, instance) def test__node_resource(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' @@ -226,7 +242,7 @@ class IronicDriverTestCase(test.NoDBTestCase): self.assertEqual(disk, result['local_gb_used']) self.assertEqual(node_uuid, result['hypervisor_hostname']) self.assertEqual('{"cpu_arch": "x86_64", "ironic_driver": "' - 'nova.virt.ironic.driver.IronicDriver", ' + 'ironic.nova.virt.ironic.driver.IronicDriver", ' '"test_spec": "test_value"}', result['stats']) @@ -251,28 +267,29 @@ class IronicDriverTestCase(test.NoDBTestCase): self.assertEqual(0, result['local_gb_used']) self.assertEqual(node_uuid, result['hypervisor_hostname']) self.assertEqual('{"cpu_arch": "x86_64", "ironic_driver": "' - 'nova.virt.ironic.driver.IronicDriver", ' + 'ironic.nova.virt.ironic.driver.IronicDriver", ' '"test_spec": "test_value"}', result['stats']) - def test__retry_on_conflict(self): + def test__retry_if_service_is_unavailable(self): test_list = [] def test_func(test_list): test_list.append(1) - self.driver._retry_on_conflict(test_func, test_list) + self.driver._retry_if_service_is_unavailable(test_func, test_list) self.assertIn(1, test_list) - def test__retry_on_conflict_fail(self): + def test__retry_if_service_is_unavailable_fail(self): CONF.set_default('api_max_retries', default=1, group='ironic') CONF.set_default('api_retry_interval', default=0, group='ironic') def test_func(): - raise ironic_exception.HTTPConflict() + raise ironic_exception.HTTPServiceUnavailable() self.assertRaises(ironic_driver.MaximumRetriesReached, - self.driver._retry_on_conflict, test_func) + self.driver._retry_if_service_is_unavailable, + test_func) def test__start_firewall(self): func_list = ['setup_basic_filtering', @@ -420,30 +437,37 @@ class IronicDriverTestCase(test.NoDBTestCase): mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() mock_get.return_value = node self.addCleanup(mock_get.stop) - mock_fg = mock.patch.object(self.driver.virtapi, 'flavor_get').start() - mock_fg.return_value = fake_flavor - self.addCleanup(mock_fg.stop) + mock_fg_bid = mock.patch.object(flavor_obj, 'get_by_id').start() + mock_fg_bid.return_value = fake_flavor + self.addCleanup(mock_fg_bid.stop) + mock_validate = mock.patch.object(FAKE_CLIENT.node, 'validate').start() mock_validate.return_value = get_test_validation() self.addCleanup(mock_validate.stop) mock_adf = mock.patch.object(self.driver, '_add_driver_fields').start() self.addCleanup(mock_adf.stop) - mock_pvifs = mock.patch.object(self.driver, 'plug_vifs').start() + mock_pvifs = mock.patch.object(self.driver, '_plug_vifs').start() self.addCleanup(mock_pvifs.stop) mock_sf = mock.patch.object(self.driver, '_start_firewall').start() self.addCleanup(mock_pvifs.stop) + mock_get_node_by_iuuid = mock.patch.object( + FAKE_CLIENT.node, 'get_by_instance_uuid').start() + self.addCleanup(mock_get_node_by_iuuid.stop) + mock_get_node_by_iuuid.return_value = node + with mock.patch.object(FAKE_CLIENT.node, 'set_provision_state') \ as mock_sps: + node.provision_state = ironic_states.ACTIVE self.driver.spawn(self.ctx, instance, None, [], None) mock_get.assert_called_once_with(node_uuid) mock_validate.assert_called_once_with(node_uuid) - mock_fg.assert_called_once_with(self.ctx, - instance['instance_type_id']) + mock_fg_bid.assert_called_once_with(self.ctx, + instance['instance_type_id']) mock_adf.assert_called_once_with(node, instance, None, fake_flavor) - mock_pvifs.assert_called_once_with(instance, None) + mock_pvifs.assert_called_once_with(node, instance, None) mock_sf.assert_called_once_with(instance, None) mock_sps.assert_called_once_with(node_uuid, 'active') @@ -464,13 +488,16 @@ class IronicDriverTestCase(test.NoDBTestCase): mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() mock_get.return_value = node self.addCleanup(mock_get.stop) - mock_fg = mock.patch.object(self.driver.virtapi, 'flavor_get').start() - mock_fg.return_value = fake_flavor - self.addCleanup(mock_fg.stop) + mock_fg_bid = mock.patch.object(flavor_obj, 'get_by_id').start() + mock_fg_bid.return_value = fake_flavor + self.addCleanup(mock_fg_bid.stop) mock_adf = mock.patch.object(self.driver, '_add_driver_fields').start() self.addCleanup(mock_adf.stop) + mock_pvifs = mock.patch.object(self.driver, '_plug_vifs').start() + self.addCleanup(mock_pvifs.stop) + with mock.patch.object(FAKE_CLIENT.node, 'validate') as mock_validate: mock_validate.return_value = get_test_validation(power=False, deploy=False) @@ -479,8 +506,8 @@ class IronicDriverTestCase(test.NoDBTestCase): mock_get.assert_called_once_with(node_uuid) mock_validate.assert_called_once_with(node_uuid) - mock_fg.assert_called_once_with(self.ctx, - instance['instance_type_id']) + mock_fg_bid.assert_called_once_with(self.ctx, + instance['instance_type_id']) mock_adf.assert_called_once_with(node, instance, None, fake_flavor) def test_spawn_node_prepare_for_deploy_fail(self): @@ -495,14 +522,13 @@ class IronicDriverTestCase(test.NoDBTestCase): mock_validate.return_value = get_test_validation() self.addCleanup(mock_validate.stop) - mock_fg = mock.patch.object(self.driver.virtapi, 'flavor_get').start() - self.addCleanup(mock_fg.stop) - mock_pvifs = mock.patch.object(self.driver, 'plug_vifs').start() + mock_fg_bid = mock.patch.object(flavor_obj, 'get_by_id').start() + self.addCleanup(mock_fg_bid.stop) + mock_pvifs = mock.patch.object(self.driver, '_plug_vifs').start() self.addCleanup(mock_pvifs.stop) - mock_upvifs = mock.patch.object(self.driver, 'unplug_vifs').start() - self.addCleanup(mock_upvifs.stop) - mock_stof = mock.patch.object(self.driver, '_stop_firewall').start() - self.addCleanup(mock_stof.stop) + mock_cleanup_deploy = mock.patch.object( + self.driver, '_cleanup_deploy').start() + self.addCleanup(mock_cleanup_deploy.stop) class TestException(Exception): pass @@ -514,10 +540,9 @@ class IronicDriverTestCase(test.NoDBTestCase): mock_get.assert_called_once_with(node_uuid) mock_validate.assert_called_once_with(node_uuid) - mock_fg.assert_called_once_with(self.ctx, - instance['instance_type_id']) - mock_upvifs.assert_called_once_with(instance, None) - mock_stof.assert_called_once_with(instance, None) + mock_fg_bid.assert_called_once_with(self.ctx, + instance['instance_type_id']) + mock_cleanup_deploy.assert_called_with(node, instance, None) def test_spawn_node_trigger_deploy_fail(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' @@ -531,16 +556,15 @@ class IronicDriverTestCase(test.NoDBTestCase): mock_validate.return_value = get_test_validation() self.addCleanup(mock_validate.stop) - mock_fg = mock.patch.object(self.driver.virtapi, 'flavor_get').start() - self.addCleanup(mock_fg.stop) - mock_pvifs = mock.patch.object(self.driver, 'plug_vifs').start() + mock_fg_bid = mock.patch.object(flavor_obj, 'get_by_id').start() + self.addCleanup(mock_fg_bid.stop) + mock_pvifs = mock.patch.object(self.driver, '_plug_vifs').start() self.addCleanup(mock_pvifs.stop) mock_sf = mock.patch.object(self.driver, '_start_firewall').start() self.addCleanup(mock_sf.stop) - mock_upvifs = mock.patch.object(self.driver, 'unplug_vifs').start() - self.addCleanup(mock_upvifs.stop) - mock_stof = mock.patch.object(self.driver, '_stop_firewall').start() - self.addCleanup(mock_stof.stop) + mock_cleanup_deploy = mock.patch.object( + self.driver, '_cleanup_deploy').start() + self.addCleanup(mock_cleanup_deploy.stop) with mock.patch.object(FAKE_CLIENT.node, 'set_provision_state') \ as mock_sps: @@ -550,43 +574,47 @@ class IronicDriverTestCase(test.NoDBTestCase): mock_get.assert_called_once_with(node_uuid) mock_validate.assert_called_once_with(node_uuid) - mock_fg.assert_called_once_with(self.ctx, - instance['instance_type_id']) - mock_upvifs.assert_called_once_with(instance, None) - mock_stof.assert_called_once_with(instance, None) + mock_fg_bid.assert_called_once_with(self.ctx, + instance['instance_type_id']) + mock_cleanup_deploy.assert_called_once_with(node, instance, None) def test_destroy(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' + network_info = 'foo' + node = get_test_node(driver='fake', uuid=node_uuid) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) - mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() - mock_get.return_value = node - self.addCleanup(mock_get.stop) + mock_get_by_iuuid = mock.patch.object( + FAKE_CLIENT.node, 'get_by_instance_uuid').start() + mock_get_by_iuuid.return_value = node + self.addCleanup(mock_get_by_iuuid.stop) mock_sps = mock.patch.object(FAKE_CLIENT.node, 'set_provision_state').start() self.addCleanup(mock_sps.stop) mock_update = mock.patch.object(FAKE_CLIENT.node, 'update').start() self.addCleanup(mock_update.stop) - mock_upvifs = mock.patch.object(self.driver, 'unplug_vifs').start() - self.addCleanup(mock_upvifs.stop) - mock_stof = mock.patch.object(self.driver, '_stop_firewall').start() - self.addCleanup(mock_stof.stop) + mock_cleanupd = mock.patch.object( + self.driver, '_cleanup_deploy').start() + self.addCleanup(mock_cleanupd.stop) - self.driver.destroy(self.ctx, instance, None, None) + self.driver.destroy(self.ctx, instance, network_info, None) mock_sps.assert_called_once_with(node_uuid, 'deleted') - mock_get.assert_called_with(node_uuid) - mock_upvifs.assert_called_once_with(instance, None) - mock_stof.assert_called_once_with(instance, None) + mock_get_by_iuuid.assert_called_with(instance.uuid) + mock_cleanupd.assert_called_with(node, instance, network_info) def test_destroy_trigger_undeploy_fail(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' - instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) - - with mock.patch.object(FAKE_CLIENT.node, 'set_provision_state') \ - as mock_sps: - mock_sps.side_effect = ironic_driver.MaximumRetriesReached - self.assertRaises(exception.NovaException, self.driver.destroy, + node = get_test_node(driver='fake', uuid=node_uuid) + with mock.patch.object(ironic_driver, 'validate_instance_and_node') \ + as fake_validate: + fake_validate.return_value = node + instance = fake_instance.fake_instance_obj(self.ctx, + node=node_uuid) + with mock.patch.object(FAKE_CLIENT.node, 'set_provision_state') \ + as mock_sps: + mock_sps.side_effect = ironic_driver.MaximumRetriesReached + self.assertRaises(exception.NovaException, self.driver.destroy, self.ctx, instance, None, None) def test_destroy_unprovision_fail(self): @@ -598,9 +626,11 @@ class IronicDriverTestCase(test.NoDBTestCase): provision_state='fake-state') instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) - mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() - mock_get.return_value = node - self.addCleanup(mock_get.stop) + mock_get_by_iuuid = mock.patch.object( + FAKE_CLIENT.node, 'get_by_instance_uuid').start() + mock_get_by_iuuid.return_value = node + self.addCleanup(mock_get_by_iuuid.stop) + mock_sps = mock.patch.object(FAKE_CLIENT.node, 'set_provision_state').start() self.addCleanup(mock_sps.stop) @@ -614,9 +644,10 @@ class IronicDriverTestCase(test.NoDBTestCase): node = get_test_node(driver='fake', uuid=node_uuid) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) - mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() - mock_get.return_value = node - self.addCleanup(mock_get.stop) + mock_get_by_iuuid = mock.patch.object( + FAKE_CLIENT.node, 'get_by_instance_uuid').start() + mock_get_by_iuuid.return_value = node + self.addCleanup(mock_get_by_iuuid.stop) mock_sps = mock.patch.object(FAKE_CLIENT.node, 'set_provision_state').start() self.addCleanup(mock_sps.stop) @@ -626,7 +657,7 @@ class IronicDriverTestCase(test.NoDBTestCase): self.assertRaises(exception.NovaException, self.driver.destroy, self.ctx, instance, None, None) mock_sps.assert_called_once_with(node_uuid, 'deleted') - mock_get.assert_called_with(node_uuid) + mock_get_by_iuuid.assert_called_with(instance.uuid) def test_reboot(self): #TODO(lucasagomes): Not implemented in the driver.py @@ -634,33 +665,51 @@ class IronicDriverTestCase(test.NoDBTestCase): def test_power_off(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' - instance = fake_instance.fake_instance_obj(self.ctx, - node=node_uuid) - with mock.patch.object(FAKE_CLIENT.node, 'set_power_state') as mock_sp: - self.driver.power_off(instance) - mock_sp.assert_called_once_with(node_uuid, 'off') + node = get_test_node(driver='fake', uuid=node_uuid) + + with mock.patch.object(ironic_driver, 'validate_instance_and_node') \ + as fake_validate: + fake_validate.return_value = node + self.addCleanup(fake_validate.stop) + instance_uuid = uuidutils.generate_uuid() + instance = fake_instance.fake_instance_obj(self.ctx, + node=instance_uuid) + + with mock.patch.object(FAKE_CLIENT.node, 'set_power_state') \ + as mock_sp: + self.driver.power_off(instance) + mock_sp.assert_called_once_with(node_uuid, 'off') def test_power_on(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' - instance = fake_instance.fake_instance_obj(self.ctx, - node=node_uuid) - with mock.patch.object(FAKE_CLIENT.node, 'set_power_state') as mock_sp: - self.driver.power_on(self.ctx, instance, - utils.get_test_network_info()) - mock_sp.assert_called_once_with(node_uuid, 'on') + node = get_test_node(driver='fake', uuid=node_uuid) - def test_plug_vifs(self): + with mock.patch.object(ironic_driver, 'validate_instance_and_node') \ + as fake_validate: + fake_validate.return_value = node + self.addCleanup(fake_validate.stop) + + instance_uuid = uuidutils.generate_uuid() + instance = fake_instance.fake_instance_obj(self.ctx, + node=instance_uuid) + + with mock.patch.object(FAKE_CLIENT.node, 'set_power_state') \ + as mock_sp: + self.driver.power_on(self.ctx, instance, + utils.get_test_network_info()) + mock_sp.assert_called_once_with(node_uuid, 'on') + + def test__plug_vifs(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = get_test_node(uuid=node_uuid) port = get_test_port() - mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() - mock_get.return_value = node - self.addCleanup(mock_get.stop) - mock_uvifs = mock.patch.object(self.driver, 'unplug_vifs').start() + mock_uvifs = mock.patch.object(self.driver, '_unplug_vifs').start() self.addCleanup(mock_uvifs.stop) - mock_update = mock.patch.object(FAKE_CLIENT.port, 'update').start() - self.addCleanup(mock_update.stop) + + mock_retry = mock.patch.object( + self.driver, '_retry_if_service_is_unavailable').start() + self.addCleanup(mock_retry.stop) with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp: mock_lp.return_value = [port] @@ -673,26 +722,43 @@ class IronicDriverTestCase(test.NoDBTestCase): expected_patch = [{'op': 'add', 'path': '/extra/vif_port_id', 'value': port_id}] - self.driver.plug_vifs(instance, network_info) + self.driver._plug_vifs(node, instance, network_info) # asserts - mock_uvifs.assert_called_once_with(instance, network_info) - mock_get.assert_called_once_with(node_uuid) + mock_uvifs.assert_called_once_with(node, instance, network_info) mock_lp.assert_called_once_with(node_uuid) - mock_update.assert_called_once_with(port.uuid, expected_patch) + mock_retry.assert_called_with(FAKE_CLIENT.port.update, + port.uuid, expected_patch) - def test_plug_vifs_count_missmatch(self): + def test_plug_vifs(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = get_test_node(uuid=node_uuid) - port = get_test_port() mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() mock_get.return_value = node self.addCleanup(mock_get.stop) - mock_uvifs = mock.patch.object(self.driver, 'unplug_vifs').start() + + mock__plug_vifs = mock.patch.object(self.driver, '_plug_vifs').start() + self.addCleanup(mock__plug_vifs.stop) + + 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__plug_vifs_count_missmatch(self): + node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' + node = get_test_node(uuid=node_uuid) + port = get_test_port() + + mock_uvifs = mock.patch.object(self.driver, '_unplug_vifs').start() self.addCleanup(mock_uvifs.stop) - mock_update = mock.patch.object(FAKE_CLIENT.port, 'update').start() - self.addCleanup(mock_update.stop) + mock_retry = mock.patch.object( + self.driver, '_retry_if_service_is_unavailable').start() + self.addCleanup(mock_retry.stop) with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp: mock_lp.return_value = [port] @@ -703,28 +769,26 @@ class IronicDriverTestCase(test.NoDBTestCase): network_info = (utils.get_test_network_info() + utils.get_test_network_info()) self.assertRaises(exception.NovaException, - self.driver.plug_vifs, instance, + self.driver._plug_vifs, node, instance, network_info) # asserts - mock_uvifs.assert_called_once_with(instance, network_info) - mock_get.assert_called_once_with(node_uuid) + mock_uvifs.assert_called_once_with(node, instance, network_info) mock_lp.assert_called_once_with(node_uuid) - # assert port.update() was not called - assert not mock_update.called + # assert port.update() was not called via _retry...() + assert not mock_retry.called - def test_plug_vifs_no_network_info(self): + def test__plug_vifs_no_network_info(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = get_test_node(uuid=node_uuid) port = get_test_port() - mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() - mock_get.return_value = node - self.addCleanup(mock_get.stop) - mock_uvifs = mock.patch.object(self.driver, 'unplug_vifs').start() + mock_uvifs = mock.patch.object(self.driver, '_unplug_vifs').start() self.addCleanup(mock_uvifs.stop) - mock_update = mock.patch.object(FAKE_CLIENT.port, 'update').start() - self.addCleanup(mock_update.stop) + + mock_retry = mock.patch.object( + self.driver, '_retry_if_service_is_unavailable').start() + self.addCleanup(mock_retry.stop) with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp: mock_lp.return_value = [port] @@ -732,14 +796,13 @@ class IronicDriverTestCase(test.NoDBTestCase): instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) network_info = [] - self.driver.plug_vifs(instance, network_info) + self.driver._plug_vifs(node, instance, network_info) # asserts - mock_uvifs.assert_called_once_with(instance, network_info) - mock_get.assert_called_once_with(node_uuid) + mock_uvifs.assert_called_once_with(node, instance, network_info) mock_lp.assert_called_once_with(node_uuid) - # assert port.update() was not called - assert not mock_update.called + # assert port.update() was not called via _retry...() + assert not mock_retry.called def test_unplug_vifs(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' diff --git a/test-requirements.txt b/test-requirements.txt index 9dd7463b05..71b8037bd3 100644 --- a/test-requirements.txt +++ b/test-requirements.txt @@ -6,6 +6,7 @@ mock>=1.0 Babel>=1.3 MySQL-python psycopg2 +python-ironicclient python-subunit>=0.0.18 testrepository>=0.0.18 testtools>=0.9.34 @@ -14,3 +15,8 @@ testtools>=0.9.34 sphinx>=1.1.2,<1.2 sphinxcontrib-pecanwsme>=0.6 oslosphinx + +# Required for Nova unit tests in ironic/nova/tests/ and can be removed +# once the driver code lands in Nova. +http://tarballs.openstack.org/nova/nova-master.tar.gz#egg=nova +mox>=0.5.3 diff --git a/tox.ini b/tox.ini index 28ad4e7a07..ea67431ccf 100644 --- a/tox.ini +++ b/tox.ini @@ -9,10 +9,11 @@ install_command = pip install -U {opts} {packages} setenv = VIRTUAL_ENV={envdir} deps = -r{toxinidir}/requirements.txt -r{toxinidir}/test-requirements.txt -commands = - python setup.py testr --slowest --testr-args='{posargs}' - whitelist_externals = bash +commands = + bash -c "TESTS_DIR=./ironic/tests/ python setup.py testr --slowest --testr-args='{posargs}'" + bash -c "TESTS_DIR=./ironic/nova/tests/ python setup.py testr --slowest --testr-args='{posargs}'" + bash -c "cat .testrepository/1 >>.testrepository/0" [tox:jenkins] downloadcache = ~/cache/pip @@ -37,7 +38,7 @@ commands = {posargs} ignore = E12,E711 builtins = _ -exclude = .venv,.git,.tox,dist,doc,*openstack/common*,*lib/python*,*egg,build,tools +exclude = .venv,.git,.tox,dist,doc,*openstack/common*,*lib/python*,*egg,build,tools,*ironic/nova* [hacking] import_exceptions = ironic.openstack.common.gettextutils._,testtools.matchers