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)