Exemple #1
0
    def test_check_for_versions_intersection_positive(self):
        func_list = \
            [versioned_method.VersionedMethod('foo',
                                              versions.Version('', '', '',
                                                               '2.1'),
                                              versions.Version('', '', '',
                                                               '2.4'),
                                              None),
             versioned_method.VersionedMethod('foo',
                                              versions.Version('', '', '',
                                                               '2.3'),
                                              versions.Version('', '', '',
                                                               '3.1'),
                                              None),
             versioned_method.VersionedMethod('foo',
                                              versions.Version('', '', '',
                                                               '2.9'),
                                              versions.Version('', '', '',
                                                               '3.4'),
                                              None)
             ]

        result = base.Controller.check_for_versions_intersection(
            func_list=func_list)
        self.assertTrue(result)
Exemple #2
0
    def test_check_for_versions_intersection_negative(self):
        func_list = \
            [versioned_method.VersionedMethod('foo',
                                              versions.Version('', '', '',
                                                               '2.1'),
                                              versions.Version('', '', '',
                                                               '2.4'),
                                              None),
             versioned_method.VersionedMethod('foo',
                                              versions.Version('', '', '',
                                                               '2.11'),
                                              versions.Version('', '', '',
                                                               '3.1'),
                                              None),
             versioned_method.VersionedMethod('foo',
                                              versions.Version('', '', '',
                                                               '2.8'),
                                              versions.Version('', '', '',
                                                               '2.9'),
                                              None),
             ]

        result = base.Controller.check_for_versions_intersection(
            func_list=func_list)
        self.assertFalse(result)

        func_list = \
            [versioned_method.VersionedMethod('foo',
                                              versions.Version('', '', '',
                                                               '2.12'),
                                              versions.Version('', '', '',
                                                               '2.14'),
                                              None),
             versioned_method.VersionedMethod('foo',
                                              versions.Version('', '', '',
                                                               '3.0'),
                                              versions.Version('', '', '',
                                                               '3.4'),
                                              None)
             ]

        result = base.Controller.check_for_versions_intersection(
            func_list=func_list)
        self.assertFalse(result)
Exemple #3
0
    def test_check_for_versions_intersection_shared_start_end(self):
        func_list = \
            [versioned_method.VersionedMethod('foo',
                                              versions.Version('', '', '',
                                                               '1.1'),
                                              versions.Version('', '', '',
                                                               '1.1'),
                                              None),
             versioned_method.VersionedMethod('foo',
                                              versions.Version('', '', '',
                                                               '1.1'),
                                              versions.Version('', '', '',
                                                               '1.2'),
                                              None)
             ]

        result = base.Controller.check_for_versions_intersection(
            func_list=func_list)
        self.assertTrue(result)
Exemple #4
0
        def decorator(f):
            obj_min_ver = versions.Version('', '', '', min_ver)
            if max_ver:
                obj_max_ver = versions.Version('', '', '', max_ver)
            else:
                obj_max_ver = versions.Version('', '', '',
                                               versions.CURRENT_MAX_VER)

            # Add to list of versioned methods registered
            func_name = f.__name__
            new_func = versioned_method.VersionedMethod(
                func_name, obj_min_ver, obj_max_ver, f)

            func_dict = getattr(cls, VER_METHOD_ATTR, {})
            if not func_dict:
                setattr(cls, VER_METHOD_ATTR, func_dict)

            func_list = func_dict.get(func_name, [])
            if not func_list:
                func_dict[func_name] = func_list
            func_list.append(new_func)

            is_intersect = Controller.check_for_versions_intersection(
                func_list)

            if is_intersect:
                raise exception.ApiVersionsIntersect(
                    name=new_func.name,
                    min_ver=new_func.start_version,
                    max_ver=new_func.end_version
                )

            # Ensure the list is sorted by minimum version (reversed)
            # so later when we work through the list in order we find
            # the method which has the latest version which supports
            # the version requested.
            func_list.sort(key=lambda f: f.start_version, reverse=True)

            return f