+             module = self.client.module_proxy.build_from_file(

+                     ownername, projectname, args.yaml, distgit=args.distgit)

+             module = self.client.module_proxy.build_from_url(

+                     ownername, projectname, args.url, distgit=args.distgit)

+     parser_build_module.add_argument(

+         "--distgit",

+         help="Dist-git instance to build against, e.g. 'fedora'"

+     )

+ 

+ 

+ @pytest.mark.parametrize('patch_name', ['build_from_file', 'build_from_url'])

+ @pytest.mark.parametrize('args', [[], ['--distgit', 'test']])

+ @mock.patch('copr_cli.main.config_from_file', return_value=mock_config)

+ def test_module_build(config, patch_name, args):

+     argv = ["build-module", "testproject"]

+ 

+     if patch_name == 'build_from_file':

+         argv += ["--yaml", "non-existing.yaml"]

+     else:

+         argv += ["--url", "http://example.com/test.yml"]

+ 

+     module = 'copr.v3.proxies.module'

+     with mock.patch('{0}.ModuleProxy.{1}'.format(module, patch_name)) as p:

+         main.main(argv=argv + args)

+ 

+         assert len(p.call_args_list) == 1

+         kwargs = p.call_args_list[0][1]

+         assert 'distgit' in kwargs

+         if args:

+             assert kwargs['distgit'] == args[1]

+         else:

+             assert kwargs['distgit'] is None

+ """

+ add dist_git_instance table

+ 

+ Revision ID: 2561c13a3556

+ Revises: d230af5e05d8

+ Create Date: 2020-01-30 14:49:07.698008

+ """

+ 

+ import sqlalchemy as sa

+ from alembic import op

+ 

+ 

+ revision = '2561c13a3556'

+ down_revision = 'd230af5e05d8'

+ 

+ def upgrade():

+     new_table = op.create_table('dist_git_instance',

+     sa.Column('id', sa.Integer(), nullable=False),

+     sa.Column('name', sa.String(length=50), nullable=False),

+     sa.Column('clone_url', sa.String(length=100), nullable=False),

+     sa.Column('clone_package_uri', sa.String(length=100), nullable=False),

+     sa.Column('priority', sa.Integer(), nullable=False),

+     sa.PrimaryKeyConstraint('id'),

+     sa.UniqueConstraint('name')

+     )

+     op.bulk_insert(new_table, [{

+         'name': 'fedora',

+         'clone_url': 'https://src.fedoraproject.org',

+         'clone_package_uri': 'rpms/{pkgname}.git',

+         'priority': 100,

+     }])

+ 

+ def downgrade():

+     op.drop_table('dist_git_instance')

+ from coprs.logic.dist_git_logic import DistGitLogic

+ class DistGitValidator(object):

+     def __call__(self, form, field):

+         if field.data not in form.distgit_choices:

+             message = "DistGit ID must be one of: {}".format(

+                 ", ".join(form.distgit_choices))

+             raise wtforms.ValidationError(message)

+ 

+ 

+ class NoneFilter():

+     def __init__(self, default):

+         self.default = default

+ 

+     def __call__(self, value):

+         if value in [None, 'None']:

+             return self.default

+         return value

+ 

+ 

+ def get_module_build_form(*args, **kwargs):

+     class ModuleBuildForm(FlaskForm):

+         distgit_choices = [x.id for x in DistGitLogic.ordered().all()]

+         distgit_default = distgit_choices[0]

+ 

+         modulemd = FileField("modulemd")

+         scmurl = wtforms.StringField()

+         branch = wtforms.StringField()

+ 

+         distgit = wtforms.SelectField(

+             'Build against DistGit instance',

+             choices=[(x, x) for x in distgit_choices],

+             validators=[DistGitValidator()],

+             filters=[NoneFilter(distgit_default)],

+         )

+ 

+     return ModuleBuildForm(*args, **kwargs)

+ from sqlalchemy import desc

+ from coprs import models

+ 

+ 

+ class DistGitLogic:

+     @classmethod

+     def ordered(cls):

+         'get the default dist git instance object'

+         query = models.DistGitInstance.query

+         return query.order_by(desc('priority'), 'name')

+ 

+     @classmethod

+     def get_with_default(cls, distgit_name=None):

+         if distgit_name is None:

+             return cls.ordered().limit(1).one()

+         query = models.DistGitInstance.query.filter_by(name=distgit_name)

+         return query.one()

+ from coprs.logic.dist_git_logic import DistGitLogic

+     def __init__(self, user, copr, yaml, filename=None, distgit_name=None):

+         self.distgit = DistGitLogic.get_with_default(distgit_name)

+         return self.distgit.package_clone_url(pkgname)

+ from sqlalchemy.event import listens_for

+ 

+ 

+ class DistGitInstance(db.Model):

+     """ Dist-git instances, e.g. Fedora/CentOS/RHEL/ """

+ 

+     # numeric id, not used ATM

+     id = db.Column(db.Integer, primary_key=True)

+ 

+     # case sensitive identificator, e.g. 'fedora'

+     name = db.Column(db.String(50), nullable=False, unique=True)

+ 

+     # e.g. 'https://src.fedoraproject.org'

+     clone_url = db.Column(db.String(100), nullable=False)

+ 

+     # e.g. 'rpms/{pkgname}', needs to contain {pkgname} to be expanded later

+     clone_package_uri = db.Column(db.String(100), nullable=False)

+ 

+     # for UI form ordering, higher number means higher priority

