From fedcc4c28b897ae6a18e4a03eab1f0c2a72c2889 Mon Sep 17 00:00:00 2001
From: Andrew Butcher <abutcher@redhat.com>
Date: Mon, 27 Mar 2017 16:09:40 -0400
Subject: Use oo_version_gte_3_6+ for future versions and treat 1.x origin as
 legacy. Add tests.

---
 filter_plugins/openshift_version.py | 87 +++++++++++++++++++++++++------------
 1 file changed, 59 insertions(+), 28 deletions(-)

(limited to 'filter_plugins')

diff --git a/filter_plugins/openshift_version.py b/filter_plugins/openshift_version.py
index df8f565f0..1403e9dcc 100644
--- a/filter_plugins/openshift_version.py
+++ b/filter_plugins/openshift_version.py
@@ -12,7 +12,7 @@ Custom version comparison filters for use in openshift-ansible
 from distutils.version import LooseVersion
 
 
-def gte_function_builder(name, versions):
+def legacy_gte_function_builder(name, versions):
     """
     Build and return a version comparison function.
 
@@ -46,50 +46,81 @@ def gte_function_builder(name, versions):
     return _gte_function
 
 
+def gte_function_builder(name, gte_version):
+    """
+    Build and return a version comparison function.
+
+    Ex: name = 'oo_version_gte_3_6'
+        version = '3.6'
+
+        returns oo_version_gte_3_6, a function which based on the
+        version will return true if the provided version is greater
+        than or equal to the function's version
+    """
+    def _gte_function(version):
+        """
+        Dynamic function created by gte_function_builder.
+
+        Ex: version = '3.1'
+            returns True/False
+        """
+        version_gte = False
+        if str(version) >= LooseVersion(gte_version):
+            version_gte = True
+        return version_gte
+    _gte_function.__name__ = name
+    return _gte_function
+
+
 # pylint: disable=too-few-public-methods
 class FilterModule(object):
     """
     Filters for version checking.
     """
-    #: The major versions to start incrementing. (enterprise, origin)
-    majors = [(3, 1)]
-
-    #: The minor version to start incrementing
-    minor = 3
-    #: The number of iterations to increment
-    minor_iterations = 10
+    # Each element of versions is composed of (major, minor_start, minor_end)
+    # Origin began versioning 3.x with 3.6, so begin 3.x with 3.6.
+    versions = [(3, 6, 10)]
 
     def __init__(self):
         """
         Creates a new FilterModule for ose version checking.
         """
         self._filters = {}
-        # For each major version
-        for enterprise, origin in self.majors:
+
+        # For each set of (major, minor, minor_iterations)
+        for major, minor_start, minor_end in self.versions:
             # For each minor version in the range
-            for minor in range(self.minor, self.minor_iterations):
+            for minor in range(minor_start, minor_end):
                 # Create the function name
-                func_name = 'oo_version_gte_{}_{}_or_{}_{}'.format(
-                    enterprise, minor, origin, minor)
+                func_name = 'oo_version_gte_{}_{}'.format(major, minor)
                 # Create the function with the builder
-                func = gte_function_builder(
-                    func_name, {
-                        'enterprise': '{}.{}.0'.format(enterprise, minor),
-                        'origin': '{}.{}.0'.format(origin, minor)
-                    })
+                func = gte_function_builder(func_name, "{}.{}.0".format(major, minor))
                 # Add the function to the mapping
                 self._filters[func_name] = func
 
-        # Create filters with special versioning requirements
-        self._filters['oo_version_gte_3_1_or_1_1'] = gte_function_builder('oo_version_gte_3_1_or_1_1',
-                                                                          {'enterprise': '3.0.2.905',
-                                                                           'origin': '1.1.0'})
-        self._filters['oo_version_gte_3_1_1_or_1_1_1'] = gte_function_builder('oo_version_gte_3_1_or_1_1',
-                                                                              {'enterprise': '3.1.1',
-                                                                               'origin': '1.1.1'})
-        self._filters['oo_version_gte_3_2_or_1_2'] = gte_function_builder('oo_version_gte_3_2_or_1_2',
-                                                                          {'enterprise': '3.1.1.901',
-                                                                           'origin': '1.2.0'})
+        # Create filters with special versioning requirements.
+        # Treat all Origin 1.x as special case.
+        legacy_filters = [{'name': 'oo_version_gte_3_1_or_1_1',
+                           'versions': {'enterprise': '3.0.2.905',
+                                        'origin': '1.1.0'}},
+                          {'name': 'oo_version_gte_3_1_1_or_1_1_1',
+                           'versions': {'enterprise': '3.1.1',
+                                        'origin': '1.1.1'}},
+                          {'name': 'oo_version_gte_3_2_or_1_2',
+                           'versions': {'enterprise': '3.1.1.901',
+                                        'origin': '1.2.0'}},
+                          {'name': 'oo_version_gte_3_3_or_1_3',
+                           'versions': {'enterprise': '3.3.0',
+                                        'origin': '1.3.0'}},
+                          {'name': 'oo_version_gte_3_4_or_1_4',
+                           'versions': {'enterprise': '3.4.0',
+                                        'origin': '1.4.0'}},
+                          {'name': 'oo_version_gte_3_5_or_1_5',
+                           'versions': {'enterprise': '3.5.0',
+                                        'origin': '1.5.0'}}]
+        for legacy_filter in legacy_filters:
+            self._filters[legacy_filter['name']] = legacy_gte_function_builder(legacy_filter['name'],
+                                                                               legacy_filter['versions'])
 
     def filters(self):
         """
-- 
cgit v1.2.1