def test_connect_sg_to_port(self, *_):
mock_neutron = MockNeutronClient(update=True)
ctx = MockCloudifyContext(
source=MockRelationshipSubjectContext(node=mock.MagicMock(),
instance=mock.MagicMock()),
target=MockRelationshipSubjectContext(node=mock.MagicMock(),
instance=mock.MagicMock()))
with mock.patch('neutron_plugin.port.ctx', ctx):
neutron_plugin.port.connect_security_group(mock_neutron)
self.assertIsNone(ctx.operation._operation_retry)
def test_connect_sg_to_port_race_condition(self, *_):
mock_neutron = MockNeutronClient(update=False)
ctx = MockCloudifyContext(
source=MockRelationshipSubjectContext(node=mock.MagicMock(),
instance=mock.MagicMock()),
target=MockRelationshipSubjectContext(
node=mock.MagicMock(),
instance=MockNodeInstanceContext(
runtime_properties={OPENSTACK_ID_PROPERTY: 'test-sg-id'})))
with mock.patch('neutron_plugin.port.ctx', ctx):
neutron_plugin.port.connect_security_group(mock_neutron, ctx=ctx)
self.assertIsInstance(ctx.operation._operation_retry,
OperationRetry)
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_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_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_stop():
from cloudify_healer.stopper import stop
# start process then stop it
p = subprocess.Popen(["exec sleep 120"], shell=True)
ctx = MockCloudifyContext(source=MockRelationshipSubjectContext(
None, MockNodeInstanceContext(runtime_properties={"pid": str(p.pid)})))
current_ctx.set(ctx)
stop()
sleep(2)
if p.poll() is None:
p.terminate()
p.wait()
assert False
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_relationship(self,
type=RBAC_POLICY_APPLIED_FOR_RELATIONSHIP_TYPE,
runtime_properties=None):
class _MockRelationshipContext(MockRelationshipContext):
@property
def type_hierarchy(self):
return [self.type]
return _MockRelationshipContext(
MockRelationshipSubjectContext(
node=None,
instance=MockNodeInstanceContext(
runtime_properties=runtime_properties or {},
)
),
type=type
)
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)