Python utils.random_unicode函数代码示例

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