def setUp(self): super(GetConsoleOutputTestCase, self).setUp() stubs.stubout_session(self.stubs, xenapi_fake.SessionBase) self._session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass', fake.FakeVirtAPI()) self.vmops = vmops.VMOps(self._session, fake.FakeVirtAPI()) self.vms = []
def setUp(self): super(BareMetalTileraTestCase, self).setUp() self.flags(**COMMON_FLAGS) self.flags(**BAREMETAL_FLAGS) self.driver = tilera.Tilera(fake_virt.FakeVirtAPI()) fake_image.stub_out_image_service(self.stubs) self.addCleanup(fake_image.FakeImageService_reset) self.context = utils.get_test_admin_context() self.test_block_device_info = None, self.instance = utils.get_test_instance() self.test_network_info = utils.get_test_network_info() self.node_info = bm_db_utils.new_bm_node( service_host='test_host', cpus=4, memory_mb=2048, ) self.nic_info = [ { 'address': '22:22:22:22:22:22', 'datapath_id': '0x1', 'port_no': 1 }, { 'address': '33:33:33:33:33:33', 'datapath_id': '0x2', 'port_no': 2 }, ]
def setUp(self): super(LibvirtVolumeTestCase, self).setUp() self.executes = [] def fake_execute(*cmd, **kwargs): self.executes.append(cmd) return None, None self.stubs.Set(utils, 'execute', fake_execute) class FakeLibvirtDriver(object): def __init__(self, hyperv="QEMU"): self.hyperv = hyperv def get_hypervisor_type(self): return self.hyperv def get_all_block_devices(self): return [] self.fake_conn = FakeLibvirtDriver(fake.FakeVirtAPI()) self.connr = { 'ip': '127.0.0.1', 'initiator': 'fake_initiator', 'host': 'fake_host' }
def setUp(self): super(BareMetalLibVirtVolumeDriverTestCase, self).setUp() self.flags(volume_drivers=[ 'fake=nova.virt.libvirt.volume.LibvirtFakeVolumeDriver', 'fake2=nova.virt.libvirt.volume.LibvirtFakeVolumeDriver', ], group='libvirt') self.driver = volume_driver.LibvirtVolumeDriver(fake.FakeVirtAPI()) self.disk_info = { 'dev': 'vdc', 'bus': 'baremetal', 'type': 'baremetal', } self.connection_info = {'driver_volume_type': 'fake'} self.mount_point = '/dev/vdc' self.mount_device = 'vdc' self.source_path = '/dev/sdx' self.instance = { 'uuid': '12345678-1234-1234-1234-123467890123456', 'name': 'instance-00000001' } self.fixed_ips = [ { 'address': '10.2.3.4' }, { 'address': '172.16.17.18' }, ] self.iqn = 'iqn.fake:instance-00000001-dev-vdc' self.tid = 100
def test_public_api_signatures(self): self.flags(connection_url='test_url', connection_password='******', group='xenserver') stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests) inst = xenapi.XenAPIDriver(fake.FakeVirtAPI(), False) self.assertPublicAPISignatures(inst)
def _get_base_class(self): # We do this because it has the side-effect of loading all the # volume drivers self.useFixture(fakelibvirt.FakeLibvirtFixture()) driver.LibvirtDriver(fake.FakeVirtAPI(), False) return volume.LibvirtBaseVolumeDriver
def setUp(self): super(_VirtDriverTestCase, self).setUp() self.flags(instances_path=self.useFixture(fixtures.TempDir()).path) self.connection = importutils.import_object(self.driver_module, fake.FakeVirtAPI()) self.ctxt = test_utils.get_test_admin_context() self.image_service = fake_image.FakeImageService()
def setUp(self): super(BareMetalDriverWithDBTestCase, self).setUp() self.flags(**COMMON_FLAGS) self.flags(**BAREMETAL_FLAGS) fake_image.stub_out_image_service(self.stubs) self.context = utils.get_test_admin_context() self.driver = bm_driver.BareMetalDriver(fake_virt.FakeVirtAPI()) self.addCleanup(fake_image.FakeImageService_reset)
def setUp(self): super(LXDTestDriver, self).setUp() self.ml = stubs.lxd_mock() lxd_patcher = mock.patch('pylxd.api.API', mock.Mock(return_value=self.ml)) lxd_patcher.start() self.addCleanup(lxd_patcher.stop) self.connection = driver.LXDDriver(fake.FakeVirtAPI())
def setUp(self): super(IronicDriverTestCase, self).setUp() self.flags(**IRONIC_FLAGS) self.driver = ironic_driver.IronicDriver(None) self.driver.virtapi = fake.FakeVirtAPI() self.ctx = nova_context.get_admin_context() # mock retries configs to avoid sleeps and make tests run quicker CONF.set_default('api_max_retries', default=1, group='ironic') CONF.set_default('api_retry_interval', default=0, group='ironic')
def test_set_bootable(self): self.flags(connection_url='test_url', connection_password='******', group='xenserver') stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests) driver = xenapi.XenAPIDriver(fake.FakeVirtAPI(), False) self.mox.StubOutWithMock(driver._vmops, 'set_bootable') driver._vmops.set_bootable('inst', True) self.mox.ReplayAll() driver.set_bootable('inst', True)
def test_overhead(self): self.flags(xenapi_connection_url='test_url', xenapi_connection_password='******') stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests) driver = xenapi.XenAPIDriver(fake.FakeVirtAPI(), False) instance = {'memory_mb': 30720} # expected memory overhead per: # https://wiki.openstack.org/wiki/XenServer/Overhead expected = math.ceil(251.832) overhead = driver.estimate_instance_overhead(instance) self.assertEqual(expected, overhead['memory_mb'])
def setUp(self): super(PCSDriverTestCase, self).setUp() self.conn = driver.PCSDriver(fake.FakeVirtAPI(), True) self.conn.init_host(host='localhost') self.conn.psrv.test_add_vms(vms) self.conn.psrv.test_set_host_info(HOST_INFO) self.conn.vif_driver = mock.MagicMock() self.conn._inject_files = mock.MagicMock() self.user_id = 'fake' self.project_id = 'fake' self.context = context.get_admin_context()
def setUp(self): super(BareMetalLibVirtVolumeDriverTestCase, self).setUp() self.flags(libvirt_volume_drivers=[ 'fake=nova.virt.libvirt.volume.LibvirtFakeVolumeDriver', 'fake2=nova.virt.libvirt.volume.LibvirtFakeVolumeDriver', ]) self.driver = volume_driver.LibvirtVolumeDriver(fake.FakeVirtAPI()) self.disk_info = { 'dev': 'vdc', 'bus': 'baremetal', 'type': 'baremetal', } self.connection_info = {'driver_volume_type': 'fake'}
def setUp(self): super(PowerVMComputeDriver, self).setUp() # Set up the mock CPU stats (init_host uses it) self.useFixture(HostCPUStats()) self.drv = driver.PowerVMDriver(fake.FakeVirtAPI()) self.drv.adapter = self.useFixture(pvm_fx.AdapterFx()).adpt self._init_host() self.drv.image_api = mock.Mock() disk_adpt_fx = self.useFixture(DiskAdapter()) self.drv.disk_dvr = disk_adpt_fx.std_disk_adpt
def setUp(self): super(NWFilterTestCase, self).setUp() class Mock(object): pass self.user_id = 'fake' self.project_id = 'fake' self.context = context.RequestContext(self.user_id, self.project_id) self.fake_libvirt_connection = Mock() self.fw = firewall.NWFilterFirewall( fake.FakeVirtAPI(), lambda: self.fake_libvirt_connection)
def setUp(self): super(_VirtDriverTestCase, self).setUp() self.flags(instances_path=self.useFixture(fixtures.TempDir()).path) self.connection = importutils.import_object(self.driver_module, fake.FakeVirtAPI()) self.ctxt = test_utils.get_test_admin_context() self.image_service = fake_image.FakeImageService() # NOTE(dripton): resolve_driver_format does some file reading and # writing and chowning that complicate testing too much by requiring # using real directories with proper permissions. Just stub it out # here; we test it in test_imagebackend.py self.stubs.Set(imagebackend.Image, 'resolve_driver_format', imagebackend.Image._get_driver_format)
def setUp(self): super(LXDTestContainerOps, self).setUp() self.ml = stubs.lxd_mock() lxd_patcher = mock.patch('pylxd.api.API', mock.Mock(return_value=self.ml)) lxd_patcher.start() self.addCleanup(lxd_patcher.stop) self.operations = (container_ops.LXDContainerOperations( fake.FakeVirtAPI())) self.mv = mock.MagicMock() vif_patcher = mock.patch.object(self.operations, 'vif_driver', self.mv) vif_patcher.start() self.addCleanup(vif_patcher.stop)
def test_overhead(self): self.flags(connection_url='test_url', connection_password='******', group='xenserver') stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests) driver = xenapi.XenAPIDriver(fake.FakeVirtAPI(), False) instance = {'memory_mb': 30720, 'vcpus': 4} # expected memory overhead per: # https://wiki.openstack.org/wiki/XenServer/Overhead expected = ((instance['memory_mb'] * xenapi_driver.OVERHEAD_PER_MB) + (instance['vcpus'] * xenapi_driver.OVERHEAD_PER_VCPU) + xenapi_driver.OVERHEAD_BASE) expected = math.ceil(expected) overhead = driver.estimate_instance_overhead(instance) self.assertEqual(expected, overhead['memory_mb'])
def setUp(self, mock_service, mock_machine_info): mock_service.side_effect = gce_mock.get_gce_service mock_machine_info.side_effect = gce_mock.get_machines_info super(GCENovaTestCase, self).setUp() self._driver = GCEDriver(fake.FakeVirtAPI()) self._driver.gce_zone = 'us-central1-c' self._driver.gce_project = 'omni-163105' self._driver.gce_svc_key = "{0}/omni.json".format(DATA_DIR) self.context = context.get_admin_context() self.instance = fake_instance.fake_instance_obj(self.context) self.instance.system_metadata = {'image_gce_link': 'fake_link'} self.instance.metadata = {'gce_id': "instance-1"} self.instance.display_name = "fake_instance" self.instance.flavor.name = "n1-standard-1" self._driver.init_host(None)
def setUp(self): super(IptablesFirewallTestCase, self).setUp() self.user_id = 'fake' self.project_id = 'fake' self.context = context.RequestContext(self.user_id, self.project_id) class FakeLibvirtDriver(object): def nwfilterDefineXML(*args, **kwargs): """setup_basic_rules in nwfilter calls this.""" pass self.fake_libvirt_connection = FakeLibvirtDriver() self.fw = firewall.IptablesFirewallDriver( fake.FakeVirtAPI(), get_connection=lambda: self.fake_libvirt_connection)
def setUp(self): super(IronicDriverTestCase, self).setUp() self.flags(**IRONIC_FLAGS) self.driver = ironic_driver.IronicDriver(None) self.driver.virtapi = fake.FakeVirtAPI() self.ctx = nova_context.get_admin_context() # mock _get_client self.mock_cli_patcher = mock.patch.object(self.driver, '_get_client') self.mock_cli = self.mock_cli_patcher.start() self.mock_cli.return_value = FAKE_CLIENT def stop_patchers(): if self.mock_cli: self.mock_cli_patcher.stop() self.addCleanup(stop_patchers)
def test_available_resource(self): self.flags(connection_url='test_url', connection_password='******', group='xenserver') stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests) driver = xenapi.XenAPIDriver(fake.FakeVirtAPI(), False) driver._session.product_version = (6, 8, 2) self.stubs.Set(driver, 'get_host_stats', self.host_stats) resources = driver.get_available_resource(None) self.assertEqual(6008002, resources['hypervisor_version']) self.assertEqual(50, resources['vcpus']) self.assertEqual(3, resources['memory_mb']) self.assertEqual(4, resources['local_gb']) self.assertEqual(10, resources['vcpus_used']) self.assertEqual(3 - 2, resources['memory_mb_used']) self.assertEqual(5, resources['local_gb_used']) self.assertEqual('xen', resources['hypervisor_type']) self.assertEqual('somename', resources['hypervisor_hostname'])
def setUp(self): super(LibvirtVolumeTestCase, self).setUp() self.executes = [] def fake_execute(*cmd, **kwargs): self.executes.append(cmd) return None, None self.stubs.Set(utils, 'execute', fake_execute) class FakeLibvirtDriver(object): def __init__(self, hyperv="QEMU", version=1005001): self.hyperv = hyperv self.version = version def get_hypervisor_version(self): return self.version def get_hypervisor_type(self): return self.hyperv def get_all_block_devices(self): return [] self.fake_conn = FakeLibvirtDriver(fake.FakeVirtAPI()) self.connr = { 'ip': '127.0.0.1', 'initiator': 'fake_initiator', 'host': 'fake_host' } self.disk_info = { "bus": "virtio", "dev": "vde", "type": "disk", } self.name = 'volume-00000001' self.location = '10.0.2.15:3260' self.iqn = 'iqn.2010-10.org.openstack:%s' % self.name self.vol = {'id': 1, 'name': self.name} self.uuid = '875a8070-d0b9-4949-8b31-104d125c9a64' self.user = '******'
def setUp(self): super(TestZVMGuestOp, self).setUp() self.flags(cloud_connector_url='https://1.1.1.1:1111', image_tmp_path='/test/image', reachable_timeout=300, group='zvm') self.flags(my_ip='192.168.1.1', instance_name_template='test%04x') with test.nested( mock.patch('nova.virt.zvm.utils.ConnectorClient.call'), mock.patch('pwd.getpwuid'), ) as (mcall, getpwuid): getpwuid.return_value = mock.Mock(pw_name='test') mcall.return_value = {'hypervisor_hostname': 'TESTHOST', 'ipl_time': 'TESTTIME'} self._driver = driver.ZVMDriver(fake.FakeVirtAPI()) self._hypervisor = self._driver._hypervisor self._context = context.RequestContext('fake_user', 'fake_project') self._instance = fake_instance.fake_instance_obj( self._context) self._guest = guest.Guest(self._hypervisor, self._instance, self._driver.virtapi)
def _get_driver(self): stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests) self.flags(connection_url='test_url', connection_password='******', group='xenserver') return xenapi.XenAPIDriver(fake.FakeVirtAPI(), False)
def _setup_mock_vmops(self, product_brand=None, product_version=None): self._session = self._get_mock_session(product_brand, product_version) self._vmops = vmops.VMOps(self._session, fake.FakeVirtAPI())
def _setup_mock_vmops(self, product_brand=None, product_version=None): stubs.stubout_session(self.stubs, xenapi_fake.SessionBase) self._session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass', fake.FakeVirtAPI()) self.vmops = vmops.VMOps(self._session, fake.FakeVirtAPI())
def setUp(self, mock_connector, pod_conn): """Initial setup of mocks for all of the unit tests.""" super(TestRSDDriver, self).setUp() # Mock out the connection to the RSD redfish API self.root_conn = mock.MagicMock() mock_connector.return_value = self.root_conn # Create sample collections and instances of Chassis/System/Nodes with open('rsd_virt_for_nova/tests/json_samples/root.json', 'r') as f: self.root_conn.get.return_value.json.return_value = json.loads( f.read()) self.rsd = rsd_lib.main.RSDLib('http://foo.bar:8442', username='******', password='******', verify=False).factory() with open('rsd_virt_for_nova/tests/json_samples/chassis_col.json', 'r') as f: self.root_conn.get.return_value.json.return_value = json.loads( f.read()) self.chassis_col = chassis.ChassisCollection(self.root_conn, '/redfish/v1/Chassis', redfish_version='1.0.2') with open('rsd_virt_for_nova/tests/json_samples/chassis.json', 'r') as f: self.root_conn.get.return_value.json.return_value = json.loads( f.read()) self.chassis_inst = chassis.Chassis(self.root_conn, '/redfish/v1/Chassis/Chassis1', redfish_version='1.0.2') with open('rsd_virt_for_nova/tests/json_samples/node_col.json', 'r') as f: self.root_conn.get.return_value.json.return_value = json.loads( f.read()) self.node_collection = node.NodeCollection(self.root_conn, '/redfish/v1/Nodes', redfish_version='1.0.2') with open('rsd_virt_for_nova/tests/json_samples/node.json', 'r') as f: self.root_conn.get.return_value.json.return_value = json.loads( f.read()) self.node_inst = node.Node(self.root_conn, '/redfish/v1/Nodes/Node1', redfish_version='1.0.2') with open('rsd_virt_for_nova/tests/json_samples/node_assembled.json', 'r') as f: self.root_conn.get.return_value.json.return_value = json.loads( f.read()) self.node_ass_inst = node.Node(self.root_conn, '/redfish/v1/Nodes/Node1', redfish_version='1.0.2') with open('rsd_virt_for_nova/tests/json_samples/sys_collection.json', 'r') as f: self.root_conn.get.return_value.json.return_value = \ json.loads(f.read()) self.system_col = system.SystemCollection(self.root_conn, '/redfish/v1/Systems', redfish_version='1.0.2') with open('rsd_virt_for_nova/tests/json_samples/system.json', 'r') as f: self.root_conn.get.return_value.json.return_value = json.loads( f.read()) self.system_inst = system.System(self.root_conn, '/redfish/v1/Systems/System1', redfish_version='1.0.2') # Mock out a fake virt driver and its dependencies/parameters self.RSD = driver.RSDDriver(fake.FakeVirtAPI()) # Create Fake flavors and instances gb = self.system_inst.memory_summary.size_gib mem = self.RSD.conv_GiB_to_MiB(gb) proc = self.system_inst.processors.summary.count flav_id = str(mem) + 'MB-' + str(proc) + 'vcpus' res = fields.ResourceClass.normalize_name(self.system_inst.identity) spec = 'resources:' + res # Mock out some instances for testing self.flavor = FakeFlavor(gb, mem, str('RSD.' + flav_id), self.system_inst.identity, spec) self.inst1 = FakeInstance('inst1', power_state.RUNNING, 'inst1id', self.flavor) self.invalid_inst = FakeInstance('inv_inst', power_state.RUNNING, 'inv_inst_id', self.flavor) self.RSD.instances = {self.inst1.uuid: self.inst1} # A provider tree for testing on the placement API self.ptree = provider_tree.ProviderTree() self.test_image_meta = { "disk_format": "raw", }
def set_up_virtapi(self): self.virtapi = fake.FakeVirtAPI()