def test_on_get_with_name_filter(self):
client, env = get_client_env(query_string='name=imageA')
vgbdtg = client['Virtual_Guest_Block_Device_Template_Group']
vgbdtg.getPublicImages.return_value = [{
'globalIdentifier': 'uuid',
'blockDevicesDiskSpaceTotal': 1000,
'name': 'imageA',
'status': {
'keyName': 'ACTIVE',
'name': 'Active'
},
}]
client['Account'].getPrivateBlockDeviceTemplateGroups.return_value = [{
'globalIdentifier':
'uuid2',
'blockDevicesDiskSpaceTotal':
2000,
'name':
'imageB',
'status': {
'keyName': 'ACTIVE',
'name': 'Active'
},
}]
# 1. There is one image pass the filter and returned in result.
req = api.Request(env, sl_client=client)
resp = falcon.Response()
images.ImagesV2(self.app, detail=True).on_get(req, resp)
self.assertEqual(resp.status, 200)
self.assertEqual(len(resp.body['images']), 1)
image1 = resp.body['images'][0]
self.assertEqual(image1['id'], 'uuid')
self.assertEqual(image1['name'], 'imageA')
self.assertEqual(image1['size'], 1000)
self.assertEqual('active', image1['status'])
# 2. There is no any image could pass the filter and been returned.
__client, env = get_client_env(query_string='name=imageX')
req = api.Request(env, sl_client=__client)
resp = falcon.Response()
images.ImagesV2(self.app).on_get(req, resp)
self.assertEqual(resp.status, 200)
self.assertEqual(len(resp.body['images']), 0)
def perform_flavor_detail(self, tenant_id, flavor_list, flavor_id):
env = get_client_env()
self.req = api.Request(env)
self.resp = falcon.Response()
self.app = mock.MagicMock()
instance = flavors.FlavorV2(app=self.app, flavors=flavor_list)
instance.on_get(self.req, self.resp, flavor_id, tenant_id)
def test_list_servers_basic(self, vs_list_instances):
"""Basic test for listing servers without details."""
client, env = get_client_env()
req = api.Request(env, sl_client=client)
resp = falcon.Response()
link_url = 'http://localhost:5000/compute/v2/servers/14331143'
with mock.patch.object(self.app,
'get_endpoint_url',
return_value=link_url) as get_url_mock:
self.instance.on_get(req, resp, tenant_id=None)
get_url_mock.assert_called_once_with('compute',
req,
'v2_server',
server_id='14331143')
vs_list_instances.assert_called_once_with(
**servers.get_list_params(req))
self.assertEqual(200, resp.status)
self.assertEqual(['servers'], resp.body.keys())
instances = resp.body['servers']
self.assertEqual(1, len(instances))
server = instances[0]
self.assertItemsEqual(['id', 'links', 'name'], server.keys())
self.assertEqual('14331143', server['id'])
self.assertEqual('fake-server', server['name'])
self.assertEqual(1, len(server['links']))
self.assertDictEqual({
'href': link_url,
'rel': 'self'
}, server['links'][0])
def test_list_images_no_details(self):
client, env = get_client_env()
vgbdtg = client['Virtual_Guest_Block_Device_Template_Group']
vgbdtg.getPublicImages.return_value = [{
'globalIdentifier': 'uuid',
'name': 'some image',
}]
client['Account'].getPrivateBlockDeviceTemplateGroups.return_value = [{
'globalIdentifier':
'uuid2',
'name':
'some other image',
}]
req = api.Request(env, sl_client=client)
resp = falcon.Response()
images.ImagesV2(self.app).on_get(req, resp)
self.assertEqual(resp.status, 200)
self.assertEqual(len(resp.body['images']), 2)
image1 = resp.body['images'][0]
expected_keys = ['id', 'links', 'name']
self.assertEqual(expected_keys, sorted(image1.keys()))
self.assertEqual(image1['id'], 'uuid')
self.assertEqual(image1['name'], 'some image')
self._assert_image_links(image1)
image2 = resp.body['images'][1]
self.assertEqual(expected_keys, sorted(image2.keys()))
self.assertEqual(image2['id'], 'uuid2')
self.assertEqual(image2['name'], 'some other image')
self._assert_image_links(image2)
def test_sl_client(self):
# Jumpgate request has an sl_client property.
env = helpers.create_environ()
r = api.Request(env)
self.assertIsNone(r.sl_client)
r.sl_client = 'fake_client'
self.assertEqual('fake_client', r.sl_client)
def test_on_post_invalid_create(self, create_instance_mock):
create_instance_mock.side_effect = Exception('badrequest')
client, env = get_client_env(body=self.body_string)
req = api.Request(env, sl_client=client)
resp = falcon.Response()
self.instance.on_post(req, resp, 'tenant_id')
self.assertEqual(resp.status, 400)
def perform_extra_detail_key(self, tenant_id, flavor_id, key_id):
env = get_client_env()
self.req = api.Request(env)
self.resp = falcon.Response()
flavors = flavor_list_loader.Flavors.get_flavors(app=mock.MagicMock())
instance = extra_specs.ExtraSpecsFlavorKeyV2(app=mock.MagicMock(),
flavors=flavors)
instance.on_get(self.req, self.resp, tenant_id, flavor_id, key_id)
def test_on_get_response_subnetv2_invalid_id(self):
"""Test invalid id"""
client, env = get_client_env()
req = api.Request(env, sl_client=client)
resp = falcon.Response()
subnets.SubnetV2().on_get(req, resp, 'BAD_ID')
self.assertEqual(resp.status, 400)
def perform_server_action(self, body_str, tenant_id, instance_id, flavors):
self.client, self.env = get_client_env(body=body_str)
self.vg_clientMock = self.client['Virtual_Guest']
self.req = api.Request(self.env, sl_client=self.client)
self.resp = falcon.Response()
instance = servers.ServerActionV2(app=mock.MagicMock(),
flavors=flavors)
instance.on_post(self.req, self.resp, tenant_id, instance_id)
def perform_get_vol_details(self, tenant_id, instance_id, volume_id):
self.client, self.env = get_client_env()
self.vg_clientMock = self.client['Virtual_Guest']
self.vdi_clientMock = self.client['Virtual_Disk_Image']
self.req = api.Request(self.env, sl_client=self.client)
self.resp = falcon.Response()
instance = volumes.OSVolumeAttachmentV2()
instance.on_get(self.req, self.resp, tenant_id, instance_id, volume_id)
def test_on_post_invalid(self):
self.body['server']['networks'][0]['uuid'] = 'invalid'
client, env = get_client_env(
body='{"server": {"name": "testserver", '
'"imageRef": "a1783280-6b1f", "flavorRef": "invalid"}}')
req = api.Request(env, sl_client=client)
resp = falcon.Response()
self.instance.on_post(req, resp, 'tenant_id')
self.assertEqual(resp.status, 400)
def test_on_get_subnetsv2_response_list(self):
"""Test list function"""
client, env = get_client_env(query_string='name=10')
SUBNET_DICT['id'] = 10
client['Account'].getSubnets.return_value = [SUBNET_DICT]
req = api.Request(env, sl_client=client)
resp = falcon.Response()
subnets.SubnetsV2().on_get(req, resp)
self.check_body_response(resp.body['subnets'][0])
def test_on_get_response_subnetsv2_show_no_match(self):
"""Test show function in SubnetsV2 with no matching ID"""
client, env = get_client_env(query_string='name=10')
SUBNET_DICT['id'] = 9
client['Account'].getSubnets.return_value = []
req = api.Request(env, sl_client=client)
resp = falcon.Response()
subnets.SubnetsV2().on_get(req, resp)
self.assertEqual(resp.status, 200)
self.assertEqual(resp.body['subnets'], [])
def test_on_get_response_subnetv2(self):
"""Test working path of SubnetV2()"""
client, env = get_client_env(query_string='name=10')
SUBNET_DICT['id'] = 10
client['Network_Subnet'].getObject.return_value = SUBNET_DICT
req = api.Request(env, sl_client=client)
resp = falcon.Response()
subnets.SubnetV2().on_get(req, resp, 10)
self.assertEqual(resp.status, 200)
self.check_body_response(resp.body['subnet'])
def test_on_get_response_subnetsv2_show(self):
"""Test show function in SubnetsV2"""
client, env = get_client_env()
SUBNET_DICT['id'] = 10
client['Account'].getSubnets.return_value = [SUBNET_DICT]
req = api.Request(env, sl_client=client)
resp = falcon.Response()
subnets.SubnetsV2().on_get(req, resp)
self.assertEqual(resp.status, 200)
self.check_body_response(resp.body['subnets'][0])
def test_on_get_response_networksv2_show_no_match(self):
"""Test show function in NetworksV2 with no matching ID"""
client, env = get_client_env(query_string='name=123321')
client['Account'].getNetworkVlans.return_value = []
req = api.Request(env, sl_client=client)
resp = falcon.Response()
networks.NetworksV2().on_get(req, resp)
self.assertEqual(resp.status, 200)
self.assertEqual(resp.body['networks'], [])
def test_on_get_response_networksv2_list_filter_private(self):
client, env = get_client_env(query_string='name=private')
client['Account'].getNetworkVlans.return_value = []
req = api.Request(env, sl_client=client)
resp = falcon.Response()
networks.NetworksV2().on_get(req, resp)
self.assertEqual(resp.status, 200)
self.assertEqual(len(resp.body['networks']), 1)
self.assertEqual(
resp.body['networks'][0],
networks.format_network(networks.VLANS['private'], TENANT_ID))
def test_on_get_fail(self):
client, env = get_client_env()
vgbdtg = client['Virtual_Guest_Block_Device_Template_Group']
error = SoftLayer.SoftLayerAPIError(
"SoftLayer_Exception_ObjectNotFound",
"Unable to find object with id of '1'")
vgbdtg.getObject.side_effect = error
req = api.Request(env, sl_client=client)
resp = falcon.Response()
self.assertRaises(SoftLayer.SoftLayerAPIError,
images.ImageV1(self.app).on_get, req, resp, '1')
def test_on_post_create_fail(self, vsMock):
client, env = get_client_env(body='{"createImage": \
{"name": "foobar"}}')
vg_clientMock = client['Virtual_Guest']
e = SoftLayer.SoftLayerAPIError(123, 'abc')
vg_clientMock.createArchiveTransaction.side_effect = e
req = api.Request(env, sl_client=client)
resp = falcon.Response()
instance = servers.ServerActionV2(app=mock.MagicMock(),
flavors=FLAVOR_LIST)
instance.on_post(req, resp, TENANT_ID, INSTANCE_ID)
self.assertRaises(SoftLayer.SoftLayerAPIError,
vg_clientMock.createArchiveTransaction)
self.assertEqual(resp.status, 500)
def test_on_get_response_networksv2_show(self):
"""Test show function in NetworksV2"""
client, env = get_client_env(query_string='name=123321')
account = client['Account']
fake_net = get_fake_net(network='PRIVATE')
account.getNetworkVlans.return_value = [fake_net]
req = api.Request(env, sl_client=client)
resp = falcon.Response()
networks.NetworksV2().on_get(req, resp)
self.assertEqual(resp.status, 200)
self.assertEqual(resp.body['networks'][0],
networks.format_network(fake_net, TENANT_ID))
def test_on_get_response_networkv2_public(self):
"""Test working path of NetworkV2()"""
client, env = get_client_env(query_string='name=123321')
net_vlan = client['Network_Vlan']
fake_net = get_fake_net()
net_vlan.getObject.return_value = fake_net
req = api.Request(env, sl_client=client)
resp = falcon.Response()
networks.NetworkV2().on_get(req, resp, fake_net['id'])
self.assertEqual(resp.body['network'],
networks.format_network(fake_net, TENANT_ID))
self.assertEqual(resp.status, 200)
self.assertEqual(resp.body['network']['provider:physical_network'],
False)
def test_on_get_no_block_devices(self):
client, env = get_client_env()
vg_clientMock = client['Virtual_Guest']
gbdMock = vg_clientMock.getBlockDevices
gbdMock.side_effect = SoftLayer.SoftLayerAPIError(
404, 'No Block Devices', None)
req = api.Request(env, sl_client=client)
resp = falcon.Response()
instance = volumes.OSVolumeAttachmentV2()
instance.on_get(req, resp, TENANT_ID, INSTANCE_ID, VOLUME_ID)
self.assertEqual(
resp.body,
{'volumeFault': {
'message': 'No Block Devices',
'code': '500'
}})
def test_on_delete(self):
client, env = get_client_env()
vg_clientMock = client['Virtual_Guest']
vdi_clientMock = client['Virtual_Disk_Image']
vdi_clientMock.getObject.return_value = {
'blockDevices': [{
'guestId': INSTANCE_ID
}]
}
req = api.Request(env, sl_client=client)
resp = falcon.Response()
instance = volumes.OSVolumeAttachmentV2()
instance.on_delete(req, resp, TENANT_ID, INSTANCE_ID, VOLUME_ID)
vg_clientMock.detachDiskImage.assert_called_with(VOLUME_ID,
id=INSTANCE_ID)
self.assertEqual(resp.status, 202)
def test_on_delete_fail_detach_getObject_exception(self):
client, env = get_client_env()
vdi_clientMock = client['Virtual_Disk_Image']
vdi_clientMock.getObject.side_effect = (SoftLayer.SoftLayerAPIError(
404, 'No Object', None))
req = api.Request(env, sl_client=client)
resp = falcon.Response()
instance = volumes.OSVolumeAttachmentV2()
instance.on_delete(req, resp, TENANT_ID, INSTANCE_ID, VOLUME_ID)
vdi_clientMock.getObject.assert_called_with(id=VOLUME_ID,
mask='blockDevices')
self.assertEqual(
resp.body,
{'volumeFault': {
'message': 'No Object',
'code': '500'
}})
def test_on_get(self):
client, env = get_client_env()
vgbdtg = client['Virtual_Guest_Block_Device_Template_Group']
vgbdtg.getPublicImages.return_value = [{
'globalIdentifier': 'uuid',
'blockDevicesDiskSpaceTotal': 1000,
'name': 'some image',
'status': {
'keyName': 'ACTIVE',
'name': 'Active'
},
}]
client['Account'].getPrivateBlockDeviceTemplateGroups.return_value = [{
'globalIdentifier':
'uuid2',
'blockDevicesDiskSpaceTotal':
2000,
'name':
'some other image',
'status': {
'keyName': 'DEPRECATED',
'name': 'Deprecated'
},
}]
req = api.Request(env, sl_client=client)
resp = falcon.Response()
images.ImagesV2(self.app, detail=True).on_get(req, resp)
self.assertEqual(resp.status, 200)
self.assertEqual(len(resp.body['images']), 2)
image1 = resp.body['images'][0]
self.assertEqual(image1['id'], 'uuid')
self.assertEqual(image1['name'], 'some image')
self.assertEqual(image1['size'], 1000)
self.assertEqual('active', image1['status'])
self._assert_image_links(image1)
image2 = resp.body['images'][1]
self.assertEqual(image2['id'], 'uuid2')
self.assertEqual(image2['name'], 'some other image')
self.assertEqual(image2['size'], 2000)
self.assertEqual('deactivated', image2['status'])
self._assert_image_links(image2)
def perform_server_detail(self,
tenant_id,
server_id,
get_instance_mock,
updates=None):
self.client, self.env = get_client_env()
instanceSV = servers.ServerV2(app=mock.MagicMock())
instance = {
'status': {
'keyName': 'ACTIVE',
'name': 'Active'
},
'modifyDate': '',
'maxCpu': 2,
'createDate': '2014-06-03T15:12:37-06:00',
'hostname': 'csh-test',
'sshKeys': [],
'id': 4953216,
'powerState': {
'keyName': 'HALTED',
'name': 'Halted'
},
'blockDeviceTemplateGroup': {
'publicFlag': 0,
'name': 'ajiang-jumpgate-sandbox-v1',
'userRecordId': 201260,
'createDate': '2014-05-10T20:36:51-06:00',
'statusId': 1,
'globalIdentifier': '9b013d4e-27ce-4673-9607-ef863a88e3a8',
'parentId': '',
'transactionId': '',
'id': 141214,
'accountId': 333582
},
'maxMemory': 2048,
'accountId': 333582
}
if updates is not None:
instance.update(updates)
get_instance_mock.return_value = instance
self.req = api.Request(self.env, sl_client=self.client)
self.resp = falcon.Response()
instanceSV.on_get(self.req, self.resp, tenant_id, server_id)
def test_on_get_response(self):
"""Test working path of ComputeV2()"""
env = get_client_env()
req = api.Request(env)
resp = falcon.Response()
# Test with a tenant passed in; tenant id is an optional parameter;
# this would happen when the nova client is used
self.app = mock.MagicMock()
self.app.get_endpoint_url.return_value = base_compute_url
version2_object = versionv2.VersionV2(app=self.app)
version2_object.on_get(req, resp, "99999")
self.check_response_body(resp.body['version'])
# Now test with NO tenant passed in
version2_object.on_get(req, resp)
self.check_response_body(resp.body['version'])
self.assertEqual(resp.status, '200 OK')
def test_on_get(self):
client, env = get_client_env()
vg_clientMock = client['Virtual_Guest']
vg_clientMock.getBlockDevices.return_value = [{
'diskImage': {
'type': {
'keyName': 'not SWAP'
},
'id': VOLUME_ID
}
}]
req = api.Request(env, sl_client=client)
resp = falcon.Response()
instance = volumes.OSVolumeAttachmentV2()
instance.on_get(req, resp, TENANT_ID, INSTANCE_ID, VOLUME_ID)
self.assertEqual(list(resp.body.keys()), ['volumeAttachment'])
self.assertIn('device', resp.body['volumeAttachment'])
self.assertIn('id', resp.body['volumeAttachment'])
self.assertIn('serverId', resp.body['volumeAttachment'])
self.assertIn('volumeId', resp.body['volumeAttachment'])
def test_on_get_fail_invalid_volume_id(self):
client, env = get_client_env()
vg_clientMock = client['Virtual_Guest']
vg_clientMock.getBlockDevices.return_value = [{
'diskImage': {
'type': {
'keyName': 'not SWAP'
},
'id': '0123456'
}
}]
req = api.Request(env, sl_client=client)
resp = falcon.Response()
instance = volumes.OSVolumeAttachmentV2()
instance.on_get(req, resp, TENANT_ID, INSTANCE_ID, VOLUME_ID)
self.assertEqual(
resp.body,
{'volumeFault': {
'message': 'Invalid volume id.',
'code': '400'
}})
def test_on_get_response_networksv2_list_no_filter(self):
# Verify that a list with no filter will return all of the
# networks from getNetworkVlans along with the placeholder
# public and private networks
client, env = get_client_env()
fake_net = get_fake_net(network='PRIVATE')
client['Account'].getNetworkVlans.return_value = [fake_net]
req = api.Request(env, sl_client=client)
resp = falcon.Response()
networks.NetworksV2().on_get(req, resp)
nets = [fake_net] + networks.VLANS.values()
expected = [networks.format_network(net, TENANT_ID) for net in nets]
self.assertEqual(resp.status, 200)
self.assertEqual(len(resp.body['networks']), 3)
# Assert that we have 3 networks: the fake network,
# public placeholder network, and the private placeholder network
self.assertItemsEqual(resp.body['networks'], expected)
