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_name()
fake_email = utils.random_name()
fake_username = utils.random_name()
fake_uid = utils.random_name()
fake_region = utils.random_name()
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_http_methods(self):
ident = self.base_identity_class()
ident._call = Mock()
uri = utils.random_name()
dkv = utils.random_name()
data = {dkv: dkv}
hkv = utils.random_name()
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_manager_list_all(self):
clt = self.client
mgr = clt._manager
fake_name = utils.random_name()
ret_body = {"domains": [{"name": fake_name}]}
uri_string_next = utils.random_name()
next_uri = "%s/domains/%s" % (example_uri, uri_string_next)
mgr.count = 0
def mock_get(uri):
if mgr.count:
return ({}, ret_body)
mgr.count += 1
ret = {
"totalEntries": 2,
"links": [{
"href": next_uri,
"rel": "next"
}]
}
ret.update(ret_body)
return ({}, ret)
clt.method_get = Mock(wraps=mock_get)
ret = mgr._list(example_uri, list_all=True)
self.assertEqual(len(ret), 2)
def test_reset_paging_body(self):
clt = self.client
mgr = clt._manager
mgr._paging["domain"]["total_entries"] = 99
mgr._paging["domain"]["next_uri"] = "FAKE"
exp_entries = random.randint(100, 200)
uri_string_next = utils.random_name()
next_uri = "%s/domains/%s" % (example_uri, uri_string_next)
uri_string_prev = utils.random_name()
prev_uri = "%s/domains/%s" % (example_uri, uri_string_prev)
body = {
"totalEntries":
exp_entries,
"links": [{
"href": next_uri,
"rel": "next"
}, {
"href": prev_uri,
"rel": "previous"
}]
}
mgr._reset_paging("domain", body=body)
self.assertEqual(mgr._paging["domain"]["total_entries"], exp_entries)
self.assertEqual(mgr._paging["domain"]["next_uri"],
"/domains/%s" % uri_string_next)
self.assertEqual(mgr._paging["domain"]["prev_uri"],
"/domains/%s" % uri_string_prev)
def test_clt_resolve_lbs_dict(self):
clt = fakes.FakeAutoScaleClient()
key = utils.random_name()
val = utils.random_name()
lb_dict = {key: val}
ret = clt._resolve_lbs(lb_dict)
self.assertEqual(ret, [lb_dict])
def __init__(self, name=None, info=None, *args, **kwargs):
name = name or utils.random_name(ascii_only=True)
info = info or {"fake": "fake"}
super(FakeLoadBalancer, self).__init__(name, info, *args, **kwargs)
self.id = utils.random_name(ascii_only=True)
self.port = random.randint(1, 256)
self.manager = FakeLoadBalancerManager()
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)
fake_name = utils.random_name()
fake_email = utils.random_name()
fake_username = utils.random_name()
fake_uid = utils.random_name()
fake_region = utils.random_name()
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_create_body_volume_defaults(self):
clt = self.client
size = random.randint(MIN_SIZE, MAX_SIZE)
name = utils.random_name()
snapshot_id = utils.random_name()
display_description = utils.random_name()
volume_type = utils.random_name()
metadata = {}
availability_zone = utils.random_name()
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 = clt._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_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_name(), utils.random_name())
sav_stdout = sys.stdout
out = StringIO.StringIO()
sys.stdout = out
utils.add_method(ident, lambda self: "", "_get_auth_endpoint")
dkv = utils.random_name()
data = {dkv: dkv}
jdata = json.dumps(data)
hkv = utils.random_name()
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_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)
fake_name = utils.random_name()
fake_email = utils.random_name()
fake_username = utils.random_name()
fake_uid = utils.random_name()
fake_region = utils.random_name()
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_auth_with_token_rax(self):
ident = self.rax_identity_class()
mid = utils.random_name()
oid = utils.random_name()
token = utils.random_name()
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_create_body_user(self):
clt = self.client
nm = utils.random_name()
pw = utils.random_name()
ret = clt._create_body(nm, password=pw, database_names=[])
expected = {"users": [{"name": nm, "password": pw, "databases": []}]}
self.assertEqual(ret, expected)
def test_auth_with_token_id(self):
for cls in self.id_classes.values():
ident = cls()
tok = utils.random_name()
tenant_id = utils.random_name()
resp = fakes.FakeIdentityResponse()
# Need to stuff this into the standard response
sav = resp.content["access"]["token"]["tenant"]["id"]
resp.content["access"]["token"]["tenant"]["id"] = tenant_id
ident.method_post = Mock(return_value=resp)
ident.auth_with_token(tok, tenant_id=tenant_id)
ident.method_post.assert_called_once_with(
"tokens",
headers={
'Content-Type': 'application/json',
'Accept': 'application/json'
},
std_headers=False,
data={'auth': {
'token': {
'id': tok
},
'tenantId': tenant_id
}})
self.assertEqual(ident.tenant_id, tenant_id)
resp.content["access"]["token"]["tenant"]["id"] = sav
def test_get_temp_url_missing_key(self):
client = self.client
cname = utils.random_name(ascii_only=True)
oname = utils.random_name(ascii_only=True)
client.connection.head_account = Mock()
client.connection.head_account.return_value = {"some-other-key": "no"}
self.assertRaises(exc.MissingTemporaryURLKey, client.get_temp_url, cname, oname, seconds=120, method="GET")
def test_detach_from_instance_fail(self):
vol = self.volume
srv_id = utils.random_name()
att_id = utils.random_name()
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_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_name()
fake_email = utils.random_name()
fake_username = utils.random_name()
fake_uid = utils.random_name()
fake_region = utils.random_name()
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_revoke_user_access(self):
inst = self.instance
fakeuser = utils.random_name(ascii_only=True)
dbname1 = utils.random_name(ascii_only=True)
inst._user_manager.api.method_delete = Mock(return_value=(None, None))
inst.revoke_user_access(fakeuser, dbname1, strict=False)
inst._user_manager.api.method_delete.assert_called_once_with(
"/None/%s/databases/%s" % (fakeuser, dbname1))
def test_create_snapshot(self):
vol = self.volume
vol._snapshot_manager.create = Mock()
name = utils.random_name()
desc = utils.random_name()
vol.create_snapshot(name=name, description=desc, force=False)
vol._snapshot_manager.create.assert_called_once_with(volume=vol,
name=name, description=desc, force=False)
def test_metadata(self):
sg = self.scaling_group
metadata = utils.random_name()
newmetadata = utils.random_name()
sg.groupConfiguration = {"metadata": metadata}
self.assertEqual(sg.metadata, metadata)
sg.metadata = newmetadata
self.assertEqual(sg.metadata, newmetadata)
def test_auth_with_token(self):
pyrax.authenticated = False
tok = utils.random_name()
tname = utils.random_name()
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_create_snapshot_bad_request_other(self):
vol = self.volume
vol._snapshot_manager.create = Mock(side_effect=exc.BadRequest(
"Some other message"))
name = utils.random_name()
desc = utils.random_name()
self.assertRaises(exc.BadRequest, vol.create_snapshot, name=name,
description=desc, force=False)
def test_create_snapshot_bad_request(self):
vol = self.volume
vol._snapshot_manager.create = Mock(side_effect=exc.BadRequest(
"Invalid volume: must be available"))
name = utils.random_name()
desc = utils.random_name()
self.assertRaises(exc.VolumeNotAvailable, vol.create_snapshot,
name=name, description=desc, force=False)
def test_create_snapshot_bad_request(self):
vol = self.volume
vol._snapshot_manager.create = Mock(side_effect=exc.BadRequest(
"Invalid volume: must be available"))
name = utils.random_name()
desc = utils.random_name()
self.assertRaises(exc.VolumeNotAvailable, vol.create_snapshot,
name=name, description=desc, force=False)
def test_create_snapshot_bad_request_other(self):
vol = self.volume
vol._snapshot_manager.create = Mock(side_effect=exc.BadRequest(
"Some other message"))
name = utils.random_name()
desc = utils.random_name()
self.assertRaises(exc.BadRequest, vol.create_snapshot, name=name,
description=desc, force=False)
def test_auth_with_token(self):
pyrax.authenticated = False
tok = utils.random_name()
tname = utils.random_name()
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_delete_webhook(self):
sg = self.scaling_group
mgr = sg.manager
pol = utils.random_name()
hook = utils.random_name()
mgr.delete_webhook = Mock()
sg.delete_webhook(pol, hook)
mgr.delete_webhook.assert_called_once_with(sg, pol, hook)
def __init__(self, name=None, info=None, *args, **kwargs):
name = name or utils.random_name(ascii_only=True)
info = info or {"fake": "fake", "scalingPolicies": []}
self.groupConfiguration = {}
super(FakeScalingGroup, self).__init__(name, info, *args, **kwargs)
self.id = utils.random_name(ascii_only=True)
self.name = name
self.manager = FakeScalingGroupManager()
def test_cooldown(self):
sg = self.scaling_group
cooldown = utils.random_name()
newcooldown = utils.random_name()
sg.groupConfiguration = {"cooldown": cooldown}
self.assertEqual(sg.cooldown, cooldown)
sg.cooldown = newcooldown
self.assertEqual(sg.cooldown, newcooldown)
def test_mgr_resolve_lbs_dict(self):
sg = self.scaling_group
mgr = sg.manager
key = utils.random_name()
val = utils.random_name()
lb_dict = {key: val}
ret = mgr._resolve_lbs(lb_dict)
self.assertEqual(ret, [lb_dict])
def test_name(self):
sg = self.scaling_group
name = utils.random_name()
newname = utils.random_name()
sg.groupConfiguration = {"name": name}
self.assertEqual(sg.name, name)
sg.name = newname
self.assertEqual(sg.name, newname)
def test_get_temp_url_missing_key(self):
client = self.client
cname = utils.random_name(ascii_only=True)
oname = utils.random_name(ascii_only=True)
client.connection.head_account = Mock()
client.connection.head_account.return_value = {"some-other-key": "no"}
self.assertRaises(exc.MissingTemporaryURLKey, client.get_temp_url,
cname, oname, seconds=120, method="GET")
def test_max_entities(self):
sg = self.scaling_group
max_entities = utils.random_name()
newmax_entities = utils.random_name()
sg.groupConfiguration = {"maxEntities": max_entities}
self.assertEqual(sg.max_entities, max_entities)
sg.max_entities = newmax_entities
self.assertEqual(sg.max_entities, newmax_entities)
def test_client_create_snapshot(self):
clt = self.client
vol = self.volume
name = utils.random_name()
description = utils.random_name()
vol.create_snapshot = Mock()
clt.create_snapshot(vol, name=name, description=description, force=True)
vol.create_snapshot.assert_called_once_with(name=name, description=description, force=True)
def test_snapshot_name_property(self):
snap = self.snapshot
nm = utils.random_name()
snap.display_name = nm
self.assertEqual(snap.name, snap.display_name)
nm = utils.random_name()
snap.name = nm
self.assertEqual(snap.name, snap.display_name)
def test_create_snapshot(self):
vol = self.volume
vol._snapshot_manager.create = Mock()
name = utils.random_name()
desc = utils.random_name()
vol.create_snapshot(name=name, description=desc, force=False)
vol._snapshot_manager.create.assert_called_once_with(volume=vol, name=name,
description=desc, force=False)
def test_detach_from_instance_fail(self):
vol = self.volume
srv_id = utils.random_name()
att_id = utils.random_name()
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_detach_from_instance(self):
vol = self.volume
srv_id = utils.random_name()
att_id = utils.random_name()
vol.attachments = [{"server_id": srv_id, "id": att_id}]
vol._nova_volumes.delete_server_volume = Mock()
vol.detach()
vol._nova_volumes.delete_server_volume.assert_called_once_with(srv_id, att_id)
def test_volume_description_property(self):
vol = self.volume
nm = utils.random_name()
vol.display_description = nm
self.assertEqual(vol.description, vol.display_description)
nm = utils.random_name()
vol.description = nm
self.assertEqual(vol.description, vol.display_description)
def test_revoke_user_access(self):
inst = self.instance
fakeuser = utils.random_name(ascii_only=True)
dbname1 = utils.random_name(ascii_only=True)
inst._user_manager.api.method_delete = Mock(return_value=(None, None))
inst.revoke_user_access(fakeuser, dbname1, strict=False)
inst._user_manager.api.method_delete.assert_called_once_with(
"/None/%s/databases/%s" % (fakeuser, dbname1))
def test_snapshot_description_property(self):
snap = self.snapshot
nm = utils.random_name()
snap.display_description = nm
self.assertEqual(snap.description, snap.display_description)
nm = utils.random_name()
snap.description = nm
self.assertEqual(snap.description, snap.display_description)
def test_snapshot_name_property(self):
snap = self.snapshot
nm = utils.random_name()
snap.display_name = nm
self.assertEqual(snap.name, snap.display_name)
nm = utils.random_name()
snap.name = nm
self.assertEqual(snap.name, snap.display_name)
def test_snapshot_description_property(self):
snap = self.snapshot
nm = utils.random_name()
snap.display_description = nm
self.assertEqual(snap.description, snap.display_description)
nm = utils.random_name()
snap.description = nm
self.assertEqual(snap.description, snap.display_description)
def test_volume_description_property(self):
vol = self.volume
nm = utils.random_name()
vol.display_description = nm
self.assertEqual(vol.description, vol.display_description)
nm = utils.random_name()
vol.description = nm
self.assertEqual(vol.description, vol.display_description)
def test_volume_name_property(self):
vol = self.volume
nm = utils.random_name()
vol.display_name = nm
self.assertEqual(vol.name, vol.display_name)
nm = utils.random_name()
vol.name = nm
self.assertEqual(vol.name, vol.display_name)
def test_volume_name_property(self):
vol = self.volume
nm = utils.random_name()
vol.display_name = nm
self.assertEqual(vol.name, vol.display_name)
nm = utils.random_name()
vol.name = nm
self.assertEqual(vol.name, vol.display_name)
def test_client_create_snapshot_not_available(self):
clt = self.client
vol = self.volume
name = utils.random_name()
description = utils.random_name()
cli_exc = exc.ClientException(409, "Request conflicts with in-progress")
vol._snapshot_manager.create = Mock(side_effect=cli_exc)
self.assertRaises(exc.VolumeNotAvailable, clt.create_snapshot, vol,
name=name, description=description)
def test_list_user_access(self):
inst = self.instance
dbname1 = utils.random_name(ascii_only=True)
dbname2 = utils.random_name(ascii_only=True)
acc = {"databases": [{"name": dbname1}, {"name": dbname2}]}
inst._user_manager.api.method_get = Mock(return_value=(None, acc))
db_list = inst.list_user_access("fakeuser")
self.assertEqual(len(db_list), 2)
self.assertTrue(db_list[0].name in (dbname1, dbname2))
def test_client_create_snapshot_not_available(self):
clt = self.client
vol = self.volume
name = utils.random_name()
description = utils.random_name()
cli_exc = exc.ClientException(409, "Request conflicts with in-progress")
vol._snapshot_manager.create = Mock(side_effect=cli_exc)
self.assertRaises(exc.VolumeNotAvailable, clt.create_snapshot, vol,
name=name, description=description)
def test_get_user(self):
inst = self.instance
good_name = utils.random_name()
bad_name = utils.random_name()
user = fakes.FakeDatabaseUser(manager=None, info={"name": good_name})
inst.list_users = Mock(return_value=[user])
returned = inst.get_user(good_name)
self.assertEqual(returned, user)
self.assertRaises(exc.NoSuchDatabaseUser, inst.get_user, bad_name)
def test_get_user(self):
inst = self.instance
good_name = utils.random_name()
bad_name = utils.random_name()
user = fakes.FakeDatabaseUser(manager=None, info={"name": good_name})
inst.list_users = Mock(return_value=[user])
returned = inst.get_user(good_name)
self.assertEqual(returned, user)
self.assertRaises(exc.NoSuchDatabaseUser, inst.get_user, bad_name)
def test_download_object(self):
cont = self.container
cont.client.download_object = Mock()
oname = utils.random_name(ascii_only=True)
dname = utils.random_name(ascii_only=True)
stru = random.choice((True, False))
cont.download_object(oname, dname, structure=stru)
cont.client.download_object.assert_called_once_with(cont, oname,
dname, structure=stru)
def test_detach_from_instance(self):
vol = self.volume
srv_id = utils.random_name()
att_id = utils.random_name()
vol.attachments = [{"server_id": srv_id, "id": att_id}]
vol._nova_volumes.delete_server_volume = Mock()
vol.detach()
vol._nova_volumes.delete_server_volume.assert_called_once_with(
srv_id, att_id)
def test_get_db_names_fail(self):
inst = self.instance
mgr = inst._user_manager
mgr.instance = inst
dbname1 = utils.random_name(ascii_only=True)
dbname2 = utils.random_name(ascii_only=True)
sav = inst.list_databases
inst.list_databases = Mock(return_value=((dbname1, dbname2)))
self.assertRaises(exc.NoSuchDatabase, mgr._get_db_names, "BAD")
inst.list_databases = sav
def test_client_create_snapshot(self):
clt = self.client
vol = self.volume
name = utils.random_name()
description = utils.random_name()
vol.create_snapshot = Mock()
clt.create_snapshot(vol, name=name, description=description,
force=True)
vol.create_snapshot.assert_called_once_with(name=name,
description=description, force=True)
def test_get_temp_url_windows(self):
client = self.client
nm = "%s\\" % utils.random_name(ascii_only=True)
cname = "\\%s\\" % utils.random_name(ascii_only=True)
oname = utils.random_name(ascii_only=True)
client.connection.head_account = Mock()
client.connection.head_account.return_value = {
"x-account-meta-temp-url-key": nm, "some-other-key": "no"}
ret = client.get_temp_url(cname, oname, seconds=120, method="GET")
self.assertFalse("\\" in ret)
def test_download_object(self):
cont = self.container
cont.client.download_object = Mock()
oname = utils.random_name(ascii_only=True)
dname = utils.random_name(ascii_only=True)
stru = random.choice((True, False))
cont.download_object(oname, dname, structure=stru)
cont.client.download_object.assert_called_once_with(cont,
oname,
dname,
structure=stru)
def test_get_db_names_not_strict(self):
inst = self.instance
mgr = inst._user_manager
mgr.instance = inst
dbname1 = utils.random_name(ascii_only=True)
dbname2 = utils.random_name(ascii_only=True)
sav = inst.list_databases
inst.list_databases = Mock(return_value=((dbname1, dbname2)))
resp = mgr._get_db_names("BAD", strict=False)
self.assertEqual(resp, ["BAD"])
inst.list_databases = sav
def test_get_temp_url_unicode(self):
client = self.client
nm = utils.random_name(ascii_only=False)
cname = utils.random_name(ascii_only=True)
oname = utils.random_name(ascii_only=True)
client.connection.head_account = Mock()
client.connection.head_account.return_value = {
"x-account-meta-temp-url-key": nm, "some-other-key": "no"}
client.post_account = Mock()
self.assertRaises(exc.UnicodePathError, client.get_temp_url, cname,
oname, seconds=120, method="GET")
def test_grant_user_access(self):
inst = self.instance
fakeuser = utils.random_name(ascii_only=True)
dbname1 = utils.random_name(ascii_only=True)
inst._user_manager.api.method_put = Mock(return_value=(None, None))
inst.grant_user_access(fakeuser, dbname1, strict=False)
inst._user_manager.api.method_put.assert_called_once_with(
"/None/%s/databases" % fakeuser,
body={"databases": [{
"name": dbname1
}]})
def test_create_user_for_instance(self):
clt = self.client
inst = self.instance
sav = inst.create_user
inst.create_user = Mock()
nm = utils.random_name()
pw = utils.random_name()
ret = clt.create_user(inst, nm, pw, ["db"])
inst.create_user.assert_called_once_with(name=nm,
password=pw,
database_names=["db"])
inst.create_user = sav
