def test_call(self):
ident = self.base_identity_class()
sav_post = requests.post
requests.post = Mock()
sav_debug = ident.http_log_debug
ident.http_log_debug = True
uri = "https://%s/%s" % (utils.random_unicode(), utils.random_unicode())
sav_stdout = sys.stdout
out = StringIO.StringIO()
sys.stdout = out
utils.add_method(ident, lambda self: "", "_get_auth_endpoint")
dkv = utils.random_unicode()
data = {dkv: dkv}
jdata = json.dumps(data)
hkv = utils.random_unicode()
headers = {hkv: hkv}
for std_headers in (True, False):
expected_headers = ident._standard_headers() if std_headers else {}
expected_headers.update(headers)
for admin in (True, False):
ident.method_post(uri, data=data, headers=headers,
std_headers=std_headers, admin=admin)
requests.post.assert_called_with(uri, data=jdata,
headers=expected_headers, verify=True)
self.assertTrue(out.getvalue())
out.seek(0)
out.truncate()
out.close()
requests.post = sav_post
ident.http_log_debug = sav_debug
sys.stdout = sav_stdout
def test_queue_mgr_create_body(self):
clt = self.client
mgr = clt._manager
name = utils.random_unicode()
metadata = utils.random_unicode()
ret = mgr._create_body(name, metadata=metadata)
self.assertEqual(ret, {"metadata": metadata})
def test_claim(self):
msgs = []
num = random.randint(1, 9)
for ii in range(num):
msg_id = utils.random_unicode()
claim_id = utils.random_unicode()
age = utils.random_unicode()
body = utils.random_unicode()
ttl = utils.random_unicode()
href = "http://example.com/%s" % msg_id
info = {"href": href,
"age": age,
"body": body,
"ttl": ttl,
}
msgs.append(info)
id_ = _safe_id()
href = "http://example.com/%s" % id_
info = {"href": href,
"messages": msgs,
}
mgr = fakes.FakeQueueManager()
mgr._message_manager = fakes.FakeQueueManager()
clm = QueueClaim(manager=mgr, info=info)
self.assertEqual(clm.id, id_)
self.assertEqual(len(clm.messages), num)
def test_http_methods(self):
ident = self.base_identity_class()
ident._call = Mock()
uri = utils.random_unicode()
dkv = utils.random_unicode()
data = {dkv: dkv}
hkv = utils.random_unicode()
headers = {hkv: hkv}
std_headers = True
ident.method_get(uri, admin=False, data=data, headers=headers,
std_headers=std_headers)
ident._call.assert_called_with("GET", uri, False, data, headers,
std_headers)
ident.method_head(uri, admin=False, data=data, headers=headers,
std_headers=std_headers)
ident._call.assert_called_with("HEAD", uri, False, data, headers,
std_headers)
ident.method_post(uri, admin=False, data=data, headers=headers,
std_headers=std_headers)
ident._call.assert_called_with("POST", uri, False, data, headers,
std_headers)
ident.method_put(uri, admin=False, data=data, headers=headers,
std_headers=std_headers)
ident._call.assert_called_with("PUT", uri, False, data, headers,
std_headers)
ident.method_delete(uri, admin=False, data=data, headers=headers,
std_headers=std_headers)
ident._call.assert_called_with("DELETE", uri, False, data,
headers, std_headers)
def test_auth_with_token_rax(self):
ident = self.rax_identity_class()
mid = utils.random_unicode()
oid = utils.random_unicode()
token = utils.random_unicode()
class FakeResp(object):
info = None
def json(self):
return self.info
resp_main = FakeResp()
resp_main.info = {"access": {
"serviceCatalog": [{"a": "a", "name": "a", "type": "a"}],
"user": {"roles":
[{"tenantId": oid, "name": "object-store:default"}],
}}}
resp_obj = FakeResp()
resp_obj.info = {"access": {
"serviceCatalog": [{"b": "b", "name": "b", "type": "b"}]}}
ident._call_token_auth = Mock(side_effect=(resp_main, resp_obj))
def fake_parse(dct):
svcs = dct.get("access", {}).get("serviceCatalog", {})
pyrax.services = [svc["name"] for svc in svcs]
ident._parse_response = fake_parse
ident.auth_with_token(token, tenant_id=mid)
ident._call_token_auth.assert_called_with(token, oid, None)
self.assertTrue("a" in pyrax.services)
self.assertTrue("b" in pyrax.services)
def test_findall(self):
mgr = self.client._manager
mgr.findall = Mock()
prop = utils.random_unicode()
val = utils.random_unicode()
self.client.findall(prop=val)
mgr.findall.assert_called_once_with(prop=val)
def test_create_body_volume_defaults(self):
mgr = self.client._manager
size = random.randint(MIN_SIZE, MAX_SIZE)
name = utils.random_unicode()
snapshot_id = utils.random_unicode()
display_description = utils.random_unicode()
volume_type = utils.random_unicode()
metadata = {}
availability_zone = utils.random_unicode()
fake_body = {
"volume": {
"size": size,
"snapshot_id": snapshot_id,
"display_name": name,
"display_description": display_description,
"volume_type": volume_type,
"metadata": metadata,
"availability_zone": availability_zone,
}
}
ret = mgr._create_body(
name=name,
size=size,
volume_type=volume_type,
description=display_description,
metadata=metadata,
snapshot_id=snapshot_id,
availability_zone=availability_zone,
)
self.assertEqual(ret, fake_body)
def test_update_user(self):
for cls in self.id_classes.values():
ident = cls()
resp = fakes.FakeIdentityResponse()
resp.response_type = "users"
ident.method_put = Mock(return_value=(resp, resp.json()))
fake_name = utils.random_unicode()
fake_email = utils.random_unicode()
fake_username = utils.random_unicode()
fake_uid = utils.random_unicode()
fake_region = utils.random_unicode()
fake_enabled = random.choice((True, False))
kwargs = {"email": fake_email, "username": fake_username,
"uid": fake_uid, "enabled": fake_enabled}
if isinstance(ident, self.rax_identity_class):
kwargs["defaultRegion"] = fake_region
ident.update_user(fake_name, **kwargs)
cargs = ident.method_put.call_args
self.assertEqual(len(cargs), 2)
self.assertEqual(cargs[0], ("users/%s" % fake_name, ))
data = cargs[1]["data"]["user"]
self.assertEqual(data["enabled"], fake_enabled)
self.assertEqual(data["username"], fake_username)
self.assert_(fake_email in data.values())
if isinstance(ident, self.rax_identity_class):
self.assert_(fake_region in data.values())
def test_detach_from_instance_fail(self):
vol = self.volume
srv_id = utils.random_unicode()
att_id = utils.random_unicode()
vol.attachments = [{"server_id": srv_id, "id": att_id}]
vol._nova_volumes.delete_server_volume = Mock(side_effect=Exception("test"))
self.assertRaises(exc.VolumeDetachmentFailed, vol.detach)
def test_create_body_volume(self):
mgr = self.client._manager
size = random.randint(MIN_SIZE, MAX_SIZE)
name = utils.random_unicode()
snapshot_id = utils.random_unicode()
clone_id = utils.random_unicode()
display_description = None
volume_type = None
metadata = None
availability_zone = utils.random_unicode()
fake_body = {"volume": {
"size": size,
"snapshot_id": snapshot_id,
"source_volid": clone_id,
"display_name": name,
"display_description": "",
"volume_type": "SATA",
"metadata": {},
"availability_zone": availability_zone,
}}
ret = mgr._create_body(name=name, size=size, volume_type=volume_type,
description=display_description, metadata=metadata,
snapshot_id=snapshot_id, clone_id=clone_id,
availability_zone=availability_zone)
self.assertEqual(ret, fake_body)
def __init__(self, *args, **kwargs):
id_ = utils.random_unicode()
href = "http://example.com/%s" % id_
info = kwargs.pop("info", {"href": href})
info["name"] = utils.random_unicode()
mgr = kwargs.pop("manager", FakeQueueManager())
super(FakeQueueMessage, self).__init__(manager=mgr, info=info, *args, **kwargs)
def test_imgmgr_create_body(self):
clt = self.client
mgr = clt._manager
nm = utils.random_unicode()
meta = utils.random_unicode()
body = mgr._create_body(nm, metadata=meta)
self.assertEqual(body, {"metadata": meta})
def test_img_member_mgr_create_body(self):
img = self.image
mgr = img._member_manager
nm = utils.random_unicode()
project_id = utils.random_unicode()
ret = mgr._create_body(nm, project_id)
self.assertEqual(ret, {"member": project_id})
def test_img_update(self):
img = self.image
key = utils.random_unicode()
val = utils.random_unicode()
img.manager.update = Mock()
img.update({key: val})
img.manager.update.assert_called_once_with(img, {key: val})
def test_http_methods(self):
ident = self.base_identity_class()
ident._call = Mock()
uri = utils.random_unicode()
dkv = utils.random_unicode()
data = {dkv: dkv}
hkv = utils.random_unicode()
headers = {hkv: hkv}
std_headers = True
ident.method_get(uri, admin=False, data=data, headers=headers,
std_headers=std_headers)
ident._call.assert_called_with(requests.get, uri, False, data, headers,
std_headers)
ident.method_head(uri, admin=False, data=data, headers=headers,
std_headers=std_headers)
ident._call.assert_called_with(requests.head, uri, False, data, headers,
std_headers)
ident.method_post(uri, admin=False, data=data, headers=headers,
std_headers=std_headers)
ident._call.assert_called_with(requests.post, uri, False, data, headers,
std_headers)
ident.method_put(uri, admin=False, data=data, headers=headers,
std_headers=std_headers)
ident._call.assert_called_with(requests.put, uri, False, data, headers,
std_headers)
ident.method_delete(uri, admin=False, data=data, headers=headers,
std_headers=std_headers)
ident._call.assert_called_with(requests.delete, uri, False, data,
headers, std_headers)
def test_create_snapshot(self):
vol = self.volume
vol.manager.create_snapshot = Mock()
name = utils.random_unicode()
desc = utils.random_unicode()
vol.create_snapshot(name=name, description=desc, force=False)
vol.manager.create_snapshot.assert_called_once_with(volume=vol, name=name, description=desc, force=False)
def test_update_user(self):
ident = self.rax_identity_class()
resp = fakes.FakeIdentityResponse()
resp.response_type = "users"
ident.method_put = Mock(return_value=resp)
fake_name = utils.random_unicode()
fake_email = utils.random_unicode()
fake_username = utils.random_unicode()
fake_uid = utils.random_unicode()
fake_region = utils.random_unicode()
fake_enabled = random.choice((True, False))
ident.update_user(
fake_name,
email=fake_email,
username=fake_username,
uid=fake_uid,
defaultRegion=fake_region,
enabled=fake_enabled,
)
cargs = ident.method_put.call_args
self.assertEqual(len(cargs), 2)
self.assertEqual(cargs[0], ("users/%s" % fake_name,))
data = cargs[1]["data"]["user"]
self.assertEqual(data["enabled"], fake_enabled)
self.assertEqual(data["username"], fake_username)
self.assert_(fake_email in data.values())
self.assert_(fake_region in data.values())
def test_queue_post_message(self):
q = self.queue
q._message_manager.create = Mock()
body = utils.random_unicode()
ttl = utils.random_unicode()
q.post_message(body, ttl)
q._message_manager.create.assert_called_once_with(body, ttl)
def __init__(self, *args, **kwargs):
info = kwargs.pop("info", {"fake": "fake"})
info["name"] = utils.random_unicode()
info["id"] = utils.random_unicode()
mgr = kwargs.pop("manager", FakeImageManager())
kwargs["member_manager_class"] = FakeImageMemberManager
kwargs["tag_manager_class"] = FakeImageTagManager
super(FakeImage, self).__init__(mgr, info, *args, **kwargs)
def test_queue_id_property(self):
q = self.queue
val = utils.random_unicode()
q.name = val
self.assertEqual(q.id, val)
val = utils.random_unicode()
q.id = val
self.assertEqual(q.name, val)
def test_clt_delete_message(self):
clt = self.client
q = self.queue
msg_id = utils.random_unicode()
claim_id = utils.random_unicode()
q.delete_message = Mock()
clt.delete_message(q, msg_id, claim_id=claim_id)
q.delete_message.assert_called_once_with(msg_id, claim_id=claim_id)
def test_queue_claim_messages(self):
q = self.queue
q._claim_manager.claim = Mock()
ttl = utils.random_unicode()
grace = utils.random_unicode()
count = random.randint(1, 9)
q.claim_messages(ttl, grace, count=count)
q._claim_manager.claim.assert_called_once_with(ttl, grace, count=count)
def test_clt_post_message(self):
clt = self.client
q = self.queue
body = utils.random_unicode()
ttl = utils.random_unicode()
q.post_message = Mock()
clt.post_message(q, body, ttl)
q.post_message.assert_called_once_with(body, ttl)
def test_queue_delete_message(self):
q = self.queue
q._message_manager.delete = Mock()
msg_id = utils.random_unicode()
claim_id = utils.random_unicode()
q.delete_message(msg_id, claim_id=claim_id)
q._message_manager.delete.assert_called_once_with(msg_id,
claim_id=claim_id)
def test_volume_name_property(self):
vol = self.volume
nm = utils.random_unicode()
vol.display_name = nm
self.assertEqual(vol.name, vol.display_name)
nm = utils.random_unicode()
vol.name = nm
self.assertEqual(vol.name, vol.display_name)
def test_list_flavors(self):
clt = self.client
clt._flavor_manager.list = Mock()
limit = utils.random_unicode()
marker = utils.random_unicode()
clt.list_flavors(limit=limit, marker=marker)
clt._flavor_manager.list.assert_called_once_with(limit=limit,
marker=marker)
def test_snapshot_name_property(self):
snap = self.snapshot
nm = utils.random_unicode()
snap.display_name = nm
self.assertEqual(snap.name, snap.display_name)
nm = utils.random_unicode()
snap.name = nm
self.assertEqual(snap.name, snap.display_name)
def test_volume_description_property(self):
vol = self.volume
nm = utils.random_unicode()
vol.display_description = nm
self.assertEqual(vol.description, vol.display_description)
nm = utils.random_unicode()
vol.description = nm
self.assertEqual(vol.description, vol.display_description)
def test_snapshot_description_property(self):
snap = self.snapshot
nm = utils.random_unicode()
snap.display_description = nm
self.assertEqual(snap.description, snap.display_description)
nm = utils.random_unicode()
snap.description = nm
self.assertEqual(snap.description, snap.display_description)
def test_auth_with_token(self):
pyrax.authenticated = False
tok = utils.random_unicode()
tname = utils.random_unicode()
pyrax.auth_with_token(tok, tenant_name=tname)
self.assertTrue(pyrax.identity.authenticated)
self.assertEqual(pyrax.identity.token, tok)
self.assertEqual(pyrax.identity.tenant_name, tname)
def test_get_user_credentials(self):
ident = self.rax_identity_class()
ident.method_get = Mock()
fake_name = utils.random_unicode()
ident.get_user_credentials(fake_name)
cargs = ident.method_get.call_args
called_uri = cargs[0][0]
self.assert_("/credentials" in called_uri)
self.assert_("users/%s/" % fake_name in called_uri)
def test_delete_tenant(self):
for cls in self.id_classes.values():
ident = cls()
resp = fakes.FakeIdentityResponse()
resp.response_type = "tenant"
ident.method_delete = Mock(return_value=resp)
fake_id = utils.random_unicode()
ident.delete_tenant(fake_id)
ident.method_delete.assert_called_with("tenants/%s" % fake_id)
def test_delete_user_fail(self):
for cls in self.id_classes.values():
ident = cls()
resp = fakes.FakeIdentityResponse()
resp.response_type = "users"
resp.status_code = 404
ident.method_delete = Mock(return_value=resp)
fake_name = utils.random_unicode()
self.assertRaises(exc.UserNotFound, ident.delete_user, fake_name)
def test_img_tasks_mgr_create(self, mock_create):
clt = self.client
mgr = clt._tasks_manager
nm = utils.random_unicode()
cont = utils.random_unicode()
class FakeCF(object):
def get_container(self, cont):
return cont
class FakeRegion(object):
client = FakeCF()
api = mgr.api
rgn = api.region_name
api.identity.object_store = {rgn: FakeRegion()}
mgr.create(nm, cont=cont)
mock_create.assert_called_once_with(nm, cont=cont)
def test_enable_root_user(self):
inst = self.instance
pw = utils.random_unicode()
fake_body = {"user": {"password": pw}}
inst.manager.api.method_post = Mock(return_value=(None, fake_body))
ret = inst.enable_root_user()
call_uri = "/instances/%s/root" % inst.id
inst.manager.api.method_post.assert_called_once_with(call_uri)
self.assertEqual(ret, pw)
def test_find_user_fail(self):
ident = self.rax_identity_class()
resp = fakes.FakeIdentityResponse()
resp.response_type = "users"
resp.status_code = 404
ident.method_get = Mock(return_value=resp)
fake_uri = utils.random_unicode()
ret = ident._find_user(fake_uri)
self.assertIsNone(ret)
def __init__(self, *args, **kwargs):
info = kwargs.pop("info", {"fake": "fake"})
label = kwargs.pop("label", kwargs.pop("name", utils.random_unicode()))
info["label"] = label
super(FakeCloudNetwork, self).__init__(manager=None,
info=info,
*args,
**kwargs)
self.id = uuid.uuid4()
def test_create_database_for_instance(self):
clt = self.client
inst = self.instance
inst.create_database = Mock(return_value=["db"])
nm = utils.random_unicode()
ret = clt.create_database(inst, nm)
self.assertEqual(ret, ["db"])
inst.create_database.assert_called_once_with(nm,
character_set=None, collate=None)
def test_create_body_db(self):
mgr = self.instance._database_manager
nm = utils.random_unicode()
ret = mgr._create_body(nm, character_set="CS", collate="CO")
expected = {"databases": [
{"name": nm,
"character_set": "CS",
"collate": "CO"}]}
self.assertEqual(ret, expected)
def test_img_member_mgr_create_403(self):
img = self.image
mgr = img._member_manager
nm = utils.random_unicode()
sav = BaseManager.create
err = exc.Forbidden(403)
BaseManager.create = Mock(side_effect=err)
self.assertRaises(exc.UnsharableImage, mgr.create, nm)
BaseManager.create = sav
def test_img_member_mgr_create_other(self):
img = self.image
mgr = img._member_manager
nm = utils.random_unicode()
sav = BaseManager.create
err = exc.OverLimit(413)
BaseManager.create = Mock(side_effect=err)
self.assertRaises(exc.OverLimit, mgr.create, nm)
BaseManager.create = sav
def test_http_methods(self):
ident = self.base_identity_class()
ident._call = Mock()
uri = utils.random_unicode()
dkv = utils.random_unicode()
data = {dkv: dkv}
hkv = utils.random_unicode()
headers = {hkv: hkv}
std_headers = True
ident.method_get(uri,
admin=False,
data=data,
headers=headers,
std_headers=std_headers)
ident._call.assert_called_with(requests.get, uri, False, data, headers,
std_headers)
ident.method_head(uri,
admin=False,
data=data,
headers=headers,
std_headers=std_headers)
ident._call.assert_called_with(requests.head, uri, False, data,
headers, std_headers)
ident.method_post(uri,
admin=False,
data=data,
headers=headers,
std_headers=std_headers)
ident._call.assert_called_with(requests.post, uri, False, data,
headers, std_headers)
ident.method_put(uri,
admin=False,
data=data,
headers=headers,
std_headers=std_headers)
ident._call.assert_called_with(requests.put, uri, False, data, headers,
std_headers)
ident.method_delete(uri,
admin=False,
data=data,
headers=headers,
std_headers=std_headers)
ident._call.assert_called_with(requests.delete, uri, False, data,
headers, std_headers)
def test_update_record(self):
clt = self.client
mgr = clt._manager
dom = self.domain
nm = utils.random_unicode()
rec_id = utils.random_unicode()
rec = fakes.FakeDNSRecord(mgr, {"id": rec_id, "name": nm})
ttl = 9999
data = "0.0.0.0"
mgr._async_call = Mock(return_value=({}, {}))
uri = "/domains/%s/records" % utils.get_id(dom)
req_body = {"id": rec_id, "name": nm, "data": data, "ttl": ttl}
clt.update_record(dom, rec, data=data, ttl=ttl)
mgr._async_call.assert_called_once_with(
uri,
method="PUT",
body={"records": [req_body]},
error_class=exc.DomainRecordUpdateFailed,
has_response=False)
def test_create_fail_other(self):
clt = self.client
err = exc.BadRequest(400)
err.message = "Something strange happened."
clt._manager.create = Mock(side_effect=err)
nm = utils.random_unicode()
self.assertRaises(exc.BadRequest,
clt.create,
label=nm,
cidr=example_cidr)
def test_create_fail_cidr_malformed(self):
clt = self.client
err = exc.BadRequest(400)
err.message = "CIDR is malformed."
clt._manager.create = Mock(side_effect=err)
nm = utils.random_unicode()
self.assertRaises(exc.NetworkCIDRMalformed,
clt.create,
label=nm,
cidr=example_cidr)
def test_create_fail_cidr(self):
clt = self.client
err = exc.BadRequest(400)
err.message = "CIDR does not contain enough addresses."
clt._manager.create = Mock(side_effect=err)
nm = utils.random_unicode()
self.assertRaises(exc.NetworkCIDRInvalid,
clt.create,
label=nm,
cidr=example_cidr)
def test_get_name(self):
nm = utils.random_unicode()
class ObjWithName(object):
name = nm
obj = ObjWithName()
self.assertEqual(utils.get_name(obj), nm)
self.assertEqual(utils.get_name(obj.name), nm)
self.assertRaises(exc.MissingName, utils.get_name, object())
def test_update_tenant(self):
for cls in self.id_classes.values():
ident = cls()
resp = fakes.FakeIdentityResponse()
resp.response_type = "tenant"
ident.method_put = Mock(return_value=resp)
fake_id = utils.random_unicode()
fake_name = utils.random_unicode()
fake_desc = utils.random_unicode()
tenant = ident.update_tenant(fake_id,
name=fake_name,
description=fake_desc)
self.assert_(isinstance(tenant, base_identity.Tenant))
cargs = ident.method_put.call_args
self.assertEqual(len(cargs), 2)
self.assertEqual(cargs[0], ("tenants/%s" % fake_id, ))
data = cargs[1]["data"]["tenant"]
self.assertEqual(data["name"], fake_name)
self.assertEqual(data["description"], fake_desc)
def test_queue_msg_mgr_no_limit_or_body(self):
q = self.queue
mgr = q._message_manager
include_claimed = random.choice((True, False))
echo = random.choice((True, False))
marker = utils.random_unicode()
pyrax.queueing._parse_marker = Mock(return_value="fake")
mgr._list = Mock(return_value=(None, None))
msgs = mgr.list(include_claimed=include_claimed, echo=echo,
marker=marker)
class FakeStatusChanger(object):
check_count = 0
id = utils.random_unicode()
@property
def status(self):
if self.check_count < 2:
self.check_count += 1
return "changing"
return "ready"
def test_iter_items_next_fetch(self):
clt = self.client
mgr = clt._manager
fake_name = utils.random_unicode()
ret_body = {"domains": [{"name": fake_name}]}
clt.method_get = Mock(return_value=({}, ret_body))
res_iter = DomainResultsIterator(mgr)
res_iter.next_uri = example_uri
ret = res_iter.next()
self.assertTrue(isinstance(ret, CloudDNSDomain))
def test_create_body_snapshot(self):
mgr = self.client._snapshot_manager
vol = self.volume
name = utils.random_unicode()
display_description = utils.random_unicode()
force = True
fake_body = {
"snapshot": {
"display_name": name,
"display_description": display_description,
"volume_id": vol.id,
"force": str(force).lower(),
}
}
ret = mgr._create_body(name=name,
description=display_description,
volume=vol,
force=force)
self.assertEqual(ret, fake_body)
def test_create_body_user(self):
inst = self.instance
mgr = inst._user_manager
nm = utils.random_unicode()
pw = utils.random_unicode()
dbnames = [utils.random_unicode(), utils.random_unicode()]
ret = mgr._create_body(nm, password=pw, database_names=dbnames)
expected = {
"users": [{
"name": nm,
"password": pw,
"databases": [{
"name": dbnames[0]
}, {
"name": dbnames[1]
}]
}]
}
self.assertEqual(ret, expected)
def test_request_content_type_header(self, mock_req):
clt = self.client
clt.http_log_debug = False
clt.timeout = utils.random_unicode()
fakeresp = fakes.FakeResponse()
fakeresp.status_code = 200
body_content = {"one": 2, "three": 4}
body = "text"
headers = {"Content-Type": None}
fake_uri = utils.random_unicode()
fake_method = utils.random_unicode()
mock_req.return_value = (fakeresp, body_content)
resp, body = clt.request(fake_uri,
fake_method,
body=body,
headers=headers)
self.assertTrue(isinstance(resp, fakes.FakeResponse))
self.assertEqual(resp.status_code, 200)
self.assertEqual(body, body_content)
def test_msg_add_details(self):
id_ = _safe_id()
claim_id = utils.random_unicode()
age = utils.random_unicode()
body = utils.random_unicode()
ttl = utils.random_unicode()
href = "http://example.com/%s" % id_
info = {"href": href,
"age": age,
"body": body,
"ttl": ttl,
}
msg = QueueMessage(manager=None, info=info)
self.assertEqual(msg.id, id_)
self.assertIsNone(msg.claim_id)
self.assertEqual(msg.age, age)
self.assertEqual(msg.body, body)
self.assertEqual(msg.ttl, ttl)
self.assertEqual(msg.href, href)
def test_create_fail_count(self):
clt = self.client
err = exc.BadRequest(400)
err.message = "Request failed: too many networks."
clt._manager.create = Mock(side_effect=err)
nm = utils.random_unicode()
self.assertRaises(exc.NetworkCountExceeded,
clt.create,
label=nm,
cidr=example_cidr)
def test_request_empty_body(self):
clt = self.client
clt.http_log_debug = False
fakeresp = fakes.FakeResponse()
fakeresp.status_code = 400
body_content = {"one": 2, "three": 4}
fakebody = json.dumps(body_content)
sav = pyrax.http.request
fakebody = ""
fake_uri = utils.random_unicode()
fake_method = utils.random_unicode()
pyrax.http.request = Mock(return_value=(fakeresp, fakebody))
savexc = exc.from_response
exc.from_response = Mock(side_effect=fakes.FakeException)
self.assertRaises(fakes.FakeException, clt.request, fake_uri,
fake_method)
exc.from_response.assert_called_once_with(fakeresp, "")
exc.from_response = savexc
pyrax.http.request = sav
def test_resize(self):
inst = self.instance
flavor_ref = utils.random_unicode()
inst.manager.api._get_flavor_ref = Mock(return_value=flavor_ref)
fake_body = {"flavorRef": flavor_ref}
inst.manager.action = Mock()
ret = inst.resize(42)
call_uri = "/instances/%s/action" % inst.id
inst.manager.action.assert_called_once_with(inst, "resize",
body=fake_body)
def test_http_log_req(self):
args = ("a", "b")
kwargs = {"headers": {"c": "C"}}
mthd = utils.random_unicode()
uri = utils.random_unicode()
sav_pdbug = pyrax._http_debug
pyrax._http_debug = False
self.assertIsNone(self.http.http_log_req(mthd, uri, args, kwargs))
pyrax._http_debug = True
sav_pldbug = pyrax._logger.debug
pyrax._logger.debug = Mock()
self.http.http_log_req(mthd, uri, args, kwargs)
pyrax._logger.debug.assert_called_once_with(
"\nREQ: curl -i -X %s a b -H 'c: C' %s\n" % (mthd, uri))
kwargs["body"] = "text"
self.http.http_log_req(mthd, uri, args, kwargs)
cargs, ckw = pyrax._logger.debug.call_args
self.assertEqual(cargs, ("REQ BODY: text\n", ))
pyrax._logger.debug = sav_pldbug
pyrax._http_debug = sav_pdbug
def test_queue_mgr_create(self):
clt = self.client
mgr = clt._manager
name = utils.random_unicode()
exp_uri = "/%s/%s" % (mgr.uri_base, name)
resp = fakes.FakeResponse()
resp.status_code = 201
mgr.api.method_put = Mock(return_value=(resp, None))
q = mgr.create(name)
self.assertTrue(isinstance(q, Queue))
self.assertEqual(q.name, name)
