Add tests for existing filters

Signed-off-by: Webster Mudge <[email protected]>

Author: wmudge

plugins/module_utils/cldr_version.py

@@ -41,17 +41,18 @@
         )?
     $
     """,
-    flags=re.X
+    flags=re.X,
 )
 
+
 class ClouderaVersion(Version):
     """Version comparison class that implements Cloudera versioning.
 
     Cloudera versioning is an extension of Semantic Versioning that uses the
     ``prerelease`` segment as service packs or patch releases.
-    
+
     Moreover, this versioning scheme allow the ``prerelease`` delimiter
-    to use whitespace (' ') and dots  ('.') in addition to the semantic 
+    to use whitespace (' ') and dots  ('.') in addition to the semantic
     version's dash ('-').
 
     Based off of ``distutils.version.Version`` and ``ansible.utils.version``.
@@ -71,7 +72,7 @@ def __init__(self, vstring=None):
             self.parse(vstring)
 
     def __repr__(self):
-        return 'ClouderaVersion(%r)' % self.vstring
+        return "ClouderaVersion(%r)" % self.vstring
 
     @staticmethod
     def from_loose_version(loose_version):
@@ -90,7 +91,7 @@ def from_loose_version(loose_version):
             raise ValueError("%r is not a LooseVersion" % loose_version)
 
         extra_idx = 3
-        for marker in ('-', '+'):
+        for marker in ("-", "+"):
             try:
                 idx = version.index(marker)
             except ValueError:
@@ -104,14 +105,15 @@ def from_loose_version(loose_version):
             raise ValueError("Non integer values in %r" % loose_version)
 
         # Extra is everything to the right of the core version
-        extra = re.search('[+-].+$', loose_version.vstring)
+        extra = re.search("[+-].+$", loose_version.vstring)
 
         version = version + [0] * (3 - len(version))
         return ClouderaVersion(
-            '%s%s' % (
-                '.'.join(str(v) for v in version),
-                extra.group(0) if extra else ''
-            )
+            "%s%s"
+            % (
+                ".".join(str(v) for v in version),
+                extra.group(0) if extra else "",
+            ),
         )
 
     def parse(self, vstring) -> None:
@@ -129,9 +131,14 @@ def parse(self, vstring) -> None:
         self.buildmetadata = None
 
         if prerelease:
-            self.prerelease = tuple(_Numeric(x) if x.isdigit() else _Alpha(x) for x in prerelease.split('.'))
+            self.prerelease = tuple(
+                _Numeric(x) if x.isdigit() else _Alpha(x) for x in prerelease.split(".")
+            )
         if buildmetadata:
-            self.buildmetadata = tuple(_Numeric(x) if x.isdigit() else _Alpha(x) for x in buildmetadata.split('.'))
+            self.buildmetadata = tuple(
+                _Numeric(x) if x.isdigit() else _Alpha(x)
+                for x in buildmetadata.split(".")
+            )
 
     @property
     def core(self) -> tuple[int | None, int | None, int | None]:

plugins/test/cldr.py

@@ -19,40 +19,53 @@
 from ansible import errors
 from ansible.module_utils.common.text.converters import to_native, to_text
 
-from ansible_collections.cloudera.exe.plugins.module_utils.cldr_version import ClouderaVersion
+from ansible_collections.cloudera.exe.plugins.module_utils.cldr_version import (
+    ClouderaVersion,
+)
 
 
 def cldr_version_compare(value, version, operator="eq"):
-    """ Perform a Cloudera version comparison on a value """
+    """Perform a Cloudera version comparison on a value"""
     op_map = {
-        '==': 'eq', '=': 'eq', 'eq': 'eq',
-        '<': 'lt', 'lt': 'lt',
-        '<=': 'le', 'le': 'le',
-        '>': 'gt', 'gt': 'gt',
-        '>=': 'ge', 'ge': 'ge',
-        '!=': 'ne', '<>': 'ne', 'ne': 'ne'
+        "==": "eq",
+        "=": "eq",
+        "eq": "eq",
+        "<": "lt",
+        "lt": "lt",
+        "<=": "le",
+        "le": "le",
+        ">": "gt",
+        "gt": "gt",
+        ">=": "ge",
+        "ge": "ge",
+        "!=": "ne",
+        "<>": "ne",
+        "ne": "ne",
     }
 
     if operator in op_map:
         operator = op_map[operator]
     else:
         raise errors.AnsibleFilterError(
-            'Invalid operator type (%s). Must be one of %s' % (operator, ', '.join(map(repr, op_map)))
+            "Invalid operator type (%s). Must be one of %s"
+            % (operator, ", ".join(map(repr, op_map))),
         )
