def test_evaluate_negative(self):
# given
value = 5
runtime_properties = {
'key': {
'nested_key1': {
'nested_key2': value
}
},
'other_key': 'blahblahblah'
}
node_ctx = MockNodeContext()
node_ctx.type_hierarchy = ['cloudify.nodes.Root']
relationship_ctx = MockRelationshipContext(target=None,
type=self.relationship_type)
relationship_ctx.type_hierarchy = [
'cloudify.relationships.connected_to', self.relationship_type
]
instance_ctx = MockNodeInstanceContext(
runtime_properties=runtime_properties)
# when
result = self.full_rule.evaluate(relationship_ctx, node_ctx,
instance_ctx)
# then
self.assertEquals((False, None), result)
def test_resolve_negative(self):
# given
argument1_name = 'var1'
rule1 = Mock()
rule1.argument_name = argument1_name
rule1_evaluate_value = None
rule1_evaluate_mock = Mock(return_value=(False, rule1_evaluate_value))
rule1.evaluate = rule1_evaluate_mock
rules = [rule1]
resolver = InstanceInputArgumentResolver(rules)
relationship_target_node_mock = Mock()
relationship_target_instance_mock = Mock()
relationship_mock = MockRelationshipContext(
target=MockRelationshipSubjectContext(
node=relationship_target_node_mock,
instance=relationship_target_instance_mock),
type='cloudify.relationships.connected_to')
ctx_mock = Mock()
ctx_instance_mock = Mock()
ctx_instance_mock.relationships = [relationship_mock]
ctx_mock.instance = ctx_instance_mock
# then
with self.assertRaises(InputArgumentResolvingError):
# when
resolver.resolve(ctx_mock)
def get_mock_relationship_ctx_for_node(self, rel_specs):
"""
This method will generate list of mock relationship associated with
certain node
:param rel_specs: Relationships is an ordered collection of
relationship specs - dicts with the keys "node" and "instance" used
to construct the MockNodeContext and the MockNodeInstanceContext,
and optionally a "type" key.
Examples: [
{},
{"node": {"id": 5}},
{
"type": "some_type",
"instance": {
"id": 3,
"runtime_properties":{}
}
}
]
:return list: Return list of "MockRelationshipContext" instances
"""
relationships = []
for rel_spec in rel_specs:
node = rel_spec.get('node', {})
node_id = node.pop('id', uuid.uuid4().hex)
instance = rel_spec.get('instance', {})
instance_id = instance.pop(
'id', '{0}_{1}'.format(node_id,
uuid.uuid4().hex))
if 'properties' not in node:
node['properties'] = {}
mock_data = {
'id': node_id,
'properties': node['properties'],
}
if rel_spec.get('type_hierarchy'):
mock_data['type_hierarchy'] = rel_spec['type_hierarchy']
node_ctx = CustomMockNodeContext(**mock_data)
instance_ctx = MockNodeInstanceContext(id=instance_id, **instance)
rel_subject_ctx = MockRelationshipSubjectContext(
node=node_ctx, instance=instance_ctx)
rel_type = rel_spec.get('type')
rel_ctx = MockRelationshipContext(target=rel_subject_ctx,
type=rel_type)
relationships.append(rel_ctx)
return relationships
def _get_ctx_mock(self, instance_id, boot):
rel_specs = [MockRelationshipContext(
target=MockRelationshipSubjectContext(node=MockNodeContext(
properties={'boot': boot}), instance=MockNodeInstanceContext(
runtime_properties={
OPENSTACK_TYPE_PROPERTY: VOLUME_OPENSTACK_TYPE,
OPENSTACK_ID_PROPERTY: instance_id,
VOLUME_BOOTABLE: False
})))]
ctx = mock.MagicMock()
ctx.instance = MockNodeInstanceContext(relationships=rel_specs)
ctx.logger = setup_logger('mock-logger')
return ctx
def test_resolve_negative(self):
# given
argument1_name = 'var1'
argument2_name = 'var2'
relationship_target_node_mock = Mock()
relationship_target_instance_mock = Mock()
relationship_target_instance_mock.id = '6'
relationship_source_node_mock = Mock()
relationship_source_instance_mock = Mock()
relationship_ctx = MockRelationshipContext(
target=MockRelationshipSubjectContext(
node=relationship_target_node_mock,
instance=relationship_target_instance_mock))
relationship_source_instance_mock.relationships = [relationship_ctx]
rule1 = Mock()
rule1.argument_name = argument1_name
rule1_evaluate_value = 'value1'
rule1_evaluate_mock = Mock(
side_effect=lambda ctx, node, instance:
(True, rule1_evaluate_value)
if (node == relationship_source_node_mock and instance ==
relationship_source_instance_mock) else (False, None))
rule1.evaluate = rule1_evaluate_mock
rule2 = Mock()
rule2.argument_name = argument2_name
rule2_evaluate_mock = Mock(return_value=(False, None))
rule2.evaluate = rule2_evaluate_mock
rules = [rule1, rule2]
resolver = RelationshipInputArgumentResolver(rules)
ctx_mock = Mock()
ctx_mock.target = MockRelationshipSubjectContext(
node=relationship_target_node_mock,
instance=relationship_target_instance_mock)
ctx_mock.source = MockRelationshipSubjectContext(
node=relationship_source_node_mock,
instance=relationship_source_instance_mock)
# then
with self.assertRaises(InputArgumentResolvingError):
# when
resolver.resolve(ctx_mock)
def test_resolve_positive(self):
# given
argument1_name = 'var1'
argument2_name = 'var2'
rule1 = Mock()
rule1.argument_name = argument1_name
rule1_evaluate_value = 'value1'
rule1_evaluate_mock = Mock(return_value=(True, rule1_evaluate_value))
rule1.evaluate = rule1_evaluate_mock
rule2 = Mock()
rule2.argument_name = argument2_name
rule2_evaluate_value = 'value2'
rule2_evaluate_mock = Mock(return_value=(True, rule2_evaluate_value))
rule2.evaluate = rule2_evaluate_mock
rules = [rule1, rule2]
resolver = InstanceInputArgumentResolver(rules)
relationship_target_node_mock = Mock()
relationship_target_instance_mock = Mock()
relationship_mock = MockRelationshipContext(
target=MockRelationshipSubjectContext(
node=relationship_target_node_mock,
instance=relationship_target_instance_mock),
type='cloudify.relationships.connected_to')
ctx_mock = Mock()
ctx_instance_mock = Mock()
ctx_instance_mock.relationships = [relationship_mock]
ctx_mock.instance = ctx_instance_mock
# when
result = resolver.resolve(ctx_mock)
# then
self.assertEquals(
result, {
argument1_name: rule1_evaluate_value,
argument2_name: rule2_evaluate_value
})
rule1_evaluate_mock.assert_called_once_with(
relationship_mock, relationship_target_node_mock,
relationship_target_instance_mock)
rule2_evaluate_mock.assert_called_once_with(
relationship_mock, relationship_target_node_mock,
relationship_target_instance_mock)
def test_create_with_download(self):
subnettarget = MockRelationshipContext(
target=MockCloudifyContext('subnet'))
subnettarget.target.node.type_hierarchy =\
['cloudify.nodes.aws.ec2.Subnet']
ctx = MockCloudifyContext("test_create")
ctx.download_resource = MagicMock(return_value='abc')
with patch(PATCH_PREFIX + 'LambdaBase'),\
patch(PATCH_PREFIX + 'utils') as utils,\
patch(PATCH_PREFIX + 'path_exists',
MagicMock(return_value=False)),\
patch(PATCH_PREFIX + 'os_remove', MagicMock(return_value=True)),\
patch(PATCH_PREFIX + 'open',
MagicMock(return_value=StringIO(u"test"))):
fun = function.LambdaFunction(ctx)
fun.logger = MagicMock()
fun.resource_id = 'test_function'
fake_client = self.make_client_function('create_function',
return_value={
'FunctionArn':
'test_function_arn',
'FunctionName':
'test_function'
})
fun.client = fake_client
resource_config = {
'VpcConfig': {
'SubnetIds': []
},
'Code': {
'ZipFile': True
}
}
utils.find_rels_by_node_type = MagicMock(
return_value=[subnettarget])
utils.get_resource_id = MagicMock(return_value='test_id')
utils.find_rel_by_node_type = MagicMock(return_value=subnettarget)
utils.get_resource_id = MagicMock(return_value='Role')
function.create(ctx, fun, resource_config)
self.assertEqual('test', resource_config['Code']['ZipFile'])
self.assertEqual(
{
'SubnetIds': ['Role'],
'SecurityGroupIds': ['Role']
}, resource_config['VpcConfig'])
def _make_vm_ctx_with_relationships(self, rel_specs, properties=None):
"""Prepare a mock CloudifyContext from the given relationship spec.
rel_specs is an ordered collection of relationship specs - dicts
with the keys "node" and "instance" used to construct the
MockNodeContext and the MockNodeInstanceContext, and optionally a
"type" key.
Examples: [
{},
{"node": {"id": 5}},
{
"type": "some_type",
"instance": {
"id": 3,
"runtime_properties":{}
}
}
]
"""
if properties is None:
properties = {}
relationships = []
for rel_spec in rel_specs:
node = rel_spec.get('node', {})
node_id = node.pop('id', uuid.uuid4().hex)
instance = rel_spec.get('instance', {})
instance_id = instance.pop(
'id', '{0}_{1}'.format(node_id,
uuid.uuid4().hex))
if 'properties' not in node:
node['properties'] = {}
node_ctx = MockNodeContext(id=node_id, **node)
instance_ctx = MockNodeInstanceContext(id=instance_id, **instance)
rel_subject_ctx = MockRelationshipSubjectContext(
node=node_ctx, instance=instance_ctx)
rel_type = rel_spec.get('type')
rel_ctx = MockRelationshipContext(target=rel_subject_ctx,
type=rel_type)
relationships.append(rel_ctx)
return MockCloudifyContext(node_id='vm',
properties=properties,
relationships=relationships)
def _mock_item_to_resources_list_rel_ctx(self):
# target
tar_rel_subject_ctx = MockRelationshipSubjectContext(
node=MockNodeContext(
id='test_resources',
type='cloudify.nodes.resources.List',
properties={
'resource_config': [
'10.0.1.0/24',
'10.0.2.0/24',
'10.0.3.0/24'
]
}
),
instance=MockNodeInstanceContext(
id='test_resources_123456',
runtime_properties={},
)
)
rel_ctx = MockRelationshipContext(
type='cloudify.relationships.resources.reserve_list_item',
target=tar_rel_subject_ctx
)
# source
src_ctx = MockCloudifyContext(
node_id='test_item_123456',
node_type='cloudify.nodes.resources.ListItem',
source=self,
target=tar_rel_subject_ctx,
relationships=rel_ctx
)
current_ctx.set(src_ctx)
return src_ctx
def test_resolve_positive(self):
# given
argument1_name = 'var1'
argument2_name = 'var2'
relationship_target_node_mock = Mock()
relationship_target_instance_mock = Mock()
relationship_target_instance_mock.id = '5'
relationship_source_node_mock = Mock()
relationship_source_instance_mock = Mock()
relationship_ctx = MockRelationshipContext(
target=MockRelationshipSubjectContext(
node=relationship_target_node_mock,
instance=relationship_target_instance_mock))
relationship_source_instance_mock.relationships = [relationship_ctx]
rule1 = Mock()
rule1.argument_name = argument1_name
rule1_evaluate_value = 'value1'
rule1_evaluate_mock = Mock(
side_effect=lambda ctx, node, instance:
(True, rule1_evaluate_value)
if (node == relationship_source_node_mock and instance ==
relationship_source_instance_mock) else (False, None))
rule1.evaluate = rule1_evaluate_mock
rule2 = Mock()
rule2.argument_name = argument2_name
rule2_evaluate_value = 'value2'
rule2_evaluate_mock = Mock(
side_effect=lambda ctx, node, instance:
(True, rule2_evaluate_value)
if (node == relationship_target_node_mock and instance ==
relationship_target_instance_mock) else (False, None))
rule2.evaluate = rule2_evaluate_mock
rules = [rule1, rule2]
resolver = RelationshipInputArgumentResolver(rules)
ctx_mock = Mock()
ctx_mock.target = MockRelationshipSubjectContext(
node=relationship_target_node_mock,
instance=relationship_target_instance_mock)
ctx_mock.source = MockRelationshipSubjectContext(
node=relationship_source_node_mock,
instance=relationship_source_instance_mock)
# when
result = resolver.resolve(ctx_mock)
# then
self.assertEquals(
result, {
argument1_name: rule1_evaluate_value,
argument2_name: rule2_evaluate_value
})
rule1_evaluate_mock_expected_calls = [
call(relationship_ctx, relationship_target_node_mock,
relationship_target_instance_mock),
call(relationship_ctx, relationship_source_node_mock,
relationship_source_instance_mock)
]
rule1_evaluate_mock.assert_has_calls(
rule1_evaluate_mock_expected_calls)
rule2_evaluate_mock_expected_calls = [
call(relationship_ctx, relationship_target_node_mock,
relationship_target_instance_mock)
]
rule2_evaluate_mock.assert_has_calls(
rule2_evaluate_mock_expected_calls)
