def test_create_with_generic_exception(self): responders = [{ 'Fastly': { 'id': str(uuid.uuid4()), 'links': [{ 'domain': u'blog.mocksite.com', 'href': u'blog.mocksite.com.global.prod.fastly.net', 'rel': 'access_url' }, { 'domain': u'test.mocksite.com', 'href': u'test.mocksite.com.global.prod.fastly.net', 'rel': 'access_url' }] } }] subdomain = mock.Mock() subdomain.add_records = mock.Mock( side_effect=exc.NotFound('Subdomain not found')) self.client.find = mock.Mock(return_value=subdomain) dns_details = self.controller.create(responders) for responder in responders: for provider_name in responder: self.assertIsNotNone(dns_details[provider_name]['error']) self.assertIsNotNone( dns_details[provider_name]['error_detail'])
def test_create_with_subdomain_not_found_exception(self): domain_names = [u'blog.mocksite.com', u'test.mocksite.com'] responders = [{ 'Fastly': { 'id': str(uuid.uuid4()), 'links': [{ 'domain': u'blog.mocksite.com', 'href': u'blog.mocksite.com.global.prod.fastly.net', 'rel': 'access_url' }, { 'domain': u'test.mocksite.com', 'href': u'test.mocksite.com.global.prod.fastly.net', 'rel': 'access_url' }] } }] self.client.find = mock.Mock( side_effect=exc.NotFound('Subdomain not found')) dns_details = self.controller.create(responders) access_urls_map = {} for provider_name in dns_details: access_urls_map[provider_name] = {} access_urls_list = dns_details[provider_name]['access_urls'] for access_urls in access_urls_list: access_urls_map[provider_name][access_urls['domain']] = ( access_urls['operator_url']) for responder in responders: for provider_name in responder: for domain_name in domain_names: self.assertIsNotNone( access_urls_map[provider_name][domain_name])
def test_delete_with_exception_subdomain_not_found(self): akamai_access_urls = [{ u'provider_url': u'mycdn.com.v2.mdc.edgesuite.net', u'domain': u'mocksite.com', u'operator_url': u'mocksite.com.cdn80.mycdn.com' }] fastly_access_urls = [{ u'provider_url': u'mocksite.com.global.fastly.net', u'domain': u'mocksite.com', u'operator_url': u'mocksite.cdn80.mycdn.com' }] akamai_details = mock.Mock() akamai_details.access_urls = akamai_access_urls fastly_details = mock.Mock() fastly_details.access_urls = fastly_access_urls provider_details = {'Akamai': akamai_details, 'Fastly': fastly_details} self.client.find = mock.Mock( side_effect=exc.NotFound('Subdomain not found')) dns_responder = self.controller.delete(provider_details) for provider_name in provider_details: self.assertIsNotNone(dns_responder[provider_name]['error']) self.assertIsNotNone(dns_responder[provider_name]['error_detail']) self.assertIsNotNone(dns_responder[provider_name]['error_class'])
def test_delete_with_delete_exception(self): akamai_access_urls = [{ u'provider_url': u'mycdn.com.v2.mdc.edgesuite.net', u'domain': u'mocksite.com', u'operator_url': u'mocksite.com.cdn80.mycdn.com' }] fastly_access_urls = [{ u'provider_url': u'mocksite.com.global.fastly.net', u'domain': u'mocksite.com', u'operator_url': u'mocksite.cdn80.mycdn.com' }] akamai_details = mock.Mock() akamai_details.access_urls = akamai_access_urls fastly_details = mock.Mock() fastly_details.access_urls = fastly_access_urls provider_details = {'Akamai': akamai_details, 'Fastly': fastly_details} subdomain = mock.Mock() subdomain.add_records = mock.Mock() self.client.find = mock.Mock(return_value=subdomain) record = mock.Mock() record.delete = mock.Mock( side_effect=exc.NotFound('Generic exception')) self.client.search_records = mock.Mock(return_value=[record]) dns_responder = self.controller.delete(provider_details) for provider_name in provider_details: self.assertIsNotNone(dns_responder[provider_name]['error']) self.assertIsNotNone(dns_responder[provider_name]['error_detail']) self.assertIsNotNone(dns_responder[provider_name]['error_class'])
def test_clt_queue_not_exists(self): clt = self.client clt._manager.head = Mock(side_effect=exc.NotFound("")) name = utils.random_unicode() ret = clt.queue_exists(name) self.assertFalse(ret) clt._manager.head.assert_called_once_with(name)
def test_list_user_access_not_found(self): inst = self.instance mgr = inst._user_manager mgr.api.method_get = Mock(side_effect=exc.NotFound("")) username = utils.random_unicode() user = fakes.FakeDatabaseUser(mgr, info={"name": username}) self.assertRaises(exc.NoSuchDatabaseUser, mgr.list_user_access, user)
def test_base_list(self): clt = self.client mgr = clt._manager mgr.api.method_get = Mock(side_effect=exc.NotFound("")) uri = utils.random_unicode() ret = mgr.list(uri) self.assertEqual(ret, [])
def get(self, id_): """ Need to customize, since Queues are not returned with normal response bodies. """ if self.api.queue_exists(id_): return Queue(self, {"queue": {"name": id_, "id_": id_}}, key="queue") raise exc.NotFound("The queue '%s' does not exist." % id_)
def test_grant_user_access_not_found(self): inst = self.instance mgr = inst._user_manager mgr.api.method_put = Mock(side_effect=exc.NotFound("")) username = utils.random_unicode() user = fakes.FakeDatabaseUser(mgr, info={"name": username}) db_names = utils.random_unicode() mgr._get_db_names = Mock(return_value=[]) self.assertRaises(exc.NoSuchDatabaseUser, mgr.grant_user_access, user, db_names)
def test_pickle(self): error = exc.NotFound(42, 'message', 'details', 0xDEADBEEF) pickled_error = pickle.dumps(error, -1) unpickled_error = pickle.loads(pickled_error) self.assertIsInstance(unpickled_error, exc.NotFound) self.assertEqual(unpickled_error.code, 42) self.assertEqual(unpickled_error.message, 'message') self.assertEqual(unpickled_error.details, 'details') self.assertEqual(unpickled_error.request_id, 0xDEADBEEF)
def test_update_remove_domains_with_subdomain_not_found_exception(self): subdomain = mock.Mock() subdomain.add_records = mock.Mock() client = mock.Mock() client.find = mock.Mock( side_effect=exc.NotFound('Subdomain not found')) records = [mock.Mock(), mock.Mock()] client.search_records = mock.Mock(return_value=records) self.controller.client = client domains_new = [ domain.Domain('test.domain.com'), domain.Domain('blog.domain.com') ] service_updates = service.Service( service_id=self.service_old.service_id, name='myservice', domains=domains_new, origins=[], flavor_id='standard') responders = [{ 'Fastly': { 'id': str(uuid.uuid4()), 'links': [{ 'domain': u'blog.domain.com', 'href': u'blog.domain.com.global.prod.fastly.net', 'rel': 'access_url' }, { 'domain': u'test.domain.com', 'href': u'test.domain.com.global.prod.fastly.net', 'rel': 'access_url' }] } }] dns_details = self.controller.update(self.service_old, service_updates, responders) access_urls_map = {} for provider_name in dns_details: access_urls_map[provider_name] = {} access_urls_list = dns_details[provider_name]['access_urls'] for access_urls in access_urls_list: if 'operator_url' in access_urls: access_urls_map[provider_name][access_urls['domain']] = ( access_urls['operator_url']) for responder in responders: for provider_name in responder: for domain_new in domains_new: self.assertIsNotNone( access_urls_map[provider_name][domain_new.domain])
def test_assure_domain_name(self): @assure_domain def test(self, domain): return domain clt = self.client dom = self.domain clt._manager._get = Mock(side_effect=exc.NotFound("")) clt._manager._list = Mock(return_value=[dom]) d3 = test(clt, dom.name) self.assertEqual(d3, dom) self.assertTrue(isinstance(d3, CloudDNSDomain))
def test_list_ptr_records_not_found(self): clt = self.client mgr = clt._manager dvc = fakes.FakeDNSDevice() href = "%s/%s" % (example_uri, dvc.id) svc_name = "cloudServersOpenStack" uri = "/rdns/%s?href=%s" % (svc_name, href) mgr._get_ptr_details = Mock(return_value=(href, svc_name)) clt.method_get = Mock(side_effect=exc.NotFound("")) ret = clt.list_ptr_records(dvc) clt.method_get.assert_called_once_with(uri) self.assertEqual(ret, [])
def test_imgmgr_update_member_not_found(self): clt = self.client mgr = clt._manager img = self.image status = random.choice(("pending", "accepted", "rejected")) project_id = utils.random_unicode() clt.identity.tenant_id = project_id exp_uri = "/%s/%s/members/%s" % (mgr.uri_base, img.id, project_id) exp_body = {"status": status} mgr.api.method_put = Mock(side_effect=exc.NotFound("")) self.assertRaises(exc.InvalidImageMember, mgr.update_image_member, img.id, status)
def test_get_flavor_ref_not_found(self): clt = self.client info = {"id": 1, "name": "test_flavor", "ram": 42, "links": [{ "href": example_uri, "rel": "self"}]} flavor_obj = CloudDatabaseFlavor(clt._manager, info) clt.get_flavor = Mock(side_effect=exc.NotFound("")) clt.list_flavors = Mock(return_value=[flavor_obj]) self.assertRaises(exc.FlavorNotFound, clt._get_flavor_ref, "nonsense")
def test_get_flavor_ref_for_ram(self): clt = self.client info = {"id": 1, "name": "test_flavor", "ram": 42, "links": [{ "href": example_uri, "rel": "self"}]} flavor_obj = CloudDatabaseFlavor(clt._manager, info) clt.get_flavor = Mock(side_effect=exc.NotFound("")) clt.list_flavors = Mock(return_value=[flavor_obj]) ret = clt._get_flavor_ref(42) self.assertEqual(ret, example_uri)
def find(self, **kwargs): """ Finds a single item with attributes matching ``**kwargs``. This isn't very efficient: it loads the entire list then filters on the Python side. """ matches = self.findall(**kwargs) num_matches = len(matches) if not num_matches: msg = "No %s matching: %s." % (self.resource_class.__name__, kwargs) raise exc.NotFound(404, msg) if num_matches > 1: msg = "More than one %s matching: %s." % ( self.resource_class.__name__, kwargs) raise exc.NoUniqueMatch(400, msg) else: return matches[0]
def test_is_shard_full_shard_not_found(self): self.client.find.side_effect = exc.NotFound(404) self.assertTrue(self.controller.is_shard_full('shard_name'))
def db_flavor_get_by_name(name): for flavor in _db_flavor_list(): if flavor.name == name: return _db_flavor_to_dict(flavor) error = u'Database flavor {0} not found.'.format(name) raise exc.NotFound(error)
def test_get_user_fail(self): inst = self.instance bad_name = utils.random_unicode() inst._user_manager.get = Mock(side_effect=exc.NotFound("")) self.assertRaises(exc.NoSuchDatabaseUser, inst.get_user, bad_name)