def test_merge_relationship_type_interfaces_no_interfaces_on_overridden(self):  # NOQA

        overriding_interfaces = {
            'interface1': {
                'start': {},
                'stop': {}
            },
            'interface2': {
                'start': {}
            }
        }
        overridden_interfaces = {}

        expected_merged_interfaces = {
            'interface1': {
                'start': NO_OP,
                'stop': NO_OP
            },
            'interface2': {
                'start': NO_OP
            }
        }

        self._validate_type_interfaces(overriding_interfaces)
        self._validate_type_interfaces(overridden_interfaces)
        actual_merged_interfaces = merge_relationship_type_interfaces(
            overriding_interfaces=overriding_interfaces,
            overridden_interfaces=overridden_interfaces)

        self.assertEqual(actual_merged_interfaces,
                         expected_merged_interfaces)
Ejemplo n.º 2
0
    def test_merge_relationship_type_interfaces_no_interfaces_on_overridden(self):  # NOQA

        overriding_interfaces = {
            'interface1': {
                'start': {},
                'stop': {}
            },
            'interface2': {
                'start': {}
            }
        }
        overridden_interfaces = {}

        expected_merged_interfaces = {
            'interface1': {
                'start': NO_OP,
                'stop': NO_OP
            },
            'interface2': {
                'start': NO_OP
            }
        }

        self._validate_type_interfaces(overriding_interfaces)
        self._validate_type_interfaces(overridden_interfaces)
        actual_merged_interfaces = merge_relationship_type_interfaces(
            overriding_interfaces=overriding_interfaces,
            overridden_interfaces=overridden_interfaces)

        self.assertEqual(actual_merged_interfaces,
                         expected_merged_interfaces)
    def test_merge_relationship_type_interfaces_no_target_interfaces_on_overridden(self):  # NOQA

        overriding_relationship_type = self._create_relationship_type(
            source_interfaces={
                'interface1': {
                    'start': {},
                    'stop': {}
                },
                'interface2': {
                    'start': {}
                }
            },
            target_interfaces={
                'interface1': {
                    'start': {},
                    'stop': {}
                },
                'interface2': {
                    'start': {}
                }
            }
        )

        overridden_relationship_type = self._create_relationship_type(
            source_interfaces={
                'interface1': {
                    'start': {
                        'implementation': 'mock.tasks.start'
                    },
                    'stop': {
                        'implementation': 'mock.tasks.stop',
                        'inputs': {
                            'key': {
                                'default': 'value'
                            }
                        }
                    }
                }
            }
        )

        expected_merged_interfaces = {
            SOURCE_INTERFACES: {
                'interface1': {
                    'start': NO_OP,
                    'stop': NO_OP
                },
                'interface2': {
                    'start': NO_OP
                }
            },
            TARGET_INTERFACES: {
                'interface1': {
                    'start': NO_OP,
                    'stop': NO_OP
                },
                'interface2': {
                    'start': NO_OP
                }
            }
        }
        actual_merged_interfaces = merge_relationship_type_interfaces(
            overriding_relationship_type=overriding_relationship_type,
            overridden_relationship_type=overridden_relationship_type
        )

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

        overriding_relationship_type = self._create_relationship_type(
            source_interfaces={
                'interface1': {
                    'start': {
                        'implementation': 'mock.tasks.start'
                    },
                    'stop': {
                        'implementation': 'mock.tasks.stop',
                        'inputs': {
                            'key': {
                                'default': 'value'
                            }
                        }
                    }
                }
            },
            target_interfaces={
                'interface1': {
                    'start': {
                        'implementation': 'mock.tasks.start'
                    },
                    'stop': {
                        'implementation': 'mock.tasks.stop',
                        'inputs': {
                            'key': {
                                'default': 'value'
                            }
                        }
                    }
                }
            }
        )
        overridden_relationship_type = self._create_relationship_type(
            source_interfaces={
                'interface1': {
                    'start': {},
                    'stop': {}
                },
                'interface2': {
                    'start': {}
                }
            },
            target_interfaces={
                'interface1': {
                    'start': {},
                    'stop': {}
                },
                'interface2': {
                    'start': {}
                }
            }
        )

        expected_merged_interfaces = {
            SOURCE_INTERFACES: {
                'interface1': {
                    'start': {
                        'implementation': 'mock.tasks.start',
                        'inputs': {},
                        'executor': None,
                        'max_retries': None,
                        'retry_interval': None
                    },
                    'stop': {
                        'implementation': 'mock.tasks.stop',
                        'inputs': {
                            'key': {
                                'default': 'value'
                            }
                        },
                        'executor': None,
                        'max_retries': None,
                        'retry_interval': None
                    }
                },
                'interface2': {
                    'start': {
                        'implementation': '',
                        'inputs': {},
                        'executor': None,
                        'max_retries': None,
                        'retry_interval': None
                    }
                }
            },
            TARGET_INTERFACES: {
                'interface1': {
                    'start': {
                        'implementation': 'mock.tasks.start',
                        'inputs': {},
                        'executor': None,
                        'max_retries': None,
                        'retry_interval': None
                    },
                    'stop': {
                        'implementation': 'mock.tasks.stop',
                        'inputs': {
                            'key': {
                                'default': 'value'
                            }
                        },
                        'executor': None,
                        'max_retries': None,
                        'retry_interval': None
                    }
                },
                'interface2': {
                    'start': {
                        'implementation': '',
                        'inputs': {},
                        'executor': None,
                        'max_retries': None,
                        'retry_interval': None
                    }
                }
            }
        }
        actual_merged_interfaces = merge_relationship_type_interfaces(
            overriding_relationship_type=overriding_relationship_type,
            overridden_relationship_type=overridden_relationship_type
        )

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

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

        overridden_interfaces = {
            'interface1': {
                'start': {},
                'stop': {}
            },
            'interface2': {
                'start': {}
            }
        }

        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': {
                            'default': 'value'
                        }
                    },
                    'executor': None,
                    'max_retries': None,
                    'retry_interval': None
                }
            },
            'interface2': {
                'start': {
                    'implementation': '',
                    'inputs': {},
                    'executor': None,
                    'max_retries': None,
                    'retry_interval': None
                }
            }
        }

        self._validate_type_interfaces(overriding_interfaces)
        self._validate_type_interfaces(overridden_interfaces)
        actual_merged_interfaces = merge_relationship_type_interfaces(
            overriding_interfaces=overriding_interfaces,
            overridden_interfaces=overridden_interfaces)

        self.assertEqual(actual_merged_interfaces,
                         expected_merged_interfaces)
Ejemplo n.º 6
0
    def test_merge_relationship_type_interfaces(self):

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

        overridden_interfaces = {
            'interface1': {
                'start': {},
                'stop': {}
            },
            'interface2': {
                'start': {}
            }
        }

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

        self._validate_type_interfaces(overriding_interfaces)
        self._validate_type_interfaces(overridden_interfaces)
        actual_merged_interfaces = merge_relationship_type_interfaces(
            overriding_interfaces=overriding_interfaces,
            overridden_interfaces=overridden_interfaces)

        self.assertEqual(actual_merged_interfaces,
                         expected_merged_interfaces)