def test_merge_relationship_type_no_interfaces_and_instance_interfaces(self):  # NOQA

        relationship_type_interfaces = {}
        relationship_instance_interfaces = {
            'interface1': {
                'start': 'mock.tasks.start-overridden'
            }
        }

        expected_merged_interfaces = {
            'interface1': {
                'start': {
                    'implementation': 'mock.tasks.start-overridden',
                    'inputs': {},
                    'executor': None,
                    'max_retries': None,
                    'retry_interval': None
                }
            }
        }

        self._validate_type_interfaces(relationship_type_interfaces)
        self._validate_instance_interfaces(relationship_instance_interfaces)
        actual_merged_interfaces = \
            merge_relationship_type_and_instance_interfaces(
                relationship_type_interfaces=relationship_type_interfaces,
                relationship_instance_interfaces=relationship_instance_interfaces)  # noqa

        self.assertEqual(actual_merged_interfaces,
                         expected_merged_interfaces)
Example #2
0
    def test_merge_relationship_type_no_interfaces_and_instance_interfaces(self):  # NOQA

        relationship_type_interfaces = {}
        relationship_instance_interfaces = {
            'interface1': {
                'start': 'mock.tasks.start-overridden'
            }
        }

        expected_merged_interfaces = {
            'interface1': {
                'start': {
                    'implementation': 'mock.tasks.start-overridden',
                    'inputs': {},
                    'executor': None,
                    'max_retries': None,
                    'retry_interval': None,
                    'timeout': None,
                    'timeout_recoverable': None
                }
            }
        }

        self._validate_type_interfaces(relationship_type_interfaces)
        self._validate_instance_interfaces(relationship_instance_interfaces)
        actual_merged_interfaces = \
            merge_relationship_type_and_instance_interfaces(
                relationship_type_interfaces=relationship_type_interfaces,
                relationship_instance_interfaces=relationship_instance_interfaces)  # noqa

        self.assertEqual(actual_merged_interfaces,
                         expected_merged_interfaces)
Example #3
0
    def test_merge_relationship_type_and_instance_interfaces(self):

        relationship_type_interfaces = {
            'interface1': {
                'start': {
                    'implementation': 'mock.tasks.start'
                },
                'stop': {
                    'implementation': 'mock.tasks.stop',
                    'inputs': {
                        'key': {
                            'default': 'value'
                        }
                    }
                }
            }
        }

        relationship_instance_interfaces = {
            'interface1': {
                'start': 'mock.tasks.start-overridden'
            }
        }

        expected_merged_interfaces = {
            'interface1': {
                'start': {
                    'implementation': 'mock.tasks.start-overridden',
                    'inputs': {},
                    'executor': None,
                    'max_retries': None,
                    'retry_interval': None
                },
                'stop': {
                    'implementation': 'mock.tasks.stop',
                    'inputs': {
                        'key': 'value'
                    },
                    'executor': None,
                    'max_retries': None,
                    'retry_interval': None
                }
            }
        }

        self._validate_type_interfaces(relationship_type_interfaces)
        self._validate_instance_interfaces(relationship_instance_interfaces)
        actual_merged_interfaces = \
            merge_relationship_type_and_instance_interfaces(
                relationship_type_interfaces=relationship_type_interfaces,
                relationship_instance_interfaces=relationship_instance_interfaces)  # noqa

        self.assertEqual(actual_merged_interfaces, expected_merged_interfaces)
    def test_merge_relationship_type_and_instance_no_interfaces(self):

        relationship_type_interfaces = {
            'interface1': {
                'start': {
                    'implementation': 'mock.tasks.start'
                },
                'stop': {
                    'implementation': 'mock.tasks.stop',
                    'inputs': {
                        'key': {
                            'default': 'value'
                        }
                    }
                }
            }
        }

        relationship_instance_interfaces = {}

        expected_merged_interfaces = {
            'interface1': {
                'start': {
                    'implementation': 'mock.tasks.start',
                    'inputs': {},
                    'executor': None,
                    'max_retries': None,
                    'retry_interval': None
                },
                'stop': {
                    'implementation': 'mock.tasks.stop',
                    'inputs': {
                        'key': 'value'
                    },
                    'executor': None,
                    'max_retries': None,
                    'retry_interval': None
                }
            }
        }

        self._validate_type_interfaces(relationship_type_interfaces)
        self._validate_instance_interfaces(relationship_instance_interfaces)
        actual_merged_interfaces = \
            merge_relationship_type_and_instance_interfaces(
                relationship_type_interfaces=relationship_type_interfaces,
                relationship_instance_interfaces=relationship_instance_interfaces)  # noqa

        self.assertEqual(actual_merged_interfaces,
                         expected_merged_interfaces)
    def parse(self, relationship_type):
        result = self.build_dict_result()
        for interfaces in [constants.SOURCE_INTERFACES, constants.TARGET_INTERFACES]:
            result[interfaces] = interfaces_parser.merge_relationship_type_and_instance_interfaces(
                relationship_type_interfaces=relationship_type[interfaces],
                relationship_instance_interfaces=result[interfaces],
            )

        result[constants.TYPE_HIERARCHY] = relationship_type[constants.TYPE_HIERARCHY]

        result["target_id"] = result["target"]
        del result["target"]

        return result
    def test_merge_relationship_no_target_interfaces_type_and_instance_interfaces(self):  # NOQA

        relationship_type = self._create_relationship_type(
            source_interfaces={
                'interface1': {
                    'start': {
                        'implementation': 'mock.tasks.start'
                    },
                    'stop': {
                        'implementation': 'mock.tasks.stop',
                        'inputs': {
                            'key': {
                                'default': 'value'
                            }
                        }
                    }
                }
            }
        )
        relationship_instance = self._create_relationship_instance(
            source_interfaces={
                'interface1': {
                    'start': 'mock.tasks.start-overridden'
                }
            },
            target_interfaces={
                'interface1': {
                    'start': 'mock.tasks.start-overridden'
                }
            }
        )

        expected_merged_interfaces = {
            SOURCE_INTERFACES: {
                'interface1': {
                    'start': {
                        'implementation': 'mock.tasks.start-overridden',
                        'inputs': {},
                        'executor': None,
                        'max_retries': None,
                        'retry_interval': None
                    },
                    'stop': {
                        'implementation': 'mock.tasks.stop',
                        'inputs': {
                            'key': 'value'
                        },
                        'executor': None,
                        'max_retries': None,
                        'retry_interval': None
                    }
                }
            },
            TARGET_INTERFACES: {
                'interface1': {
                    'start': {
                        'implementation': 'mock.tasks.start-overridden',
                        'inputs': {},
                        'executor': None,
                        'max_retries': None,
                        'retry_interval': None
                    }
                }
            }
        }

        actual_merged_interfaces = \
            merge_relationship_type_and_instance_interfaces(
                relationship_type=relationship_type,
                relationship_instance=relationship_instance
            )

        self.assertEqual(actual_merged_interfaces,
                         expected_merged_interfaces)