Merge #1552 Fix the provides of base modules

module_build_service/mmd_resolver.py

@@ -228,9 +228,14 @@ class MMDResolver(object):
 
         - module(platform:el8.1.0) = 80100 - Modules can require specific platform stream.
         - module(platform:el8) = 80100 - Module can also require just platform:el8.
+
+        :return: A boolean that is True if a provides for the stream version was added to the input
+            solvable.
         """
+        base_stream_ver = False
+
         if mmd.get_module_name() not in conf.base_module_names:
-            return
+            return base_stream_ver
 
         # When depsolving, we will need to follow specific rules to choose the right base
         # module, like sorting the base modules sharing the same virtual streams based on
@@ -240,13 +245,14 @@ class MMDResolver(object):
         # to Provides.
         stream_version = ModuleBuild.get_stream_version(mmd.get_stream_name(), right_pad=False)
         if stream_version:
+            base_stream_ver = True
             self.solvable_provides(
                 solvable, mmd.get_module_name(), mmd.get_stream_name(), str(stream_version))
 
         xmd = mmd.get_xmd()
         # Return in case virtual_streams are not set for this mmd.
         if not xmd.get("mbs", {}).get("virtual_streams"):
-            return
+            return base_stream_ver
 
         version = stream_version or mmd.get_version()
         # For each virtual stream, add
@@ -254,6 +260,8 @@ class MMDResolver(object):
         for stream in xmd["mbs"]["virtual_streams"]:
             self.solvable_provides(solvable, mmd.get_module_name(), stream, str(version))
 
+        return base_stream_ver
+
     def _get_base_module_stream_overrides(self, mmd):
         """
         Checks the xmd["mbs"]["buildrequires"] and returns the dict containing
@@ -326,11 +334,14 @@ class MMDResolver(object):
             # no particular stream is used - for example when buildrequiring
             # "gtk: []"
             self.solvable_provides(solvable, n)
+
+            base_stream_ver = self._add_base_module_provides(solvable, mmd)
+
             # Add "Provides: module(name:stream) = version", so we can find buildrequired
             # modules when "gtk:[1]" is used and also choose the latest version.
-            self.solvable_provides(solvable, n, s, str(v))
-
-            self._add_base_module_provides(solvable, mmd)
+            # Skipped if this is a base module with a stream version defined.
+            if not base_stream_ver:
+                self.solvable_provides(solvable, n, s, str(v))
 
             base_module_stream_overrides = self._get_base_module_stream_overrides(mmd)
             # Fill in the "Requires" of this module, so we can track its dependencies

tests/test_mmd_resolver.py

@@ -25,6 +25,7 @@
 
 import collections
 import pytest
+import solv
 
 from module_build_service.mmd_resolver import MMDResolver
 from module_build_service import Modulemd
@@ -400,3 +401,35 @@ class TestMMDResolver:
         }
 
         assert expanded == expected
+
+    @pytest.mark.parametrize(
+        "nsvc, requires, expected",
+        (
+            ("platform:f28:0:c0", {}, True),
+            ("platform:latest:5:c8", {}, False),
+            ("gtk:3:0:c8", {"platform": ["f28"]}, False)
+        ),
+    )
+    def test_base_module_stream_version(self, nsvc, requires, expected):
+        """
+        Tests that add_base_module_provides returns True for base modules with stream versions
+        """
+        mmd = self._make_mmd(nsvc, requires)
+        solvable = self.mmd_resolver.available_repo.add_solvable()
+        solvable.name = nsvc
+        solvable.evr = str(mmd.get_version())
+        solvable.arch = "x86_64"
+        assert self.mmd_resolver._add_base_module_provides(solvable, mmd) is expected
+
+    @pytest.mark.parametrize(
+        "nsvc, expected",
+        (
+            ("platform:f28:3:c0", {"module(platform)", "module(platform:f28) = 28.0"}),
+            ("platform:latest:5:c8", {"module(platform)", "module(platform:latest) = 5"}),
+        ),
+    )
+    def test_base_module_provides(self, nsvc, expected):
+        self.mmd_resolver.add_modules(self._make_mmd(nsvc, {}))
+        ns = nsvc.rsplit(":", 2)[0]
+        provides = self.mmd_resolver.solvables[ns][0].lookup_deparray(solv.SOLVABLE_PROVIDES)
+        assert {str(provide) for provide in provides} == expected