-    
+
     try:
         method = getattr(py_operator, operator)
-        return method(ClouderaVersion(to_text(value)), ClouderaVersion(to_text(version)))
+        return method(
+            ClouderaVersion(to_text(value)),
+            ClouderaVersion(to_text(version)),
+        )
     except Exception as e:
-        raise errors.AnsibleFilterError('Version comparison failed: %s' % to_native(e))
+        raise errors.AnsibleFilterError("Version comparison failed: %s" % to_native(e))
 
 
 class TestModule(object):
-    """ Cloudera jinja2 tests """
+    """Cloudera jinja2 tests"""
 
     def tests(self):
         return {
             # failure testing
-            'version': cldr_version_compare,
+            "version": cldr_version_compare,
         }
-  

tests/unit/plugins/conftest.py

@@ -21,22 +21,28 @@
 import logging
 import pytest
 
-from ansible_collections.cloudera.exe.plugins.filter.core_exe import FilterModule as filters_exe
+from ansible_collections.cloudera.exe.plugins.filter.core_exe import (
+    FilterModule as filters_exe,
+)
 from ansible_collections.cloudera.exe.plugins.test.cldr import TestModule as tests_exe
 
 
 LOG = logging.getLogger(__name__)
 
 # Pytest fixtures
 
+
 @pytest.fixture(scope="module")
 def filter():
     def get_filter(filter_short_name: str):
         return filters_exe().filters().get(filter_short_name)
+
     return get_filter
 
+
 @pytest.fixture(scope="module")
 def test():
     def get_test(test_short_name: str):
         return tests_exe().tests().get(test_short_name)
+
     return get_test

tests/unit/plugins/filter/test_core_exe.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2025 Cloudera, Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import, division, print_function
+
+__metaclass__ = type
+
+import pytest
+
+from unittest import TestCase
+
+
+dataset = [
+    (
+        {"foo": "bar", "gaz": "blaz", "nested": {"duz": "ferr"}},
+        {"gaz": "blergh", "derr": "zaar", "nested": {"wuz": "gug"}},
+        False,
+        {
+            "foo": "bar",
+            "gaz": "blaz",
+            "derr": "zaar",
+            "nested": {"duz": "ferr"},
+        },
+    ),
+    (
+        {"foo": "bar", "gaz": "blaz", "nested": {"duz": "ferr"}},
+        {"gaz": "blergh", "derr": "zaar", "nested": {"wuz": "gug"}},
+        True,
+        {
+            "foo": "bar",
+            "gaz": "blaz",
+            "derr": "zaar",
+            "nested": {"duz": "ferr", "wuz": "gug"},
+        },
+    ),
+]
+
+
+@pytest.mark.parametrize("source,target,recursive,expected", dataset)
+def test_filter_version(filter, source, target, recursive, expected):
+    onto_filter = filter("combine_onto")
+
+    actual = onto_filter([source, target], recursive=recursive)
+
+    TestCase().assertDictEqual(expected, actual)

tests/unit/plugins/filter/test_filter_combine_onto.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2025 Cloudera, Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import, division, print_function
+
+__metaclass__ = type
+
+import pytest
+
+
+dataset = [
+    ("1.2.3", (1, 2, 3, None, None)),
+    ("1.2.3 SP1", (1, 2, 3, tuple(["SP1"]), None)),
+    ("1.2.3-SP1", (1, 2, 3, tuple(["SP1"]), None)),
+    ("1.2.3.SP1", (1, 2, 3, tuple(["SP1"]), None)),
+    ("1.2.3 SP1.400", (1, 2, 3, tuple(["SP1", 400]), None)),
+    ("1.2.3+Build", (1, 2, 3, None, tuple(["Build"]))),
+    ("1.2.3+Build.400", (1, 2, 3, None, tuple(["Build", 400]))),
+]
+
+
+@pytest.mark.parametrize("vstring,expected", dataset)
+def test_filter_version(filter, vstring, expected):
+    version_filter = filter("version")
+
+    actual = version_filter(vstring)
+
+    assert actual.get("major") == expected[0]
+    assert actual.get("minor") == expected[1]
+    assert actual.get("patch") == expected[2]
+    assert actual.get("prerelease") == expected[3]
+    assert actual.get("buildmetadata") == expected[4]