}

              ]

          },

      }

      images = lb.find_container_images(query)

      pprint(images)

          repo = self._get_repository_from_image(image_nvr)

          self._verify_repository_data(repo)

          if not images:

              raise ValueError(

                  "No published images tagged by %r found in repository" % (

          rebuildable_images = {}

          images = self.lb.find_images_with_included_srpms(

          for image in images:

              nvr = image["brew"]["build"]

              self._verify_image_data(image)

          # Get the published version of this image to find out if the image

          # was actually published.

          images = lb_instance.get_images_by_nvrs(

          if images:

              self["published"] = True

          else:

          repositories = self.find_container_repositories(repo_request)

          return {r["repository"]: r for r in repositories}

          """

          Returns the default projection list for containerImage objects.

          :param list srpm_names: When not None, defines the SRPM names which

              are returned in "rpm_manifest" field of containerImage.;

          """

          projection = [

              {"field": "brew", "include": True, "recursive": True},

              {"field": "content_sets", "include": True, "recursive": True},

              {"field": "parent_brew_build", "include": True, "recursive": False},

          ]

              if srpm_names:

                  projection += [

                      {"field": "rpm_manifest.*.rpms", "include": True, "recursive": True,

      def find_images_with_included_srpms(

              self, content_sets, srpm_nvrs, repositories, published=True,

          """

          Query lightblue and find the containerImages in the given containerRepositories.

          :param dict repositories: List of repository names to look for.

          :param bool published: whether to limit queries to published

              repositories

          """

          auto_rebuild_tags = set()

          for repo in repositories.values():

              },

              "projection": self._get_default_projection(

                  srpm_names=srpm_name_to_nvrs.keys(),

          }

          if content_sets:

          return images

      def get_images_by_nvrs(self, nvrs, published=True, content_sets=None,

          """Query lightblue and returns containerImages defined by list of

          `nvrs`.

          :param list content_sets: List of content_sets the image includes RPMs

              from.

          :param list srpm_nvrs: list of SRPM NVRs to look for

          :param list srpm_names: list of SRPM names to look for.

          :return: List of containerImages.

          :rtype: list of ContainerImages.

                  ]

              },

              "projection": self._get_default_projection(

          }

          if content_sets is not None:

                      }

                  ]

              },

          }

          images = self.find_container_images(image_request)

          if not images:

              },

              "projection": self._get_default_projection(

                  srpm_names=[srpm_name] if srpm_name else None,

          }

          images = self.find_container_images(query)

                  continue

              possible_latest_parents = self.find_images_with_included_srpms(

              for possible_latest_parent in possible_latest_parents:

                  # Treat the `possible_latest_parent` as `latest_parent` in case its

                  # Name and Version are the same and Release is higher.

          self.assertEqual(image["published"], True)

          lb.get_images_by_nvrs.assert_called_once_with(

              ["package-name-1-4-12.10"], published=True,

      def test_resolve_published_unpublished(self):

          image = ContainerImage.create({

          image.resolve_published(lb)

          self.assertEqual(image["published"], False)

          lb.get_images_by_nvrs.asssert_has_calls([

              call(["package-name-1-4-12.10"])])

          self.assertEqual(image["rpm_manifest"], "x")