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_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)