+     priority = db.Column(db.Integer, default=100, nullable=False)

+ 

+     def package_clone_url(self, pkgname):

+         url = '/'.join([self.clone_url, self.clone_package_uri])

+         return url.format(pkgname=pkgname)

+ 

+ 

+ @listens_for(DistGitInstance.__table__, 'after_create')

+ def insert_fedora_distgit(*args, **kwargs):

+     db.session.add(DistGitInstance(

+         name="fedora",

+         clone_url="https://src.fedoraproject.org",

+         clone_package_uri="rpms/{pkgname}",

+     ))

+     db.session.commit()

+     form = forms.get_module_build_form(meta={'csrf': False})

+         facade = ModuleBuildFacade(flask.g.user, copr, mod_info.yaml,

+                                    mod_info.filename, form.distgit.data)

+ from coprs.logic.dist_git_logic import DistGitLogic

+         # This table has after_create() hook with default data in models.py, so

+         # we actually need to drop it so the setup_method() re-creates the data

+         self.db.engine.execute('drop table dist_git_instance')

+ 

+     @pytest.fixture

+     def f_other_distgit(self):

+         self.dg0 = DistGitLogic.get_with_default()

+         self.dg1 = models.DistGitInstance(

+             name='test',

+             clone_url='git://example.com',

+             clone_package_uri='some/uri/{pkgname}/git',

+             priority='80',

+         )

+         self.dg2 = models.DistGitInstance(

+             name='prioritized',

+             clone_url='git://prio.com',

+             clone_package_uri='some/other/uri/{pkgname}/git',

+             priority='120',

+         )

+         self.db.session.add_all([self.dg1, self.dg2])

+ 

+     def test_distgit_option(self, f_users, f_coprs, f_mock_chroots_many,

+                             f_builds, f_modules, f_other_distgit, f_db):

+         pkg1 = Modulemd.ComponentRpm(name="foo", rationale="foo package")

+         generator = ModulemdGenerator(name="testmodule", stream="master",

+                                       version=123, summary="some summary")

+ 

+         # check default distgit

+         facade = ModuleBuildFacade(self.u1, self.c1, generator.generate(),

+                                    "testmodule.yaml")

+         facade.add_builds({"foo": pkg1}, self.m1)

+         assert facade.distgit.id == self.dg2.id

+         assert facade.get_clone_url('foo', pkg1) == \

+             'git://prio.com/some/other/uri/foo/git'

+ 

+         # check explicit distgit

+         facade = ModuleBuildFacade(self.u1, self.c1, generator.generate(),

+                                    "testmodule.yaml", distgit_name='test')

+         facade.add_builds({"foo": pkg1}, self.m1)

+         assert facade.distgit == self.dg1

+         assert facade.get_clone_url('foo', pkg1) == \

+             'git://example.com/some/uri/foo/git'

+ 

+ import os

+ import mock

+ import pytest

+ import tempfile

+ import shutil

+ from json import loads

+ from copr.v3 import ModuleProxy

+ 

+ 

+ class TestModuleProxy(object):

+     config_auth = {

+         "copr_url": "http://copr",

+         "login": "test_api_login",

+         "token": "test_api_token",

+     }

+ 

+     def setup_method(self, method):

+         self.tmpdir = tempfile.mkdtemp(prefix='test-python-copr-modules')

+         self.yaml_file = os.path.join(self.tmpdir, 'test.yaml')

+         with open(self.yaml_file, 'w') as f:

+             f.write("")

+ 

+     def teardown_method(self, method):

+         shutil.rmtree(self.tmpdir)

+ 

+     @pytest.mark.parametrize('distgit_opt', [None, 'fedora'])

+     @mock.patch('copr.v3.requests.requests.request')

+     def test_module_dist_git_choice_url(self, request, distgit_opt):

+         proxy = ModuleProxy(self.config_auth)

+         proxy.build_from_url('owner', 'project', 'http://test.yaml',

+                              distgit=distgit_opt)

+ 

+         assert len(request.call_args_list) == 1

+         call = request.call_args_list[0]

+         kwargs = call[1]

+         json = kwargs['json']

+         if distgit_opt is None:

+             assert 'distgit' not in json

+         else:

+             assert json['distgit'] == distgit_opt

+ 

+         assert json['scmurl'] == 'http://test.yaml'

+ 

+     @pytest.mark.parametrize('distgit_opt', [None, 'fedora'])

+     @mock.patch('copr.v3.requests.requests.request')

+     def test_module_dist_git_choice_upload(self, request, distgit_opt):

+         proxy = ModuleProxy(self.config_auth)

+         proxy.build_from_file('owner', 'project',

+                               self.yaml_file,

+                               distgit=distgit_opt)

+ 

+         assert len(request.call_args_list) == 1

+         call = request.call_args_list[0]

+         kwargs = call[1]

+         json = kwargs['json']

+ 

+         assert json is None

+ 

+         # ('json', 'jsonstr', 'application/json')

+         json_encoded = kwargs['data'].encoder.fields['json']

+         json = loads(json_encoded[1])

+ 

+         if distgit_opt is None:

+             assert json is None

+         else:

+             assert json['distgit'] == distgit_opt

+     def build_from_url(self, ownername, projectname, url, branch="master",

+                        distgit=None):

+         if distgit is not None:

+             data["distgit"] = distgit

+     def build_from_file(self, ownername, projectname, path, distgit=None):

+         data = None

+         if distgit is not None:

+             data = {"distgit": distgit}

+                               params=params, files=files, data=data, auth=self.auth)