def merge(self):
if self.node_type_operation is None:
# the operation is not defined in the type
# should be merged by the node template operation
return self.node_template_operation
if self.node_template_operation is None:
# the operation is not defined in the template
# should be merged by the node type operation
# this will validate that all schema inputs have
# default values
return operation_mapping(
implementation=self.node_type_operation['implementation'],
inputs=merge_schema_and_instance_inputs(
schema_inputs=self.node_type_operation['inputs'],
instance_inputs={}
),
executor=self.node_type_operation['executor'],
max_retries=self.node_type_operation['max_retries'],
retry_interval=self.node_type_operation['retry_interval'],
timeout=self.node_type_operation['timeout'],
timeout_recoverable=self.node_type_operation[
'timeout_recoverable']
)
if self.node_template_operation == NO_OP:
# no-op overrides
return NO_OP
if self.node_type_operation == NO_OP:
# no-op overridden
return self.node_template_operation
merged_operation_implementation = self._derive_implementation()
merged_operation_inputs = self._derive_inputs(
merged_operation_implementation)
merged_operation_executor = self._derive_executor(
merged_operation_implementation)
merged_operation_retries = self._derive_max_retries(
merged_operation_implementation)
merged_operation_retry_interval = self._derive_retry_interval(
merged_operation_implementation)
merged_operation_timeout = self._derive_timeout(
merged_operation_implementation)
merged_operation_timeout_recoverable = \
self._derive_timeout_recoverable(merged_operation_implementation)
return operation_mapping(
implementation=merged_operation_implementation,
inputs=merged_operation_inputs,
executor=merged_operation_executor,
max_retries=merged_operation_retries,
retry_interval=merged_operation_retry_interval,
timeout=merged_operation_timeout,
timeout_recoverable=merged_operation_timeout_recoverable
)
def test_basic_namespaced_relationship(self):
imported_yaml = self.BLUEPRINT_WITH_INTERFACES_AND_PLUGINS + """
relationships:
empty_rel: {}
test_relationship:
derived_from: empty_rel
source_interfaces:
test_interface3:
test_interface3_op1: {}
target_interfaces:
test_interface4:
test_interface4_op1:
implementation: test_plugin.task_name
inputs:
key:
type: string
default: value
executor: central_deployment_agent
max_retries: 5
retry_interval: 6
test_interface4_op2: test_plugin.task_name
"""
import_file_name = self.make_yaml_file(imported_yaml)
main_yaml = self.BASIC_VERSION_SECTION_DSL_1_3 + """
imports:
- {0}--{1}
""".format('test', import_file_name)
parsed_yaml = self.parse_1_3(main_yaml)
test_relationship = (
parsed_yaml[constants.RELATIONSHIPS]['test--test_relationship'])
self.assertEquals('test--test_relationship', test_relationship['name'])
self.assertEquals(test_relationship[constants.TYPE_HIERARCHY],
['test--empty_rel', 'test--test_relationship'])
result_test_interface_3 = \
(test_relationship[interfaces_const.SOURCE_INTERFACES]
['test_interface3'])
self.assertEquals(interfaces_const.NO_OP,
result_test_interface_3['test_interface3_op1'])
result_test_interface_4 = \
(test_relationship[interfaces_const.TARGET_INTERFACES]
['test_interface4'])
self.assertEquals(
operation_mapping(
implementation='test--test_plugin.task_name',
inputs={'key': {
'default': 'value',
'type': 'string'
}},
executor='central_deployment_agent',
max_retries=5,
retry_interval=6),
result_test_interface_4['test_interface4_op1'])
self.assertEquals(
operation_mapping(implementation='test--test_plugin.task_name',
inputs={},
executor=None,
max_retries=None,
retry_interval=None),
result_test_interface_4['test_interface4_op2'])
def merge(self):
if self.overriding_node_type_operation is None:
return self.overridden_node_type_operation
if self.overriding_node_type_operation == NO_OP:
return NO_OP
merged_operation_implementation = \
self.overriding_node_type_operation['implementation']
merged_operation_inputs = \
self.overriding_node_type_operation['inputs']
merged_operation_executor = \
self.overriding_node_type_operation['executor']
merged_operation_max_retries = \
self.overriding_node_type_operation['max_retries']
merged_operation_retry_interval = \
self.overriding_node_type_operation['retry_interval']
return operation_mapping(
implementation=merged_operation_implementation,
inputs=merged_operation_inputs,
executor=merged_operation_executor,
max_retries=merged_operation_max_retries,
retry_interval=merged_operation_retry_interval
)
def _create_operation(raw_operation):
if raw_operation is None:
return None
if isinstance(raw_operation, str):
return operation_mapping(
implementation=raw_operation,
inputs={},
executor=None,
max_retries=None,
retry_interval=None
)
if isinstance(raw_operation, dict):
return operation_mapping(
implementation=raw_operation.get('implementation', ''),
inputs=raw_operation.get('inputs', {}),
executor=raw_operation.get('executor', None),
max_retries=raw_operation.get('max_retries', None),
retry_interval=raw_operation.get('retry_interval', None)
)
def assert_operation(op, extra_properties=False):
inputs = {}
if extra_properties:
inputs.update({'key': {'default': 'value'}})
self.assertEqual(
op,
operation_mapping(implementation='test--stub.py',
inputs=inputs,
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None))
def test_instance_relationships_standard_relationship(self):
yaml = self.MINIMAL_BLUEPRINT + """
test_node2:
type: test_type
relationships:
- type: test_relationship
target: test_node
source_interfaces:
test_interface1:
install: test_plugin.install
relationships:
test_relationship: {}
plugins:
test_plugin:
executor: central_deployment_agent
source: dummy
"""
result = self.parse(yaml)
self.assertEquals(2, len(result['nodes']))
nodes = self._sort_result_nodes(result['nodes'],
['test_node', 'test_node2'])
self.assertEquals('test_node2', nodes[1]['id'])
self.assertEquals(1, len(nodes[1]['relationships']))
relationship = nodes[1]['relationships'][0]
self.assertEquals('test_relationship', relationship['type'])
self.assertEquals('test_node', relationship['target_id'])
self.assertEqual(
operation_mapping(implementation='test_plugin.install',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
relationship['source_interfaces']['test_interface1']['install'])
relationship_source_operations = relationship['source_operations']
self.assertEqual(
op_struct('test_plugin',
'install',
executor='central_deployment_agent'),
relationship_source_operations['install'])
self.assertEqual(
op_struct('test_plugin',
'install',
executor='central_deployment_agent'),
relationship_source_operations['test_interface1.install'])
self.assertEqual(2, len(relationship_source_operations))
self.assertEquals(8, len(relationship))
plugin_def = nodes[1]['plugins'][0]
self.assertEquals('test_plugin', plugin_def['name'])
def test_top_level_relationships_single_complete_relationship(self):
yaml = self.BLUEPRINT_WITH_INTERFACES_AND_PLUGINS + """
relationships:
empty_rel: {}
test_relationship:
derived_from: empty_rel
source_interfaces:
test_interface3:
test_interface3_op1: {}
target_interfaces:
test_interface4:
test_interface4_op1:
implementation: test_plugin.task_name
inputs: {}
"""
result = self.parse(yaml)
self._assert_blueprint(result)
self.assertEqual(
{
'name': 'empty_rel',
'properties': {},
'source_interfaces': {},
'target_interfaces': {},
'type_hierarchy': ['empty_rel']
}, result['relationships']['empty_rel'])
test_relationship = result['relationships']['test_relationship']
self.assertEquals('test_relationship', test_relationship['name'])
self.assertEquals(test_relationship['type_hierarchy'],
['empty_rel', 'test_relationship'])
result_test_interface_3 = \
test_relationship['source_interfaces']['test_interface3']
self.assertEquals(NO_OP,
result_test_interface_3['test_interface3_op1'])
result_test_interface_4 = \
test_relationship['target_interfaces']['test_interface4']
self.assertEquals(
operation_mapping(implementation='test_plugin.task_name',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
result_test_interface_4['test_interface4_op1'])
def test_top_level_relationships_recursive_imports(self):
bottom_level_yaml = self.BLUEPRINT_WITH_INTERFACES_AND_PLUGINS + """
relationships:
empty_rel: {}
test_relationship:
derived_from: empty_rel
source_interfaces:
test_interface2:
install:
implementation: test_plugin.install
inputs: {}
terminate:
implementation: test_plugin.terminate
inputs: {}
"""
bottom_file_name = self.make_yaml_file(bottom_level_yaml)
mid_level_yaml = """
relationships:
test_relationship2:
derived_from: "test_relationship3"
imports:
- {0}""".format(bottom_file_name)
mid_file_name = self.make_yaml_file(mid_level_yaml)
top_level_yaml = """
relationships:
test_relationship3:
target_interfaces:
test_interface2:
install:
implementation: test_plugin.install
inputs: {}
terminate:
implementation: test_plugin.terminate
inputs: {}
imports:
- """ + mid_file_name
result = self.parse(top_level_yaml)
self._assert_blueprint(result)
self.assertEqual(
{
'name': 'empty_rel',
'properties': {},
'source_interfaces': {},
'target_interfaces': {},
'type_hierarchy': ['empty_rel']
}, result['relationships']['empty_rel'])
test_relationship = result['relationships']['test_relationship']
self.assertEquals('test_relationship', test_relationship['name'])
self.assertEqual(
operation_mapping(implementation='test_plugin.install',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
test_relationship['source_interfaces']['test_interface2']
['install'])
self.assertEqual(
operation_mapping(implementation='test_plugin.terminate',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
test_relationship['source_interfaces']['test_interface2']
['terminate'])
self.assertEquals(
2, len(test_relationship['source_interfaces']['test_interface2']))
self.assertEquals(6, len(test_relationship))
test_relationship2 = result['relationships']['test_relationship2']
self.assertEquals('test_relationship2', test_relationship2['name'])
self.assertEqual(
operation_mapping(implementation='test_plugin.install',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
test_relationship2['target_interfaces']['test_interface2']
['install'])
self.assertEqual(
operation_mapping(implementation='test_plugin.terminate',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
test_relationship2['target_interfaces']['test_interface2']
['terminate'])
self.assertEquals(
2, len(test_relationship2['target_interfaces']['test_interface2']))
self.assertEquals(6, len(test_relationship2))
test_relationship3 = result['relationships']['test_relationship3']
self.assertEquals('test_relationship3', test_relationship3['name'])
self.assertEqual(
operation_mapping(implementation='test_plugin.install',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
test_relationship3['target_interfaces']['test_interface2']
['install'])
self.assertEqual(
operation_mapping(implementation='test_plugin.terminate',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
test_relationship3['target_interfaces']['test_interface2']
['terminate'])
self.assertEquals(
2, len(test_relationship3['target_interfaces']['test_interface2']))
self.assertEquals(5, len(test_relationship3))
def test_relationship_interfaces_inheritance_merge(self):
# testing for a complete inheritance path for relationships
# from top-level relationships to a relationship instance
yaml = self.MINIMAL_BLUEPRINT + """
test_node2:
type: test_type
relationships:
- type: relationship
target: test_node
target_interfaces:
test_interface:
destroy: test_plugin.destroy1
source_interfaces:
test_interface:
install2: test_plugin.install2
destroy2: test_plugin.destroy2
relationships:
parent_relationship:
target_interfaces:
test_interface:
install: {}
source_interfaces:
test_interface:
install2: {}
relationship:
derived_from: parent_relationship
target_interfaces:
test_interface:
install:
implementation: test_plugin.install
inputs: {}
terminate:
implementation: test_plugin.terminate
inputs: {}
source_interfaces:
test_interface:
install2:
implementation: test_plugin.install
inputs: {}
terminate2:
implementation: test_plugin.terminate
inputs: {}
plugins:
test_plugin:
executor: central_deployment_agent
source: dummy
"""
result = self.parse(yaml)
self.assertEquals(2, len(result['nodes']))
nodes = self._sort_result_nodes(result['nodes'],
['test_node', 'test_node2'])
node_relationship = nodes[1]['relationships'][0]
relationship = result['relationships']['relationship']
parent_relationship = result['relationships']['parent_relationship']
self.assertEquals(2, len(result['relationships']))
self.assertEquals(5, len(parent_relationship))
self.assertEquals(6, len(relationship))
self.assertEquals(8, len(node_relationship))
self.assertEquals('parent_relationship', parent_relationship['name'])
self.assertEquals(1, len(parent_relationship['target_interfaces']))
self.assertEquals(
1, len(parent_relationship['target_interfaces']['test_interface']))
self.assertIn(
'install',
parent_relationship['target_interfaces']['test_interface'])
self.assertEquals(1, len(parent_relationship['source_interfaces']))
self.assertEquals(
1, len(parent_relationship['source_interfaces']['test_interface']))
self.assertIn(
'install2',
parent_relationship['source_interfaces']['test_interface'])
self.assertEquals('relationship', relationship['name'])
self.assertEquals('parent_relationship', relationship['derived_from'])
self.assertEquals(1, len(relationship['target_interfaces']))
self.assertEquals(
2, len(relationship['target_interfaces']['test_interface']))
self.assertEqual(
operation_mapping(implementation='test_plugin.install',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
relationship['target_interfaces']['test_interface']['install'])
self.assertEqual(
operation_mapping(implementation='test_plugin.terminate',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
relationship['target_interfaces']['test_interface']['terminate'])
self.assertEquals(1, len(relationship['source_interfaces']))
self.assertEquals(
2, len(relationship['source_interfaces']['test_interface']))
self.assertEqual(
operation_mapping(implementation='test_plugin.install',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
relationship['source_interfaces']['test_interface']['install2'])
self.assertEqual(
operation_mapping(implementation='test_plugin.terminate',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
relationship['source_interfaces']['test_interface']['terminate2'])
self.assertEquals('relationship', node_relationship['type'])
self.assertEquals('test_node', node_relationship['target_id'])
self.assertEquals(1, len(node_relationship['target_interfaces']))
self.assertEquals(
3, len(node_relationship['target_interfaces']['test_interface']))
self.assertEqual(
operation_mapping(implementation='test_plugin.install',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
node_relationship['target_interfaces']['test_interface']
['install'])
self.assertEqual(
operation_mapping(implementation='test_plugin.terminate',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
relationship['target_interfaces']['test_interface']['terminate'])
self.assertEqual(
operation_mapping(implementation='test_plugin.destroy1',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
node_relationship['target_interfaces']['test_interface']
['destroy'])
self.assertEquals(1, len(node_relationship['source_interfaces']))
self.assertEquals(
3, len(node_relationship['source_interfaces']['test_interface']))
self.assertEquals(
operation_mapping(implementation='test_plugin.install2',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
node_relationship['source_interfaces']['test_interface']
['install2'])
self.assertEqual(
operation_mapping(implementation='test_plugin.terminate',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
relationship['source_interfaces']['test_interface']['terminate2'])
self.assertEquals(
operation_mapping(implementation='test_plugin.destroy2',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
node_relationship['source_interfaces']['test_interface']
['destroy2'])
rel_source_ops = node_relationship['source_operations']
self.assertEqual(
op_struct('test_plugin',
'install2',
executor='central_deployment_agent'),
rel_source_ops['install2'])
self.assertEqual(
op_struct('test_plugin',
'install2',
executor='central_deployment_agent'),
rel_source_ops['test_interface.install2'])
self.assertEqual(
op_struct('test_plugin',
'terminate',
executor='central_deployment_agent'),
rel_source_ops['terminate2'])
self.assertEqual(
op_struct('test_plugin',
'terminate',
executor='central_deployment_agent'),
rel_source_ops['test_interface.terminate2'])
self.assertEqual(
op_struct('test_plugin',
'destroy2',
executor='central_deployment_agent'),
rel_source_ops['destroy2'])
self.assertEqual(
op_struct('test_plugin',
'destroy2',
executor='central_deployment_agent'),
rel_source_ops['test_interface.destroy2'])
self.assertEquals(6, len(rel_source_ops))
rel_target_ops = node_relationship['target_operations']
self.assertEqual(
op_struct('test_plugin',
'install',
executor='central_deployment_agent'),
rel_target_ops['install'])
self.assertEqual(
op_struct('test_plugin',
'install',
executor='central_deployment_agent'),
rel_target_ops['test_interface.install'])
self.assertEqual(
op_struct('test_plugin',
'terminate',
executor='central_deployment_agent'),
rel_target_ops['terminate'])
self.assertEqual(
op_struct('test_plugin',
'terminate',
executor='central_deployment_agent'),
rel_target_ops['test_interface.terminate'])
self.assertEqual(
op_struct('test_plugin',
'destroy1',
executor='central_deployment_agent'),
rel_target_ops['destroy'])
self.assertEqual(
op_struct('test_plugin',
'destroy1',
executor='central_deployment_agent'),
rel_target_ops['test_interface.destroy'])
self.assertEquals(6, len(rel_source_ops))
def test_relationships_and_node_recursive_inheritance(self):
# testing for a complete inheritance path for relationships
# from top-level relationships to a relationship instance
yaml = self.MINIMAL_BLUEPRINT + """
test_node2:
type: test_type
relationships:
- type: relationship
target: test_node
source_interfaces:
test_interface3:
install: test_plugin.install
target_interfaces:
test_interface1:
install: test_plugin.install
relationships:
relationship:
derived_from: parent_relationship
source_interfaces:
test_interface2:
install:
implementation: test_plugin.install
inputs: {}
terminate:
implementation: test_plugin.terminate
inputs: {}
parent_relationship:
target_interfaces:
test_interface3:
install: {}
plugins:
test_plugin:
executor: central_deployment_agent
source: dummy
"""
result = self.parse(yaml)
self.assertEquals(2, len(result['nodes']))
nodes = self._sort_result_nodes(result['nodes'],
['test_node', 'test_node2'])
node_relationship = nodes[1]['relationships'][0]
relationship = result['relationships']['relationship']
parent_relationship = result['relationships']['parent_relationship']
self.assertEquals(2, len(result['relationships']))
self.assertEquals(5, len(parent_relationship))
self.assertEquals(6, len(relationship))
self.assertEquals(8, len(node_relationship))
self.assertEquals('parent_relationship', parent_relationship['name'])
self.assertEquals(1, len(parent_relationship['target_interfaces']))
self.assertEquals(
1,
len(parent_relationship['target_interfaces']['test_interface3']))
self.assertEquals(
{
'implementation': '',
'inputs': {},
'executor': None,
'max_retries': None,
'retry_interval': None,
'timeout': None,
'timeout_recoverable': None
}, parent_relationship['target_interfaces']['test_interface3']
['install'])
self.assertEquals('relationship', relationship['name'])
self.assertEquals('parent_relationship', relationship['derived_from'])
self.assertEquals(1, len(relationship['target_interfaces']))
self.assertEquals(
1, len(relationship['target_interfaces']['test_interface3']))
self.assertEquals(
NO_OP,
relationship['target_interfaces']['test_interface3']['install'])
self.assertEquals(1, len(relationship['source_interfaces']))
self.assertEquals(
2, len(relationship['source_interfaces']['test_interface2']))
self.assertEqual(
operation_mapping(implementation='test_plugin.install',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
relationship['source_interfaces']['test_interface2']['install'])
self.assertEqual(
operation_mapping(implementation='test_plugin.terminate',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
relationship['source_interfaces']['test_interface2']['terminate'])
self.assertEquals('relationship', node_relationship['type'])
self.assertEquals('test_node', node_relationship['target_id'])
self.assertEquals(2, len(node_relationship['target_interfaces']))
self.assertEquals(
1, len(node_relationship['target_interfaces']['test_interface3']))
self.assertEquals(
NO_OP, node_relationship['target_interfaces']['test_interface3']
['install'])
self.assertEquals(
1, len(node_relationship['target_interfaces']['test_interface1']))
self.assertEqual(
operation_mapping(implementation='test_plugin.install',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
node_relationship['target_interfaces']['test_interface1']
['install'])
self.assertEquals(2, len(node_relationship['source_interfaces']))
self.assertEquals(
1, len(node_relationship['source_interfaces']['test_interface3']))
self.assertEquals(
operation_mapping(implementation='test_plugin.install',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
node_relationship['source_interfaces']['test_interface2']
['install'])
self.assertEquals(
2, len(node_relationship['source_interfaces']['test_interface2']))
self.assertEquals(
operation_mapping(implementation='test_plugin.install',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
node_relationship['source_interfaces']['test_interface2']
['install'])
self.assertEquals(
operation_mapping(implementation='test_plugin.terminate',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
node_relationship['source_interfaces']['test_interface2']
['terminate'])
rel_source_ops = node_relationship['source_operations']
self.assertEquals(4, len(rel_source_ops))
self.assertEqual(
op_struct('test_plugin',
'install',
executor='central_deployment_agent'),
rel_source_ops['test_interface2.install'])
self.assertEqual(
op_struct('test_plugin',
'install',
executor='central_deployment_agent'),
rel_source_ops['test_interface3.install'])
self.assertEqual(
op_struct('test_plugin',
'terminate',
executor='central_deployment_agent'),
rel_source_ops['terminate'])
self.assertEqual(
op_struct('test_plugin',
'terminate',
executor='central_deployment_agent'),
rel_source_ops['test_interface2.terminate'])
rel_target_ops = node_relationship['target_operations']
self.assertEquals(2, len(rel_target_ops))
self.assertEqual(op_struct('', '', {}),
rel_target_ops['test_interface3.install'])
self.assertEqual(
op_struct('test_plugin',
'install',
executor='central_deployment_agent'),
rel_target_ops['test_interface1.install'])
def test_instance_relationships_relationship_inheritance(self):
# possibly 'inheritance' is the wrong term to use here,
# the meaning is for checking that the relationship properties from the
# top-level relationships
# section are used for instance-relationships which declare their types
# note there are no overrides in this case; these are tested in the
# next, more thorough test
yaml = self.MINIMAL_BLUEPRINT + """
test_node2:
type: test_type
relationships:
- type: test_relationship
target: test_node
source_interfaces:
interface1:
op1: test_plugin.task_name1
relationships:
relationship: {}
test_relationship:
derived_from: relationship
target_interfaces:
interface2:
op2:
implementation: test_plugin.task_name2
inputs: {}
plugins:
test_plugin:
executor: central_deployment_agent
source: dummy
"""
result = self.parse(yaml)
self.assertEquals(2, len(result['nodes']))
nodes = self._sort_result_nodes(result['nodes'],
['test_node', 'test_node2'])
relationship = nodes[1]['relationships'][0]
self.assertEquals('test_relationship', relationship['type'])
self.assertEquals('test_node', relationship['target_id'])
self.assertEqual(
operation_mapping(implementation='test_plugin.task_name1',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
relationship['source_interfaces']['interface1']['op1'])
self.assertEqual(
operation_mapping(implementation='test_plugin.task_name2',
inputs={},
executor=None,
max_retries=None,
retry_interval=None,
timeout=None,
timeout_recoverable=None),
relationship['target_interfaces']['interface2']['op2'])
rel_source_ops = relationship['source_operations']
self.assertEqual(
op_struct('test_plugin',
'task_name1',
executor='central_deployment_agent'),
rel_source_ops['op1'])
self.assertEqual(
op_struct('test_plugin',
'task_name1',
executor='central_deployment_agent'),
rel_source_ops['interface1.op1'])
self.assertEquals(2, len(rel_source_ops))
rel_target_ops = relationship['target_operations']
self.assertEqual(
op_struct('test_plugin',
'task_name2',
executor='central_deployment_agent'),
rel_target_ops['op2'])
self.assertEqual(
op_struct('test_plugin',
'task_name2',
executor='central_deployment_agent'),
rel_target_ops['interface2.op2'])
self.assertEquals(2, len(rel_target_ops))
self.assertEquals(8, len(relationship))
