def test_invalid_tag_ignored(self): # Fix for bug 1356784 - we treated any tag as a version, not just those # that are valid versions. self.repo.commit() self.repo.tag('1') self.repo.commit() # when the tree is tagged and its wrong: self.repo.tag('badver') version = packaging._get_version_from_git() self.assertThat(version, matchers.StartsWith('1.0.1.dev1.g')) # When the tree isn't tagged, we also fall through. self.repo.commit() version = packaging._get_version_from_git() self.assertThat(version, matchers.StartsWith('1.0.1.dev2.g')) # We don't fall through x.y versions self.repo.commit() self.repo.tag('1.2') self.repo.commit() self.repo.tag('badver2') version = packaging._get_version_from_git() self.assertThat(version, matchers.StartsWith('1.2.1.dev1.g')) # Or x.y.z versions self.repo.commit() self.repo.tag('1.2.3') self.repo.commit() self.repo.tag('badver3') version = packaging._get_version_from_git() self.assertThat(version, matchers.StartsWith('1.2.4.dev1.g')) # Or alpha/beta/pre versions self.repo.commit() self.repo.tag('1.2.4.0a1') self.repo.commit() self.repo.tag('badver4') version = packaging._get_version_from_git() self.assertThat(version, matchers.StartsWith('1.2.4.dev1.g'))
def assertValidListLinks(self, links): self.assertIsNotNone(links) self.assertIsNotNone(links.get('self')) self.assertThat(links['self'], matchers.StartsWith('http://localhost')) self.assertIn('next', links) if links['next'] is not None: self.assertThat(links['next'], matchers.StartsWith('http://localhost')) self.assertIn('previous', links) if links['previous'] is not None: self.assertThat(links['previous'], matchers.StartsWith('http://localhost'))
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 _validate_oauth_headers(self, auth_header, oauth_client): """Assert that the data in the headers matches the data that is produced from oauthlib. """ self.assertThat(auth_header, matchers.StartsWith('OAuth ')) auth_header = auth_header[len('OAuth '):] # NOTE(stevemar): In newer versions of oauthlib there is # an additional argument for getting oauth parameters. # Adding a conditional here to revert back to no arguments # if an earlier version is detected. if tuple(oauthlib.__version__.split('.')) > ('0', '6', '1'): header_params = oauth_client.get_oauth_params(None) else: header_params = oauth_client.get_oauth_params() parameters = dict(header_params) self.assertEqual('HMAC-SHA1', parameters['oauth_signature_method']) self.assertEqual('1.0', parameters['oauth_version']) self.assertIsInstance(parameters['oauth_nonce'], six.string_types) self.assertEqual(oauth_client.client_key, parameters['oauth_consumer_key']) if oauth_client.resource_owner_key: self.assertEqual(oauth_client.resource_owner_key, parameters['oauth_token'],) if oauth_client.verifier: self.assertEqual(oauth_client.verifier, parameters['oauth_verifier']) if oauth_client.callback_uri: self.assertEqual(oauth_client.callback_uri, parameters['oauth_callback']) if oauth_client.timestamp: self.assertEqual(oauth_client.timestamp, parameters['oauth_timestamp']) return parameters
def assertValidEntity(self, entity, ref=None, keys_to_check=None): """Make assertions common to all API entities. If a reference is provided, the entity will also be compared against the reference. """ if keys_to_check is not None: keys = keys_to_check else: keys = ['name', 'description', 'enabled'] for k in ['id'] + keys: msg = '%s unexpectedly None in %s' % (k, entity) self.assertIsNotNone(entity.get(k), msg) self.assertIsNotNone(entity.get('links')) self.assertIsNotNone(entity['links'].get('self')) self.assertThat(entity['links']['self'], matchers.StartsWith('http://localhost')) self.assertIn(entity['id'], entity['links']['self']) if ref: for k in keys: msg = '%s not equal: %s != %s' % (k, ref[k], entity[k]) self.assertEqual(ref[k], entity[k]) return entity
def _validate_oauth_headers(self, auth_header, oauth_client): """Assert that the data in the headers matches the data that is produced from oauthlib. """ self.assertThat(auth_header, matchers.StartsWith('OAuth ')) auth_header = auth_header[len('OAuth '):] header_params = oauth_client.get_oauth_params() parameters = dict(header_params) self.assertEqual('HMAC-SHA1', parameters['oauth_signature_method']) self.assertEqual('1.0', parameters['oauth_version']) self.assertIsInstance(parameters['oauth_nonce'], six.string_types) self.assertEqual(oauth_client.client_key, parameters['oauth_consumer_key']) if oauth_client.resource_owner_key: self.assertEqual( oauth_client.resource_owner_key, parameters['oauth_token'], ) if oauth_client.verifier: self.assertEqual(oauth_client.verifier, parameters['oauth_verifier']) if oauth_client.callback_uri: self.assertEqual(oauth_client.callback_uri, parameters['oauth_callback']) if oauth_client.timestamp: self.assertEqual(oauth_client.timestamp, parameters['oauth_timestamp']) return parameters
def test_actions(self): """Test that information on actions can be invoked Test that information on actions can be invoked on each MuranoPL object are persisted into object header ('?' key) during serialization of Objects section of Object Model """ serialized = self._runner.serialized_model actions = serialized['Objects']['?'].get('_actions') self.assertIsInstance(actions, dict) action_names = [action['name'] for action in actions.values()] self.assertIn('testAction', action_names) self.assertNotIn('notAction', action_names) self.assertIn('testRootMethod', action_names) action_meta = None for action in actions.values(): self.assertIsInstance(action.get('enabled'), bool) self.assertIsInstance(action.get('name'), six.string_types) self.assertThat( action['name'], matchers.StartsWith('test')) if action['name'] == 'testActionMeta': action_meta = action else: self.assertEqual(action['title'], action['name']) self.assertIsNotNone(action_meta) self.assertEqual(action_meta['title'], "Title of the method") self.assertEqual(action_meta['description'], "Description of the method") self.assertEqual(action_meta['helpText'], "HelpText of the method")
def _validate_oauth_headers(self, auth_header, oauth_client): """Validate data in the headers. Assert that the data in the headers matches the data that is produced from oauthlib. """ self.assertThat(auth_header, matchers.StartsWith('OAuth ')) parameters = dict( oauth1.rfc5849.utils.parse_authorization_header(auth_header)) self.assertEqual('HMAC-SHA1', parameters['oauth_signature_method']) self.assertEqual('1.0', parameters['oauth_version']) self.assertIsInstance(parameters['oauth_nonce'], six.string_types) self.assertEqual(oauth_client.client_key, parameters['oauth_consumer_key']) if oauth_client.resource_owner_key: self.assertEqual( oauth_client.resource_owner_key, parameters['oauth_token'], ) if oauth_client.verifier: self.assertEqual(oauth_client.verifier, parameters['oauth_verifier']) if oauth_client.callback_uri: self.assertEqual(oauth_client.callback_uri, parameters['oauth_callback']) return parameters
def test_simple_get(self): path = '/%s' % uuid.uuid4().hex public_url = '%s%s' % (PUBLIC_SERVICE_URL, path) json_a = uuid.uuid4().hex json_b = uuid.uuid4().hex service_mock = self.requests_mock.get( public_url, json={json_a: json_b}, status_code=200, reason='OK', headers={'Content-Type': 'application/json'}) resp = self.shell('get', path, '--os-service-type', self.service_type, '--os-auth-type', 'password', '--os-auth-url', AUTH_URL, '--os-project-id', self.project_id, '--os-user-id', self.user_id) self.assertEqual('GET', self.requests_mock.last_request.method) self.assertEqual(public_url, self.requests_mock.last_request.url) self.assertTrue(service_mock.called) self.assertThat(resp, matchers.StartsWith('HTTP/1.1 200 OK')) self.assertIn('Content-Type: application/json', resp) r = '.*{\s*"%s":\s*"%s"\s*}$' % (json_a, json_b) self.assertThat(resp, matchers.MatchesRegex(r, re.M | re.S))
def test_db_instance(self): driver = mongodb.DataDriver(self._conf) databases = driver.message_databases + [driver.queues_database] for db in databases: self.assertThat(db.name, matchers.StartsWith(driver.mongodb_conf.database))
def test_delete(self): with self.app.test_client() as c: res = c.delete('/v1/leases/{0}'.format(self.lease_uuid), headers=self.headers) res_id = res.headers.get(id.HTTP_RESP_HEADER_REQUEST_ID) self.assertEqual(204, res.status_code) self.assertIn(id.HTTP_RESP_HEADER_REQUEST_ID, res.headers) self.assertThat(res_id, matchers.StartsWith('req-'))
def test_db_instance(self): self.config(unreliable=True) cache = oslo_cache.get_cache(self.conf) control = mongodb.ControlDriver(self.conf, cache) data = mongodb.DataDriver(self.conf, cache, control) for db in data.message_databases: self.assertThat(db.name, matchers.StartsWith( data.mongodb_conf.database))
def test_timestamp_invalid(self): test_property_schema = {'type': 'timestamp'} # invalid timestamp - day out of range value = '2015-04-115T02:59:43.1Z' propertyInstance = Property('test_property', value, test_property_schema) error = self.assertRaises(ValueError, propertyInstance.validate) expected_message = (_('"%s" is not a valid timestamp.') % value) self.assertThat(str(error), matchers.StartsWith(expected_message))
def test_db_instance(self): cache = oslo_cache.get_cache() driver = mongodb.DataDriver(self.conf, cache) databases = (driver.message_databases + [driver.queues_database]) for db in databases: self.assertThat(db.name, matchers.StartsWith(driver.mongodb_conf.database))
def test_screenshot_and_page_dump_enabled(self): test = SSTStringTestCase('ignored') test.script_code = 'assert False' test.screenshots_on = True test.results_directory = 'results' self.run_failing_test(test) # We get a screenshot and a pagesource self.assertTrue(os.path.exists('results')) files = sorted(os.listdir('results')) self.assertEqual(2, len(files)) def byte_size(f): return os.path.getsize(os.path.join(test.results_directory, f)) self.assertGreater(byte_size(files[0]), 0) self.assertGreater(byte_size(files[1]), 0) self.assertThat(files[0], matchers.StartsWith('pagesource-')) self.assertThat(files[1], matchers.StartsWith('screenshot-'))
def test_tacker_context_create(self): ctx = context.Context('user_id', 'tenant_id') self.assertEqual('user_id', ctx.user_id) self.assertEqual('tenant_id', ctx.project_id) self.assertEqual('tenant_id', ctx.tenant_id) self.assertThat(ctx.request_id, matchers.StartsWith('req-')) self.assertEqual('user_id', ctx.user) self.assertEqual('tenant_id', ctx.tenant) self.assertIsNone(ctx.user_name) self.assertIsNone(ctx.tenant_name)
def test_send_cross_tenant(self): sid, message = base.generate_small_message() headers = {'X-Roles': 'admin, monitoring-delegate'} cross_tennant_id = '2106b2c8da0eecdb3df4ea84a0b5624b' fields = {'tenant_id': cross_tennant_id} response = self._run_and_wait(sid, message, headers=headers, fields=fields) self.assertThat(response[0]['_source']['tenant'], matchers.StartsWith(cross_tennant_id))
def test_preversion_too_low_semver_headers(self): # That is, the target version is either already released or not high # enough for the semver requirements given api breaks etc. self.repo.commit() self.repo.tag('1.2.3') self.repo.commit('sem-ver: feature') # Note that we can't target 1.2.4, the feature header means we need # to be working on 1.3.0 or above. err = self.assertRaises( ValueError, packaging._get_version_from_git, '1.2.4') self.assertThat(err.args[0], matchers.StartsWith('git history'))
def test_delete(self): with self.app.test_client() as c: self.get_computehosts.return_value = fake_computehost( id=self.host_id) res = c.delete('/v1/{0}'.format(self.host_id), headers=self.headers) res_id = res.headers.get(id.HTTP_RESP_HEADER_REQUEST_ID) self.assertEqual(204, res.status_code) self.assertIn(id.HTTP_RESP_HEADER_REQUEST_ID, res.headers) self.assertThat(res_id, matchers.StartsWith('req-'))
def test_preversion_too_low_simple(self): # That is, the target version is either already released or not high # enough for the semver requirements given api breaks etc. self.repo.commit() self.repo.tag('1.2.3') self.repo.commit() # Note that we can't target 1.2.3 anymore - with 1.2.3 released we # need to be working on 1.2.4. err = self.assertRaises( ValueError, packaging._get_version_from_git, '1.2.3') self.assertThat(err.args[0], matchers.StartsWith('git history'))
def test_send_cross_project(self): sid, message = base.generate_small_message() headers = {'X-Roles': 'admin, monitoring-delegate'} cross_tennant_id = '2106b2c8da0eecdb3df4ea84a0b5624b' fields = {'project_id': cross_tennant_id} response = self._run_and_wait(sid, message, headers=headers, fields=fields) log_msg = response[0] for key in CONF.monitoring.log_project_id_path: log_msg = log_msg.pop(key) self.assertThat(log_msg, matchers.StartsWith(cross_tennant_id))
def test_generate_request_id(self): @webob.dec.wsgify def application(req): return req.environ[request_id.ENV_REQUEST_ID] app = request_id.RequestId(application) req = webob.Request.blank('/test') res = req.get_response(app) res_req_id = res.headers.get(request_id.HTTP_RESP_HEADER_REQUEST_ID) self.assertThat(res_req_id, matchers.StartsWith(b'req-')) # request-id in request environ is returned as response body self.assertEqual(res_req_id, res.body)
def test_actions(self): """Test that information on actions can be invoked on each MuranoPL object are persisted into object header ('?' key) during serialization of Objects section of Object Model """ serialized = self._runner.serialized_model self.assertIsInstance(serialized['Objects']['?'].get('_actions'), dict) for action in serialized['Objects']['?']['_actions'].values(): self.assertIsInstance(action.get('enabled'), bool) self.assertIsInstance(action.get('name'), types.StringTypes) self.assertThat(action['name'], matchers.StartsWith('test'))
def test_generate_request_id(self): @webob.dec.wsgify def application(req): return req.environ[ENV_REQUEST_ID] app = compute_req_id.ComputeReqIdMiddleware(application) req = webob.Request.blank('/test') req_id = context.generate_request_id() req.environ[ENV_REQUEST_ID] = req_id res = req.get_response(app) res_id = res.headers.get(compute_req_id.HTTP_RESP_HEADER_REQUEST_ID) self.assertThat(res_id, matchers.StartsWith('req-')) self.assertEqual(res_id.encode('utf-8'), res.body)
def test_neutron_context_create(self): ctx = context.Context('user_id', 'tenant_id') self.assertEqual('user_id', ctx.user_id) self.assertEqual('tenant_id', ctx.project_id) self.assertEqual('tenant_id', ctx.tenant_id) request_id = ctx.request_id if isinstance(request_id, bytes): request_id = request_id.decode('utf-8') self.assertThat(request_id, matchers.StartsWith('req-')) self.assertEqual('user_id', ctx.user) self.assertEqual('tenant_id', ctx.tenant) self.assertIsNone(ctx.user_name) self.assertIsNone(ctx.tenant_name) self.assertIsNone(ctx.auth_token)
def _assert_response(self, actual_resp, expected_status_code, expected_resp_body, key='lease', expected_api_version='reservation 1.0'): res_id = actual_resp.headers.get(id.HTTP_RESP_HEADER_REQUEST_ID) api_version = actual_resp.headers.get( api_version_request.API_VERSION_REQUEST_HEADER) self.assertIn(id.HTTP_RESP_HEADER_REQUEST_ID, actual_resp.headers) self.assertIn(api_version_request.API_VERSION_REQUEST_HEADER, actual_resp.headers) self.assertIn(api_version_request.VARY_HEADER, actual_resp.headers) self.assertThat(res_id, matchers.StartsWith('req-')) self.assertEqual(expected_status_code, actual_resp.status_code) self.assertEqual(expected_resp_body, actual_resp.get_json()[key]) self.assertEqual(expected_api_version, api_version) self.assertEqual( 'OpenStack-API-Version', actual_resp.headers.get(api_version_request.VARY_HEADER))
def test_stack_trace(self): self._runner.preserve_exception = True e = self.assertRaises( dsl_exception.MuranoPlException, self._runner.testStackTrace) call_stack = e.format() self.assertThat( call_stack, matchers.StartsWith( 'exceptions.LookupError: just random Python exception')) self.assertIsInstance(e.original_exception, LookupError) filename, line = e.original_exception._position self.assertThat( call_stack, matchers.MatchesRegex( r'.*^ File \".*ExceptionHandling\.yaml\", ' r'line \d+:\d+ in method testStackTrace .*' r'of class ExceptionHandling$.*' r'^ File \".*{0}\", line {1} ' r'in method exception_func$.*'.format(filename, line), re.MULTILINE | re.DOTALL))
def assert_starts_with(self, expected_prefix, observed_str, msg=None): self.assertThat(observed_str, matchers.StartsWith(expected_prefix), msg)
def _test_validate_exception(self, profile, expected_msg): e = self.assertRaises(q_exc.InvalidInput, self.plugin._validate_portinfo, profile) self.assertThat(str(e), matchers.StartsWith(expected_msg))
def test_untagged_version_after_rc_has_dev_version_preversion(self): self.repo.commit() self.repo.tag('1.2.3.0a1') self.repo.commit() version = packaging._get_version_from_git('1.2.3') self.assertThat(version, matchers.StartsWith('1.2.3.0a2.dev1'))