@staticmethod

      def get_last_builds_in_stream_version_lte(

          """

          Returns the latest builds in "ready" state for given name:stream limited by

          `stream_version`. The `stream_version` is int generated by `get_stream_version(...)`

          :param list virtual_streams: A list of the virtual streams to filter on. The filtering uses

              "or" logic. When falsy, no filtering occurs.

          """

          query = (

              session.query(ModuleBuild)

              .filter(ModuleBuild.name == name)

              .order_by(sqlalchemy.cast(ModuleBuild.version, db.BigInteger).desc())

          )

              if module:

                  return load_mmd(module.modulemd)

          """

          Gets the module modulemds from the resolver.

          :param name: a string of the module's name

              be returned.

          :kwarg strict: Normally this function returns [] if no module can be

              found.  If strict=True, then a UnprocessableEntity is raised.

          :return: List of Modulemd metadata instances matching the query

          """

          if version and context:

          with models.make_session(self.config) as session:

              if not version and not context:

              else:

                  raise NotImplementedError(

                      "This combination of name/stream/version/context is not implemented")

                      "Cannot find any module builds for %s:%s" % (name, stream))

              return [build.mmd() for build in builds]

      def get_buildrequired_modulemds(self, name, stream, base_module_nsvc):

          """

          Returns modulemd metadata of all module builds with `name` and `stream` buildrequiring

          self.mbs_prod_url = config.mbs_url

          self._generic_error = "Failed to query MBS with query %r returned HTTP status %s"

          """

          Generates dict with MBS params query.

          :param str version/int: Version of the module to query.

          :param str context: Context of the module to query.

          """

          query = {

              "name": name,

              "stream": stream,

              "verbose": True,

              "order_desc_by": "version",

          }

          return query

      def _get_modules(

      ):

          """Query and return modules from MBS with specific info

          :rtype: list[dict]

          :raises UnprocessableEntity: if no modules are found and ``strict`` is True.

          """

          query["page"] = 1

          query["per_page"] = 10

          query.update(kwargs)

          else:

              return modules

          if rv:

              return rv[0]

          strict=False,

          stream_version_lte=False,

          virtual_streams=None,

      ):

          """

          Gets the module modulemds from the resolver.

          if virtual_streams:

              extra_args["virtual_stream"] = virtual_streams

          if not modules:

              return []

              mmds.append(load_mmd(yaml))

          return mmds

      def get_buildrequired_modulemds(self, name, stream, base_module_nsvc):

          """

          Returns modulemd metadata of all module builds with `name` and `stream` buildrequiring

          raise NotImplementedError()

      @abstractmethod

      ):

          raise NotImplementedError()

      old versions of the base module based on the stream version.

      :param Modulemd mmd: Input modulemd metadata.

      """

      seen = set()

      resolver = module_build_service.resolver.system_resolver

      for deps in mmd.get_dependencies():

                  # `stream_mmd`.

                  if not virtual_streams:

                      seen.add(ns)

                      continue

                  virtual_streams = xmd["mbs"]["virtual_streams"]

                  if conf.allow_only_compatible_base_modules:

                      stream_version_lte = True

                  else:

                      stream_version_lte = False

                  # Just in case it was queried for but MBS didn't find it

                  seen.add(ns)

              break

      # Get the MMDs of all compatible base modules based on the buildrequires.

      base_module_mmds = _get_base_module_mmds(mmd)

          base_module_choices = " or ".join(conf.base_module_names)

          raise UnprocessableEntity(

              "None of the base module ({}) streams in the buildrequires section could be found"

          )

      # Add base modules to `mmds`.

          ns = ":".join([base_module.get_module_name(), base_module.get_stream_name()])

          mmds.setdefault(ns, [])

          mmds[ns].append(base_module)

      # Get all the buildrequires of the module of interest.

      for deps in mmd.get_dependencies():

          deps_dict = deps_to_dict(deps, 'buildtime')

          mmds = _get_mmds_from_requires(

      # Now get the requires of buildrequires recursively.

      for mmd_key in list(mmds.keys()):

                      True,

                      default_streams,

                      raise_if_stream_ambigous,

                  )

      # Make single list from dict of lists.

          assert nsvcs == set(["testmodule:master:20170109091357:123"])

      @pytest.mark.parametrize("stream_versions", [False, True])

          tests.init_data(1, multiple_stream_versions=True)

          resolver = mbs_resolver.GenericResolver.create(tests.conf, backend="db")

          nsvcs = set([mmd.get_nsvc() for mmd in result])

          if stream_versions:

              assert nsvcs == set(["platform:f29.1.0:3:00000000", "platform:f29.0.0:3:00000000"])

          else:

      @pytest.mark.parametrize("empty_buildrequires", [False, True])

      def test_get_module_build_dependencies(self, empty_buildrequires, db_session):

              "order_desc_by": "version",

              "page": 1,

              "per_page": 10,

              "virtual_stream": ["f28"],

          }

          mock_session.get.assert_called_once_with(mbs_url, params=expected_query)

              "order_desc_by": "version",

              "page": 1,

              "per_page": 10,

          }

          mock_session.get.assert_called_once_with(mbs_url, params=expected_query)

          assert nsvcs == expected

                  "order_desc_by": "version",

                  "page": 1,

                  "per_page": 10,

              },

              {

                  "name": "platform",

                  "order_desc_by": "version",

                  "page": 1,

                  "per_page": 10,

              },

          ]

              "order_desc_by": "version",

              "page": 1,

              "per_page": 10,

          }

          mock_session.get.assert_called_once_with(mbs_url, params=expected_query)

          assert set(result) == expected

              "order_desc_by": "version",

              "page": 1,

              "per_page": 10,

          }

          mock_session.get.assert_called_once_with(mbs_url, params=expected_query)

  import pytest

  import module_build_service.utils

  from module_build_service.errors import StreamAmbigous

  from tests import db, clean_database, make_module, init_data, read_staged_data

          mmds = module_build_service.utils.mse._get_base_module_mmds(mmd)

          expected = set(["platform:f29.0.0", "platform:f29.1.0", "platform:f29.2.0"])

          # Verify no duplicates were returned before doing set operations

          # Verify the expected ones were returned

          actual = set()

              actual.add("{}:{}".format(mmd_.get_module_name(), mmd_.get_stream_name()))

          assert actual == expected

          else:

              expected = set(["platform:f29.0.0", "platform:f29.1.0", "platform:f29.2.0"])

          # Verify no duplicates were returned before doing set operations

          # Verify the expected ones were returned

          actual = set()

              actual.add("{}:{}".format(mmd_.get_module_name(), mmd_.get_stream_name()))

          assert actual == expected

      def test__get_base_module_mmds_virtual_streams_only_major_versions(self, cfg):

          """Ensure the correct results are returned without duplicates."""

          init_data(data_size=1, multiple_stream_versions=["foo28", "foo29", "foo30"])

          mmd = module_build_service.utils.load_mmd(read_staged_data("testmodule_v2"))

          deps = mmd.get_dependencies()[0]

          new_deps = Modulemd.Dependencies()

          mmd.add_dependencies(new_deps)

          mmds = module_build_service.utils.mse._get_base_module_mmds(mmd)

          # Verify no duplicates were returned before doing set operations

          assert len(mmds) == len(expected)