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)
