def test_one_container(self): """ tests to ensure behavior is normal with one container """ # setup expectation swift_stub = SwiftClientStub() swift_stub.with_account('123223') cont_name = 'a-container-name' swift_stub.with_container(cont_name) # interact conn = swiftclient.client.Connection() conn.get_auth() conn.put_container(cont_name) # get headers plus container metadata self.assertThat(len(conn.get_account()), matchers.Is(2)) # verify container details account_containers = conn.get_account()[1] self.assertThat(len(account_containers), matchers.Is(1)) self.assertThat(account_containers[0], matchers.KeysEqual('count', 'bytes', 'name')) self.assertThat(account_containers[0]['name'], matchers.Is(cont_name)) # get container details cont_info = conn.get_container(cont_name) self.assertIsNotNone(cont_info) self.assertThat(cont_info[0], matchers.KeysEqual('content-length', 'x-container-object-count', 'accept-ranges', 'x-container-bytes-used', 'x-timestamp', 'x-trans-id', 'date', 'content-type')) self.assertThat(len(cont_info[1]), matchers.Equals(0)) # remove container swift_stub.without_container(cont_name) with testtools.ExpectedException(swiftclient.ClientException): conn.get_container(cont_name) # ensure there are no more containers in account self.assertThat(len(conn.get_account()[1]), matchers.Is(0))
def test_non_verbose(self): stdout = io.StringIO() root = self.useFixture(fixtures.TempDir()).path proj = {'root': root} actions = [project.Verbose(u'fred')] project.write(proj, actions, stdout, False) self.expectThat(stdout.getvalue(), matchers.Equals(''))
def match(self, actual): response_data = actual.json if u"links" in response_data: del response_data[u"links"] return matchers.Equals(self.expected_data).match(response_data)
def test_prepare_request_body(self): body = { 'fake': { 'name': 'terminator', 'model': 'T-800', } } params = [ { 'param-name': 'name', 'required': True }, { 'param-name': 'model', 'required': True }, { 'param-name': 'quote', 'required': False, 'default-value': "i'll be back" }, ] expect = { 'fake': { 'name': 'terminator', 'model': 'T-800', 'quote': "i'll be back", } } actual = self.controller._prepare_request_body(body, params) self.assertThat(expect, matchers.Equals(actual))
def test_translate_urls(self): href_rel = self.getUniqueString() href = self.getUniqueString() href_template_rel = self.getUniqueString() href_template = self.getUniqueString() href_vars = {self.getUniqueString(): self.getUniqueString()} original_json_home = { 'resources': { href_rel: { 'href': href }, href_template_rel: { 'href-template': href_template, 'href-vars': href_vars } } } new_json_home = copy.deepcopy(original_json_home) new_prefix = self.getUniqueString() json_home.translate_urls(new_json_home, new_prefix) exp_json_home = { 'resources': { href_rel: { 'href': new_prefix + href }, href_template_rel: { 'href-template': new_prefix + href_template, 'href-vars': href_vars } } } self.assertThat(new_json_home, matchers.Equals(exp_json_home))
def test_list_projects_search_compat_v3(self): project_data = self._get_project_data( description=self.getUniqueString('projectDesc')) self.register_uris([ dict(method='GET', uri=self.get_mock_url(resource=('projects?domain_id=%s' % project_data.domain_id)), status_code=200, json={'projects': [project_data.json_response['project']]}) ]) projects = self.op_cloud.search_projects( domain_id=project_data.domain_id) self.assertThat(len(projects), matchers.Equals(1)) self.assertThat(projects[0].id, matchers.Equals(project_data.project_id)) self.assert_calls()
def test_suffix(self, mock_isdir): def check_params(root, source, suffix, softupdate, hacking, stdout, verbose, non_std_reqs): self.expectThat(suffix, matchers.Equals('global')) update.main(['-o', 'global', '/dev/zero'], _worker=check_params) self.expectThat(mock_isdir.called, matchers.Equals(True))
def test_build_v3_parameter_relation(self): parameter_name = self.getUniqueString() relation = json_home.build_v3_parameter_relation(parameter_name) exp_relation = ( 'http://docs.openstack.org/api/openstack-identity/3/param/%s' % parameter_name) self.assertThat(relation, matchers.Equals(exp_relation))
def test_json_home_v3(self): # If the request is /v3 and the Accept header is application/json-home # then the server responds with a JSON Home document. client = self.client(self.public_app) resp = client.get('/v3/', headers={'Accept': 'application/json-home'}) self.assertThat(resp.status, tt_matchers.Equals('200 OK')) self.assertThat(resp.headers['Content-Type'], tt_matchers.Equals('application/json-home')) exp_json_home_data = { 'resources': V3_JSON_HOME_RESOURCES_INHERIT_ENABLED} self.assertThat(jsonutils.loads(resp.body), tt_matchers.Equals(exp_json_home_data))
def test_create_client_removes_url_path_if_version_specified(self): # If specifying a version on the client creation call, ensure # the auth_url is versionless and the version required is passed # into the Client() call. self.set_up_keystone_mocks() auth_kwargs, all_kwargs = self.make_auth_args() credential = objects.Credential("http://auth_url/v2.0", "user", "pass", "tenant") keystone = osclients.Keystone(credential, {}, mock.MagicMock()) client = keystone.create_client(version="3") self.assertIs(client, self.ksc_client.Client()) called_with = self.ksc_client.Client.call_args_list[0][1] self.expectThat(called_with["auth_url"], matchers.Equals("http://auth_url/")) self.expectThat(called_with["version"], matchers.Equals("3"))
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_ordering(self): ordered_versions = [ "1.2.3.dev6", "1.2.3.dev7", "1.2.3.a4.dev12", "1.2.3.a4.dev13", "1.2.3.a4", "1.2.3.a5.dev1", "1.2.3.a5", "1.2.3.b3.dev1", "1.2.3.b3", "1.2.3.rc2.dev1", "1.2.3.rc2", "1.2.3.rc3.dev1", "1.2.3", "1.2.4", "1.3.3", "2.2.3", ] for v in ordered_versions: sv = version.SemanticVersion.from_pip_string(v) self.expectThat(sv, matchers.Equals(sv)) for left, right in itertools.combinations(ordered_versions, 2): l_pos = ordered_versions.index(left) r_pos = ordered_versions.index(right) if l_pos < r_pos: m1 = matchers.LessThan m2 = matchers.GreaterThan else: m1 = matchers.GreaterThan m2 = matchers.LessThan left_sv = version.SemanticVersion.from_pip_string(left) right_sv = version.SemanticVersion.from_pip_string(right) self.expectThat(left_sv, m1(right_sv)) self.expectThat(right_sv, m2(left_sv))
def test_find_unique_file_name(self): tmp_delta = deltas.BaseDeltasGenerator( source_path=self.source_file, target_path=self.target_file, delta_format='xdelta3', delta_tool_path=self.delta_tool_path) unique_file_name = tmp_delta.find_unique_file_name( tmp_delta.source_path) self.assertThat(unique_file_name, m.Equals(tmp_delta.source_path + '-0')) with open(unique_file_name, 'wb') as f: f.write(b'tmp file.') self.assertThat(tmp_delta.find_unique_file_name(tmp_delta.source_path), m.Equals(tmp_delta.source_path + '-1'))
def test_set_and_get_queue_metadata(self): # Retrieve random queue queue_name = self.queues[data_utils.rand_int_id( 0, len(self.queues) - 1)] # Check the Queue has no metadata resp, body = self.get_queue_metadata(queue_name) self.assertEqual('200', resp['status']) self.assertThat(body, matchers.HasLength(0)) # Create metadata key3 = [0, 1, 2, 3, 4] key2 = data_utils.rand_name('value') req_body1 = dict() req_body1[data_utils.rand_name('key3')] = key3 req_body1[data_utils.rand_name('key2')] = key2 req_body = dict() req_body[data_utils.rand_name('key1')] = req_body1 # Set Queue Metadata resp, body = self.set_queue_metadata(queue_name, req_body) self.assertEqual('204', resp['status']) self.assertEqual('', body) # Get Queue Metadata resp, body = self.get_queue_metadata(queue_name) self.assertEqual('200', resp['status']) self.assertThat(body, matchers.Equals(req_body))
def test_create_role(self): role_data = self._get_role_data() self.register_uris([ dict(method='POST', uri=self.get_mock_url(), status_code=200, json=role_data.json_response, validate=dict(json=role_data.json_request)) ]) role = self.cloud.create_role(role_data.role_name) self.assertIsNotNone(role) self.assertThat(role.name, matchers.Equals(role_data.role_name)) self.assertThat(role.id, matchers.Equals(role_data.role_id)) self.assert_calls()
def test_build_v3_resource_relation(self): resource_name = self.getUniqueString() relation = json_home.build_v3_resource_relation(resource_name) exp_relation = ( 'http://docs.openstack.org/api/openstack-identity/3/rel/%s' % resource_name) self.assertThat(relation, matchers.Equals(exp_relation))
def test_stdout(self): stdout = io.StringIO() root = self.useFixture(fixtures.TempDir()).path proj = {'root': root} actions = [project.StdOut(u'fred\n')] project.write(proj, actions, stdout, True) self.expectThat(stdout.getvalue(), matchers.Equals('fred\n'))
def test_json_examples_have_matching_entries(self): # TODO(lbragstad): Once all policies have been removed from # policy.v3cloudsample.json, remove this test. removed_policies = [ 'identity:create_credential', 'identity:get_credential', 'identity:list_credentials', 'identity:update_credential', 'identity:delete_credential', 'identity:create_registered_limits', 'identity:get_registered_limit', 'identity:list_registered_limits', 'identity:update_registered_limit', 'identity:delete_registered_limit' ] policy_keys = self._get_default_policy_rules() for p in removed_policies: del policy_keys[p] cloud_policy_keys = set( json.load(open(unit.dirs.etc('policy.v3cloudsample.json')))) policy_extra_keys = [ 'admin_or_token_subject', 'service_admin_or_token_subject', 'token_subject', ] expected_policy_keys = list(cloud_policy_keys) + policy_extra_keys diffs = set(policy_keys).difference(set(expected_policy_keys)) self.assertThat(diffs, matchers.Equals(set()))
def test_two_objects(self): with SwiftClientStub() as swift_stub: swift_stub.with_account('123223') swift_stub.with_container('bob') swift_stub.with_container('bob2') swift_stub.with_object('bob', 'test', 'test_contents') swift_stub.with_object('bob', 'test2', 'test_contents2') conn = swiftclient.client.Connection() self.assertIs(len(conn.get_account()), 2) cont_info = conn.get_container('bob') self.assertIsNotNone(cont_info) self.assertThat( cont_info[0], matchers.KeysEqual('content-length', 'x-container-object-count', 'accept-ranges', 'x-container-bytes-used', 'x-timestamp', 'x-trans-id', 'date', 'content-type')) self.assertThat(len(cont_info[1]), matchers.Equals(2)) self.assertThat( cont_info[1][0], matchers.Equals({ 'bytes': 13, 'last_modified': '2013-03-15T22:10:49.361950', 'hash': 'ccc55aefbf92aa66f42b638802c5e7f6', 'name': 'test', 'content_type': 'application/octet-stream', 'contents': 'test_contents' })) self.assertThat( conn.get_object('bob', 'test')[1], matchers.Is('test_contents')) self.assertThat( conn.get_object('bob', 'test2')[1], matchers.Is('test_contents2')) swift_stub.without_object('bob', 'test') with ExpectedException(swiftclient.ClientException): conn.delete_object('bob', 'test') self.assertThat(len(conn.get_container('bob')[1]), matchers.Is(1)) swift_stub.without_container('bob') with ExpectedException(swiftclient.ClientException): conn.get_container('bob') self.assertThat(len(conn.get_account()), matchers.Is(2))
def test_list_services(self): service_data = self._get_service_data() self.register_uris([ dict(method='GET', uri=self.get_mock_url(), status_code=200, json={'services': [service_data.json_response_v3['service']]}) ]) services = self.cloud.list_services() self.assertThat(len(services), matchers.Equals(1)) self.assertThat(services[0].id, matchers.Equals(service_data.service_id)) self.assertThat(services[0].name, matchers.Equals(service_data.service_name)) self.assertThat(services[0].type, matchers.Equals(service_data.service_type)) self.assert_calls()
def test_json_examples_have_matching_entries(self): policy_keys = self._load_entries(tests.dirs.etc('policy.json')) cloud_policy_keys = self._load_entries( tests.dirs.etc('policy.v3cloudsample.json')) diffs = set(policy_keys).difference(set(cloud_policy_keys)) self.assertThat(diffs, matchers.Equals(set()))
def test_cms_hash_token_default_md5(self): """The default hash method is md5.""" token = self.examples.SIGNED_TOKEN_SCOPED token_id_default = cms.cms_hash_token(token) token_id_md5 = cms.cms_hash_token(token, mode='md5') self.assertThat(token_id_default, matchers.Equals(token_id_md5)) # md5 hash is 32 chars. self.assertThat(token_id_default, matchers.HasLength(32))
def make_request(accept_types=None): client = TestClient(self.public_app) headers = None if accept_types: headers = {'Accept': accept_types} resp = client.get('/v3', headers=headers) self.assertThat(resp.status, tt_matchers.Equals('200 OK')) return resp.headers['Content-Type']
def test_create_domain(self): domain_data = self._get_domain_data(description=uuid.uuid4().hex, enabled=True) self.register_uris([ dict(method='POST', uri=self.get_mock_url(), status_code=200, json=domain_data.json_response, validate=dict(json=domain_data.json_request)) ]) domain = self.cloud.create_domain(domain_data.domain_name, domain_data.description) self.assertThat(domain.id, matchers.Equals(domain_data.domain_id)) self.assertThat(domain.name, matchers.Equals(domain_data.domain_name)) self.assertThat(domain.description, matchers.Equals(domain_data.description)) self.assert_calls()
def test_create_project_v2(self): self.use_keystone_v2() project_data = self._get_project_data(v3=False) self.register_uris([ dict(method='POST', uri=self.get_mock_url(v3=False), status_code=200, json=project_data.json_response, validate=dict(json=project_data.json_request)) ]) project = self.op_cloud.create_project( name=project_data.project_name, description=project_data.description) self.assertThat(project.id, matchers.Equals(project_data.project_id)) self.assertThat(project.name, matchers.Equals(project_data.project_name)) self.assert_calls()
def test_parse_single_host_new_format(self): """Test parse_host_config with single host new format """ hosts = '192.168.1.10:1234' ret = self.parse_config_test_run(hosts, OVERRIDE_PORT) self.assertIsInstance(ret, tuple) self.assertThat(ret, matchers.Equals( (('192.168.1.10', 1234),) ))
def test_errors(self): stdout = io.StringIO() root = self.useFixture(fixtures.TempDir()).path proj = {'root': root} actions = [project.Error(u'fred')] with testtools.ExpectedException(Exception): project.write(proj, actions, stdout, True) self.expectThat(stdout.getvalue(), matchers.Equals('fred\n'))
def test_logging_options_kept(self): argv = ["-v", "--log-level", "debug", "import"] with mock.patch( 'git_upstream.commands.GitUpstreamCommand.run') as mock_import: main.main(argv) self.assertThat(mock_import.call_args[0][0].script_cmdline[2:], matchers.Equals(argv[:3]))
def test_use_auto_detect_cores(self, mockCpu_count): @concurrent def parallel_test(): return True result = parallel_test(concurrent=[{} for _ in range(10)], n_workers=0) self.assertThat(result, matchers.Equals([True for _ in range(10)])) mockCpu_count.assert_called_once_with()
def test_update_domain(self): domain_data = self._get_domain_data( description=self.getUniqueString('domainDesc')) domain_resource_uri = self.get_mock_url(append=[domain_data.domain_id]) self.register_uris([ dict(method='PATCH', uri=domain_resource_uri, status_code=200, json=domain_data.json_response, validate=dict(json=domain_data.json_request))]) domain = self.cloud.update_domain( domain_data.domain_id, name=domain_data.domain_name, description=domain_data.description) self.assertThat(domain.id, matchers.Equals(domain_data.domain_id)) self.assertThat(domain.name, matchers.Equals(domain_data.domain_name)) self.assertThat( domain.description, matchers.Equals(domain_data.description)) self.assert_calls()