BuildRequires: python3-pytest

  BuildRequires: python3-pytest-cov

  BuildRequires: python3-munch

  BuildRequires: python3-lockfile

  BuildRequires: python3-daemon

  from backend.daemons.backend import CoprBackend, run_backend

  from backend.exceptions import CoprBackendError

  STDOUT = "stdout"

  STDERR = "stderr"

  from backend.job import BuildJob

  from backend.vm_manage.models import VmDescriptor

  from backend.daemons.dispatcher import Worker

  import shutil

  import os

  import pytest

  from backend.daemons.job_grab import CoprJobGrab

  import tempfile

  import shutil

  import os

  import pytest

  import backend.daemons.log as log_module

  from backend.daemons.log import RedisLogHandler

  from backend.constants import JOB_GRAB_TASK_END_PUBSUB

  from backend.exceptions import VmError, VmSpawnLimitReached

  import pytest

  from backend.job import BuildJob

  import pytest

  from types import MethodType

  import shutil

  import os

  import pytest

  from backend.mockremote import MockRemote

  from munch import Munch

  import pytest

  from copr_prune_results import Pruner

  from copr_prune_results import main as prune_main

  import pytest

  from backend.actions import Action, ActionType, ActionResult

  from backend.exceptions import CreateRepoError, CoprKeygenRequestError

  import time

  import pytest

  from backend.createrepo import createrepo, createrepo_unsafe, add_appdata, run_cmd_unsafe

  from backend.exceptions import CreateRepoError

  from backend.frontend import FrontendClient

  import pytest

  @pytest.yield_fixture

  from backend.exceptions import CoprSignError, CoprSignNoKeyError, CoprKeygenRequestError

  from backend.sign import get_pubkey, _sign_one, sign_rpms_in_dir, create_user_keys

  from backend.vm_manage import EventTopics, PUBSUB_MB

  from backend.vm_manage.check import HealthChecker, check_health

  import pytest

  from backend.vm_manage.event_handle import EventHandler, Recycle

  from backend.vm_manage.models import VmDescriptor

  import pytest

  from backend.helpers import get_redis_connection

  from backend.vm_manage.executor import Executor

  import pytest

  from backend.daemons.vm_master import VmMaster

  from backend.helpers import get_redis_connection

  import pytest

  from backend.helpers import get_redis_connection

  from backend.vm_manage.spawn import Spawner, spawn_instance, do_spawn_and_publish

  import pytest

  from backend.vm_manage import EventTopics

  from backend.vm_manage.terminate import Terminator, terminate_vm

  import pytest

  BuildRequires: python3-munch

  BuildRequires: python3-requests

  BuildRequires: python3-rpkg

  BuildRequires: python3-pytest

  BuildRequires: python3-pytest-cov

  import shutil

  import time

  import os

  import logging

  from munch import Munch

  from subprocess import check_output

  import copy

  import pytest

  from munch import Munch

  from base import Base

  from unittest import mock

          assert mc_import_package.call_args[0][3] == 'somepath.src.rpm'

          print(self.importer.post_back_safe.has_calls([

          ]))

      def test_run(self, mc_time, mc_worker):

  import pytest

  from pyrpkg import rpkgError

  from munch import Munch

  from base import Base

          branches = ['f25', 'f26']

          setup_git_repo(reponame, branches)

          assert mc_subprocess_check_output.has_calls([

          ])

      def refresh_cgit_listing(self, mc_subprocess_check_output):

          refresh_cgit_listing(self.opts)

          assert mc_subprocess_check_output.has_calls([

          ])

  BuildRequires: python3-redis

  BuildRequires: python3-dateutil

  BuildRequires: python3-pytest

  BuildRequires: python3-decorator

  BuildRequires: python3-markdown

  BuildRequires: python3-pytz

  # coding: utf-8

  class ApiError(Exception):

      def __init__(self, code, msg, data=None, **kwargs):

      def __str__(self):

          return str(self.data)

  class AuthFailed(ApiError):

      def __init__(self, msg=None, data=None, **kwargs):

  from coprs import models

  from coprs.logic.coprs_logic import BranchesLogic

  from coprs.helpers import StatusEnum

  class CoprsTestCase(object):

  from copy import deepcopy

  from flask import Flask, current_app

  from coprs import app

  from coprs.helpers import parse_package_name, generate_repo_url, \

  import json

  from coprs.helpers import ActionTypeEnum

  from coprs.logic.actions_logic import ActionsLogic

  import yaml

  from munch import Munch

  from tests.coprs_test_case import CoprsTestCase

  from coprs.logic.modules_logic import ModuleBuildFacade, ModulemdGenerator, MBSResponse, MBSProxy

  from modulemd.components.rpm import ModuleComponentRPM

          assert component.name == self.b1.package_name

          assert component.rationale == "A reason why package is in the module"

              assert component.repository.startswith("http://distgiturl.org")

              assert component.repository.endswith(".git")

              assert chroot.dist_git_url.startswith(component.repository)

          builds = [self.b1.id, self.b3.id]

          generator = ModulemdGenerator(config=self.config)

              generator.add_components(packages, filter_packages, builds)

              assert add_component.call_count == 2

      def test_components_different_chroots(self, f_users, f_coprs, f_mock_chroots, f_builds, f_db):

  class TestMBSProxy(CoprsTestCase):

      def test_post(self, post_mock):

          url = "http://some-module-build-service.org"

          proxy = MBSProxy(url)

  from copy import deepcopy

  from tests.coprs_test_case import CoprsTestCase

  import flask

  import pytest

  from coprs import models

  from coprs.helpers import ActionTypeEnum

  %global with_test 1

  %if 0%{?rhel} < 7 && 0%{?rhel} > 0

  %global _pkgdocdir %{_docdir}/%{name}-%{version}

  %endif

  Name:       {{{ git_dir_name }}}

  # for tests

  BuildRequires: python3-pytest

  BuildRequires: python3-pytest-cov

  Requires:   haveged

  Requires:   gnupg2

  # tests

  Requires:   python3-pytest

  Requires:   python3-pytest-cov

  # scriptlets

  Requires(post): initscripts

  BuildRequires: python3-devel

  BuildRequires: python3-setuptools

  BuildRequires: python3-requests

  BuildRequires: python3-six

  BuildRequires: python3-flask

  import os

  from requests.models import Response

  from copr import CoprClient

  path = os.path.abspath(__file__)

  dir_path = os.path.dirname(path)

  resource_location = os.path.join(dir_path, "resources")

  BuildRequires: python3-devel

  BuildRequires: python3-setuptools

  BuildRequires: python3-pytest

  BuildRequires: python3-requests

  BuildRequires: python3-requests-toolbelt

  BuildRequires: python3-marshmallow

  Release: 1%{?dist}

  URL: https://pagure.io/copr/copr

  License: GPLv2+

  # Source is created by:

  # git clone https://pagure.io/copr/copr.git

  # rpkg spec --sources

  Source0: {{{ git_dir_pack }}}

  BuildRequires: %python-devel

  BuildRequires: %rpm_python

  BuildRequires: asciidoc

  BuildRequires: %python-setuptools

  Requires: %python

  Requires: %python_pfx-jinja2

  Requires: %python_pfx-munch

  Requires: %python-configparser

  Requires: %python-simplejson

  Requires: mock

  Requires: git

  %prep

  %setup -q

  %build

  name="%{name}" version="%{version}" summary="%{summary}" %python_build

  a2x -d manpage -f manpage man/copr-rpmbuild.1.asciidoc

          self.use_bootstrap_container = task.get("use_bootstrap_container")

          self.pkg_manager_conf = "dnf" if "custom-1" in task.get("chroot") else "yum"

          self.timeout = task.get("timeout", 3600)

          self.sourcedir = sourcedir

          self.resultdir = resultdir

          self.config = config

  #!/bin/sh

  import tempfile

  import unittest

  CONFIG = """

  [main]

      def read_config_data(self, config_data):

          fd, config_path = tempfile.mkstemp()

          f.write(config_data)

          f.close()

          return config_path, helpers.read_config(config_path)

  from . import TestCase

  class TestProvider(TestCase):

      def setUp(self):

          self.source_json = {}

          self.resultdir = "/path/to/resultdir"

      def test_create_rpmmacros(self, mock_open):

          provider = Provider(self.source_json, self.resultdir, self.config)

          mock_open.return_value = rpmmacros

          provider.create_rpmmacros()

          mock_open.assert_called_with("{}/.rpmmacros".format(provider.workdir), "w")

          calls = [

          ]

          rpmmacros.assert_has_calls(calls, any_order=True)

  import unittest

  import tempfile

  import os

  class TestHelpers(unittest.TestCase):

      def test_string2list(self):

          self.assertEqual(string2list(',,foo\tbar\tbaz'), ['foo', 'bar', 'baz'])

      def test_locate_srpm(self):

  import re

  import unittest

  import configparser

  import subprocess

  import datetime

  class TestMockBuilder(unittest.TestCase):

      def setUp(self):

              "task_id": "10-fedora-24-x86_64",

              "timeout": 21600,

              "use_bootstrap_container": False,

          }

          self.sourcedir = "/path/to/sourcedir"

          self.resultdir = "/path/to/resultdir"

          self.assertEqual(config_opts["use_bootstrap_container"], False)

          self.assertEqual(config_opts["yum.conf"], [])

      def test_produce_rpm(self, popen_mock, get_mock_uniqueext_mock):

          builder = MockBuilder(self.task, self.sourcedir, self.resultdir, self.config)

          get_mock_uniqueext_mock.return_value = '2'

          popen_mock.return_value = process

          builder.produce_rpm("/path/to/pkg.src.rpm", "/path/to/configs", "/path/to/results")

          assert_cmd = ['unbuffer', '/usr/bin/mock',

                        '--resultdir', '/path/to/results',

                        '--uniqueext', '2',

                        '-r', 'child']

      def test_touch_success_file(self, mock_open):

          builder = MockBuilder(self.task, self.sourcedir, self.resultdir, self.config)

          builder.touch_success_file()

  import unittest

  class TestProvidersFactory(unittest.TestCase):

  from . import TestCase

  class TestPyPIProvider(TestCase):

      def setUp(self):

         self.assertEqual(provider.pypi_package_name, "motionpaint")

         self.assertEqual(provider.python_versions, [2, 3])

      def test_produce_srpm(self, mock_open, run_cmd):

          provider = PyPIProvider(self.source_json, "/some/tmp/directory", self.config)

          provider.produce_srpm()

  from munch import Munch

  from . import TestCase

  class TestRubyGemsProvider(TestCase):

      def setUp(self):

          provider = RubyGemsProvider(self.source_json, self.resultdir, self.config)

          self.assertEqual(provider.gem_name, "A_123")

      def test_produce_srpm(self, mock_open, run_cmd):

          provider = RubyGemsProvider(self.source_json, self.resultdir, self.config)

          provider.produce_srpm()

          assert_cmd = ["gem2rpm", "A_123", "--srpm", "-C", "/path/to/resultdir", "--fetch"]

          run_cmd.assert_called_with(assert_cmd)

      def test_empty_license(self, mock_open, run_cmd):

          stderr = ("error: line 8: Empty tag: License:"

                    "Command failed: rpmbuild -bs --nodeps --define '_sourcedir /tmp/gem2rpm-foo-20170905-3367-c2flks'"

  import tempfile

  import os