def test_create_fw_rule_sets(self):
params = {
u'project': u'PID',
u'name': u'name',
u'image': u'image',
u'instance-type': u'flavor',
u'fw-rule-sets': [u'3', u'8']
}
sgs = [
doubles.make(self.mox, doubles.SecurityGroup, id=u'3', name='sg3'),
doubles.make(self.mox, doubles.SecurityGroup, id=u'8', name='sg8')
]
instances.client_set_for_tenant(u'PID').AndReturn(self.tcs)
self.tcs.compute.security_groups.get(u'3').AndReturn(sgs[0])
self.tcs.compute.security_groups.get(u'8').AndReturn(sgs[1])
self.tcs.compute.servers.create(
name=u'name',
image=u'image',
flavor=u'flavor',
security_groups=['sg3', 'sg8'],
key_name=None,
admin_pass=None
).AndReturn('VM1')
instances._instance_to_view('VM1').AndReturn('REPLY')
self.mox.ReplayAll()
data = self.interact(params)
self.assertEquals(data, 'REPLY')
def test_project_to_view_works(self):
tenant = doubles.make(self.mox, doubles.Tenant,
id=u'c4fc65e', name=u'Project X')
net = doubles.make(self.mox, doubles.Network,
label=u'net22', id=u'2699a5')
quotaset = doubles.make(self.mox, doubles.QuotaSet)
gb = 1024 * 1024 * 1024
expected = {
u'id': u'c4fc65e',
u'href': u'/v1/projects/c4fc65e',
u'name': u'Project X',
u'description': u'Rather long description.',
u'cpus-limit': 33,
u'ram-limit': 50 * gb,
u'instances-limit': 10,
u'links': {
u'manage-users': '/v1/projects/c4fc65e/users/',
u'stats': '/v1/stats/by-project/c4fc65e'
},
u'network': {
u'id': u'2699a5',
u'name': u'net22',
u'href': u'/v1/networks/2699a5'
}
}
with self.app.test_request_context():
result = projects._project_to_view(tenant, net, quotaset)
self.assertEquals(expected, result)
def test_image_to_view_works(self):
tenant = doubles.make(self.mox, doubles.Tenant, id=u"TENANT", name=u"TestTenant")
image = doubles.make(
self.mox,
doubles.Image,
id=u"IMAGE",
name=u"TestImage",
size=123456,
owner=tenant.id,
created_at="2012-10-15T01:43:00",
disk_format=u"raw",
container_format=u"bare",
checksum="831a05f7bdeadbabe5l1k3133715e7ea",
status="active",
)
expected = {
u"id": u"IMAGE",
u"href": "/v1/images/IMAGE",
u"data-href": "/v1/images/IMAGE/data",
u"name": u"TestImage",
u"global": False,
u"project": {u"id": u"TENANT", u"name": u"TestTenant", u"href": "/v1/projects/TENANT"},
u"created": datetime(2012, 10, 15, 01, 43, 00),
u"disk-format": u"raw",
u"container-format": u"bare",
u"md5sum": "831a05f7bdeadbabe5l1k3133715e7ea",
u"size": 123456,
u"status": u"active",
}
def test_net_to_dict_works(self):
net = doubles.make(self.mox, doubles.Network,
id='271',
label='testnet',
vlan=42,
cidr='10.5.2.0/24',
netmask='255.255.255.0',
project_id='PID')
tenant = doubles.make(self.mox, doubles.Tenant,
id='PID', name='ptest')
expected = {
'id': '271',
'href': '/v1/networks/271',
'name': 'testnet',
'vlan': 42,
'cidr': '10.5.2.0/24',
'used': True,
'project': {
u'href': '/v1/projects/PID',
u'id': 'PID',
u'name': 'ptest'
}
}
self.fake_client_set.identity_admin\
.tenants.get(u'PID').AndReturn(tenant)
self.mox.ReplayAll()
with self.app.test_request_context():
self.install_fake_auth()
data = networks._net_to_dict(net)
self.assertEquals(data, expected)
def test_remind_reminds(self):
server_mgr = self.fake_client_set.compute.servers
instances.admin_client_set().AndReturn(self.fake_client_set)
user_mgr = self.fake_client_set.identity_admin.users
server = doubles.make(self.mox, doubles.Server,
id='v2', name='instance-2', user_id='UID')
user = doubles.make(self.mox, doubles.User,
id='UID', name='user', email='*****@*****.**',
fullname='The Test User Fullname')
expires = datetime(2013, 1, 19, 11, 12, 13)
instances.datetime.utcnow().AndReturn('UTCNOW')
instances.InstanceDataDAO.remind_list('UTCNOW')\
.AndReturn([InstanceData(instance_id='v2',
expires_at=expires)])
server_mgr.get('v2').AndReturn(server)
user_mgr.get('UID').AndReturn(user)
instances.send_instance_reminder(user.email, 'instance-2', 'v2',
expires, greeting=user.fullname)
instances.InstanceDataDAO.update('v2', remind_at=None)
self.mox.ReplayAll()
with self.app.test_request_context():
instances.remind_about_instances()
def test_get_all_projects(self):
tenants = (
doubles.make(self.mox, doubles.Tenant, name=u'tnt1', id=u't1'),
doubles.make(self.mox, doubles.Tenant, name=u'tnt2', id=u't2'),
doubles.make(self.mox, doubles.Tenant,
name=u'systenant', id=u'SYSTENANT_ID'))
nets = (
self.net(label=u'net2', id=u'netid2', project_id=u't2'),
self.net(label=u'net_', id=u'netid_', project_id=None), # unused
self.net(label=u'net1', id=u'netid1', project_id=u't1'))
self.tm_mock.list().AndReturn(tenants)
self.nm_mock.list().AndReturn(nets)
projects._quotaset_for_project(u't1').AndReturn('QUOTA1')
projects._project_to_view(tenants[0], nets[2], 'QUOTA1')\
.AndReturn('PROJECT1')
projects._quotaset_for_project(u't2').AndReturn('QUOTA2')
projects._project_to_view(tenants[1], nets[0], 'QUOTA2')\
.AndReturn('PROJECT2')
expected = {
u'collection': {
u'name': u'projects',
u'size': 2
},
u'projects': [ 'PROJECT1', 'PROJECT2' ]
}
self.mox.ReplayAll()
rv = self.client.get('/v1/projects/')
data = self.check_and_parse_response(rv)
self.assertEquals(data, expected)
def test_project_creation_works(self):
self.mox.StubOutWithMock(projects, '_project_to_view')
self.mox.StubOutWithMock(projects, '_quotaset_for_project')
networks = self.fake_client_set.compute.networks
tenants = self.fake_client_set.identity_admin.tenants
tenant = doubles.make(self.mox, doubles.Tenant,
name=self.name, id='PID',
description=self.description)
networks.get(self.net_id).AndReturn(
doubles.make(self.mox, doubles.Network,
label='NETLABEL', id=self.net_id, project_id=None))
tenants.create(self.name, self.description).AndReturn(tenant)
networks.associate(self.net_id, tenant.id)
networks.get(self.net_id).AndReturn('UPDATED NETWORK')
projects._quotaset_for_project(tenant.id).AndReturn('QUOTA')
projects._project_to_view(tenant, 'UPDATED NETWORK', 'QUOTA')\
.AndReturn('REPLY')
self.mox.ReplayAll()
data = self.interact()
self.assertEquals(data, 'REPLY')
def test_project_to_view_no_quota(self):
tenant = doubles.make(self.mox, doubles.Tenant,
id=u'c4fc65e', name=u'Project X')
net = doubles.make(self.mox, doubles.Network,
label=u'net22', id=u'2699a5')
expected = {
u'id': u'c4fc65e',
u'href': u'/v1/projects/c4fc65e',
u'name': u'Project X',
u'description': u'Rather long description.',
u'links': {
u'manage-users': '/v1/projects/c4fc65e/users/',
u'stats': '/v1/stats/by-project/c4fc65e'
},
u'network': {
u'id': u'2699a5',
u'name': u'net22',
u'href': u'/v1/networks/2699a5'
}
}
with self.app.test_request_context():
result = projects._project_to_view(tenant, net, None)
self.assertEquals(expected, result)
def test_sg_to_view_works(self):
tenant = doubles.make(self.mox, doubles.Tenant,
id=u'PID', name=u'Tenant')
sg = doubles.make(self.mox, doubles.SecurityGroup,
id=42, name=u'Test SG',
description=u'XXX', tenant_id=u'PID')
expected = {
u'id': u'42',
u'name': u'Test SG',
u'description': u'XXX',
u'project': {
u'id': u'PID',
u'href': '/v1/projects/PID',
u'name': u'Tenant'
},
u'rules-href': u'/v1/fw-rule-sets/42/rules/',
u'href': u'/v1/fw-rule-sets/42'
}
self.mox.ReplayAll()
with self.app.test_request_context():
res = fw_rule_sets._sg_to_view(sg, tenant.name)
self.assertEquals(expected, res)
def test_list_works(self):
tenants = (
doubles.make(self.mox, doubles.Tenant, name='t1', id=u'PID1'),
doubles.make(self.mox, doubles.Tenant, name='systenant', id=u'S'),
doubles.make(self.mox, doubles.Tenant, name='t2', id=u'PID2'))
self.fake_client_set.identity_admin.tenants.list().AndReturn(tenants)
tcs1 = mock_client_set(self.mox)
fw_rule_sets.client_set_for_tenant(u'PID1', fallback_to_api=True) \
.AndReturn(tcs1)
tcs1.compute.security_groups.list().AndReturn(['SG1', 'SG2'])
fw_rule_sets._sg_to_view('SG1', tenants[0].name).AndReturn('REPLY1')
fw_rule_sets._sg_to_view('SG2', tenants[0].name).AndReturn('REPLY2')
tcs2 = mock_client_set(self.mox)
fw_rule_sets.client_set_for_tenant(u'PID2', fallback_to_api=True) \
.AndReturn(tcs2)
tcs2.compute.security_groups.list().AndReturn(['SG3'])
fw_rule_sets._sg_to_view('SG3', tenants[2].name).AndReturn('REPLY3')
expected = {
'collection': {
'name': 'fw-rule-sets',
'size': 3
},
'fw-rule-sets': ['REPLY1', 'REPLY2', 'REPLY3']
}
self.mox.ReplayAll()
rv = self.client.get('/v1/fw-rule-sets/')
data = self.check_and_parse_response(rv)
self.assertEquals(data, expected)
def setUp(self):
super(AddProjectUserTestCase, self).setUp()
self.project_id = u'PID'
self.user_id = u'UID'
self.tenant = doubles.make(self.mox, doubles.Tenant,
id=self.project_id)
self.user = doubles.make(self.mox, doubles.User,
id=self.user_id, name='username')
def setUp(self):
super(RemoveProjectUserTestCase, self).setUp()
self.project_id = u'PID'
self.user_id = u'UID'
self.tenant = doubles.make(self.mox, doubles.Tenant,
id=self.project_id)
self.roles = [
doubles.make(self.mox, doubles.Role, id=u'AR', name=u'admin'),
doubles.make(self.mox, doubles.Role, id=u'MR', name=u'member')
]
def test_current_user_project_ids(self):
tenants = [doubles.make(self.mox, doubles.Tenant, id='PID1'),
doubles.make(self.mox, doubles.Tenant, id='PID2')]
self.fake_client_set.identity_public.tenants.list() \
.AndReturn(tenants)
self.mox.ReplayAll()
with self.app.test_request_context():
self.install_fake_auth()
ids = auth.current_user_project_ids()
self.assertEquals(ids, set(('PID1', 'PID2')))
def setUp(self):
super(InstanceRuleSetsTestCase, self).setUp()
self.server = doubles.make(self.mox, doubles.Server,
id=u'VMID', name=u'ExampleVM')
self.sg = doubles.make(self.mox, doubles.SecurityGroup,
id=2, name=u'ExampleSG', tenant_id='PID')
self.sg2 = doubles.make(self.mox, doubles.SecurityGroup,
id=142, name=u'AnotherSG', tenant_id='PID')
self.sg_id = unicode(self.sg.id)
self.mox.StubOutWithMock(ifwrs, 'link_for_security_group')
self.mox.StubOutWithMock(ifwrs, 'assert_admin_or_project_user')
def setUp(self):
super(AddFwRuleSetToVMTestCase, self).setUp()
self.mox.StubOutWithMock(ifwrs, 'client_set_for_tenant')
self.mox.StubOutWithMock(ifwrs, 'link_for_security_group')
self.server = doubles.make(self.mox, doubles.Server,
tenant_id='FWPROJECT',
id=u'VMID', name=u'ExampleVM')
self.sg = doubles.make(self.mox, doubles.SecurityGroup,
tenant_id='FWPROJECT',
id=2, name=u'ExampleSG')
self.sg_id = unicode(self.sg.id)
def setUp(self):
super(UserFetchesUserTestCase, self).setUp()
self.mox.StubOutWithMock(users.auth, 'admin_client_set')
self.mox.StubOutWithMock(users.auth, 'current_user_id')
self.mox.StubOutWithMock(users.auth, 'current_user_project_ids')
self.user = doubles.make(self.mox, doubles.User,
id='UID', name='Test')
self.role = doubles.make(self.mox, doubles.Role,
tenant={'id': 'PID'},
id='ROLE', name='Role')
self.admin_cs = self._fake_client_set_factory()
def setUp(self):
super(ImagesAsUserTestCase, self).setUp()
self.mox.StubOutWithMock(images.auth, "client_set_for_tenant")
self.mox.StubOutWithMock(images.auth, "default_tenant_id")
self.mox.StubOutWithMock(images.auth, "current_user_project_ids")
self.mox.StubOutWithMock(images, "_image_to_view")
self.tenant = doubles.make(self.mox, doubles.Tenant, id="PID", name="ptest")
self.images = [
doubles.make(self.mox, doubles.Image, id="IMAGE1", owner="SYS"),
doubles.make(self.mox, doubles.Image, id="IMAGE2", owner="PID"),
doubles.make(self.mox, doubles.Image, id="IMAGE3", owner="PID"),
]
def test_servers_for_user_none(self):
self.mox.StubOutWithMock(instances, 'client_set_for_tenant')
tenants = [doubles.make(self.mox, doubles.Tenant, id='P2'),
doubles.make(self.mox, doubles.Tenant, id='P3')]
self.fake_client_set.identity_public.tenants.list() \
.AndReturn(tenants)
self.mox.ReplayAll()
with self.app.test_request_context('/v1/instances?my-projects=true'
'&project:eq=P1'):
self.install_fake_auth()
instances.parse_collection_request(instances._SCHEMA.sortby)
result = instances._servers_for_user()
self.assertEquals(result, [])
def test_bound_client_user(self):
# pretend we have unbound client set:
self.fake_client_set.http_client.access['user']['roles'] = []
tenants = [doubles.make(self.mox, doubles.Tenant, id='PID1'),
doubles.make(self.mox, doubles.Tenant, id='PID2')]
self.fake_client_set.identity_public.tenants.list() \
.AndReturn(tenants)
auth.client_set_for_tenant('PID1').AndReturn('FAKE_CS')
self.mox.ReplayAll()
with self.app.test_request_context():
self.install_fake_auth()
self.assertEquals(auth.bound_client_set(), 'FAKE_CS')
def setUp(self):
super(RemoveFwRuleSetFromVMTestCase, self).setUp()
self.mox.StubOutWithMock(ifwrs, 'link_for_security_group')
self.mox.StubOutWithMock(ifwrs, 'client_set_for_tenant')
self.mox.StubOutWithMock(ifwrs,
'assert_admin_or_project_user')
self.server = doubles.make(self.mox, doubles.Server,
id=u'VMID', name=u'ExampleVM',
tenant_id=u'FWPROJECT')
self.sg = doubles.make(self.mox, doubles.SecurityGroup,
id=2, name=u'ExampleSG',
tenant_id=u'FWPROJECT')
self.tcs = mock_client_set(self.mox)
self.sg_id = unicode(self.sg.id)
def setUp(self):
super(UserFromNovaTestCase, self).setUp()
self.mox.StubOutWithMock(users, 'InvitesDAO')
self.roles = [
doubles.make(self.mox, doubles.Role,
role={'id': u'42', 'name': u'admin'},
tenant={'id': 'SYS', 'name': 'systenant'}),
doubles.make(self.mox, doubles.Role,
role={'id': u'43', 'name': u'member'},
tenant={'id': 'PID', 'name': 'ptest'}),
doubles.make(self.mox, doubles.Role,
role={'id': u'44', 'name': u'member'},
tenant={'id': 'PID2', 'name': 'other'})
]
def test_get_one(self):
flavors = [
doubles.make(self.mox, doubles.Flavor, id="42111"),
doubles.make(self.mox, doubles.Flavor, id="42"),
doubles.make(self.mox, doubles.Flavor, id="421"),
]
self.fake_client_set.compute.flavors.list().AndReturn(flavors)
instance_types._instance_type_to_view(flavors[1]).AndReturn('REPLY')
self.mox.ReplayAll()
rv = self.client.get('/v1/instance-types/42')
data = self.check_and_parse_response(rv)
self.assertEquals(data, 'REPLY')
def test_delete_user_with_keys(self):
keys = [doubles.make(self.mox, doubles.Keypair, id='kp1'),
doubles.make(self.mox, doubles.Keypair, id='kp2')]
user_keypairs = self.fake_client_set.compute_ext.user_keypairs
user_keypairs.list('user-a') \
.AndReturn(keys)
user_keypairs.delete('user-a', 'kp1') \
.AndRaise(osc_exc.NotFound('gone'))
self.app.logger.exception(IsA(basestring), 'kp1', 'user-a')
user_keypairs.delete('user-a', 'kp2')
self.fake_client_set.identity_admin.users.delete('user-a')
self.mox.ReplayAll()
rv = self.client.delete('/v1/users/user-a')
self.assertEquals(rv.status_code, 204)
def test_user_to_view_send_invite_code(self):
"""What we got when resending invite without disabling user"""
user = doubles.make(self.mox, doubles.User,
id=u'42', name=u'iv', email=u'*****@*****.**',
fullname=u'Example User', enabled=True)
date = datetime(2012, 9, 15, 15, 03, 00)
invite = Token(user_id=user.id, created_at=date,
complete=False, code='THE_CODE')
user.list_roles().AndReturn([])
expected = {
u'id': u'42',
u'name': u'iv',
u'href': u'/v1/users/42',
u'email': u'*****@*****.**',
u'fullname': 'Example User',
u'admin': False,
u'projects': [],
u'completed-registration': True, # because user can work
u'invited-at': date,
u'invitation-code': 'THE_CODE',
u'links': {
u'send-invite': '/v1/users/42/send-invite',
u'ssh-keys': '/v1/users/42/ssh-keys/',
}
}
self.mox.ReplayAll()
with self.app.test_request_context():
self.install_fake_auth()
data = users.user_to_view(user, invite, send_code=True)
self.assertEquals(data, expected)
def test_user_to_view_disabled_noadmin(self):
user = doubles.make(self.mox, doubles.User,
id=u'42', name=u'iv', email=u'*****@*****.**',
fullname=u'Example User', enabled=False)
user.list_roles().AndReturn([])
users.InvitesDAO.get_for_user(user.id).AndReturn(None)
expected = {
u'id': u'42',
u'name': u'iv',
u'href': u'/v1/users/42',
u'email': u'*****@*****.**',
u'fullname': 'Example User',
u'admin': False,
u'projects': [],
u'completed-registration': False,
u'links': {
u'send-invite': '/v1/users/42/send-invite',
u'ssh-keys': '/v1/users/42/ssh-keys/',
}
}
self.mox.ReplayAll()
with self.app.test_request_context():
self.install_fake_auth()
data = users.user_to_view(user)
self.assertEquals(data, expected)
def test_stats_work(self):
images = [doubles.make(self.mox, doubles.Image,
id=str(i), name='image%s' % i, is_public=p)
for i, p in enumerate((True, False, False, True, False))]
expected = {
'projects': 3,
'instances': 14,
'users': 9,
'total-images': 5,
'global-images': 2,
'by-project-stats-href': u'/v1/stats/by-project/'
}
tenants = ['systenant', 'tenant1', 'tenant2', 'tenant3']
cs = self.fake_client_set
cs.identity_admin.tenants.list().AndReturn(tenants)
cs.identity_admin.users.list()\
.AndReturn(['user%s' % i for i in xrange(9)])
cs.compute.servers.list(search_opts={'all_tenants': 1})\
.AndReturn(['instance%s' % i for i in xrange(14)])
stats.list_all_images(cs.image.images).AndReturn(images)
self.mox.ReplayAll()
rv = self.client.get('/v1/stats')
data = self.check_and_parse_response(rv)
self.assertEquals(expected, data)
def setUp(self):
super(ListImagesTestCase, self).setUp()
self.mox.StubOutWithMock(images.auth, "client_set_for_tenant")
self.mox.StubOutWithMock(images.auth, "default_tenant_id")
self.mox.StubOutWithMock(images.auth, "assert_admin")
self.mox.StubOutWithMock(images.auth, "api_client_set")
self.mox.StubOutWithMock(images, "_image_to_view")
self.tenants = [
doubles.make(self.mox, doubles.Tenant, id="SYS", name="systenant"),
doubles.make(self.mox, doubles.Tenant, id="PID", name="ptest"),
]
self.images = [
doubles.make(self.mox, doubles.Image, id="IMAGE1", owner="SYS"),
doubles.make(self.mox, doubles.Image, id="IMAGE2", owner="PID"),
doubles.make(self.mox, doubles.Image, id="IMAGE3", owner="PID"),
]
def test_rule_object_to_view_works(self):
rule = doubles.make(self.mox, doubles.SecurityGroupRule,
**self.to_view)
self.mox.ReplayAll()
with self.app.test_request_context():
res = fw_rules._fw_rule_object_to_view(rule)
self.assertEquals(res, self.expected)
def test_global_image_to_view(self):
image = doubles.make(
self.mox,
doubles.Image,
id=u"IMAGE",
name=u"TestImage",
size=123456,
owner=None,
created_at="2012-10-15T01:43:00",
disk_format=u"raw",
container_format=u"bare",
checksum="831a05f7bdeadbabe5l1k3133715e7ea",
status=u"active",
)
expected = {
u"id": u"IMAGE",
u"href": "/v1/images/IMAGE",
u"data-href": "/v1/images/IMAGE/data",
u"name": u"TestImage",
u"global": True,
u"created": datetime(2012, 10, 15, 01, 43, 00),
u"disk-format": u"raw",
u"container-format": u"bare",
u"md5sum": "831a05f7bdeadbabe5l1k3133715e7ea",
u"size": 123456,
u"status": u"active",
}
def setUp(self):
super(DeleteProjectTestCase, self).setUp()
self.tenant_id = u'PID'
self.tenant = doubles.make(self.mox, doubles.Tenant,
id=self.tenant_id)
self.mox.StubOutWithMock(projects, '_project_has_servers')
self.mox.StubOutWithMock(projects, '_project_has_images')
def test_global_image_to_view(self):
image = doubles.make(self.mox, doubles.Image,
id=u'IMAGE', name=u'TestImage', size=123456,
owner=None, created_at='2012-10-15T01:43:00',
disk_format=u'raw', container_format=u'bare',
checksum='831a05f7bdeadbabe5l1k3133715e7ea',
status=u'active')
expected = {
u'id': u'IMAGE',
u'href': '/v1/images/IMAGE',
u'data-href': '/v1/images/IMAGE/data',
u'name': u'TestImage',
u'global': True,
u'created': datetime(2012, 10, 15, 01, 43, 00),
u'disk-format': u'raw',
u'container-format': u'bare',
u'md5sum': '831a05f7bdeadbabe5l1k3133715e7ea',
u'size': 123456,
u'status': u'active',
}
def test_to_view(self):
flavor = doubles.make(self.mox,
doubles.Flavor,
id=u'42',
name=u'my test',
vcpus=4,
ram=8192,
disk=10,
ephemeral=80)
expected = {
u'id': u'42',
u'href': u'/v1/instance-types/42',
u'name': u'my test',
u'cpus': 4,
u'ram': 8 * _GB,
u'root-size': 10 * _GB,
u'ephemeral-size': 80 * _GB
}
with self.app.test_request_context():
res = instance_types._instance_type_to_view(flavor)
self.assertEquals(expected, res)
def test_user_to_view_send_invite_code(self):
"""What we got when resending invite without disabling user"""
user = doubles.make(self.mox,
doubles.User,
id=u'42',
name=u'iv',
email=u'*****@*****.**',
fullname=u'Example User',
enabled=True)
date = datetime(2012, 9, 15, 15, 03, 00)
invite = Token(user_id=user.id,
created_at=date,
complete=False,
code='THE_CODE')
user.list_roles().AndReturn([])
expected = {
u'id': u'42',
u'name': u'iv',
u'href': u'/v1/users/42',
u'email': u'*****@*****.**',
u'fullname': 'Example User',
u'admin': False,
u'projects': [],
u'completed-registration': True, # because user can work
u'invited-at': date,
u'invitation-code': 'THE_CODE',
u'links': {
u'send-invite': '/v1/users/42/send-invite',
u'ssh-keys': '/v1/users/42/ssh-keys/',
}
}
self.mox.ReplayAll()
with self.app.test_request_context():
self.install_fake_auth()
data = users.user_to_view(user, invite, send_code=True)
self.assertEquals(data, expected)
def test_list_works(self):
sg = doubles.make(self.mox, doubles.SecurityGroup,
id=u'42', name='Test SG', tenant_id='TENANT',
rules=['RULE1', 'RULE2'])
self.fake_client_set.compute.security_groups.get(sg.id).AndReturn(sg)
fw_rules.auth.assert_admin_or_project_user('TENANT', eperm_status=404)
fw_rules._fw_rule_dict_to_view('RULE1').AndReturn('REPLY1')
fw_rules._fw_rule_dict_to_view('RULE2').AndReturn('REPLY2')
expected = {
'collection': {
'name': 'rules',
'size': 2,
'parent-href': '/v1/fw-rule-sets/%s' % sg.id
},
'rules': [ 'REPLY1', 'REPLY2' ]
}
self.mox.ReplayAll()
rv = self.client.get('/v1/fw-rule-sets/%s/rules/' % sg.id)
data = self.check_and_parse_response(rv)
self.assertEquals(data, expected)
def test_list_nodes_work(self):
hm = self.fake_client_set.compute.hosts
hm.list_all().AndReturn([
doubles.make(self.mox, doubles.Host, _info=info)
for info in _TEST_HOSTS
])
hm.get('master').AndReturn('MASTER_DATA')
nodes._node_to_view('master', 'MASTER_DATA').AndReturn('H1')
hm.get('slave1').AndRaise(osc_exc.NotFound('gone'))
hm.get('slave2').AndReturn('SLAVE_DATA')
nodes._node_to_view('slave2', 'SLAVE_DATA').AndReturn('H3')
expected = {
'collection': {
'name': 'nodes',
'size': 2,
},
'nodes': ['H1', 'H3']
}
self.mox.ReplayAll()
rv = self.client.get('/v1/nodes/')
data = self.check_and_parse_response(rv)
self.assertEquals(data, expected)
def test_net_to_dict_no_project(self):
net = doubles.make(self.mox,
doubles.Network,
id='271',
label='testnet',
vlan=42,
cidr='10.5.2.0/24',
netmask='255.255.255.0',
project_id=None)
expected = {
'id': '271',
'href': '/v1/networks/271',
'name': 'testnet',
'vlan': 42,
'cidr': '10.5.2.0/24',
'used': False,
}
self.mox.ReplayAll()
with self.app.test_request_context():
self.install_fake_auth()
data = networks._net_to_dict(net)
self.assertEquals(data, expected)
def test_remind_user_not_found(self):
server_mgr = self.fake_client_set.compute.servers
user_mgr = self.fake_client_set.identity_admin.users
server = doubles.make(self.mox,
doubles.Server,
id='v2',
name='instance-2',
user_id='UID')
expires = datetime(2013, 1, 19, 11, 12, 13)
instances.admin_client_set().AndReturn(self.fake_client_set)
instances.datetime.utcnow().AndReturn('UTCNOW')
instances.InstanceDataDAO.remind_list('UTCNOW')\
.AndReturn([InstanceData(instance_id='v2',
expires_at=expires)])
server_mgr.get('v2').AndReturn(server)
user_mgr.get('UID').AndRaise(osc_exc.NotFound('deleted'))
instances.InstanceDataDAO.update('v2', remind_at=None)
self.mox.ReplayAll()
with self.app.test_request_context():
instances.remind_about_instances()
def test_create_admin(self):
client = self.fake_client_set
new_user = doubles.make(self.mox, doubles.User, id='NUID')
(name, email, passw) = ('user-a', '*****@*****.**', 'bananas')
client.identity_admin.users.list().AndReturn([self.user])
client.identity_admin.users.create(name=name,
password=passw,
email=email,
enabled=True).AndReturn(new_user)
# see doubles.py, near line 100 for role id and tenant id here
client.identity_admin.roles.add_user_role('NUID', u'ADMIN_ROLE_ID',
u'SYSTENANT_ID')
users.user_to_view(new_user).AndReturn('new-user-dict')
self.mox.ReplayAll()
data = self._interact({
"name": name,
"email": email,
"password": passw,
"admin": True
})
self.assertEquals(data, 'new-user-dict')
def setUp(self):
super(ImageDownloadTestCase, self).setUp()
self.mox.StubOutWithMock(images, '_fetch_image')
self.image = doubles.make(self.mox, doubles.Image,
id=u'IMG', owner=u'PID', name='test image',
status='active', size=42)
def test_list_works(self):
tenants = [
doubles.make(self.mox, doubles.Tenant, **kwargs)
for kwargs in (dict(id=u'p1', name=u'test1'),
dict(id=u'p2', name=u'test2'),
dict(id=u'SYS', name=u'systenant'))
]
servers = [
doubles.make(self.mox, doubles.Server, tenant_id='p2'),
doubles.make(self.mox, doubles.Server, tenant_id='SYS'),
]
images = [
doubles.make(self.mox, doubles.Image, **kwargs)
for kwargs in (dict(id='x', is_public=True),
dict(id='y', is_public=False, owner='p2'),
dict(id='z', is_public=True, owner='p1'))
]
self.fake_client_set.identity_admin.tenants.list()\
.AndReturn(tenants)
auth.default_tenant_id().AndReturn('SYS')
self.fake_client_set.identity_admin.tenants.list_users('p1')\
.AndReturn([])
auth.default_tenant_id().AndReturn('SYS')
self.fake_client_set.identity_admin.tenants.list_users('p2')\
.AndReturn([])
auth.default_tenant_id().AndReturn('SYS')
self.fake_client_set.compute.servers\
.list(search_opts={'all_tenants': 1})\
.AndReturn(servers)
stats.list_all_images(self.fake_client_set.image.images)\
.AndReturn(images)
expected = [
{
'href': '/v1/stats/by-project/p1',
'project': {
'href': '/v1/projects/p1',
'id': 'p1',
'name': 'test1'
},
'instances': 0,
'members': 0,
'local-images': 1,
'total-images': 2
},
{
'href': '/v1/stats/by-project/p2',
'project': {
'href': '/v1/projects/p2',
'id': 'p2',
'name': 'test2'
},
'instances': 1,
'members': 0,
'local-images': 1,
'total-images': 3
},
]
self.mox.ReplayAll()
rv = self.client.get('/v1/stats/by-project/')
data = self.check_and_parse_response(rv)
self.assertEquals(data['stats'], expected)
def _net(**kwargs):
return doubles.make(self.mox, doubles.Network, **kwargs)
def setUp(self):
super(DeleteProjectTestCase, self).setUp()
self.tenant_id = u'PID'
self.tenant = doubles.make(self.mox, doubles.Tenant, id=self.tenant_id)
self.mox.StubOutWithMock(projects, '_project_has_servers')
self.mox.StubOutWithMock(projects, '_project_has_images')
