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()
