def docker(self, obj):
"""Construct docker client based on object.
:param obj: Object for which the client is created. It is expected to
be None when retrieving an existing client. When creating
a client, it contains the user and project to be used.
"""
if self._dockerclient is not None:
return self._dockerclient
host_node = self.properties.get(self.HOST_NODE, None)
host_cluster = self.properties.get(self.HOST_CLUSTER, None)
ctx = context.get_admin_context()
self.host = self._get_host(ctx, host_node, host_cluster)
# TODO(Anyone): Check node.data for per-node host selection
host_type = self.host.rt['profile'].type_name
if host_type not in self._VALID_HOST_TYPES:
msg = _("Type of host node (%s) is not supported") % host_type
raise exc.InternalError(message=msg)
host_ip = self._get_host_ip(obj, self.host.physical_id, host_type)
if host_ip is None:
msg = _("Unable to determine the IP address of host node")
raise exc.InternalError(message=msg)
url = 'tcp://%(ip)s:%(port)d' % {
'ip': host_ip,
'port': self.properties[self.PORT]
}
self._dockerclient = docker_driver.DockerClient(url)
return self._dockerclient
def _get_random_node(self, ctx, host_cluster):
"""Get a node randomly from the host cluster.
:param ctx: An instance of the request context.
:param host_cluster: The uuid of the hosting cluster.
"""
self.cluster = None
try:
self.cluster = cluster.Cluster.load(ctx, cluster_id=host_cluster)
except exc.ResourceNotFound as ex:
msg = ex.enhance_msg('host', ex)
raise exc.InternalError(message=msg)
nodes = self.cluster.rt['nodes']
if len(nodes) == 0:
msg = _("The cluster (%s) contains no nodes") % host_cluster
raise exc.InternalError(message=msg)
else:
good_nodes = []
for i in range(len(nodes)):
if nodes[i].status == "ACTIVE":
good_nodes.append(nodes[i])
if len(good_nodes) > 0:
node = good_nodes[random.randrange(len(good_nodes))]
else:
msg = _("There is no active nodes running in the cluster (%s)"
) % host_cluster
raise exc.InternalError(message=msg)
return node
def test_member_add(self, mock_get_current):
node = mock.Mock()
lb_id = 'LB_ID'
pool_id = 'POOL_ID'
port = '80'
subnet = 'subnet1'
subnet_obj = mock.Mock()
subnet_obj.name = 'subnet1'
subnet_obj.id = 'SUBNET_ID'
subnet_obj.network_id = 'NETWORK_ID'
network_obj = mock.Mock()
network_obj.name = 'network1'
network_obj.id = 'NETWORK_ID'
member = mock.Mock()
member.id = 'MEMBER_ID'
node_detail = {
'name': 'node-01',
'addresses': {
'network1': ['ipaddr_net1'],
'network2': ['ipaddr_net2']
}
}
node.get_details.return_value = node_detail
self.nc.subnet_get.return_value = subnet_obj
self.nc.network_get.return_value = network_obj
self.nc.pool_member_create.return_value = member
self.lb_driver._wait_for_lb_ready = mock.Mock()
self.lb_driver._wait_for_lb_ready.return_value = True
res = self.lb_driver.member_add(node, lb_id, pool_id, port, subnet)
self.assertEqual('MEMBER_ID', res)
self.nc.subnet_get.assert_called_once_with(subnet)
self.nc.network_get.assert_called_once_with('NETWORK_ID')
self.nc.pool_member_create.assert_called_once_with(
pool_id, 'ipaddr_net1', port, 'SUBNET_ID')
# Exception happens in subnet_get
self.nc.subnet_get.side_effect = exception.InternalError(
code=500, message="Can't find subnet1")
res = self.lb_driver.member_add(node, lb_id, pool_id, port, subnet)
self.assertIsNone(res)
# Exception happens in network_get
self.nc.subnet_get.side_effect = None
self.nc.subnet_get.return_value = subnet_obj
self.nc.network_get.side_effect = exception.InternalError(
code=500, message="Can't find NETWORK_ID")
res = self.lb_driver.member_add(node, lb_id, pool_id, port, subnet)
self.assertIsNone(res)
# Exception happens in pool_member_create
self.nc.subnet_get.side_effect = None
self.nc.subnet_get.return_value = subnet_obj
self.nc.network_get.side_effect = None
self.nc.network_get.return_value = network_obj
self.nc.pool_member_create.side_effect = exception.InternalError(
code=500, message="CREATE FAILED")
res = self.lb_driver.member_add(node, lb_id, pool_id, port, subnet)
self.assertIsNone(res)
def _build_action(self, context, message):
body = message.get('body', None)
if not body:
msg = _('Message body is empty.')
raise exc.InternalError(message=msg)
# Message format check
cluster = body.get('cluster', None)
action = body.get('action', None)
params = body.get('params', {})
if not cluster or not action:
msg = _('Both cluster identity and action must be specified.')
raise exc.InternalError(message=msg)
# Cluster existence check
# TODO(YanyanHu): Or maybe we can relax this constraint to allow
# user to trigger CLUSTER_CREATE action by sending message?
try:
cluster_obj = self._find_cluster(context, cluster)
except exc.ResourceNotFound:
msg = _('Cluster (%(cid)s) cannot be found.') % {'cid': cluster}
raise exc.InternalError(message=msg)
# Permission check
if not context.is_admin and self.user != cluster_obj.user:
msg = _('%(user)s is not allowed to trigger actions on '
'cluster %(cid)s.') % {
'user': self.user,
'cid': cluster
}
raise exc.InternalError(message=msg)
# Use receiver owner context to build action
context.user = self.user
context.project = self.project
context.domain = self.domain
# Action name check
if action not in consts.CLUSTER_ACTION_NAMES:
msg = _("Illegal cluster action '%s' specified.") % action
raise exc.InternalError(message=msg)
kwargs = {
'name': 'receiver_%s_%s' % (self.id[:8], message['id'][:8]),
'cause': action_mod.CAUSE_RPC,
'status': action_mod.Action.READY,
'inputs': params
}
action_id = action_mod.Action.create(context, cluster_obj.id, action,
**kwargs)
return action_id
def test__get_base_url_failed_get_endpoint_exception(
self, mock_senlin_driver, mock_get_service_creds):
cfg.CONF.set_override('default_region_name',
'RegionOne',
enforce_type=True)
fake_driver = mock.Mock()
fake_kc = mock.Mock()
fake_cred = mock.Mock()
mock_senlin_driver.return_value = fake_driver
fake_driver.identity.return_value = fake_kc
mock_get_service_creds.return_value = fake_cred
fake_kc.get_senlin_endpoint.side_effect = exception.InternalError(
message='Error!')
receiver = rb.Receiver('webhook',
CLUSTER_ID,
'FAKE_ACTION',
id=UUID1,
params={
'KEY': 884,
'FOO': 'BAR'
})
res = receiver._get_base_url()
self.assertIsNone(res)
mock_get_service_creds.assert_called_once_with()
fake_kc.get_senlin_endpoint.assert_called_once_with()
def test_do_create_failed_wait(self):
spec = copy.deepcopy(self.spec)
del spec['properties']['timeout']
profile = stack.StackProfile('t', spec)
oc = mock.Mock()
stack_node = mock.Mock()
stack_node.name = 'test_stack'
fake_stack = mock.Mock(id='FAKE_ID')
oc.stack_create = mock.Mock(return_value=fake_stack)
err = exc.InternalError(code=400, message='Timeout')
oc.wait_for_stack = mock.Mock(side_effect=err)
profile._orchestrationclient = oc
# do it
ex = self.assertRaises(exc.EResourceCreation,
profile.do_create,
stack_node)
# assertions
self.assertEqual('Failed in creating stack: Timeout.',
six.text_type(ex))
kwargs = {
'stack_name': mock.ANY,
'template': self.spec['properties']['template'],
'template_url': self.spec['properties']['template_url'],
'timeout_mins': None,
'disable_rollback': self.spec['properties']['disable_rollback'],
'parameters': self.spec['properties']['parameters'],
'files': self.spec['properties']['files'],
'environment': self.spec['properties']['environment'],
}
oc.stack_create.assert_called_once_with(**kwargs)
oc.wait_for_stack.assert_called_once_with('FAKE_ID', 'CREATE_COMPLETE',
timeout=None)
def test__get_trust_fatal(self, mock_rpc, mock_driver, mock_context):
x_rpc = mock.Mock()
x_rpc.credential_get.return_value = None
mock_rpc.return_value = x_rpc
x_svc_cred = {'uid': 'FAKE_ID', 'passwd': 'FAKE_PASS'}
mock_context.return_value = x_svc_cred
x_admin_id = 'FAKE_ADMIN_ID'
mock_keystone = mock.Mock()
mock_keystone.get_user_id.return_value = x_admin_id
err = exception.InternalError(code=500, message='Boom')
mock_keystone.trust_get_by_trustor.side_effect = err
x_driver = mock.Mock()
x_driver.identity.return_value = mock_keystone
mock_driver.return_value = x_driver
ex = self.assertRaises(exception.InternalError,
self.middleware._get_trust,
self.context)
self.assertEqual('Boom', six.text_type(ex))
mock_rpc.assert_called_once_with()
x_rpc.credential_get.assert_called_once_with(self.context)
mock_driver.assert_called_once_with()
x_driver.identity.assert_called_once_with({
'auth_url': self.context.auth_url,
'project_id': self.context.project,
'user_id': self.context.user,
'token': self.context.auth_token,
})
mock_context.assert_called_once_with()
mock_keystone.get_user_id.assert_called_once_with(
uid='FAKE_ID', passwd='FAKE_PASS')
mock_keystone.trust_get_by_trustor.assert_called_once_with(
self.context.user, 'FAKE_ADMIN_ID', self.context.project)
def _get_host_ip(self, obj, host_node, host_type):
"""Fetch the ip address of physical node.
:param obj: The node object representing the container instance.
:param host_node: The name or ID of the hosting node object.
:param host_type: The type of the hosting node, which can be either a
nova server or a heat stack.
:returns: The fixed IP address of the hosting node.
"""
host_ip = None
if host_type == self.HOST_NOVA_SERVER:
server = self.compute(obj).server_get(host_node)
private_addrs = server.addresses['private']
for addr in private_addrs:
if addr['version'] == 4 and addr['OS-EXT-IPS:type'] == 'fixed':
host_ip = addr['addr']
elif host_type == self.HOST_HEAT_STACK:
stack = self.orchestration(obj).stack_get(host_node)
outputs = stack.outputs or {}
if outputs:
for output in outputs:
if output['output_key'] == 'fixed_ip':
host_ip = output['output_value']
break
if not outputs or host_ip is None:
msg = _("Output 'fixed_ip' is missing from the provided stack"
" node")
raise exc.InternalError(message=msg)
return host_ip
def test_member_add_member_create_failed(self, mock_get_current,
mock_load):
node = mock.Mock()
subnet_obj = mock.Mock(id='SUBNET_ID', network_id='NETWORK_ID')
subnet_obj.name = 'subnet'
network_obj = mock.Mock(id='NETWORK_ID')
network_obj.name = 'network1'
node_detail = {
'name': 'node-01',
'addresses': {
'network1': [{'addr': 'ipaddr_net1'}],
'network2': [{'addr': 'ipaddr_net2'}]
}
}
mock_load.return_value = node
node.get_details.return_value = node_detail
# Exception happens in pool_member_create
self.lb_driver._wait_for_lb_ready = mock.Mock()
self.lb_driver._wait_for_lb_ready.return_value = True
self.nc.subnet_get.return_value = subnet_obj
self.nc.network_get.return_value = network_obj
self.oc.pool_member_create.side_effect = exception.InternalError(
code=500, message="CREATE FAILED")
res = self.lb_driver.member_add(node, 'LB_ID', 'POOL_ID', 80,
'subnet')
self.assertIsNone(res)
def test_attach_failed_finding(self):
self.spec['properties']['servergroup']['name'] = 'KONGFU'
x_profile = mock.Mock()
x_profile.type = 'os.nova.server-1.0'
x_profile.spec = {'foo': 'bar'}
cluster = mock.Mock(id='CLUSTER_ID',
user='******',
project='PROJ',
rt={'profile': x_profile})
x_nova = mock.Mock()
err = exc.InternalError(code=500, message='Boom')
x_nova.server_group_find.side_effect = err
policy = ap.AffinityPolicy('test-policy', self.spec)
mock_nova = self.patchobject(policy, 'nova', return_value=x_nova)
# do it
res, data = policy.attach(cluster)
# assertions
self.assertFalse(res)
self.assertEqual("Failed in retrieving servergroup 'KONGFU'.", data)
mock_nova.assert_called_once_with('USER', 'PROJ')
x_nova.server_group_find.assert_called_once_with('KONGFU', True)
def test__build_trust_create_new_trust_failed(self, mock_keystone,
mock_load_session,
mock_load_auth):
mock_auth = mock.Mock()
mock_session = mock.Mock()
mock_session.get_user_id.return_value = 'zaqar-trustee-user-id'
mock_load_session.return_value = mock_session
mock_load_auth.return_value = mock_auth
mock_kc = mock.Mock()
mock_keystone.return_value = mock_kc
mock_trust = mock.Mock()
mock_trust.id = 'mock-trust-id'
message = mmod.Message('message',
None,
None,
id=UUID,
user='******',
project='project1')
message.notifier_roles = ['test_role']
mock_kc.trust_get_by_trustor.return_value = None
mock_kc.trust_create.side_effect = exception.InternalError()
self.assertRaises(exception.EResourceCreation, message._build_trust)
mock_kc.trust_get_by_trustor.assert_called_once_with(
'user1', 'zaqar-trustee-user-id', 'project1')
mock_kc.trust_create.assert_called_once_with('user1',
'zaqar-trustee-user-id',
'project1', ['test_role'])
def test_do_create_failed_create(self):
oc = mock.Mock()
profile = stack.StackProfile('t', self.spec)
node = mock.Mock(id='NODE_ID', cluster_id='CLUSTER_ID', index=123)
node.name = 'test_node'
err = exc.InternalError(code=400, message='Too Bad')
oc.stack_create = mock.Mock(side_effect=err)
profile._orchestrationclient = oc
# do it
ex = self.assertRaises(exc.EResourceCreation,
profile.do_create,
node)
# assertions
self.assertEqual('Failed in creating stack: Too Bad.',
six.text_type(ex))
call_args = {
'stack_name': mock.ANY,
'template': self.spec['properties']['template'],
'template_url': self.spec['properties']['template_url'],
'timeout_mins': self.spec['properties']['timeout'],
'disable_rollback': self.spec['properties']['disable_rollback'],
'parameters': self.spec['properties']['parameters'],
'files': self.spec['properties']['files'],
'environment': self.spec['properties']['environment'],
'tags': ",".join(['cluster_node_id=NODE_ID',
'cluster_id=CLUSTER_ID',
'cluster_node_index=123'])
}
oc.stack_create.assert_called_once_with(**call_args)
self.assertEqual(0, oc.wait_for_stack.call_count)
def test_do_validate_fails(self):
oc = mock.Mock()
profile = stack.StackProfile('t', self.spec)
profile._orchestrationclient = oc
err = exc.InternalError(code=400, message='Boom')
oc.stack_create = mock.Mock(side_effect=err)
node_obj = mock.Mock()
node_obj.name = 'stack_node'
ex = self.assertRaises(exc.InvalidSpec,
profile.do_validate, node_obj)
props = self.spec['properties']
call_args = {
'stack_name': mock.ANY,
'template': props['template'],
'template_url': props['template_url'],
'parameters': props['parameters'],
'files': props['files'],
'environment': props['environment'],
'preview': True,
}
oc.stack_create.assert_called_once_with(**call_args)
self.assertEqual('Failed in validating template: Boom',
six.text_type(ex))
def test_do_create_failed(self):
cc = mock.Mock()
profile = server.ServerProfile('t', self.spec)
profile._computeclient = cc
self._stubout_profile(profile,
mock_image=True,
mock_flavor=True,
mock_keypair=True,
mock_net=True)
node_obj = mock.Mock(id='FAKE_NODE_ID',
index=123,
cluster_id='FAKE_CLUSTER_ID',
data={
'placement': {
'zone': 'AZ1',
'servergroup': 'SERVER_GROUP_1'
}
})
node_obj.name = 'TEST_SERVER'
cc.server_create.side_effect = exc.InternalError(
code=500, message="creation failed.")
ex = self.assertRaises(exc.EResourceCreation, profile.do_create,
node_obj)
self.assertEqual('Failed in creating server: creation failed.',
six.text_type(ex))
self.assertEqual(0, cc.wait_for_server.call_count)
def parse_exception(ex):
'''Parse exception code and yield useful information.'''
code = 500
if isinstance(ex, sdk_exc.HttpException):
code = ex.status_code
message = ex.message
data = {}
try:
data = jsonutils.loads(ex.details)
except Exception:
# Some exceptions don't have details record or
# are not in JSON format
pass
# try dig more into the exception record
code = data.get('code', code)
error = data.get('error', None)
if error:
code = data['error'].get('code', code)
message = data['error'].get('message', message)
elif isinstance(ex, sdk_exc.SDKException):
# Besides HttpException there are some other exceptions like
# ResourceTimeout can be raised from SDK, handle them here.
message = ex.message
elif isinstance(ex, req_exc.RequestException):
# Exceptions that are not captured by SDK
code = ex.errno
message = six.text_type(ex)
elif isinstance(ex, Exception):
message = six.text_type(ex)
# LOG.exception(ex)
raise senlin_exc.InternalError(code=code, message=message)
def test_run_workflow_failed_creation(self):
node = nodem.Node('node1', PROFILE_ID, 'FAKE_CLUSTER')
node.physical_id = 'FAKE_NODE'
wfc = mock.Mock()
wfc.workflow_find.return_value = None
err = exception.InternalError(message='boom')
wfc.workflow_create.side_effect = err
wfc.execution_create = mock.Mock()
x_profile = mock.Mock()
x_profile.workflow = mock.Mock(return_value=wfc)
node.rt['profile'] = x_profile
options = {
'workflow_name': 'foo',
'inputs': {
'definition': {
'bar': 'baz'
},
'FAKE_KEY1': 'FAKE_VALUE1',
'FAKE_KEY2': 'FAKE_VALUE2',
}
}
ex = self.assertRaises(exception.EResourceOperation, node.run_workflow,
**options)
self.assertEqual("Failed in executing workflow 'foo': boom.",
six.text_type(ex))
x_profile.workflow.assert_called_once_with(node)
wfc.workflow_find.assert_called_once_with('foo')
wfc.workflow_create.assert_called_once_with({'bar': 'baz'},
scope='private')
self.assertEqual(0, wfc.execution_create.call_count)
def test_handle_stop_driver_failure(self, mock_docker):
mock_docker.side_effect = exc.InternalError(message="Boom")
obj = mock.Mock(physical_id='FAKE_ID')
docker = dp.DockerProfile('container', self.spec)
ex = self.assertRaises(exc.EResourceOperation, docker.handle_stop, obj)
self.assertEqual("Failed in stop container 'FAKE_ID': "
"Boom.", str(ex))
def parse_exception(ex):
"""Parse exception code and yield useful information."""
code = 500
if isinstance(ex, sdk_exc.HttpException):
# some exceptions don't contain status_code
if hasattr(ex, "status_code") and ex.status_code is not None:
code = ex.status_code
elif hasattr(ex, "http_status") and ex.http_status is not None:
code = ex.http_status
message = str(ex)
data = {}
if ex.details is None and ex.response is not None:
data = ex.response.json()
else:
try:
data = jsonutils.loads(ex.details)
except Exception:
# Some exceptions don't have details record or
# are not in JSON format
pass
# try dig more into the exception record
# usually 'data' has two types of format :
# type1: {"forbidden": {"message": "error message", "code": 403}
# type2: {"code": 404, "error": { "message": "not found"}}
if data:
code = data.get('code', code)
message = data.get('message', message)
error = data.get('error', None)
if error:
code = data.get('code', code)
message = data['error'].get('message', message)
else:
for value in data.values():
code = value.get('code', code)
message = value.get('message', message)
elif isinstance(ex, sdk_exc.SDKException):
# Besides HttpException there are some other exceptions like
# ResourceTimeout can be raised from SDK, handle them here.
message = str(ex)
elif isinstance(ex, req_exc.RequestException):
# Exceptions that are not captured by SDK
code = ex.errno
message = str(ex)
else:
# This could be a generic exception or something we don't understand
message = str(ex)
if code >= 500 or code in (400, 401, 403):
LOG.error(message)
else:
LOG.info(message)
raise senlin_exc.InternalError(code=code, message=message)
def test_member_remove_member_delete_failed(self):
self.lb_driver._wait_for_lb_ready = mock.Mock()
self.lb_driver._wait_for_lb_ready.return_value = True
self.oc.pool_member_delete.side_effect = exception.InternalError(
code=500, message='')
res = self.lb_driver.member_remove('LB_ID', 'POOL_ID', 'MEMBER_ID')
self.assertFalse(res)
self.oc.pool_member_delete.assert_called_once_with('POOL_ID',
'MEMBER_ID')
def test_lb_create_loadbalancer_creation_failed(self):
lb_obj = mock.Mock()
lb_obj.id = 'LB_ID'
subnet_obj = mock.Mock()
subnet_obj.name = 'subnet'
subnet_obj.id = 'SUBNET_ID'
subnet_obj.network_id = 'NETWORK_ID'
self.oc.loadbalancer_create.return_value = lb_obj
self.nc.subnet_get.return_value = subnet_obj
self.lb_driver._wait_for_lb_ready = mock.Mock()
self.lb_driver._wait_for_lb_ready.side_effect = [False]
self.lb_driver.lb_delete = mock.Mock()
status, res = self.lb_driver.lb_create(self.vip, self.pool, self.hm)
self.assertFalse(status)
msg = _('Failed in creating loadbalancer (%s).') % 'LB_ID'
self.assertEqual(msg, res)
self.oc.loadbalancer_create.assert_called_once_with(
'SUBNET_ID',
None,
self.vip['address'],
self.vip['admin_state_up'],
availability_zone=None)
self.lb_driver._wait_for_lb_ready.assert_called_once_with('LB_ID')
self.lb_driver.lb_delete.assert_called_once_with(loadbalancer='LB_ID')
# Exception happens in subnet_get.
self.nc.subnet_get.side_effect = exception.InternalError(
code=500, message='GET FAILED')
status, res = self.lb_driver.lb_create(self.vip, self.pool, self.hm)
self.assertFalse(status)
msg = _('Failed in getting subnet: GET FAILED.')
self.assertEqual(msg, res)
# Exception happens in loadbalancer_create.
self.nc.subnet_get.side_effect = None
self.oc.loadbalancer_create.side_effect = exception.InternalError(
code=500, message='CREATE FAILED')
status, res = self.lb_driver.lb_create(self.vip, self.pool, self.hm)
self.assertFalse(status)
msg = _('Failed in creating loadbalancer: CREATE FAILED.')
self.assertEqual(msg, res)
def test_check_object_exception_return_value(self, mock_load):
profile = pb.Profile
profile.load(self.ctx).do_check = mock.Mock(
side_effect=exception.InternalError(code=400, message='BAD'))
obj = mock_load
res = profile.check_object(self.ctx, obj)
profile.load(self.ctx).do_check.assert_called_once_with(obj)
self.assertEqual(False, res)
def test_notify_claiming_message_failed(self, mock_zaqar):
mock_zc = mock.Mock()
mock_zaqar.return_value = mock_zc
mock_zc.claim_create.side_effect = exception.InternalError()
message = mmod.Message('message', None, None, id=UUID)
message.channel = {'queue_name': 'queue1'}
res = message.notify(self.context)
self.assertIsNone(res)
mock_zc.claim_create.assert_called_once_with('queue1')
def test_node_create_internal_error(self, mock_create, mock_status,
mock_handle_exception, mock_event):
ex = exception.InternalError(code=500, message='internal error')
mock_create.side_effect = ex
node = nodem.Node('node1', self.profile.id, self.cluster.id,
self.context)
res = node.do_create(self.context)
self.assertFalse(res)
mock_handle_exception.assert_called_once_with(self.context, 'create',
'ERROR', ex)
mock_event.assert_called_once_with(self.context, node, 'create')
def test_do_get_details_failed_retrieval(self):
profile = stack.StackProfile('t', self.spec)
node_obj = mock.Mock(physical_id='STACK_ID')
oc = mock.Mock()
oc.stack_get.side_effect = exc.InternalError(message='BOOM')
profile._orchestrationclient = oc
res = profile.do_get_details(node_obj)
self.assertEqual({'Error': {'code': 500, 'message': 'BOOM'}}, res)
oc.stack_get.assert_called_once_with('STACK_ID')
def test_handle_unpause_docker_failure(self, mock_docker):
x_docker = mock.Mock()
mock_docker.return_value = x_docker
x_docker.unpause.side_effect = exc.InternalError(message="Boom")
obj = mock.Mock(physical_id='FAKE_ID')
docker = dp.DockerProfile('container', self.spec)
ex = self.assertRaises(exc.EResourceOperation, docker.handle_unpause,
obj)
self.assertEqual("Failed in unpausing container 'FAKE_ID': "
"Boom.", six.text_type(ex))
def test_translate_exception_with_exception(self):
@sdk.translate_exception
def test_func(driver):
raise (Exception('test exception'))
error = senlin_exc.InternalError(code=500, message='BOOM')
self.patchobject(sdk, 'parse_exception', side_effect=error)
ex = self.assertRaises(senlin_exc.InternalError, test_func,
mock.Mock())
self.assertEqual(500, ex.code)
self.assertEqual('BOOM', ex.message)
def test_do_join_failed_get_stack(self):
profile = stack.StackProfile('t', self.spec)
oc = mock.Mock()
profile._orchestrationclient = oc
err = exc.InternalError(code=400, message='Boom')
oc.stack_get.side_effect = err
node = mock.Mock(physical_id='STACK_ID')
res = profile.do_join(node, 'CLUSTER_ID')
self.assertFalse(res)
oc.stack_get.assert_called_once_with('STACK_ID')
def test_do_adopt_failed_get(self):
profile = stack.StackProfile('t', self.spec)
oc = mock.Mock()
oc.stack_get.side_effect = exc.InternalError(message='BOOM')
profile._orchestrationclient = oc
node_obj = mock.Mock(physical_id='FAKE_ID')
res = profile.do_adopt(node_obj)
expected = {'Error': {'code': 500, 'message': 'BOOM'}}
self.assertEqual(expected, res)
oc.stack_get.assert_called_once_with('FAKE_ID')
def test_do_check_failed_checking(self):
node_obj = mock.Mock(physical_id='FAKE_ID')
profile = stack.StackProfile('t', self.spec)
oc = mock.Mock()
profile._orchestrationclient = oc
oc.stack_check = mock.Mock(
side_effect=exc.InternalError(code=400, message='BOOM'))
self.assertRaises(exc.EResourceOperation, profile.do_check, node_obj)
oc.stack_check.assert_called_once_with('FAKE_ID')
self.assertEqual(0, oc.wait_for_stack.call_count)
def test_member_add_network_get_failed(self, mock_get_current):
subnet_obj = mock.Mock()
subnet_obj.name = 'subnet'
subnet_obj.id = 'SUBNET_ID'
subnet_obj.network_id = 'NETWORK_ID'
# Exception happens in network_get
self.nc.subnet_get.return_value = subnet_obj
self.nc.network_get.side_effect = exception.InternalError(
code=500, message="Can't find NETWORK_ID")
res = self.lb_driver.member_add('node', 'LB_ID', 'POOL_ID', 80,
'subnet')
self.assertIsNone(res)
