freshmaker_images = []

      for image in security_images:

              freshmaker_images.append(image)

      logging.debug("All shipped containers with security fixes: ")

  from flask import g

  from flask_login import login_required as _login_required

  from freshmaker import conf, log

  from freshmaker.models import User, commit_on_success

          Creates new ErrataAdvisory instance from the Erratum ID.

          """

          data = errata._get_advisory(errata_id)

          if not erratum_data:

              return None

          erratum_data = erratum_data[0]

  from flask import jsonify

  from freshmaker import app, log

  class ValidationError(ValueError):

      pass

  class Forbidden(ValueError):

      pass

  @app.errorhandler(Unauthorized)

  def unauthorized_error(e):

      """Flask error handler for Unauthorized exceptions"""

  @app.errorhandler(Forbidden)

              images, get_nvr=lambda image: image['brew']['build'], reverse=True)

          images = []

          for k, v in groupby(sorted_images, key=lambda x: x['brew']['build']):

          # In case we query for unpublished images, we need to return just

          # the latest NVR for given name-version, otherwise images would

          work_queue_put(wrapped_msg)

      except ValueError as e:

          log.warn("No FreshmakerConsumer found.  Shutting down?  %r" % e)

          # In the event that `moksha.hub._hub` hasn't yet been initialized, we

          # need to store messages on the side until it becomes available.

          # As a last-ditch effort, try to hang initial messages in the config.

              packages.add(parsed_nvr["name"])

          # ODCS client expects list and not set for packages/builds, so convert

          if not self.handler.dry_run:

              with krb_context():

  requests

  enum34 ; python_version <= '2.7'

  odcs[client]

  dogpile.cache

  pyldap

  koji

  copr

  mock

  pytest

  vcrpy

  tox

  import flask

  from mock import patch, Mock

  import freshmaker.auth

  from freshmaker.auth import load_krb_user_from_request

  from freshmaker.auth import load_openidc_user

  from freshmaker.auth import query_ldap_groups

  from freshmaker import app, db

  from freshmaker.models import User

  from tests.helpers import ModelsTestCase, FreshmakerTestCase

          with app.test_request_context():

              with self.assertRaises(Unauthorized) as ctx:

                  load_krb_user_from_request(flask.request)

  class TestLoadOpenIDCUserFromRequest(ModelsTestCase):

                      load_openidc_user(flask.request)

                  self.assertTrue(

                      'Required OIDC scope new-compose not present.' in

  class TestQueryLdapGroups(FreshmakerTestCase):

      @patch.object(freshmaker.conf, 'handler_build_whitelist', new={

          'MyHandler': {

              'image': {

              }

          }

      })

      @patch.object(freshmaker.conf, 'handler_build_whitelist', new={

          'MyHandler': {

              'image': {

                  'advisory_state': 'REL_PREP'

              }

          }

      @patch.object(freshmaker.conf, 'handler_build_whitelist', new={

          'MyHandler': {

              'image': any_(

                  {'advisory_state': 'REL_PREP'},

              )

          }

      @patch.object(freshmaker.conf, 'handler_build_whitelist', new={

          'MyHandler': {

              'image': all_(

                  any_(

                      {'has_hightouch_bugs': True},

                      {'severity': ['critical', 'important']}

      @patch.object(freshmaker.conf, 'handler_build_whitelist', new={

          'MyHandler': {

          }

      })

      @patch.object(freshmaker.conf, 'handler_build_blacklist', new={

          'MyHandler': {

          }

      })

      def test_blacklist(self):

                              {

                                  "field": "repositories.*.tags.*.name",

                                  "op": "=",

                              },

                              {

                                  "field": "repositories.*.tags.*.name",

                                  "op": "=",

                              },

                              {

                                  "field": "repositories.*.tags.*.name",

                                  "op": "=",

                              },

                          ],

                      },

              "projection": lb._get_default_projection(srpm_names=["openssl"])

          }

          # Only the second image should be returned, because the first one

          # is in repository "product1/repo1", but we have asked for images

  import fedmsg.config

  import mock

  import freshmaker

  from freshmaker import app, db, events, models, login_manager

  from tests import helpers

  import fedmsg

  import six

  from mock import patch, Mock, MagicMock

  from odcs.client.odcs import AuthMech

          # Ensure new_compose is called to request a new compose

          odcs.new_compose.assert_called_once_with(

      def _create_consumer(self):

          hub = MagicMock()

  #

  # Written by Jan Kaluza <jkaluza@redhat.com>

  import koji

  import fedmsg.config

  import freshmaker

  from freshmaker import db

          hub = MagicMock()

          producer = FreshmakerProducer(hub)

          producer.check_unfinished_koji_tasks(db.session)

      @patch('freshmaker.kojiservice.KojiService.get_task_info')

      @patch("freshmaker.consumer.get_global_consumer")

          hub = MagicMock()

          producer = FreshmakerProducer(hub)

          producer.check_unfinished_koji_tasks(db.session)

  # and then run "tox" from this directory.

  [tox]

  [testenv]

  skip_install = True

  deps = -r{toxinidir}/test-requirements.txt

  commands =

      py.test {posargs}

  [testenv:flake8]

  basepython = python3

  skip_install = true

  ignore_outcome = True

  [flake8]

\ No newline at end of file