def test_unplug(self, tag, vif_data, exists): instance = stubs.MockInstance() vif = copy.deepcopy(self.vif_data) self.mgr.net.device_exists.side_effect = exists self.assertEqual(None, self.vif_driver.unplug(instance, vif)) calls = [mock.call.net.device_exists('qbr0123456789a')] if exists[0]: calls[1:1] = [ mock.call.ex('brctl', 'delif', 'qbr0123456789a', 'qvb0123456789a', run_as_root=True), mock.call.ex('ip', 'link', 'set', 'qbr0123456789a', 'down', run_as_root=True), mock.call.ex('brctl', 'delbr', 'qbr0123456789a', run_as_root=True), mock.call.net.delete_ovs_vif_port('fakebr', 'qvo0123456789a') ] self.assertEqual(calls, self.mgr.method_calls)
def test_start_instance(self, mu, tag='', rescue=False, running=False, is_neutron=True, timeout=10, network_info=[], vifs=(), plug_side_effect=None): instance = stubs.MockInstance() container_config = mock.Mock() need_vif_plugged = True self.ml.container_running.return_value = running self.ml.container_start.return_value = ( 200, {'operation': '/1.0/operations/0123456789'}) container_ops.CONF.vif_plugging_timeout = timeout mu.is_neutron.return_value = is_neutron self.mv.plug.side_effect = plug_side_effect with mock.patch.object(self.container_ops.virtapi, 'wait_for_instance_event') as mw: self.assertEqual( None, self.container_ops.start_container(container_config, instance, network_info, need_vif_plugged)) mw.assert_called_once_with( instance, [('network-vif-plugged', vif) for vif in vifs], deadline=timeout, error_callback=self.container_ops._neutron_failed_callback) self.assertEqual( [mock.call(instance, viface) for viface in network_info], self.mv.plug.call_args_list) calls = [ mock.call.container_start('fake-uuid', 5), mock.call.wait_container_operation('0123456789', 200, -1) ] self.assertEqual(calls, self.ml.method_calls[-2:])
def test_rescue_defined(self): instance = stubs.MockInstance() self.ml.container_defined.return_value = True self.assertRaises( exception.InstanceExists, self.container_ops.spawn, {}, instance, {}, [], 'secret', rescue=True) self.ml.container_defined.called_once_with('fake-instance')
def test_detach_interface(self, tag, side_effect): instance = stubs.MockInstance() vif = mock.Mock() with mock.patch.object(self.connection.container_ops, 'vif_driver') as mv: mv.unplug.side_effect = [side_effect] self.assertEqual(None, self.connection.detach_interface(instance, vif)) mv.unplug.assert_called_once_with(instance, vif)
def test_detach_interface_fail(self): instance = stubs.MockInstance() vif = mock.Mock() with mock.patch.object(self.connection.container_ops, 'vif_driver') as mv: mv.unplug.side_effect = [TypeError] self.assertRaises(TypeError, self.connection.detach_interface, instance, vif)
def test_configure_container_configdrive_wrong_format(self): instance = stubs.MockInstance() with mock.patch.object(container_config.CONF, 'config_drive_format', new='fake-format'): self.assertRaises( exception.InstancePowerOnFailure, self.container_config.configure_container_configdrive, {}, instance, {})
def test_plug(self, tag, vif_data, exists): instance = stubs.MockInstance() vif_data = copy.deepcopy(self.vif_data) vif_data.update(vif_data) self.mgr.net.device_exists.side_effect = exists self.assertEqual(None, self.vif_driver.plug(instance, vif_data)) calls = [ mock.call.net.device_exists('qbr0123456789a'), mock.call.net.device_exists('qvo0123456789a') ] if not exists[0]: calls[1:1] = [ mock.call.ex('brctl', 'addbr', 'qbr0123456789a', run_as_root=True), mock.call.ex('brctl', 'setfd', 'qbr0123456789a', 0, run_as_root=True), mock.call.ex('brctl', 'stp', 'qbr0123456789a', 'off', run_as_root=True), mock.call.ex('tee', '/sys/class/net/qbr0123456789a/' 'bridge/multicast_snooping', process_input='0', run_as_root=True, check_exit_code=[0, 1]), ] if not exists[1]: calls.extend([ mock.call.net._create_veth_pair('qvb0123456789a', 'qvo0123456789a'), mock.call.ex('ip', 'link', 'set', 'qbr0123456789a', 'up', run_as_root=True), mock.call.ex('brctl', 'addif', 'qbr0123456789a', 'qvb0123456789a', run_as_root=True) ]) calls.append( mock.call.net.create_ovs_vif_port('fakebr', 'qvo0123456789a', '0123456789abcdef', '00:11:22:33:44:55', 'fake-uuid')) self.assertEqual(calls, self.mgr.method_calls)
def test_attach_interface(self, mo, tag, net='', config={}, info={'init': 1}, firewall_setup=None, update=None, expected_if='', success=True): instance = stubs.MockInstance() vif = { 'type': 'ovs', 'id': '0123456789abcdef', 'address': '00:11:22:33:44:55', } self.ml.get_container_config.side_effect = [config] self.ml.container_info.side_effect = [info] self.ml.container_update.side_effect = [update] mo.return_value = six.moves.cStringIO(net) with mock.patch.object(self.connection.container_ops, 'vif_driver') as mv, ( mock.patch.object((self.connection.container_ops .firewall_driver), 'firewall_driver')) \ as mf: manager = mock.Mock() manager.attach_mock(mv, 'vif_driver') manager.attach_mock(mf, 'firewall') mf.setup_basic_filtering.side_effect = [firewall_setup] self.assertEqual( None, self.connection.attach_interface(instance, {}, vif)) calls = [ mock.call.vif_driver.plug(instance, vif), mock.call.firewall.setup_basic_filtering(instance, vif) ] if not success: calls.append(mock.call.vif_driver.unplug(instance, vif)) self.assertEqual(calls, manager.method_calls) if success or update is not None: self.ml.container_update.assert_called_once_with( 'fake-uuid', { 'profiles': ['nclxd-profile'], 'devices': { 'qbr0123456789a': { 'nictype': 'bridged', 'hwaddr': '00:11:22:33:44:55', 'name': 'eth1', 'parent': 'qbr0123456789a', 'type': 'nic' } }, 'name': 'fake-uuid', 'config': {} })
def test_configure_container_config(self, tag, flavor, expected): instance = stubs.MockInstance(**flavor) config = { 'raw.lxc': 'lxc.console.logfile=/fake/lxd/root/containers/' 'fake-uuid/console.log\n' } config.update(expected) self.assertEqual({'config': config}, self.container_config.configure_container_config( {}, instance))
def test_container_unrescue(self): instance = stubs.MockInstance() network_info = mock.Mock() with contextlib.nested( mock.patch.object(container_utils.LXDContainerUtils, 'container_move'), mock.patch.object(container_utils.LXDContainerUtils, 'container_destroy')) as (container_move, container_destroy): self.connection.unrescue(instance, network_info) self.assertTrue(container_move) self.assertTrue(container_destroy)
def test_configure_container_rescuedisk(self): instance = stubs.MockInstance() self.assertEqual( { 'devices': { 'rescue': { 'path': 'mnt', 'source': '/fake/lxd/root/containers/' 'fake-uuid-backup/rootfs', 'type': 'disk' } } }, self.container_config.configure_container_rescuedisk({}, instance))
def test_configure_container_configdrive_fail_dir(self, md, mi): instance = stubs.MockInstance() injected_files = mock.Mock() self.assertRaises( AttributeError, self.container_config.configure_container_configdrive, None, instance, injected_files) md.assert_called_once_with(instance_md=mi.return_value) (md.return_value.__enter__.return_value.make_drive. assert_called_once_with('/fake/instances/path/fake-uuid/config-drive') ) mi.assert_called_once_with(instance, content=injected_files, extra_md={})
def test_spawn_new(self, tag, side_effect, mc): context = mock.Mock() instance = stubs.MockInstance() image_meta = mock.Mock() injected_files = mock.Mock() network_info = mock.Mock() block_device_info = mock.Mock() self.ml.container_defined.side_effect = [side_effect] with contextlib.nested( mock.patch.object(self.connection.container_ops, 'create_container'), ) as (create_container): self.connection.spawn(context, instance, image_meta, injected_files, None, network_info, block_device_info) self.assertTrue(create_container)
def test_get_console_output(self, me, mo): instance = stubs.MockInstance() mo.return_value.__enter__.return_value = six.BytesIO(b'fake contents') self.assertEqual(b'fake contents', self.connection.get_console_output({}, instance)) calls = [ mock.call('chown', '1234:1234', '/fake/lxd/root/containers/fake-uuid/console.log', run_as_root=True), mock.call('chmod', '755', '/fake/lxd/root/containers/fake-uuid', run_as_root=True) ] self.assertEqual(calls, me.call_args_list)
def test_configure_container_configdrive(self, md, mi): instance = stubs.MockInstance() injected_files = mock.Mock() self.assertEqual( { 'devices': { 'configdrive': { 'path': 'mnt', 'type': 'disk', 'source': '/fake/instances/path/' 'fake-uuid/config-drive' } } }, self.container_config.configure_container_configdrive( {}, instance, injected_files)) md.assert_called_once_with(instance_md=mi.return_value) (md.return_value.__enter__.return_value.make_drive. assert_called_once_with('/fake/instances/path/fake-uuid/config-drive') ) mi.assert_called_once_with(instance, content=injected_files, extra_md={})
def test_rescue(self): context = mock.Mock() instance = stubs.MockInstance() image_meta = mock.Mock() network_info = mock.Mock() self.ml.container_defined.return_value = True with contextlib.nested( mock.patch.object(container_utils.LXDContainerUtils, 'container_stop'), mock.patch.object(self.connection.container_ops, '_container_local_copy'), mock.patch.object(container_utils.LXDContainerUtils, 'container_destroy'), mock.patch.object(self.connection.container_ops, 'spawn')) as (container_stop, container_local_copy, container_destroy, spawn): self.connection.rescue(context, instance, network_info, image_meta, 'secret') self.assertTrue(container_stop) self.assertTrue(container_local_copy) self.assertTrue(container_destroy) self.assertTrue(spawn)
def test_snapshot_fail(self, tag, export_effect, update_effect, mi): instance = stubs.MockInstance() mi.get.return_value = {'name': 'mock_snapshot'} self.ml.container_snapshot_create.return_value = (200, { 'operation': '/1.0/operations/0123456789' }) self.ml.container_stop.return_value = (200, { 'operation': '/1.0/operations/1234567890' }) self.ml.container_start.return_value = (200, { 'operation': '/1.0/operations/2345678901' }) self.ml.container_publish.return_value = (200, { 'metadata': { 'fingerprint': 'abcdef0123456789' } }) self.ml.image_export.side_effect = export_effect mi.update.side_effect = update_effect self.assertRaises(exception.NovaException, self.connection.snapshot, {}, instance, '', mock.Mock())
def test_instance_exists(self, expected, name): self.assertEqual( expected, self.connection.instance_exists(stubs.MockInstance(name=name)))
def test_cleanup(self, mr): instance = stubs.MockInstance() self.assertEqual( None, self.connection.cleanup({}, instance, [], [], None, None, None)) mr.assert_called_once_with('/fake/instances/path/fake-uuid')
def test_snapshot(self, mi): context = mock.Mock() instance = stubs.MockInstance() image_id = 'mock_image' mi.get.return_value = {'name': 'mock_snapshot'} self.ml.container_snapshot_create.return_value = (200, { 'operation': '/1.0/operations/0123456789' }) self.ml.container_stop.return_value = (200, { 'operation': '/1.0/operations/1234567890' }) self.ml.container_start.return_value = (200, { 'operation': '/1.0/operations/2345678901' }) self.ml.container_publish.return_value = (200, { 'metadata': { 'fingerprint': 'abcdef0123456789' } }) manager = mock.Mock() manager.attach_mock(mi, 'image') manager.attach_mock(self.ml, 'lxd') self.assertEqual( None, self.connection.snapshot(context, instance, image_id, manager.update)) calls = [ mock.call.update(task_state='image_pending_upload'), mock.call.image.get(context, 'mock_image'), mock.call.lxd.container_snapshot_create('fake-uuid', { 'name': 'mock_snapshot', 'stateful': False }), mock.call.lxd.wait_container_operation('0123456789', 200, -1), mock.call.lxd.container_stop('fake-uuid', 5), mock.call.lxd.wait_container_operation('1234567890', 200, -1), mock.call.lxd.container_publish({ 'source': { 'name': 'fake-uuid/' 'mock_' 'snapshot', 'type': 'snapshot' } }), mock.call.lxd.alias_create({ 'name': 'mock_snapshot', 'target': 'abcdef0123456789' }), mock.call.lxd.image_export('abcdef0123456789'), mock.call.image.update( context, 'mock_image', { 'name': 'mock_snapshot', 'container_format': 'bare', 'disk_format': 'raw' }, self.ml.image_export.return_value), mock.call.update(expected_state='image_pending_upload', task_state='image_uploading'), mock.call.lxd.container_start('fake-uuid', 5) ] self.assertEqual(calls, manager.method_calls)
def test_nonetype(self): instance = stubs.MockInstance() vif_data = {'type': None} self.assertRaises(exception.NovaException, self.vif_driver.plug, instance, vif_data)
def test_unplug_fail(self): instance = stubs.MockInstance() vif_data = copy.deepcopy(self.vif_data) self.mgr.net.device_exists.side_effect = ( processutils.ProcessExecutionError) self.assertEqual(None, self.vif_driver.unplug(instance, vif_data))
def test_spawn_defined(self, tag, side_effect, expected): instance = stubs.MockInstance() self.ml.container_defined.side_effect = side_effect self.assertRaises(expected, self.connection.spawn, {}, instance, {}, [], 'secret') self.ml.container_defined.called_once_with('mock_instance')