def test_softlayer_api_error(self):
error = SoftLayer.SoftLayerAPIError('Exception', 'Exception Text')
self.env.get_module_name.side_effect = error
self.assertRaises(SystemExit,
core.main,
args=['vs', 'list'],
env=self.env)
def test_error(self):
exception = SoftLayer.SoftLayerAPIError(500, 'Error')
mock = self.set_mock('SoftLayer_Resource_Metadata', 'getUserMetadata')
mock.side_effect = exception
self.assertRaises(SoftLayer.SoftLayerAPIError, self.metadata.get,
'user_data')
def test_sl_error(self, stdoutmock, climock):
ex = SoftLayer.SoftLayerAPIError('SoftLayer_Exception', 'Not found')
climock.side_effect = ex
self.assertRaises(SystemExit, core.main)
self.assertIn("SoftLayerAPIError(SoftLayer_Exception): Not found",
stdoutmock.getvalue())
def test_softlayer_api_error_authentication_error(self):
error = SoftLayer.SoftLayerAPIError('SoftLayerException',
'Invalid API Token')
self.env.get_module_name.side_effect = error
self.assertRaises(SystemExit,
core.main,
args=['vs', 'list'],
env=self.env)
def test_softlayer_api_error(self):
e = SoftLayer.SoftLayerAPIError('fault code', 'fault string')
self.assertEqual(e.faultCode, 'fault code')
self.assertEqual(e.faultString, 'fault string')
self.assertEqual(e.reason, 'fault string')
self.assertEqual(repr(e),
"<SoftLayerAPIError(fault code): fault string>")
self.assertEqual(str(e), "SoftLayerAPIError(fault code): fault string")
def test_auth_error(self, stdoutmock, climock):
ex = SoftLayer.SoftLayerAPIError('SoftLayer_Exception',
'Invalid API token.')
climock.side_effect = ex
self.assertRaises(SystemExit, core.main)
self.assertIn("Authentication Failed:", stdoutmock.getvalue())
self.assertIn("use 'slcli config setup'", stdoutmock.getvalue())
def test_delete_guest(self):
result = self.dedicated_host._delete_guest(123)
self.assertEqual(result, 'Cancelled')
# delete_guest should return the exception message in case it fails
error_raised = SoftLayer.SoftLayerAPIError('SL Exception', 'SL message')
self.dedicated_host.guest = mock.Mock()
self.dedicated_host.guest.deleteObject.side_effect = error_raised
result = self.dedicated_host._delete_guest(369)
self.assertEqual(result, 'Exception: SL message')
def test_create_subnet_no_prices_found(self):
item_mock = self.set_mock('SoftLayer_Product_Package', 'getItems')
item_mock.return_value = SoftLayer_Product_Package.getItems
verify_mock = self.set_mock('SoftLayer_Product_Order', 'verifyOrder')
verify_mock.side_effect = SoftLayer.SoftLayerAPIError('SoftLayer_Exception', 'Price not found')
result = self.run_command(['subnet', 'create', '--v6', 'public', '32', '12346', '--test'])
self.assertRaises(SoftLayer.SoftLayerAPIError, verify_mock)
self.assertIn('Unable to order 32 public ipv6', result.exception.message, )
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_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_get_fail_block_devices_exception(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)
vdi_clientMock = client['Virtual_Disk_Image']
req = falcon.Request(env)
resp = falcon.Response()
instance = volumes.OSVolumeAttachmentsV2()
instance.on_get(req, resp, TENANT_ID, INSTANCE_ID)
self.assertEquals(
resp.body,
{'volumeFault': {
'message': 'No Block Devices',
'code': '500'
}})
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 _match_portable_storage_prices(packageId, size, exact_capacity):
# match the SL portable storage capacity that closet
# to the requested size and return the prices
prod_pkg = client['Product_Package']
price_list = prod_pkg.getItems(id=packageId,
mask='prices.id')
# each item in price_list looks like this:
# {'capacity': '150',
# 'description': '150 GB (SAN)',
# 'id': 1221,
# 'prices': [{'id': 2262}],
# 'softwareDescriptionId': '',
# 'units': 'GB',
# 'upgradeItemId': ''}
price_matrix = {}
for x in price_list:
price_matrix.update({int(x['capacity']): x['prices']})
# find the closet capacity to the requested size
if exact_capacity:
ret = False
for x in price_matrix:
if size == x:
ret = True
capacity_idx = x
break
if not ret:
raise SoftLayer.SoftLayerAPIError(
HTTP.BAD_REQUEST,
'volume_types: extra_specs: '
'drivers:exact_capacity is set to'
' True and there is no volume with'
' matching capacity')
else:
capacity_idx = min(price_matrix, key=lambda x: abs(x - size))
return price_matrix[capacity_idx]
def test_on_delete_fail_detach_exception(self):
client, env = get_client_env()
vg_clientMock = client['Virtual_Guest']
deiMock = vg_clientMock.detachDiskImage
deiMock.side_effect = (SoftLayer.SoftLayerAPIError(
404, 'Detach Error', None))
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.body,
{'volumeFault': {
'message': 'Detach Error',
'code': '500'
}})
def test_404(self):
mock = self.set_mock('SoftLayer_Resource_Metadata', 'getUserMetadata')
mock.side_effect = SoftLayer.SoftLayerAPIError(404, 'Not Found')
resp = self.metadata.get('user_data')
self.assertEqual(None, resp)
def set_SL_client(req, operation=OP_CODE['GOOD_PATH']['SIMPLE']):
if operation == OP_CODE['GOOD_PATH']['SIMPLE']:
# simple good path testing, use default sl_client
return
elif operation == OP_CODE['BAD_PATH']['VIRT_DISK_IMG_OBJ_INVALID']:
# Virtual_Disk_Image.getObject failure.
req.sl_client['Virtual_Disk_Image'].getObject = \
mock.MagicMock(
side_effect=SoftLayer.SoftLayerAPIError(400,
"MockFault",
None))
elif operation == OP_CODE['BAD_PATH']['GET_VIRT_DISK_IMGS_API']:
# getVirtualDiskImages() SLAPI failure
setattr(
req.sl_client['Account'], 'getVirtualDiskImages',
mock.MagicMock(side_effect=SoftLayer.SoftLayerAPIError(
400, "MockFault", None)))
elif operation == OP_CODE['GOOD_PATH']['RET_VIRT_DISK_IMGS']:
def _return_disk_imgs(*args, **kwargs):
return [
# This will not be returned because it's a local disk.
{
'typeId': volumes.VIRTUAL_DISK_IMAGE_TYPE['SYSTEM'],
'blockDevices': [mock.MagicMock()],
'localDiskFlag': True,
},
# This will not be returned because it's not a system disk
# image.
{
'typeId': volumes.VIRTUAL_DISK_IMAGE_TYPE['SWAP'],
'blockDevices': [mock.MagicMock()],
'localDiskFlag': False,
},
# This will be the single volume returned since it's a
# non-local system disk image.
{
'typeId':
volumes.VIRTUAL_DISK_IMAGE_TYPE['SYSTEM'],
'localDiskFlag':
False,
'blockDevices': [{
'guestId': GUEST_ID,
'diskImageId': DISK_IMG_ID,
'device': BLKDEV_MOUNT_ID,
}],
},
]
setattr(req.sl_client['Account'], 'getVirtualDiskImages',
mock.MagicMock(side_effect=_return_disk_imgs))
elif operation == OP_CODE['GOOD_PATH']['RET_VIRT_DISK_IMG']:
def _return_disk_img(*args, **kwargs):
return {
'typeId': volumes.VIRTUAL_DISK_IMAGE_TYPE['SYSTEM'],
'blockDevices': [mock.MagicMock()],
'localDiskFlag': False,
}
req.sl_client['Virtual_Disk_Image'].getObject = \
mock.MagicMock(side_effect=_return_disk_img)
elif operation == OP_CODE['BAD_PATH']['RET_BAD_VIRT_GUEST']:
def _return_disk_img_1(*args, **kwargs):
return {
'typeId':
volumes.VIRTUAL_DISK_IMAGE_TYPE['SYSTEM'],
'blockDevices': [{
'guestId': GUEST_ID,
'diskImageId': DISK_IMG_ID,
'device': BLKDEV_MOUNT_ID,
}],
}
req.sl_client['Virtual_Disk_Image'].getObject = \
mock.MagicMock(side_effect=_return_disk_img_1)
req.sl_client['Virtual_Guest'].getObject = \
mock.MagicMock(
side_effect=SoftLayer.SoftLayerAPIError(400,
"MockFault",
None))
elif operation == OP_CODE['GOOD_PATH']['RET_VIRT_DISK_BILL']:
def _return_billing_item(*args, **kwargs):
return {'billingItem': mock.MagicMock()}
req.sl_client['Virtual_Disk_Image'].getObject = \
mock.MagicMock(side_effect=_return_billing_item)
elif operation == OP_CODE['BAD_PATH']['RET_VIRT_DISK_EXCP']:
req.sl_client['Virtual_Disk_Image'].getObject = \
mock.MagicMock(
side_effect=SoftLayer.SoftLayerAPIError(400,
"MockFault",
None))
elif operation == OP_CODE['GOOD_PATH']['CREATE_VOLUME']:
def _return_all_objects(*args, **kwargs):
return [{
'name': 'Portable Storage',
'isActive': 1,
'id': PROD_PKG_ID
}]
def _return_prices(*args, **kwargs):
return [{
'id': PROD_PKG_ID,
'capacity': DISK_CAPACITY,
'prices': [{
'id': PRICE_ID
}]
}]
def _return_disk_img_2(*args, **kwargs):
return {
'typeId':
volumes.VIRTUAL_DISK_IMAGE_TYPE['SYSTEM'],
'blockDevices': [{
'guestId': GUEST_ID,
'diskImageId': DISK_IMG_ID,
'device': BLKDEV_MOUNT_ID,
}],
}
req.sl_client['Product_Package'].getAllObjects = \
mock.MagicMock(side_effect=_return_all_objects)
req.sl_client['Product_Package'].getItems = \
mock.MagicMock(side_effect=_return_prices)
req.sl_client['Location_Datacenter'].getDatacenters = \
mock.MagicMock(return_value=[{'name': DATACENTER_NAME,
'id': DATACENTER_ID}])
req.sl_client['Billing_Order'].getOrderTopLevelItems = \
mock.MagicMock(
return_value=[{'billingItem': {'resourceTableId':
DISK_IMG_ID}}])
req.sl_client['Virtual_Disk_Image'].getObject = \
mock.MagicMock(side_effect=_return_disk_img_2)
req.sl_client['Product_Order'].placeOrder = \
mock.MagicMock(return_value={'orderId': ORDERID})
def test_raise_error(self, make_api_call):
make_api_call.side_effect = SoftLayer.SoftLayerAPIError(
'faultCode', 'faultString')
self.assertRaises(
SoftLayer.SoftLayerAPIError,
self.metadata.make_request, 'something.json')
def test_raise_404_error(self, make_api_call):
make_api_call.side_effect = SoftLayer.SoftLayerAPIError(404,
'faultString')
r = self.metadata.make_request('something.json')
self.assertEqual(r, None)
