def test_config_download_no_deployment_uuid(self, mock_deployment_data, mock_config_dict, mock_deployment_resource_id, mock_git_init): heat = mock.MagicMock() self.config = ooo_config.Config(heat) stack = mock.MagicMock() heat.stacks.get.return_value = stack heat.resources.get.return_value = mock.MagicMock() stack.outputs = [{ 'output_key': 'RoleNetHostnameMap', 'output_value': { 'Controller': { 'ctlplane': ['overcloud-controller-0.ctlplane.localdomain'] }, 'Compute': { 'ctlplane': [ 'overcloud-novacompute-0.ctlplane.localdomain', 'overcloud-novacompute-1.ctlplane.localdomain', 'overcloud-novacompute-2.ctlplane.localdomain' ] } } }, { 'output_key': 'ServerIdData', 'output_value': { 'server_ids': { 'Controller': ['00b3a5e1-5e8e-4b55-878b-2fa2271f15ad'], 'Compute': [ 'a7db3010-a51f-4ae0-a791-2364d629d20d', '8b07cd31-3083-4b88-a433-955f72039e2c', '169b46f8-1965-4d90-a7de-f36fb4a830fe' ] } } }, { 'output_key': 'RoleNetworkConfigMap', 'output_value': {} }, { 'output_key': 'RoleGroupVars', 'output_value': { 'Controller': { 'any_errors_fatal': 'yes', 'max_fail_percentage': 15 }, 'Compute': { 'any_errors_fatal': 'yes', 'max_fail_percentage': 15 }, } }] deployment_data, configs = self._get_config_data('config_data.yaml') # Set the deployment to TripleOSoftwareDeployment for the first # deployment deployment_data[0].attributes['value']['deployment'] = \ 'TripleOSoftwareDeployment' # Set the physical_resource_id as '' for the second deployment deployment_data[1].attributes['value']['deployment'] = '' self.configs = configs self.deployments = deployment_data mock_deployment_data.return_value = deployment_data mock_config_dict.side_effect = self._get_config_dict mock_deployment_resource_id.side_effect = self._get_deployment_id self.tmp_dir = self.useFixture(fixtures.TempDir()).path with warnings.catch_warnings(record=True) as w: self.config.download_config(stack, self.tmp_dir) assert "Skipping deployment" in str(w[-1].message) assert "Skipping deployment" in str(w[-2].message)
def setUp(self): super(CinderCloudTestCase, self).setUp() ec2utils.reset_cache() self.useFixture(fixtures.TempDir()).path fake_utils.stub_out_utils_spawn_n(self.stubs) self.flags(compute_driver='nova.virt.fake.FakeDriver', volume_api_class='nova.tests.unit.fake_volume.API') def fake_show(meh, context, id, **kwargs): return { 'id': id, 'name': 'fake_name', 'container_format': 'ami', 'status': 'active', 'properties': { 'kernel_id': 'cedef40a-ed67-4d10-800e-17455edce175', 'ramdisk_id': 'cedef40a-ed67-4d10-800e-17455edce175', 'type': 'machine', 'image_state': 'available' } } def fake_detail(_self, context, **kwargs): image = fake_show(None, context, None) image['name'] = kwargs.get('filters', {}).get('name') return [image] self.stubs.Set(fake._FakeImageService, 'show', fake_show) self.stubs.Set(fake._FakeImageService, 'detail', fake_detail) fake.stub_out_image_service(self.stubs) def dumb(*args, **kwargs): pass self.stubs.Set(compute_utils, 'notify_about_instance_usage', dumb) fake_network.set_stub_network_methods(self.stubs) # set up our cloud self.cloud = cloud.CloudController() self.flags(scheduler_driver='nova.scheduler.chance.ChanceScheduler') # Short-circuit the conductor service self.flags(use_local=True, group='conductor') # Stub out the notification service so we use the no-op serializer # and avoid lazy-load traces with the wrap_exception decorator in # the compute service. fake_notifier.stub_notifier(self.stubs) self.addCleanup(fake_notifier.reset) # set up services self.conductor = self.start_service('conductor', manager=CONF.conductor.manager) self.compute = self.start_service('compute') self.scheduler = self.start_service('scheduler') self.network = self.start_service('network') self.consoleauth = self.start_service('consoleauth') self.user_id = 'fake' self.project_id = 'fake' self.context = context.RequestContext(self.user_id, self.project_id, is_admin=True) self.volume_api = volume.API() self.volume_api.reset_fake_api(self.context) self.useFixture(cast_as_call.CastAsCall(self.stubs)) # make sure we can map ami-00000001/2 to a uuid in FakeImageService db.s3_image_create(self.context, 'cedef40a-ed67-4d10-800e-17455edce175') db.s3_image_create(self.context, '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6')
def setUp(self): super(CinderCloudTestCase, self).setUp() ec2utils.reset_cache() vol_tmpdir = self.useFixture(fixtures.TempDir()).path self.flags(compute_driver='nova.virt.fake.FakeDriver', volume_api_class='nova.tests.fake_volume.API') def fake_show(meh, context, id): return { 'id': id, 'name': 'fake_name', 'container_format': 'ami', 'status': 'active', 'properties': { 'kernel_id': 'cedef40a-ed67-4d10-800e-17455edce175', 'ramdisk_id': 'cedef40a-ed67-4d10-800e-17455edce175', 'type': 'machine', 'image_state': 'available' } } def fake_detail(_self, context, **kwargs): image = fake_show(None, context, None) image['name'] = kwargs.get('filters', {}).get('name') return [image] self.stubs.Set(fake._FakeImageService, 'show', fake_show) self.stubs.Set(fake._FakeImageService, 'detail', fake_detail) fake.stub_out_image_service(self.stubs) def dumb(*args, **kwargs): pass self.stubs.Set(compute_utils, 'notify_about_instance_usage', dumb) fake_network.set_stub_network_methods(self.stubs) # set up our cloud self.cloud = cloud.CloudController() self.flags(scheduler_driver='nova.scheduler.chance.ChanceScheduler') # Short-circuit the conductor service self.flags(use_local=True, group='conductor') # set up services self.conductor = self.start_service('conductor', manager=CONF.conductor.manager) self.compute = self.start_service('compute') self.scheduler = self.start_service('scheduler') self.network = self.start_service('network') self.user_id = 'fake' self.project_id = 'fake' self.context = context.RequestContext(self.user_id, self.project_id, is_admin=True) self.volume_api = volume.API() self.volume_api.reset_fake_api(self.context) # NOTE(comstud): Make 'cast' behave like a 'call' which will # ensure that operations complete self.stubs.Set(rpc, 'cast', rpc.call) # make sure we can map ami-00000001/2 to a uuid in FakeImageService db.api.s3_image_create(self.context, 'cedef40a-ed67-4d10-800e-17455edce175') db.api.s3_image_create(self.context, '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6')
def test_nbd_no_devices(self): tempdir = self.useFixture(fixtures.TempDir()).path self.stub_out('nova.virt.disk.mount.nbd.NbdMount._detect_nbd_devices', _fake_detect_nbd_devices_none) n = nbd.NbdMount(self.file, tempdir) self.assertIsNone(n._allocate_nbd())
def _setup_fakelibvirt(self): # So that the _supports_direct_io does the test based # on the current working directory, instead of the # default instances_path which doesn't exist self.flags(instances_path=self.useFixture(fixtures.TempDir()).path) # Put fakelibvirt in place if 'libvirt' in sys.modules: self.saved_libvirt = sys.modules['libvirt'] else: self.saved_libvirt = None import nova.tests.virt.libvirt.fake_imagebackend as fake_imagebackend import nova.tests.virt.libvirt.fake_libvirt_utils as fake_libvirt_utils import nova.tests.virt.libvirt.fakelibvirt as fakelibvirt sys.modules['libvirt'] = fakelibvirt import nova.virt.libvirt.driver import nova.virt.libvirt.firewall self.useFixture( fixtures.MonkeyPatch('nova.virt.libvirt.driver.imagebackend', fake_imagebackend)) self.useFixture( fixtures.MonkeyPatch('nova.virt.libvirt.driver.libvirt', fakelibvirt)) self.useFixture( fixtures.MonkeyPatch('nova.virt.libvirt.driver.libvirt_utils', fake_libvirt_utils)) self.useFixture( fixtures.MonkeyPatch( 'nova.virt.libvirt.imagebackend.libvirt_utils', fake_libvirt_utils)) self.useFixture( fixtures.MonkeyPatch('nova.virt.libvirt.firewall.libvirt', fakelibvirt)) self.flags(rescue_image_id="2", rescue_kernel_id="3", rescue_ramdisk_id=None, libvirt_snapshots_directory='./') def fake_extend(image, size): pass def fake_migrateToURI(*a): pass def fake_make_drive(_self, _path): pass def fake_get_instance_disk_info(_self, instance, xml=None, block_device_info=None): return '[]' def fake_delete_instance_files(_self, _instance): pass self.stubs.Set(nova.virt.libvirt.driver.LibvirtDriver, 'get_instance_disk_info', fake_get_instance_disk_info) self.stubs.Set(nova.virt.libvirt.driver.disk, 'extend', fake_extend) self.stubs.Set(nova.virt.libvirt.driver.LibvirtDriver, '_delete_instance_files', fake_delete_instance_files) # Like the existing fakelibvirt.migrateToURI, do nothing, # but don't fail for these tests. self.stubs.Set(nova.virt.libvirt.driver.libvirt.Domain, 'migrateToURI', fake_migrateToURI) # We can't actually make a config drive v2 because ensure_tree has # been faked out self.stubs.Set(nova.virt.configdrive.ConfigDriveBuilder, 'make_drive', fake_make_drive)
def test_inner_get_dev_no_devices(self): tempdir = self.useFixture(fixtures.TempDir()).path self.stubs.Set(nbd.NbdMount, '_detect_nbd_devices', _fake_detect_nbd_devices_none) n = nbd.NbdMount(None, tempdir) self.assertFalse(n._inner_get_dev())
def _setup_fakelibvirt(self): # So that the _supports_direct_io does the test based # on the current working directory, instead of the # default instances_path which doesn't exist self.flags(instances_path=self.useFixture(fixtures.TempDir()).path) # Put fakelibvirt in place if 'libvirt' in sys.modules: self.saved_libvirt = sys.modules['libvirt'] else: self.saved_libvirt = None from nova.tests.unit.virt.libvirt import fake_imagebackend from nova.tests.unit.virt.libvirt import fakelibvirt from nova.tests.unit.virt.libvirt import fake_os_brick_connector self.useFixture(fake_imagebackend.ImageBackendFixture()) self.useFixture(fakelibvirt.FakeLibvirtFixture()) self.useFixture( fixtures.MonkeyPatch('nova.virt.libvirt.driver.connector', fake_os_brick_connector)) self.useFixture( fixtures.MonkeyPatch( 'nova.virt.libvirt.host.Host._conn_event_thread', lambda *args: None)) self.flags(rescue_image_id="2", rescue_kernel_id="3", rescue_ramdisk_id=None, snapshots_directory='./', sysinfo_serial='none', group='libvirt') def fake_wait(): pass def fake_detach_device_with_retry(_self, get_device_conf_func, device, live, *args, **kwargs): # Still calling detach, but instead of returning function # that actually checks if device is gone from XML, just continue # because XML never gets updated in these tests _self.detach_device(get_device_conf_func(device), live=live) return fake_wait self.stub_out( 'nova.virt.libvirt.driver.LibvirtDriver.' '_get_instance_disk_info_from_config', lambda self, guest_config, block_device_info: []) self.stub_out('nova.virt.disk.api.extend', lambda image, size: None) self.stub_out( 'nova.virt.libvirt.driver.LibvirtDriver.' 'delete_instance_files', lambda self, instance: None) self.stub_out('nova.virt.libvirt.guest.Guest.detach_device_with_retry', fake_detach_device_with_retry) self.stub_out('nova.virt.libvirt.guest.Guest.migrate', lambda self, destination, migrate_uri=None, migrate_disks =None, destination_xml=None, flags=0, bandwidth=0: None) # We can't actually make a config drive v2 because ensure_tree has # been faked out self.stub_out('nova.virt.configdrive.ConfigDriveBuilder.make_drive', lambda self, path: None)
def test_get_options_from_ini_empty_directory_no_target(self): # Test that no config options are loaded when an empty directory is # provided as the ini path and no target directory is provided ini_directory = self.useFixture(fixtures.TempDir()).path self.assertIsNone(bandit._get_options_from_ini(ini_directory, []))
def test_get_options_from_ini_no_ini_path_no_bandit_files(self): # Test that no config options are loaded when no ini path is provided # and the target directory contains no bandit config files (.bandit) target_directory = self.useFixture(fixtures.TempDir()).path self.assertIsNone( bandit._get_options_from_ini(None, [target_directory]))
def setUp(self): super(TestTimeDataBase, self).setUp() self.tmp_root = self.useFixture(fixtures.TempDir( rootdir=os.environ.get("ZUUL_TEST_ROOT")) ).path self.db = model.TimeDataBase(self.tmp_root)
def setUp(self): super(TestJobTimeData, self).setUp() self.tmp_root = self.useFixture(fixtures.TempDir( rootdir=os.environ.get("ZUUL_TEST_ROOT")) ).path
def _setUp(self): super()._setUp() self.core_base_path = self.useFixture(fixtures.TempDir()).path binaries_path = os.path.abspath( os.path.join(__file__, '..', 'bin', 'elf')) new_binaries_path = self.useFixture(fixtures.TempDir()).path current_path = os.environ.get('PATH') new_path = '{}:{}'.format(new_binaries_path, current_path) self.useFixture(fixtures.EnvironmentVariable('PATH', new_path)) # Copy strip for f in ['strip', 'execstack']: shutil.copy(os.path.join(binaries_path, f), os.path.join(new_binaries_path, f)) os.chmod(os.path.join(new_binaries_path, f), 0o755) # Some values in ldd need to be set with core_path with open(os.path.join(binaries_path, 'ldd')) as rf: with open(os.path.join(new_binaries_path, 'ldd'), 'w') as wf: for line in rf.readlines(): wf.write(line.replace('{CORE_PATH}', self.core_base_path)) os.chmod(os.path.join(new_binaries_path, 'ldd'), 0o755) # Some values in ldd need to be set with core_path self.patchelf_path = os.path.join(new_binaries_path, 'patchelf') with open(os.path.join(binaries_path, 'patchelf')) as rf: with open(self.patchelf_path, 'w') as wf: for line in rf.readlines(): wf.write(line.replace('{VERSION}', self._patchelf_version)) os.chmod(os.path.join(new_binaries_path, 'patchelf'), 0o755) patcher = mock.patch.object(elf.ElfFile, '_extract', new_callable=lambda: _fake_elffile_extract) patcher.start() self.addCleanup(patcher.stop) self._elf_files = { 'fake_elf-2.26': elf.ElfFile(path=os.path.join(self.root_path, 'fake_elf-2.26')), 'fake_elf-2.23': elf.ElfFile(path=os.path.join(self.root_path, 'fake_elf-2.23')), 'fake_elf-1.1': elf.ElfFile(path=os.path.join(self.root_path, 'fake_elf-1.1')), 'fake_elf-static': elf.ElfFile(path=os.path.join(self.root_path, 'fake_elf-static')), 'fake_elf-shared-object': elf.ElfFile( path=os.path.join(self.root_path, 'fake_elf-shared-object')), 'fake_elf-bad-ldd': elf.ElfFile(path=os.path.join(self.root_path, 'fake_elf-bad-ldd')), 'fake_elf-bad-patchelf': elf.ElfFile( path=os.path.join(self.root_path, 'fake_elf-bad-patchelf')), 'fake_elf-with-core-libs': elf.ElfFile( path=os.path.join(self.root_path, 'fake_elf-with-core-libs')), 'fake_elf-with-execstack': elf.ElfFile( path=os.path.join(self.root_path, 'fake_elf-with-execstack')), 'fake_elf-with-bad-execstack': elf.ElfFile(path=os.path.join(self.root_path, 'fake_elf-with-bad-execstack')), 'libc.so.6': elf.ElfFile(path=os.path.join(self.root_path, 'libc.so.6')), 'libssl.so.1.0.0': elf.ElfFile(path=os.path.join(self.root_path, 'libssl.so.1.0.0')), } for elf_file in self._elf_files.values(): with open(elf_file.path, 'wb') as f: f.write(b'\x7fELF') if elf_file.path.endswith('fake_elf-bad-patchelf'): f.write(b'nointerpreter') self.root_libraries = { 'foo.so.1': os.path.join(self.root_path, 'foo.so.1'), } for root_library in self.root_libraries.values(): with open(root_library, 'wb') as f: f.write(b'\x7fELF')
def test_install_without_pbr(self): # Test easy-install of a thing that depends on a thing using pbr tempdir = self.useFixture(fixtures.TempDir()).path # A directory containing sdists of the things we're going to depend on # in using-package. dist_dir = os.path.join(tempdir, 'distdir') os.mkdir(dist_dir) self._run_cmd(sys.executable, ('setup.py', 'sdist', '-d', dist_dir), allow_fail=False, cwd=PBR_ROOT) # testpkg - this requires a pbr-using package test_pkg_dir = os.path.join(tempdir, 'testpkg') os.mkdir(test_pkg_dir) with open(os.path.join(test_pkg_dir, 'setup.py'), 'wt') as f: f.write( textwrap.dedent("""\ #!/usr/bin/env python import setuptools setuptools.setup( name = 'pkgTest', tests_require = ['pkgReq'], test_suite='pkgReq' ) """)) with open(os.path.join(test_pkg_dir, 'setup.cfg'), 'wt') as f: f.write( textwrap.dedent("""\ [easy_install] find_links = %s """ % dist_dir)) repoTest = self.useFixture(TestRepo(test_pkg_dir)) repoTest.commit() # reqpkg - this is a package that requires pbr req_pkg_dir = os.path.join(tempdir, 'reqpkg') pkg_req_module = os.path.join(req_pkg_dir, 'pkgReq/') os.makedirs(pkg_req_module) with open(os.path.join(req_pkg_dir, 'setup.py'), 'wt') as f: f.write( textwrap.dedent("""\ #!/usr/bin/env python import setuptools setuptools.setup( setup_requires=['pbr'], pbr=True ) """)) with open(os.path.join(req_pkg_dir, 'setup.cfg'), 'wt') as f: f.write( textwrap.dedent("""\ [metadata] name = pkgReq """)) with open(os.path.join(req_pkg_dir, 'requirements.txt'), 'wt') as f: f.write( textwrap.dedent("""\ pbr """)) with open(os.path.join(req_pkg_dir, 'pkgReq/__init__.py'), 'wt') as f: f.write( textwrap.dedent("""\ print("FakeTest loaded and ran") """)) repoReq = self.useFixture(TestRepo(req_pkg_dir)) repoReq.commit() self._run_cmd(sys.executable, ('setup.py', 'sdist', '-d', dist_dir), allow_fail=False, cwd=req_pkg_dir) # A venv to test within venv = self.useFixture(Venv('nopbr', install_pbr=False)) python = venv.python # Run the depending script self.useFixture( base.CapturedSubprocess('nopbr', [python] + ['setup.py', 'test'], cwd=test_pkg_dir))
def test_write_config(self, mock_deployment_data, mock_config_dict): heat = mock.MagicMock() self.config = ooo_config.Config(heat) stack = mock.MagicMock() heat.stacks.get.return_value = stack stack.outputs = [{ 'output_key': 'RoleNetHostnameMap', 'output_value': { 'Controller': { 'ctlplane': ['overcloud-controller-0.ctlplane.localdomain'] }, 'Compute': { 'ctlplane': [ 'overcloud-novacompute-0.ctlplane.localdomain', 'overcloud-novacompute-1.ctlplane.localdomain', 'overcloud-novacompute-2.ctlplane.localdomain' ] } } }, { 'output_key': 'ServerIdData', 'output_value': { 'server_ids': { 'Controller': ['00b3a5e1-5e8e-4b55-878b-2fa2271f15ad'], 'Compute': [ 'a7db3010-a51f-4ae0-a791-2364d629d20d', '8b07cd31-3083-4b88-a433-955f72039e2c', '169b46f8-1965-4d90-a7de-f36fb4a830fe' ] } } }, { 'output_key': 'RoleData', 'output_value': { 'Controller': { 'ansible_group_vars': { 'chrony_host': 'localhost', 'chrony_acl': 'none', } } } }, { 'output_key': 'RoleGroupVars', 'output_value': { 'Controller': { 'any_errors_fatal': True, 'chrony_host': '192.168.2.1', 'chrony_foo': 'bar', 'max_fail_percentage': 15 }, 'Compute': { 'any_errors_fatal': True, 'max_fail_percentage': 15 } } }, { 'output_key': 'RoleNetworkConfigMap', 'output_value': {} }] deployment_data, configs = \ self._get_config_data('config_data.yaml') self.configs = configs self.deployments = deployment_data stack_data = self.config.fetch_config('overcloud') mock_deployment_data.return_value = deployment_data mock_config_dict.side_effect = self._get_config_dict config_dir = self.useFixture(fixtures.TempDir()).path self.config.write_config(stack_data, 'overcloud', config_dir) for f in [ 'Controller', 'Compute', ]: with open(os.path.join(config_dir, 'group_vars', f)) as fin: self.assertEqual(yaml.safe_load(fin.read()), self._get_yaml_file(f)) for d in [ 'ControllerHostEntryDeployment', 'NetworkDeployment', 'MyExtraConfigPost', 'MyPostConfig' ]: with open( os.path.join(config_dir, 'Controller', 'overcloud-controller-0', d)) as fin: self.assertEqual( yaml.safe_load(fin.read()), self._get_yaml_file( os.path.join('overcloud-controller-0', d))) for d in [ 'ComputeHostEntryDeployment', 'NetworkDeployment', 'MyExtraConfigPost' ]: with open( os.path.join(config_dir, 'Compute', 'overcloud-novacompute-0', d)) as fin: self.assertEqual( yaml.safe_load(fin.read()), self._get_yaml_file( os.path.join('overcloud-novacompute-0', d))) for d in [ 'ComputeHostEntryDeployment', 'NetworkDeployment', 'MyExtraConfigPost' ]: with open( os.path.join(config_dir, 'Compute', 'overcloud-novacompute-1', d)) as fin: self.assertEqual( yaml.safe_load(fin.read()), self._get_yaml_file( os.path.join('overcloud-novacompute-1', d))) for d in [ 'ComputeHostEntryDeployment', 'NetworkDeployment', 'MyExtraConfigPost', 'AnsibleDeployment' ]: with open( os.path.join(config_dir, 'Compute', 'overcloud-novacompute-2', d)) as fin: self.assertEqual( yaml.safe_load(fin.read()), self._get_yaml_file( os.path.join('overcloud-novacompute-2', d)))
def setUp(self): """Run before each test method to initialize test environment.""" super(TestCase, self).setUp() self.useFixture( nova_fixtures.Timeout(os.environ.get('OS_TEST_TIMEOUT', 0), self.TIMEOUT_SCALING_FACTOR)) self.useFixture(fixtures.NestedTempfile()) self.useFixture(fixtures.TempHomeDir()) self.useFixture(log_fixture.get_logging_handle_error_fixture()) self.useFixture(nova_fixtures.OutputStreamCapture()) self.useFixture(nova_fixtures.StandardLogging()) # NOTE(sdague): because of the way we were using the lock # wrapper we eneded up with a lot of tests that started # relying on global external locking being set up for them. We # consider all of these to be *bugs*. Tests should not require # global external locking, or if they do, they should # explicitly set it up themselves. # # The following REQUIRES_LOCKING class parameter is provided # as a bridge to get us there. No new tests should be added # that require it, and existing classes and tests should be # fixed to not need it. if self.REQUIRES_LOCKING: lock_path = self.useFixture(fixtures.TempDir()).path self.fixture = self.useFixture( config_fixture.Config(lockutils.CONF)) self.fixture.config(lock_path=lock_path, group='oslo_concurrency') self.useFixture(conf_fixture.ConfFixture(CONF)) self.useFixture(nova_fixtures.RPCFixture('nova.test')) if self.USES_DB: self.useFixture(nova_fixtures.Database()) self.useFixture(nova_fixtures.Database(database='api')) # NOTE(blk-u): WarningsFixture must be after the Database fixture # because sqlalchemy-migrate messes with the warnings filters. self.useFixture(nova_fixtures.WarningsFixture()) # NOTE(danms): Make sure to reset us back to non-remote objects # for each test to avoid interactions. Also, backup the object # registry. objects_base.NovaObject.indirection_api = None self._base_test_obj_backup = copy.copy( objects_base.NovaObjectRegistry._registry._obj_classes) self.addCleanup(self._restore_obj_registry) # NOTE(mnaser): All calls to utils.is_neutron() are cached in # nova.utils._IS_NEUTRON. We set it to None to avoid any # caching of that value. utils._IS_NEUTRON = None mox_fixture = self.useFixture(moxstubout.MoxStubout()) self.mox = mox_fixture.mox self.stubs = mox_fixture.stubs self.addCleanup(self._clear_attrs) self.useFixture(fixtures.EnvironmentVariable('http_proxy')) self.policy = self.useFixture(policy_fixture.PolicyFixture()) self.useFixture(nova_fixtures.PoisonFunctions()) openstack_driver.DRIVER_CACHE = {}
def setUp(self): """Run before each test method to initialize test environment.""" super(TestCase, self).setUp() test_timeout = os.environ.get('OS_TEST_TIMEOUT', 0) try: test_timeout = int(test_timeout) except ValueError: # If timeout value is invalid do not set a timeout. test_timeout = 0 if test_timeout > 0: self.useFixture(fixtures.Timeout(test_timeout, gentle=True)) self.useFixture(fixtures.NestedTempfile()) self.useFixture(fixtures.TempHomeDir()) environ_enabled = (lambda var_name: strutils.bool_from_string( os.environ.get(var_name))) if environ_enabled('OS_STDOUT_CAPTURE'): stdout = self.useFixture(fixtures.StringStream('stdout')).stream self.useFixture(fixtures.MonkeyPatch('sys.stdout', stdout)) if environ_enabled('OS_STDERR_CAPTURE'): stderr = self.useFixture(fixtures.StringStream('stderr')).stream self.useFixture(fixtures.MonkeyPatch('sys.stderr', stderr)) if environ_enabled('OS_LOG_CAPTURE'): log_format = '%(levelname)s [%(name)s] %(message)s' if environ_enabled('OS_DEBUG'): level = logging.DEBUG else: level = logging.INFO self.useFixture( fixtures.LoggerFixture(nuke_handlers=False, format=log_format, level=level)) rpc.add_extra_exmods("cinder.tests") self.addCleanup(rpc.clear_extra_exmods) self.addCleanup(rpc.cleanup) self.messaging_conf = messaging_conffixture.ConfFixture(CONF) self.messaging_conf.transport_driver = 'fake' self.messaging_conf.response_timeout = 15 self.useFixture(self.messaging_conf) rpc.init(CONF) conf_fixture.set_defaults(CONF) CONF([], default_config_files=[]) # NOTE(vish): We need a better method for creating fixtures for tests # now that we have some required db setup for the system # to work properly. self.start = timeutils.utcnow() CONF.set_default('connection', 'sqlite://', 'database') CONF.set_default('sqlite_synchronous', False, 'database') global _DB_CACHE if not _DB_CACHE: _DB_CACHE = Database(sqla_api, migration, sql_connection=CONF.database.connection, sqlite_db=CONF.database.sqlite_db, sqlite_clean_db=CONF.sqlite_clean_db) self.useFixture(_DB_CACHE) # emulate some of the mox stuff, we can't use the metaclass # because it screws with our generators self.mox = mox.Mox() self.stubs = stubout.StubOutForTesting() self.addCleanup(CONF.reset) self.addCleanup(self.mox.UnsetStubs) self.addCleanup(self.stubs.UnsetAll) self.addCleanup(self.stubs.SmartUnsetAll) self.addCleanup(self.mox.VerifyAll) self.addCleanup(self._common_cleanup) self.injected = [] self._services = [] fake_notifier.stub_notifier(self.stubs) self.override_config('fatal_exception_format_errors', True) # This will be cleaned up by the NestedTempfile fixture lock_path = self.useFixture(fixtures.TempDir()).path self.fixture = self.useFixture(config_fixture.Config(lockutils.CONF)) self.fixture.config(lock_path=lock_path, group='oslo_concurrency') self.override_config( 'policy_file', os.path.join( os.path.abspath(os.path.join( os.path.dirname(__file__), '..', )), 'cinder/tests/policy.json'))
def _setUp(self): super()._setUp() self.core_base_path = self.useFixture(fixtures.TempDir()).path binaries_path = os.path.join(get_snapcraft_path(), "tests", "bin", "elf") new_binaries_path = self.useFixture(fixtures.TempDir()).path current_path = os.environ.get("PATH") new_path = "{}:{}".format(new_binaries_path, current_path) self.useFixture(fixtures.EnvironmentVariable("PATH", new_path)) # Copy strip for f in ["strip", "execstack"]: shutil.copy(os.path.join(binaries_path, f), os.path.join(new_binaries_path, f)) os.chmod(os.path.join(new_binaries_path, f), 0o755) # Some values in ldd need to be set with core_path with open(os.path.join(binaries_path, "ldd")) as rf: with open(os.path.join(new_binaries_path, "ldd"), "w") as wf: for line in rf.readlines(): wf.write(line.replace("{CORE_PATH}", self.core_base_path)) os.chmod(os.path.join(new_binaries_path, "ldd"), 0o755) # Some values in ldd need to be set with core_path self.patchelf_path = os.path.join(new_binaries_path, "patchelf") with open(os.path.join(binaries_path, "patchelf")) as rf: with open(self.patchelf_path, "w") as wf: for line in rf.readlines(): wf.write(line.replace("{VERSION}", self._patchelf_version)) os.chmod(os.path.join(new_binaries_path, "patchelf"), 0o755) patcher = mock.patch.object( elf.ElfFile, "_extract_attributes", new_callable=lambda: _fake_elffile_extract_attributes, ) patcher.start() self.addCleanup(patcher.stop) self._elf_files = { "fake_elf-2.26": elf.ElfFile(path=os.path.join(self.root_path, "fake_elf-2.26")), "fake_elf-2.23": elf.ElfFile(path=os.path.join(self.root_path, "fake_elf-2.23")), "fake_elf-1.1": elf.ElfFile(path=os.path.join(self.root_path, "fake_elf-1.1")), "fake_elf-static": elf.ElfFile(path=os.path.join(self.root_path, "fake_elf-static")), "fake_elf-shared-object": elf.ElfFile( path=os.path.join(self.root_path, "fake_elf-shared-object")), "fake_elf-with-host-libraries": elf.ElfFile(path=os.path.join(self.root_path, "fake_elf-with-host-libraries")), "fake_elf-bad-ldd": elf.ElfFile(path=os.path.join(self.root_path, "fake_elf-bad-ldd")), "fake_elf-bad-patchelf": elf.ElfFile( path=os.path.join(self.root_path, "fake_elf-bad-patchelf")), "fake_elf-with-core-libs": elf.ElfFile( path=os.path.join(self.root_path, "fake_elf-with-core-libs")), "fake_elf-with-missing-libs": elf.ElfFile(path=os.path.join(self.root_path, "fake_elf-with-missing-libs")), "fake_elf-with-execstack": elf.ElfFile( path=os.path.join(self.root_path, "fake_elf-with-execstack")), "fake_elf-with-bad-execstack": elf.ElfFile(path=os.path.join(self.root_path, "fake_elf-with-bad-execstack")), "libc.so.6": elf.ElfFile(path=os.path.join(self.root_path, "libc.so.6")), "libssl.so.1.0.0": elf.ElfFile(path=os.path.join(self.root_path, "libssl.so.1.0.0")), } for elf_file in self._elf_files.values(): with open(elf_file.path, "wb") as f: f.write(b"\x7fELF") if elf_file.path.endswith("fake_elf-bad-patchelf"): f.write(b"nointerpreter") self.root_libraries = { "foo.so.1": os.path.join(self.root_path, "foo.so.1"), "moo.so.2": os.path.join(self.root_path, "non-standard", "moo.so.2"), } barsnap_elf = os.path.join(self.core_base_path, "barsnap.so.2") elf_list = [*self.root_libraries.values(), barsnap_elf] for root_library in elf_list: os.makedirs(os.path.dirname(root_library), exist_ok=True) with open(root_library, "wb") as f: f.write(b"\x7fELF")
def setUp(self): """Run before each test method to initialize test environment.""" super(TestCase, self).setUp() # Create default notifier self.notifier = fake_notifier.get_fake_notifier() # Mock rpc get notifier with fake notifier method that joins all # notifications with the default notifier p = mock.patch('cinder.rpc.get_notifier', side_effect=self._get_joined_notifier) p.start() # Unit tests do not need to use lazy gettext i18n.enable_lazy(False) test_timeout = os.environ.get('OS_TEST_TIMEOUT', 0) try: test_timeout = int(test_timeout) except ValueError: # If timeout value is invalid do not set a timeout. test_timeout = 0 if test_timeout > 0: self.useFixture(fixtures.Timeout(test_timeout, gentle=True)) self.useFixture(fixtures.NestedTempfile()) self.useFixture(fixtures.TempHomeDir()) environ_enabled = (lambda var_name: strutils.bool_from_string( os.environ.get(var_name))) if environ_enabled('OS_STDOUT_CAPTURE'): stdout = self.useFixture(fixtures.StringStream('stdout')).stream self.useFixture(fixtures.MonkeyPatch('sys.stdout', stdout)) if environ_enabled('OS_STDERR_CAPTURE'): stderr = self.useFixture(fixtures.StringStream('stderr')).stream self.useFixture(fixtures.MonkeyPatch('sys.stderr', stderr)) self.useFixture(log_fixture.get_logging_handle_error_fixture()) self.useFixture(cinder_fixtures.StandardLogging()) rpc.add_extra_exmods("cinder.tests.unit") self.addCleanup(rpc.clear_extra_exmods) self.addCleanup(rpc.cleanup) self.messaging_conf = messaging_conffixture.ConfFixture(CONF) self.messaging_conf.transport_driver = 'fake' self.messaging_conf.response_timeout = 15 self.useFixture(self.messaging_conf) rpc.init(CONF) # NOTE(geguileo): This is required because _determine_obj_version_cap # and _determine_rpc_version_cap functions in cinder.rpc.RPCAPI cache # versions in LAST_RPC_VERSIONS and LAST_OBJ_VERSIONS so we may have # weird interactions between tests if we don't clear them before each # test. rpc.LAST_OBJ_VERSIONS = {} rpc.LAST_RPC_VERSIONS = {} conf_fixture.set_defaults(CONF) CONF([], default_config_files=[]) # NOTE(vish): We need a better method for creating fixtures for tests # now that we have some required db setup for the system # to work properly. self.start = timeutils.utcnow() CONF.set_default('connection', 'sqlite://', 'database') CONF.set_default('sqlite_synchronous', False, 'database') global _DB_CACHE if not _DB_CACHE: _DB_CACHE = Database(sqla_api, migration, sql_connection=CONF.database.connection) self.useFixture(_DB_CACHE) # NOTE(danms): Make sure to reset us back to non-remote objects # for each test to avoid interactions. Also, backup the object # registry. objects_base.CinderObject.indirection_api = None self._base_test_obj_backup = copy.copy( objects_base.CinderObjectRegistry._registry._obj_classes) self.addCleanup(self._restore_obj_registry) # emulate some of the mox stuff, we can't use the metaclass # because it screws with our generators mox_fixture = self.useFixture(moxstubout.MoxStubout()) self.mox = mox_fixture.mox self.stubs = mox_fixture.stubs self.addCleanup(CONF.reset) self.addCleanup(self._common_cleanup) self.injected = [] self._services = [] fake_notifier.mock_notifier(self) self.override_config('fatal_exception_format_errors', True) # This will be cleaned up by the NestedTempfile fixture lock_path = self.useFixture(fixtures.TempDir()).path self.fixture = self.useFixture(config_fixture.Config(lockutils.CONF)) self.fixture.config(lock_path=lock_path, group='oslo_concurrency') lockutils.set_defaults(lock_path) self.override_config('policy_file', os.path.join( os.path.abspath( os.path.join( os.path.dirname(__file__), '..', )), self.POLICY_PATH), group='oslo_policy') self._disable_osprofiler() self._disallow_invalid_uuids() # NOTE(geguileo): This is required because common get_by_id method in # cinder.db.sqlalchemy.api caches get methods and if we use a mocked # get method in one test it would carry on to the next test. So we # clear out the cache. sqla_api._GET_METHODS = {} self.override_config('backend_url', 'file://' + lock_path, group='coordination') coordination.COORDINATOR.start() self.addCleanup(coordination.COORDINATOR.stop)
def test_nbd_no_devices(self): tempdir = self.useFixture(fixtures.TempDir()).path self.stubs.Set(nbd.NbdMount, '_detect_nbd_devices', _fake_detect_nbd_devices_none) n = nbd.NbdMount(None, tempdir) self.assertEquals(None, n._allocate_nbd())
def setUp(self): """Run before each test method to initialize test environment.""" super(TestCase, self).setUp() # Create default notifier self.notifier = fake_notifier.get_fake_notifier() # Mock rpc get notifier with fake notifier method that joins all # notifications with the default notifier self.patch('cinder.rpc.get_notifier', side_effect=self._get_joined_notifier) if self.MOCK_WORKER: # Mock worker creation for all tests that don't care about it clean_path = 'cinder.objects.cleanable.CinderCleanableObject.%s' for method in ('create_worker', 'set_worker', 'unset_worker'): self.patch(clean_path % method, return_value=None) if self.MOCK_TOOZ: self.patch('cinder.coordination.Coordinator.start') self.patch('cinder.coordination.Coordinator.stop') self.patch('cinder.coordination.Coordinator.get_lock') # Unit tests do not need to use lazy gettext i18n.enable_lazy(False) test_timeout = os.environ.get('OS_TEST_TIMEOUT', 0) try: test_timeout = int(test_timeout) except ValueError: # If timeout value is invalid do not set a timeout. test_timeout = 0 if test_timeout > 0: self.useFixture(fixtures.Timeout(test_timeout, gentle=True)) self.useFixture(fixtures.NestedTempfile()) self.useFixture(fixtures.TempHomeDir()) environ_enabled = (lambda var_name: strutils.bool_from_string(os.environ.get(var_name))) if environ_enabled('OS_STDOUT_CAPTURE'): stdout = self.useFixture(fixtures.StringStream('stdout')).stream self.useFixture(fixtures.MonkeyPatch('sys.stdout', stdout)) if environ_enabled('OS_STDERR_CAPTURE'): stderr = self.useFixture(fixtures.StringStream('stderr')).stream self.useFixture(fixtures.MonkeyPatch('sys.stderr', stderr)) self.useFixture(log_fixture.get_logging_handle_error_fixture()) self.useFixture(cinder_fixtures.StandardLogging()) rpc.add_extra_exmods("cinder.tests.unit") self.addCleanup(rpc.clear_extra_exmods) self.addCleanup(rpc.cleanup) self.messaging_conf = messaging_conffixture.ConfFixture(CONF) self.messaging_conf.transport_url = 'fake:/' self.messaging_conf.response_timeout = 15 self.useFixture(self.messaging_conf) # Load oslo_messaging_notifications config group so we can set an # override to prevent notifications from being ignored due to the # short-circuit mechanism. oslo_messaging.get_notification_transport(CONF) # We need to use a valid driver for the notifications, so we use test. self.override_config('driver', ['test'], group='oslo_messaging_notifications') rpc.init(CONF) # NOTE(geguileo): This is required because _determine_obj_version_cap # and _determine_rpc_version_cap functions in cinder.rpc.RPCAPI cache # versions in LAST_RPC_VERSIONS and LAST_OBJ_VERSIONS so we may have # weird interactions between tests if we don't clear them before each # test. rpc.LAST_OBJ_VERSIONS = {} rpc.LAST_RPC_VERSIONS = {} conf_fixture.set_defaults(CONF) CONF([], default_config_files=[]) # NOTE(vish): We need a better method for creating fixtures for tests # now that we have some required db setup for the system # to work properly. self.start = timeutils.utcnow() CONF.set_default('connection', 'sqlite://', 'database') CONF.set_default('sqlite_synchronous', False, 'database') global _DB_CACHE if not _DB_CACHE: _DB_CACHE = Database(sqla_api, migration, sql_connection=CONF.database.connection) self.useFixture(_DB_CACHE) # NOTE(blk-u): WarningsFixture must be after the Database fixture # because sqlalchemy-migrate messes with the warnings filters. self.useFixture(cinder_fixtures.WarningsFixture()) # NOTE(danms): Make sure to reset us back to non-remote objects # for each test to avoid interactions. Also, backup the object # registry. objects_base.CinderObject.indirection_api = None self._base_test_obj_backup = copy.copy( objects_base.CinderObjectRegistry._registry._obj_classes) self.addCleanup(self._restore_obj_registry) self.addCleanup(CONF.reset) self.addCleanup(self._common_cleanup) self.injected = [] self._services = [] fake_notifier.mock_notifier(self) # This will be cleaned up by the NestedTempfile fixture lock_path = self.useFixture(fixtures.TempDir()).path self.fixture = self.useFixture( config_fixture.Config(lockutils.CONF)) self.fixture.config(lock_path=lock_path, group='oslo_concurrency') lockutils.set_defaults(lock_path) self.override_config('policy_file', os.path.join( os.path.abspath( os.path.join( os.path.dirname(__file__), '..', ) ), self.POLICY_PATH), group='oslo_policy') self.override_config('resource_query_filters_file', os.path.join( os.path.abspath( os.path.join( os.path.dirname(__file__), '..', ) ), self.RESOURCE_FILTER_PATH)) self._disable_osprofiler() # NOTE(geguileo): This is required because common get_by_id method in # cinder.db.sqlalchemy.api caches get methods and if we use a mocked # get method in one test it would carry on to the next test. So we # clear out the cache. sqla_api._GET_METHODS = {} self.override_config('backend_url', 'file://' + lock_path, group='coordination') coordination.COORDINATOR.start() self.addCleanup(coordination.COORDINATOR.stop) if six.PY3: # TODO(smcginnis) Python 3 deprecates assertRaisesRegexp to # assertRaisesRegex, but Python 2 does not have the new name. This # can be removed once we stop supporting py2 or the new name is # added. self.assertRaisesRegexp = self.assertRaisesRegex # Ensure we have the default tpool size value and we don't carry # threads from other test runs. tpool.killall() tpool._nthreads = 20 # NOTE(mikal): make sure we don't load a privsep helper accidentally self.useFixture(cinder_fixtures.PrivsepNoHelperFixture())
def test_inner_get_dev_no_devices(self): tempdir = self.useFixture(fixtures.TempDir()).path self.stub_out('nova.virt.disk.mount.nbd.NbdMount._detect_nbd_devices', _fake_detect_nbd_devices_none) n = nbd.NbdMount(self.file, tempdir) self.assertFalse(n._inner_get_dev())
def _setup_fakelibvirt(self): # So that the _supports_direct_io does the test based # on the current working directory, instead of the # default instances_path which doesn't exist self.flags(instances_path=self.useFixture(fixtures.TempDir()).path) # Put fakelibvirt in place if 'libvirt' in sys.modules: self.saved_libvirt = sys.modules['libvirt'] else: self.saved_libvirt = None import nova.tests.unit.virt.libvirt.fake_imagebackend as \ fake_imagebackend import nova.tests.unit.virt.libvirt.fake_libvirt_utils as \ fake_libvirt_utils import nova.tests.unit.virt.libvirt.fakelibvirt as fakelibvirt import nova.tests.unit.virt.libvirt.fake_os_brick_connector as \ fake_os_brick_connector sys.modules['libvirt'] = fakelibvirt import nova.virt.libvirt.driver import nova.virt.libvirt.firewall import nova.virt.libvirt.host self.useFixture( fixtures.MonkeyPatch('nova.virt.libvirt.driver.imagebackend', fake_imagebackend)) self.useFixture( fixtures.MonkeyPatch('nova.virt.libvirt.driver.libvirt', fakelibvirt)) self.useFixture( fixtures.MonkeyPatch('nova.virt.libvirt.driver.libvirt_utils', fake_libvirt_utils)) self.useFixture( fixtures.MonkeyPatch('nova.virt.libvirt.host.libvirt', fakelibvirt)) self.useFixture( fixtures.MonkeyPatch( 'nova.virt.libvirt.imagebackend.libvirt_utils', fake_libvirt_utils)) self.useFixture( fixtures.MonkeyPatch('nova.virt.libvirt.firewall.libvirt', fakelibvirt)) self.useFixture( fixtures.MonkeyPatch('nova.virt.libvirt.driver.connector', fake_os_brick_connector)) fakelibvirt.disable_event_thread(self) self.flags(rescue_image_id="2", rescue_kernel_id="3", rescue_ramdisk_id=None, snapshots_directory='./', group='libvirt') def fake_extend(image, size): pass def fake_migrateToURI(*a): pass def fake_make_drive(_self, _path): pass def fake_get_instance_disk_info(_self, instance, xml=None, block_device_info=None): return '[]' def fake_delete_instance_files(_self, _instance): pass def fake_wait(): pass def fake_detach_device_with_retry(_self, get_device_conf_func, device, persistent, live, max_retry_count=7, inc_sleep_time=2, max_sleep_time=30): # Still calling detach, but instead of returning function # that actually checks if device is gone from XML, just continue # because XML never gets updated in these tests _self.detach_device(get_device_conf_func(device), persistent=persistent, live=live) return fake_wait self.stubs.Set(nova.virt.libvirt.driver.LibvirtDriver, '_get_instance_disk_info', fake_get_instance_disk_info) self.stubs.Set(nova.virt.libvirt.driver.disk, 'extend', fake_extend) self.stubs.Set(nova.virt.libvirt.driver.LibvirtDriver, 'delete_instance_files', fake_delete_instance_files) self.stubs.Set(nova.virt.libvirt.guest.Guest, 'detach_device_with_retry', fake_detach_device_with_retry) # Like the existing fakelibvirt.migrateToURI, do nothing, # but don't fail for these tests. self.stubs.Set(nova.virt.libvirt.driver.libvirt.Domain, 'migrateToURI', fake_migrateToURI) # We can't actually make a config drive v2 because ensure_tree has # been faked out self.stubs.Set(nova.virt.configdrive.ConfigDriveBuilder, 'make_drive', fake_make_drive)
def test_nbd_no_free_devices(self): tempdir = self.useFixture(fixtures.TempDir()).path n = nbd.NbdMount(self.file, tempdir) self.useFixture( fixtures.MonkeyPatch('os.path.exists', _fake_exists_all_used)) self.assertIsNone(n._allocate_nbd())
def setUp(self): super(TestCase, self).setUp() self.conf = service.prepare_service([], conf=utils.prepare_conf(), default_config_files=[], logging_level=logging.DEBUG, skip_log_opts=True) self.index = indexer.get_driver(self.conf) self.coord = metricd.get_coordinator_and_start( str(uuid.uuid4()), self.conf.coordination_url) # NOTE(jd) So, some driver, at least SQLAlchemy, can't create all # their tables in a single transaction even with the # checkfirst=True, so what we do here is we force the upgrade code # path to be sequential to avoid race conditions as the tests run # in parallel. with self.coord.get_lock(b"gnocchi-tests-db-lock"): self.index.upgrade() self.archive_policies = self.ARCHIVE_POLICIES.copy() for name, ap in six.iteritems(self.archive_policies): # Create basic archive policies try: self.index.create_archive_policy(ap) except indexer.ArchivePolicyAlreadyExists: pass py_root = os.path.abspath( os.path.join( os.path.dirname(__file__), '..', )) self.conf.set_override('paste_config', os.path.join(py_root, 'rest', 'api-paste.ini'), group="api") self.conf.set_override('policy_file', os.path.join(py_root, 'rest', 'policy.yaml'), group="oslo_policy") # NOTE(jd) This allows to test S3 on AWS if not os.getenv("AWS_ACCESS_KEY_ID"): self.conf.set_override('s3_endpoint_url', os.getenv("GNOCCHI_STORAGE_HTTP_URL"), group="storage") self.conf.set_override('s3_access_key_id', "S3RVER", group="storage") self.conf.set_override('s3_secret_access_key', "S3RVER", group="storage") storage_driver = os.getenv("GNOCCHI_TEST_STORAGE_DRIVER", "file") self.conf.set_override('driver', storage_driver, 'storage') if swexc: self.useFixture( fixtures.MockPatch('swiftclient.client.Connection', FakeSwiftClient)) if self.conf.storage.driver == 'file': tempdir = self.useFixture(fixtures.TempDir()) self.conf.set_override('file_basepath', tempdir.path, 'storage') elif self.conf.storage.driver == 'ceph': self.conf.set_override('ceph_conffile', os.getenv("CEPH_CONF"), 'storage') self.ceph_pool_name = uuid.uuid4().hex with open(os.devnull, 'w') as f: subprocess.call(("ceph -c %s osd pool create %s " "16 16 replicated") % (os.getenv("CEPH_CONF"), self.ceph_pool_name), shell=True, stdout=f, stderr=subprocess.STDOUT) subprocess.call(("ceph -c %s osd pool application " "enable %s rbd") % (os.getenv("CEPH_CONF"), self.ceph_pool_name), shell=True, stdout=f, stderr=subprocess.STDOUT) self.conf.set_override('ceph_pool', self.ceph_pool_name, 'storage') # Override the bucket prefix to be unique to avoid concurrent access # with any other test self.conf.set_override("s3_bucket_prefix", str(uuid.uuid4())[:26], "storage") self.storage = storage.get_driver(self.conf) self.incoming = incoming.get_driver(self.conf) if self.conf.storage.driver == 'redis': # Create one prefix per test self.storage.STORAGE_PREFIX = str(uuid.uuid4()).encode() if self.conf.incoming.driver == 'redis': self.incoming.SACK_NAME_FORMAT = ( str(uuid.uuid4()) + incoming.IncomingDriver.SACK_NAME_FORMAT) self.storage.upgrade() self.incoming.upgrade(3) self.chef = chef.Chef(self.coord, self.incoming, self.index, self.storage)
def get_new_temp_dir(self): """Create a new temporary directory. :returns fixtures.TempDir """ return self.useFixture(fixtures.TempDir())
def setUp(self): """Run before each test method to initialize test environment.""" # Ensure BaseTestCase's ConfigureLogging fixture is disabled since # we're using our own (StandardLogging). with fixtures.EnvironmentVariable('OS_LOG_CAPTURE', '0'): super(TestCase, self).setUp() # How many of which service we've started. {$service-name: $count} self._service_fixture_count = collections.defaultdict(int) self.useFixture(nova_fixtures.OpenStackSDKFixture()) self.useFixture(log_fixture.get_logging_handle_error_fixture()) self.stdlog = self.useFixture(nova_fixtures.StandardLogging()) # NOTE(sdague): because of the way we were using the lock # wrapper we ended up with a lot of tests that started # relying on global external locking being set up for them. We # consider all of these to be *bugs*. Tests should not require # global external locking, or if they do, they should # explicitly set it up themselves. # # The following REQUIRES_LOCKING class parameter is provided # as a bridge to get us there. No new tests should be added # that require it, and existing classes and tests should be # fixed to not need it. if self.REQUIRES_LOCKING: lock_path = self.useFixture(fixtures.TempDir()).path self.fixture = self.useFixture( config_fixture.Config(lockutils.CONF)) self.fixture.config(lock_path=lock_path, group='oslo_concurrency') self.useFixture(conf_fixture.ConfFixture(CONF)) if self.STUB_RPC: self.useFixture(nova_fixtures.RPCFixture('nova.test')) # we cannot set this in the ConfFixture as oslo only registers the # notification opts at the first instantiation of a Notifier that # happens only in the RPCFixture CONF.set_default('driver', ['test'], group='oslo_messaging_notifications') # NOTE(danms): Make sure to reset us back to non-remote objects # for each test to avoid interactions. Also, backup the object # registry. objects_base.NovaObject.indirection_api = None self._base_test_obj_backup = copy.copy( objects_base.NovaObjectRegistry._registry._obj_classes) self.addCleanup(self._restore_obj_registry) objects.Service.clear_min_version_cache() # NOTE(danms): Reset the cached list of cells from nova.compute import api api.CELLS = [] context.CELL_CACHE = {} context.CELLS = [] self.cell_mappings = {} self.host_mappings = {} # NOTE(danms): If the test claims to want to set up the database # itself, then it is responsible for all the mapping stuff too. if self.USES_DB: # NOTE(danms): Full database setup involves a cell0, cell1, # and the relevant mappings. self.useFixture(nova_fixtures.Database(database='api')) self._setup_cells() self.useFixture(nova_fixtures.DefaultFlavorsFixture()) elif not self.USES_DB_SELF: # NOTE(danms): If not using the database, we mock out the # mapping stuff and effectively collapse everything to a # single cell. self.useFixture(nova_fixtures.SingleCellSimple()) self.useFixture(nova_fixtures.DatabasePoisonFixture()) # NOTE(blk-u): WarningsFixture must be after the Database fixture # because sqlalchemy-migrate messes with the warnings filters. self.useFixture(nova_fixtures.WarningsFixture()) self.useFixture(ovo_fixture.StableObjectJsonFixture()) # NOTE(mnaser): All calls to utils.is_neutron() are cached in # nova.utils._IS_NEUTRON. We set it to None to avoid any # caching of that value. utils._IS_NEUTRON = None # Reset the global QEMU version flag. images.QEMU_VERSION = None # Reset the compute RPC API globals (mostly the _ROUTER). compute_rpcapi.reset_globals() # TODO(takashin): Remove MoxStubout fixture # after removing tests which uses mox and are related to # nova-network in the following files. # # - nova/tests/unit/api/openstack/compute/test_floating_ips.py # - nova/tests/unit/api/openstack/compute/test_security_groups.py # - nova/tests/unit/fake_network.py # - nova/tests/unit/network/test_manager.py mox_fixture = self.useFixture(moxstubout.MoxStubout()) self.mox = mox_fixture.mox self.stubs = mox_fixture.stubs self.addCleanup(self._clear_attrs) self.useFixture(fixtures.EnvironmentVariable('http_proxy')) self.policy = self.useFixture(policy_fixture.PolicyFixture()) self.useFixture(nova_fixtures.PoisonFunctions()) openstack_driver.DRIVER_CACHE = {} self.useFixture(nova_fixtures.ForbidNewLegacyNotificationFixture()) # NOTE(mikal): make sure we don't load a privsep helper accidentally self.useFixture(nova_fixtures.PrivsepNoHelperFixture()) self.useFixture(mock_fixture.MockAutospecFixture()) # FIXME(danms): Disable this for all tests by default to avoid breaking # any that depend on default/previous ordering self.flags(build_failure_weight_multiplier=0.0, group='filter_scheduler') # NOTE(melwitt): Reset the cached set of projects quota.UID_QFD_POPULATED_CACHE_BY_PROJECT = set() quota.UID_QFD_POPULATED_CACHE_ALL = False
def _start_ovsdb_server_and_idls(self): self.temp_dir = self.useFixture(fixtures.TempDir()).path # Start 2 ovsdb-servers one each for OVN NB DB and OVN SB DB # ovsdb-server with OVN SB DB can be used to test the chassis up/down # events. mgr = self.ovsdb_server_mgr = self.useFixture( process.OvsdbServer(self.temp_dir, self.OVS_INSTALL_SHARE_PATH, ovn_nb_db=True, ovn_sb_db=True, protocol=self._ovsdb_protocol)) set_cfg = cfg.CONF.set_override set_cfg('ovn_nb_connection', self.ovsdb_server_mgr.get_ovsdb_connection_path(), 'ovn') set_cfg('ovn_sb_connection', self.ovsdb_server_mgr.get_ovsdb_connection_path(db_type='sb'), 'ovn') set_cfg('ovn_nb_private_key', self.ovsdb_server_mgr.private_key, 'ovn') set_cfg('ovn_nb_certificate', self.ovsdb_server_mgr.certificate, 'ovn') set_cfg('ovn_nb_ca_cert', self.ovsdb_server_mgr.ca_cert, 'ovn') set_cfg('ovn_sb_private_key', self.ovsdb_server_mgr.private_key, 'ovn') set_cfg('ovn_sb_certificate', self.ovsdb_server_mgr.certificate, 'ovn') set_cfg('ovn_sb_ca_cert', self.ovsdb_server_mgr.ca_cert, 'ovn') num_attempts = 0 # 5 seconds should be more than enough for the transaction to complete # for the test cases. # This also fixes the bug #1607639. cfg.CONF.set_override('ovsdb_connection_timeout', 5, 'ovn') # Created monitor IDL connection to the OVN NB DB. # This monitor IDL connection can be used to # - Verify that the ML2 OVN driver has written to the OVN NB DB # as expected. # - Create and delete resources in OVN NB DB outside of the # ML2 OVN driver scope to test scenarios like ovn_nb_sync. while num_attempts < 3: try: con = self.useFixture( ConnectionFixture(constr=mgr.get_ovsdb_connection_path(), schema='OVN_Northbound')).connection self.nb_api = impl_idl_ovn.OvsdbNbOvnIdl(con) break except Exception: LOG.exception("Error connecting to the OVN_Northbound DB") num_attempts += 1 time.sleep(1) num_attempts = 0 # Create monitor IDL connection to the OVN SB DB. # This monitor IDL connection can be used to # - Create chassis rows # - Update chassis columns etc. while num_attempts < 3: try: con = self.useFixture( ConnectionFixture( constr=mgr.get_ovsdb_connection_path('sb'), schema='OVN_Southbound')).connection self.sb_api = impl_idl_ovn.OvsdbSbOvnIdl(con) break except Exception: LOG.exception("Error connecting to the OVN_Southbound DB") num_attempts += 1 time.sleep(1) class TriggerCls(mock.MagicMock): def trigger(self): pass trigger_cls = TriggerCls() if self.maintenance_worker: trigger_cls.trigger.__self__.__class__ = worker.MaintenanceWorker cfg.CONF.set_override('neutron_sync_mode', 'off', 'ovn') self.addCleanup(self.stop) # mech_driver.post_fork_initialize creates the IDL connections self.mech_driver.post_fork_initialize(mock.ANY, mock.ANY, trigger_cls.trigger)
def setUp(self): """Run before each test method to initialize test environment.""" super(TestCase, self).setUp() self.useFixture( nova_fixtures.Timeout(os.environ.get('OS_TEST_TIMEOUT', 0), self.TIMEOUT_SCALING_FACTOR)) self.useFixture(fixtures.NestedTempfile()) self.useFixture(fixtures.TempHomeDir()) self.useFixture(log_fixture.get_logging_handle_error_fixture()) self.output = nova_fixtures.OutputStreamCapture() self.useFixture(self.output) self.stdlog = nova_fixtures.StandardLogging() self.useFixture(self.stdlog) # NOTE(sdague): because of the way we were using the lock # wrapper we ended up with a lot of tests that started # relying on global external locking being set up for them. We # consider all of these to be *bugs*. Tests should not require # global external locking, or if they do, they should # explicitly set it up themselves. # # The following REQUIRES_LOCKING class parameter is provided # as a bridge to get us there. No new tests should be added # that require it, and existing classes and tests should be # fixed to not need it. if self.REQUIRES_LOCKING: lock_path = self.useFixture(fixtures.TempDir()).path self.fixture = self.useFixture( config_fixture.Config(lockutils.CONF)) self.fixture.config(lock_path=lock_path, group='oslo_concurrency') self.useFixture(conf_fixture.ConfFixture(CONF)) if self.STUB_RPC: self.useFixture(nova_fixtures.RPCFixture('nova.test')) # we cannot set this in the ConfFixture as oslo only registers the # notification opts at the first instantiation of a Notifier that # happens only in the RPCFixture CONF.set_default('driver', ['test'], group='oslo_messaging_notifications') # NOTE(danms): Make sure to reset us back to non-remote objects # for each test to avoid interactions. Also, backup the object # registry. objects_base.NovaObject.indirection_api = None self._base_test_obj_backup = copy.copy( objects_base.NovaObjectRegistry._registry._obj_classes) self.addCleanup(self._restore_obj_registry) objects.Service.clear_min_version_cache() # NOTE(danms): Reset the cached list of cells from nova.compute import api api.CELLS = [] context.CELL_CACHE = {} context.CELLS = [] self.cell_mappings = {} self.host_mappings = {} # NOTE(danms): If the test claims to want to set up the database # itself, then it is responsible for all the mapping stuff too. if self.USES_DB: # NOTE(danms): Full database setup involves a cell0, cell1, # and the relevant mappings. self.useFixture(nova_fixtures.Database(database='api')) self._setup_cells() self.useFixture(nova_fixtures.DefaultFlavorsFixture()) elif not self.USES_DB_SELF: # NOTE(danms): If not using the database, we mock out the # mapping stuff and effectively collapse everything to a # single cell. self.useFixture(nova_fixtures.SingleCellSimple()) self.useFixture(nova_fixtures.DatabasePoisonFixture()) # NOTE(blk-u): WarningsFixture must be after the Database fixture # because sqlalchemy-migrate messes with the warnings filters. self.useFixture(nova_fixtures.WarningsFixture()) self.useFixture(ovo_fixture.StableObjectJsonFixture()) # NOTE(mnaser): All calls to utils.is_neutron() are cached in # nova.utils._IS_NEUTRON. We set it to None to avoid any # caching of that value. utils._IS_NEUTRON = None # Reset the traits sync and rc cache flags resource_provider._TRAITS_SYNCED = False resource_provider._RC_CACHE = None # Reset the global QEMU version flag. images.QEMU_VERSION = None mox_fixture = self.useFixture(moxstubout.MoxStubout()) self.mox = mox_fixture.mox self.stubs = mox_fixture.stubs self.addCleanup(self._clear_attrs) self.useFixture(fixtures.EnvironmentVariable('http_proxy')) self.policy = self.useFixture(policy_fixture.PolicyFixture()) self.useFixture(nova_fixtures.PoisonFunctions()) openstack_driver.DRIVER_CACHE = {} self.useFixture(nova_fixtures.ForbidNewLegacyNotificationFixture()) # NOTE(mikal): make sure we don't load a privsep helper accidentally self.useFixture(nova_fixtures.PrivsepNoHelperFixture())
def setUp(self): os.environ["EDITOR"] = 'cat' self.tempdir = self.useFixture(fixtures.TempDir()).path os.chdir(self.tempdir)
def test_config_download_os_apply_config(self, mock_deployment_data, mock_config_dict, mock_deployment_resource_id, mock_git_init): heat = mock.MagicMock() self.config = ooo_config.Config(heat) stack = mock.MagicMock() heat.stacks.get.return_value = stack heat.resources.get.return_value = mock.MagicMock() stack.outputs = [{ 'output_key': 'RoleNetHostnameMap', 'output_value': { 'Controller': { 'ctlplane': ['overcloud-controller-0.ctlplane.localdomain'] }, 'Compute': { 'ctlplane': [ 'overcloud-novacompute-0.ctlplane.localdomain', 'overcloud-novacompute-1.ctlplane.localdomain', 'overcloud-novacompute-2.ctlplane.localdomain' ] } } }, { 'output_key': 'ServerIdData', 'output_value': { 'server_ids': { 'Controller': ['00b3a5e1-5e8e-4b55-878b-2fa2271f15ad'], 'Compute': [ 'a7db3010-a51f-4ae0-a791-2364d629d20d', '8b07cd31-3083-4b88-a433-955f72039e2c', '169b46f8-1965-4d90-a7de-f36fb4a830fe' ] } } }, { 'output_key': 'RoleNetworkConfigMap', 'output_value': {} }, { 'output_key': 'RoleGroupVars', 'output_value': { 'Controller': { 'any_errors_fatal': 'yes', 'max_fail_percentage': 15 }, 'Compute': { 'any_errors_fatal': 'yes', 'max_fail_percentage': 15 }, } }] deployment_data, configs = \ self._get_config_data('config_data.yaml') # Add a group:os-apply-config config and deployment config_uuid = str(uuid.uuid4()) configs[config_uuid] = dict(id=config_uuid, config=dict(a='a'), group='os-apply-config', outputs=[]) deployment_uuid = str(uuid.uuid4()) deployment_mock = mock.MagicMock() deployment_mock.id = deployment_uuid deployment_mock.attributes = dict( value=dict(server='00b3a5e1-5e8e-4b55-878b-2fa2271f15ad', deployment=deployment_uuid, config=config_uuid, name='OsApplyConfigDeployment')) deployment_data.append(deployment_mock) self.configs = configs self.deployments = deployment_data mock_deployment_data.return_value = deployment_data mock_config_dict.side_effect = self._get_config_dict mock_deployment_resource_id.side_effect = self._get_deployment_id self.tmp_dir = self.useFixture(fixtures.TempDir()).path with warnings.catch_warnings(record=True) as w: self.config.download_config(stack, self.tmp_dir) mock_git_init.assert_called_once_with(self.tmp_dir) # check that we got at least one of the warnings that we expected # to throw self.assertGreaterEqual(len(w), 1) self.assertGreaterEqual( len([ x for x in w if issubclass(x.category, DeprecationWarning) ]), 1) self.assertGreaterEqual( len([ x for x in w if "group:os-apply-config" in str(x.message) ]), 1)