def test_install_glob(self): stdout, _, _ = self.run_setup('install', '--root', self.temp_dir + 'installed', allow_fail=False) self.expectThat(stdout, matchers.Contains('copying data_files/a.txt')) self.expectThat(stdout, matchers.Contains('copying data_files/b.txt'))
def test_version_data_basics(self): examples = { 'keystone': V3_VERSION_LIST, 'cinder': CINDER_EXAMPLES, 'glance': GLANCE_EXAMPLES } for path, data in examples.items(): url = "%s%s" % (BASE_URL, path) mock = self.requests_mock.get(url, status_code=300, json=data) disc = discover.Discover(self.session, url) raw_data = disc.raw_version_data() clean_data = disc.version_data() for v in raw_data: for n in ('id', 'status', 'links'): msg = '%s missing from %s version data' % (n, path) self.assertThat( v, matchers.Annotate(msg, matchers.Contains(n))) for v in clean_data: for n in ('version', 'url', 'raw_status'): msg = '%s missing from %s version data' % (n, path) self.assertThat( v, matchers.Annotate(msg, matchers.Contains(n))) self.assertTrue(mock.called_once)
def test_body(self): data = "BODY DATA" self.request(response=data, headers={'Content-Type': 'application/json'}) logger_message = self.logger_message.getvalue() self.assertThat(logger_message, matchers.Contains('BODY:')) self.assertThat(logger_message, matchers.Contains(data))
def test_logfile_contains_finish(self): """Confirm that logger calls in 'finish' phase recorded Repository layout being checked B---C local/master / A---D---E upstream/master """ tree = [ ('A', []), ('B', ['A']), ('C', ['B']), ('D', ['A']), ('E', ['D']), ] branches = { 'head': ('master', 'C'), 'upstream': ('upstream/master', 'E'), } self.gittree = base.BuildTree(self.testrepo, tree, branches.values()) cmdline = self.parser.get_default('script_cmdline') tfile = None try: tfile = tempfile.NamedTemporaryFile(delete=False) # need to close to allow reopen to write tfile.close() cmdline.extend([ '-v', '--log-file', tfile.name, '--log-level', 'debug', 'import', '--into', 'master', 'upstream/master' ]) try: output = subprocess.check_output(cmdline, stderr=subprocess.STDOUT) except subprocess.CalledProcessError as cpe: self.addDetail( 'subprocess-output', content.text_content(cpe.output.decode('utf-8'))) raise self.addDetail('subprocess-output', content.text_content(output.decode('utf-8'))) logfile_contents = open(tfile.name, 'r').read() finally: if tfile and os.path.exists(tfile.name): os.remove(tfile.name) self.assertThat( logfile_contents, matchers.Contains("Merging by inverting the 'ours' strategy")) self.assertThat( logfile_contents, matchers.Contains("Replacing tree contents with those from"))
def test_manifest_exclude_honoured(self): with open(os.path.join( self.package_dir, 'pbr_testpackage.egg-info/SOURCES.txt'), 'r') as f: body = f.read() self.assertThat( body, matchers.Not(matchers.Contains('pbr_testpackage/extra.py'))) self.assertThat(body, matchers.Contains('pbr_testpackage/__init__.py'))
def test_no_required_attributes_present(self): app = FakeAttributeCheckerApp() req = self._make_request(url='/') resp = req.get_response(app) ex = self.assertRaises(exception.ValidationError, app.assert_attributes, resp.body, ['missing_attribute1', 'missing_attribute2']) self.assertThat(ex.message, matchers.Contains('missing_attribute1')) self.assertThat(ex.message, matchers.Contains('missing_attribute2'))
def test_check_immutable_params_fail(self): """Pass invalid parameter to the method and expect failure.""" ref = dict([(uuid.uuid4().hex, uuid.uuid4().hex) for _ in range(3)]) ex = self.assertRaises(exception.ImmutableAttributeError, self.api.check_immutable_params, ref) ex_msg = six.text_type(ex) self.assertThat(ex_msg, matchers.Contains(self.api.__class__.__name__)) for key in ref.keys(): self.assertThat(ex_msg, matchers.Contains(key))
def test_build_pxe_config(self): args = { 'deployment_id': 'aaa', 'deployment_key': 'bbb', 'deployment_iscsi_iqn': 'ccc', 'deployment_aki_path': 'ddd', 'deployment_ari_path': 'eee', 'aki_path': 'fff', 'ari_path': 'ggg', } config = pxe.build_pxe_config(**args) self.assertThat(config, matchers.StartsWith('default deploy')) # deploy bits are in the deploy section start = config.index('label deploy') end = config.index('label boot') self.assertThat(config[start:end], matchers.MatchesAll( matchers.Contains('kernel ddd'), matchers.Contains('initrd=eee'), matchers.Contains('deployment_id=aaa'), matchers.Contains('deployment_key=bbb'), matchers.Contains('iscsi_target_iqn=ccc'), matchers.Not(matchers.Contains('kernel fff')), )) # boot bits are in the boot section start = config.index('label boot') self.assertThat(config[start:], matchers.MatchesAll( matchers.Contains('kernel fff'), matchers.Contains('initrd=ggg'), matchers.Not(matchers.Contains('kernel ddd')), ))
def verify_cert_instance(self, cert): self.assertIsInstance(cert, _cert.Certificate) self.assertEqual("5b8f908b5495452aa13beede0afc5d99", cert.id) self.assertEqual("cert-bky", cert.name) self.assertEqual("certificate", cert.description) self.assertEqual("2016-06-27 08:14:42", cert.create_time) self.assertEqual("2016-06-27 08:14:42", cert.update_time) self.assertThat(cert.certificate, matchers.Contains("BEGIN CERTIFICATE")) self.assertThat(cert.private_key, matchers.Contains("BEGIN RSA PRIVATE KEY"))
def test_xdelta3_logs(self): self.generate_snap_pair() base_delta = deltas.XDelta3Generator(source_path=self.source_file, target_path=self.target_file) base_delta.make_delta(is_for_test=True) self.assertThat( self.fake_logger.output, m.Contains('Generating xdelta3 delta for {}'.format( os.path.basename(base_delta.target_path)))) self.assertThat(self.fake_logger.output, m.Contains('xdelta3 delta diff generation'))
def test_install_no_ChangeLog(self): stdout, _, _ = self.run_setup('install', '--root', self.temp_dir + 'installed', allow_fail=False) self.expectThat( stdout, matchers.Not(matchers.Contains('Generating ChangeLog')))
def test_logs_warning(self): req = webob.Request.blank('/') self.middleware(req.environ, self.start_fake_response) self.assertEqual(self.response_status, 200) log = "Use of the auth_uri option was deprecated in the Queens " \ "release in favor of www_authenticate_uri." self.assertThat(self.logger.output, matchers.Contains(log))
def test_get_users(self): # Get a list of users and find the test user self.data.setup_test_user() users = self.client.get_users() self.assertThat([u['name'] for u in users], matchers.Contains(self.data.test_user), "Could not find %s" % self.data.test_user)
def test_basic_params(self): method = 'GET' response = 'Test Response' status = 200 self.request(method=method, status=status, response=response) self.assertEqual(httpretty.last_request().method, method) self.assertThat(self.logger.debug_log, matchers.Contains('curl')) self.assertThat(self.logger.debug_log, matchers.Contains('-X %s' % method)) self.assertThat(self.logger.debug_log, matchers.Contains(self.url)) self.assertThat(self.logger.debug_log, matchers.Contains(str(status))) self.assertThat(self.logger.debug_log, matchers.Contains(response))
def test_meta(self): class Manager(periodic_task.PeriodicTasks): @periodic_task.periodic_task def foo(self): return 'foo' @periodic_task.periodic_task(spacing=4) def bar(self): return 'bar' @periodic_task.periodic_task(enabled=False) def baz(self): return 'baz' m = Manager(self.conf) self.assertThat(m._periodic_tasks, matchers.HasLength(2)) self.assertEqual(periodic_task.DEFAULT_INTERVAL, m._periodic_spacing['foo']) self.assertEqual(4, m._periodic_spacing['bar']) self.assertThat(m._periodic_spacing, matchers.Not(matchers.Contains('baz'))) @periodic_task.periodic_task def external(): return 42 m.add_periodic_task(external) self.assertThat(m._periodic_tasks, matchers.HasLength(3)) self.assertEqual(periodic_task.DEFAULT_INTERVAL, m._periodic_spacing['external'])
def test_freeze_smoke(self): # Use an arbitrary python, but make sure it has the venv standard lib. versions = ['/usr/bin/python3.%(v)s' % dict(v=v) for v in range(5, 10)] found = [v for v in versions if os.path.exists(v)] found_with_venv = [] for py in found: output = str( subprocess.check_output([ py, '-c', 'import pkgutil; [print(x) for x in pkgutil.iter_modules()]' ])) # Needs both venv and ensurepip if 'venv' in output and 'ensurepip' in output: found_with_venv.append(py) if len(found_with_venv) == 0: self.skipTest('Unable to find python that includes venv module') # Grab the latest version available as that is the most likely to # break. pyversion = found_with_venv[-1] req = self.useFixture(fixtures.TempDir()).path + '/r.txt' with open(req, 'wt') as output: output.write('fixtures==2.0.0') frozen = generate._freeze(req, pyversion) expected_version = pyversion[-3:] self.expectThat(frozen, matchers.HasLength(2)) self.expectThat(frozen[0], matchers.Equals(expected_version)) # There are multiple items in the dependency tree of fixtures. # Since this is a smoke test, just ensure fixtures is there. self.expectThat(frozen[1], matchers.Contains(('fixtures', '2.0.0')))
def _validate_policygroup(self, topology, pg_name=None): if self.is_dhcp_agent_present(): expected_pgs = 2 else: expected_pgs = 1 self.assertThat(topology.vsd_policygroups, matchers.HasLength(expected_pgs), message="Unexpected amount of PGs found") for vsd_policygroup in topology.vsd_policygroups: self.assertThat(vsd_policygroup['type'], matchers.Equals('SOFTWARE')) if pg_name: self.assertThat(vsd_policygroup['name'], matchers.Contains(pg_name)) vsd_pg_vports = self.vsd_client.get_vport(constants.POLICYGROUP, vsd_policygroup['ID']) self.assertThat(vsd_pg_vports, matchers.HasLength(1), message="Expected to find exactly 1 vport in PG") if topology.subnet['id'] in vsd_pg_vports[0]['externalID']: self.assertThat(vsd_pg_vports[0]['ID'], matchers.Equals( topology.vsd_switchdev_vport['ID']), message="Vport should be part of PG")
def _helper_test_validate_subnet(self, option, exception): cfg.CONF.set_override(option, 0) with self.network() as network: subnet = { 'network_id': network['network']['id'], 'cidr': '10.0.2.0/24', 'ip_version': 4, 'tenant_id': network['network']['tenant_id'], 'gateway_ip': '10.0.2.1', 'dns_nameservers': ['8.8.8.8'], 'host_routes': [{ 'destination': '135.207.0.0/16', 'nexthop': '1.2.3.4' }] } error = self.assertRaises( exception, FAKE_SERVER._validate_subnet, neutron_context.get_admin_context(load_admin_roles=False), subnet) self.assertThat( str(error), matchers.Not(matchers.Contains('built-in function id')))
def test_get_users(self): # Get a list of users and find the test user user = self.setup_test_user() users = self.users_client.list_users()['users'] self.assertThat([u['name'] for u in users], matchers.Contains(user['name']), "Could not find %s" % user['name'])
def test_get_localized_response(self): # If the request has the Accept-Language set to a supported language # and an exception is raised by the application that is translatable # then the response will have the translated message. language = uuid.uuid4().hex self._set_expected_languages(all_locales=[language]) # The arguments for the xlated message format have to match the args # for the chosen exception (exception.NotFound) xlated_msg_fmt = "Xlated NotFound, %(target)s." # Fake out gettext.translation() to return a translator for our # expected language and a passthrough translator for other langs. def fake_translation(*args, **kwargs): class IdentityTranslator(object): def ugettext(self, msgid): return msgid gettext = ugettext class LangTranslator(object): def ugettext(self, msgid): if msgid == exception.NotFound.message_format: return xlated_msg_fmt return msgid gettext = ugettext if language in kwargs.get('languages', []): return LangTranslator() return IdentityTranslator() with mock.patch.object(gettext, 'translation', side_effect=fake_translation) as xlation_mock: target = uuid.uuid4().hex # Fake app raises NotFound exception to simulate Keystone raising. class FakeApp(wsgi.Application): def index(self, context): raise exception.NotFound(target=target) # Make the request with Accept-Language on the app, expect an error # response with the translated message. req = webob.Request.blank('/') args = {'action': 'index', 'controller': None} req.environ['wsgiorg.routing_args'] = [None, args] req.headers['Accept-Language'] = language resp = req.get_response(FakeApp()) # Assert that the translated message appears in the response. exp_msg = xlated_msg_fmt % dict(target=target) self.assertThat(resp.body, matchers.Contains(exp_msg)) self.assertThat(xlation_mock.called, matchers.Equals(True))
def test_raises_AssertionError_when_test_passes(self): @utils.wip('waiting on bug #000000') def test(): pass # literally e = self.assertRaises(AssertionError, test) self.assertThat(str(e), matchers.Contains('#000000'))
def test_basic_params(self): method = 'GET' response = 'Test Response' status = 200 self.request(method=method, status_code=status, response=response) self.assertEqual(self.requests.last_request.method, method) logger_message = self.logger_message.getvalue() self.assertThat(logger_message, matchers.Contains('curl')) self.assertThat(logger_message, matchers.Contains('-X %s' % method)) self.assertThat(logger_message, matchers.Contains(self.url)) self.assertThat(logger_message, matchers.Contains(str(status))) self.assertThat(logger_message, matchers.Contains(response))
def test_attribute_missing_from_request(self): app = FakeAttributeCheckerApp() req = self._make_request(url='/?a=1&b=2') resp = req.get_response(app) ex = self.assertRaises(exception.ValidationError, app.assert_attributes, resp.body, ['a', 'missing_attribute']) self.assertThat(ex.message, matchers.Contains('missing_attribute'))
def test_raises_SkipError_when_broken_test_fails(self): @utils.wip('waiting on bug #000000') def test(): raise Exception('i expected a failure - this is a WIP') e = self.assertRaises(testcase.TestSkipped, test) self.assertThat(str(e), matchers.Contains('#000000'))
def test_discover_forwards_original_ip(self): self.requests_mock.get(BASE_URL, status_code=300, text=V3_VERSION_LIST) ip = '192.168.1.1' self.assertCreatesV3(auth_url=BASE_URL, original_ip=ip) self.assertThat(self.requests_mock.last_request.headers['forwarded'], matchers.Contains(ip))
def test_finder_ignores_files(self, mock_walk): mock_walk.return_value = [ ['.', [], ['file.txt', 'keystone.conf', 'keystone.domain0.conf']], ] domain_configs = list(cli._domain_config_finder('.')) expected_domain_configs = [('./keystone.domain0.conf', 'domain0')] self.assertThat(domain_configs, matchers.Equals(expected_domain_configs)) expected_msg_template = ('Ignoring file (%s) while scanning ' 'domain config directory') self.assertThat(self.logging.output, matchers.Contains(expected_msg_template % 'file.txt')) self.assertThat( self.logging.output, matchers.Contains(expected_msg_template % 'keystone.conf'))
def test_discover_forwards_original_ip(self): httpretty.register_uri(httpretty.GET, BASE_URL, status=300, body=V3_VERSION_LIST) ip = '192.168.1.1' self.assertCreatesV3(auth_url=BASE_URL, original_ip=ip) self.assertThat(httpretty.last_request().headers['forwarded'], matchers.Contains(ip))
def test_uploading_all_from_an_empty_directory(self): CONF(args=['domain_config_upload', '--all'], project='keystone', default_config_files=[]) cli.DomainConfigUpload.main() expected_msg = ('No domain configs uploaded from %r' % CONF.identity.domain_config_dir) self.assertThat(self.logging.output, matchers.Contains(expected_msg))
def test_model_load(self): res = self._runner.testLoadCompexModel() for i in range(3): self.assertThat(res[i], matchers.Not(matchers.Contains('node'))) self.assertEqual(self._runner.root.object_id, res[3]) self.assertEqual([ 'rootNode', ['childNode1', 'childNode2', 'childNode2'], True, True, True, True, True, 'rootNode', 'childNode2', 'childNode1' ], res[4:])
def test_basic_params(self): method = 'GET' response = 'Test Response' status = 200 self.request(method=method, status_code=status, response=response, headers={'Content-Type': 'application/json'}) self.assertEqual(self.requests_mock.last_request.method, method) logger_message = self.logger_message.getvalue() self.assertThat(logger_message, matchers.Contains('curl')) self.assertThat(logger_message, matchers.Contains('-X %s' % method)) self.assertThat(logger_message, matchers.Contains(self.url)) self.assertThat(logger_message, matchers.Contains(str(status))) self.assertThat(logger_message, matchers.Contains(response))