def test_allowed_by_policy(self):
good = [
"git://goodserver/path1#1234",
"git+ssh://maybeserver/path1#1234",
]
bad = [
"cvs://badserver/projects/42#ref",
"svn://badserver/projects/42#ref",
"git://maybeserver/badpath/project#1234",
"git://maybeserver//badpath/project#1234",
"git://maybeserver////badpath/project#1234",
"git://maybeserver/./badpath/project#1234",
"git://maybeserver//.//badpath/project#1234",
"git://maybeserver/goodpath/../badpath/project#1234",
"git://maybeserver/goodpath/..//badpath/project#1234",
"git://maybeserver/..//badpath/project#1234",
]
session = mock.MagicMock()
session.evalPolicy.side_effect = FakePolicy(policy['one']).evalPolicy
for url in good:
scm = SCM(url)
scm.assert_allowed(session=session, by_config=False, by_policy=True)
for url in bad:
scm = SCM(url)
with self.assertRaises(koji.BuildError) as cm:
scm.assert_allowed(session=session, by_config=False, by_policy=True)
self.assertRegex(str(cm.exception), '^SCM: .* is not allowed, reason: None$')
def test_checkout_svn_ssh(self):
url = "svn+ssh://user@nocommon/dist?rpms/foo/EL3#revision"
scm = SCM(url)
scm.assert_allowed(self.config)
scm.checkout(self.tempdir,
session=self.session,
uploadpath=self.uploadpath,
logfile=self.logfile)
self.assertEqual(scm.use_common, False)
self.symlink.assert_not_called()
# expected commands
cmd = [
'svn', 'checkout', '-r', 'revision',
'svn+ssh://user@nocommon/dist/rpms/foo/EL3', 'rpms/foo/EL3'
]
call1 = mock.call(self.session,
cmd[0],
cmd,
self.logfile,
self.uploadpath,
cwd=self.tempdir,
logerror=1,
append=False,
env=None)
self.log_output.assert_has_calls([call1])
def fetchDockerfile(self, src, build_tag):
"""
Gets Dockerfile. Roughly corresponds to getSRPM method of build task
"""
scm = SCM(src)
scm.assert_allowed(self.options.allowed_scms)
scmdir = os.path.join(self.workdir, 'sources')
koji.ensuredir(scmdir)
logfile = os.path.join(self.workdir, 'checkout-for-labels.log')
uploadpath = self.getUploadDir()
koji.ensuredir(uploadpath)
self.run_callbacks('preSCMCheckout', scminfo=scm.get_info(), build_tag=build_tag,
scratch=self.opts.get('scratch', False))
# Check out sources from the SCM
sourcedir = scm.checkout(scmdir, self.session, uploadpath, logfile)
self.run_callbacks("postSCMCheckout", scminfo=scm.get_info(), build_tag=build_tag,
scratch=self.opts.get('scratch', False), srcdir=sourcedir)
fn = os.path.join(sourcedir, 'Dockerfile')
if not os.path.exists(fn):
raise koji.BuildError("Dockerfile file missing: %s" % fn)
return fn
def test_allowed(self, getLogger):
config = '''
goodserver:*:no
!badserver:*
!maybeserver:/badpath/*
maybeserver:*:no
'''
good = [
"git://goodserver/path1#1234",
"git+ssh://maybeserver/path1#1234",
]
bad = [
"cvs://badserver/projects/42#ref",
"svn://badserver/projects/42#ref",
"git://maybeserver/badpath/project#1234",
"git://maybeserver//badpath/project#1234",
"git://maybeserver////badpath/project#1234",
"git://maybeserver/./badpath/project#1234",
"git://maybeserver//.//badpath/project#1234",
"git://maybeserver/goodpath/../badpath/project#1234",
"git://maybeserver/goodpath/..//badpath/project#1234",
"git://maybeserver/..//badpath/project#1234",
]
for url in good:
scm = SCM(url)
scm.assert_allowed(config)
for url in bad:
scm = SCM(url)
try:
scm.assert_allowed(config)
except koji.BuildError:
pass
else:
raise AssertionError("allowed bad url: %s" % url)
def test_checkout_error_in_command(self):
url = "git://nocommon/koji.git#asdasd"
scm = SCM(url)
scm.assert_allowed(self.config)
self.log_output.return_value = 1
with self.assertRaises(koji.BuildError):
scm.checkout(self.tempdir,
session=self.session,
uploadpath=self.uploadpath,
logfile=self.logfile)
self.assertEqual(scm.use_common, False)
self.symlink.assert_not_called()
# expected commands
cmd = [
'git', 'clone', '-n', 'git://nocommon/koji.git',
self.tempdir + '/koji'
]
call1 = mock.call(self.session,
cmd[0],
cmd,
self.logfile,
self.uploadpath,
cwd=self.tempdir,
logerror=1,
append=False,
env=None)
# should have errored after first command
self.log_output.assert_has_calls([call1])
def test_get_source_git(self, popen):
popen.return_value.wait.return_value = 0
popen.return_value.communicate = mock.MagicMock()
popen.return_value.communicate.return_value = (six.b('hash '),
six.b('any'))
url = "git://default/koji.git#asdasd"
scm = SCM(url)
scm.assert_allowed(self.config)
scm.checkout(self.tempdir,
session=self.session,
uploadpath=self.uploadpath,
logfile=self.logfile)
source = scm.get_source()
self.assertEqual(source, {
'url': url,
'source': 'git://default/koji.git#hash'
})
popen.return_value.wait.return_value = 1
with self.assertRaises(koji.GenericError) as cm:
source = scm.get_source()
self.assertEqual(cm.exception.args[0],
'Error getting commit hash for git')
def test_allowed(self, getLogger):
config = '''
goodserver:*:no
!badserver:*
!maybeserver:/badpath/*
maybeserver:*:no
'''
good = [
"git://goodserver/path1#1234",
"git+ssh://maybeserver/path1#1234",
]
bad = [
"cvs://badserver/projects/42#ref",
"svn://badserver/projects/42#ref",
"git://maybeserver/badpath/project#1234",
"git://maybeserver//badpath/project#1234",
"git://maybeserver////badpath/project#1234",
"git://maybeserver/./badpath/project#1234",
"git://maybeserver//.//badpath/project#1234",
"git://maybeserver/goodpath/../badpath/project#1234",
"git://maybeserver/goodpath/..//badpath/project#1234",
"git://maybeserver/..//badpath/project#1234",
]
for url in good:
scm = SCM(url)
scm.assert_allowed(config)
for url in bad:
scm = SCM(url)
try:
scm.assert_allowed(config)
except koji.BuildError:
pass
else:
raise AssertionError("allowed bad url: %s" % url)
def test_checkout_cvs_ssh(self):
url = "cvs+ssh://user@nocommon/cvsisdead?rpms/foo/EL3#sometag"
scm = SCM(url)
scm.assert_allowed(self.config)
scm.checkout(self.tempdir,
session=self.session,
uploadpath=self.uploadpath,
logfile=self.logfile)
self.assertEqual(scm.use_common, False)
self.symlink.assert_not_called()
# expected commands
cmd = [
'cvs', '-d', ':ext:user@nocommon:/cvsisdead', 'checkout', '-r',
'sometag', 'rpms/foo/EL3'
]
call1 = mock.call(self.session,
cmd[0],
cmd,
self.logfile,
self.uploadpath,
cwd=self.tempdir,
logerror=1,
append=False,
env={'CVS_RSH': 'ssh'})
self.log_output.assert_has_calls([call1])
def fetchDockerfile(self, src, build_tag):
"""
Gets Dockerfile. Roughly corresponds to getSRPM method of build task
"""
scm = SCM(src)
scm.assert_allowed(self.options.allowed_scms)
scmdir = os.path.join(self.workdir, 'sources')
koji.ensuredir(scmdir)
logfile = os.path.join(self.workdir, 'checkout-for-labels.log')
uploadpath = self.getUploadDir()
koji.ensuredir(uploadpath)
self.run_callbacks('preSCMCheckout', scminfo=scm.get_info(), build_tag=build_tag,
scratch=self.opts.get('scratch', False))
# Check out sources from the SCM
sourcedir = scm.checkout(scmdir, self.session, uploadpath, logfile)
self.run_callbacks("postSCMCheckout", scminfo=scm.get_info(), build_tag=build_tag,
scratch=self.opts.get('scratch', False), srcdir=sourcedir)
fn = os.path.join(sourcedir, 'Dockerfile')
if not os.path.exists(fn):
raise koji.BuildError("Dockerfile file missing: %s" % fn)
return fn
def test_badrule(self, getLogger):
config = '''
bogus-entry-should-be-ignored
goodserver:*:no
!badserver:*
'''
url = "git://goodserver/path1#1234"
scm = SCM(url)
scm.assert_allowed(config)
def test_badrule(self, getLogger):
config = '''
bogus-entry-should-be-ignored
goodserver:*:no
!badserver:*
'''
url = "git://goodserver/path1#1234"
scm = SCM(url)
scm.assert_allowed(config)
def test_get_source_other(self, popen):
popen.return_value.wait.return_value = 0
popen.return_value.communicate = mock.MagicMock()
popen.return_value.communicate.return_value = ('hash ', 'any')
url = "svn+ssh://user@nocommon/dist?rpms/foo/EL3#revision"
scm = SCM(url)
scm.assert_allowed(self.config)
scm.checkout(self.tempdir, session=self.session,
uploadpath=self.uploadpath, logfile=self.logfile)
source = scm.get_source()
self.assertEqual(source, {'url': url, 'source': url})
def test_assert_allowed_basic(self):
scm = SCM("git://scm.example.com/path1#1234")
# session must be passed
with self.assertRaises(koji.GenericError) as cm:
scm.assert_allowed(session=None, by_config=False, by_policy=True)
self.assertEqual(str(cm.exception),
'When allowed SCM assertion is by policy, session must be passed in.')
# allowed could not be None
scm.assert_allowed_by_config = mock.MagicMock()
scm.assert_allowed(allowed=None, by_config=True, by_policy=False)
scm.assert_allowed_by_config.assert_called_once_with('')
def test_get_source_other(self, popen):
popen.return_value.wait.return_value = 0
popen.return_value.communicate = mock.MagicMock()
popen.return_value.communicate.return_value = ('hash ', 'any')
url = "svn+ssh://user@nocommon/dist?rpms/foo/EL3#revision"
scm = SCM(url)
scm.assert_allowed(self.config)
scm.checkout(self.tempdir, session=self.session,
uploadpath=self.uploadpath, logfile=self.logfile)
source = scm.get_source()
self.assertEqual(source, {'url': url, 'source': url})
def test_checkout_svn_ssh(self):
url = "svn+ssh://user@nocommon/dist?rpms/foo/EL3#revision"
scm = SCM(url)
scm.assert_allowed(self.config)
scm.checkout(self.tempdir, session=self.session,
uploadpath=self.uploadpath, logfile=self.logfile)
self.assertEqual(scm.use_common, False)
self.symlink.assert_not_called()
# expected commands
cmd = ['svn', 'checkout', '-r', 'revision',
'svn+ssh://user@nocommon/dist/rpms/foo/EL3', 'rpms/foo/EL3']
call1 = mock.call(self.session, cmd[0], cmd, self.logfile,
self.uploadpath, cwd=self.tempdir, logerror=1,
append=False, env=None)
self.log_output.assert_has_calls([call1])
def test_checkout_cvs_ssh(self):
url = "cvs+ssh://user@nocommon/cvsisdead?rpms/foo/EL3#sometag"
scm = SCM(url)
scm.assert_allowed(self.config)
scm.checkout(self.tempdir, session=self.session,
uploadpath=self.uploadpath, logfile=self.logfile)
self.assertEqual(scm.use_common, False)
self.symlink.assert_not_called()
# expected commands
cmd = ['cvs', '-d', ':ext:user@nocommon:/cvsisdead', 'checkout', '-r',
'sometag', 'rpms/foo/EL3']
call1 = mock.call(self.session, cmd[0], cmd, self.logfile,
self.uploadpath, cwd=self.tempdir, logerror=1,
append=False, env={'CVS_RSH': 'ssh'})
self.log_output.assert_has_calls([call1])
def test_checkout_git_common(self):
url = "git://default/koji.git#asdasd"
scm = SCM(url)
scm.assert_allowed(self.config)
scm.checkout(self.tempdir,
session=self.session,
uploadpath=self.uploadpath,
logfile=self.logfile)
self.assertEqual(scm.use_common, True)
self.symlink.assert_called_once()
# expected commands
cmd = [
'git', 'clone', '-n', 'git://default/koji.git',
self.tempdir + '/koji'
]
call1 = mock.call(self.session,
cmd[0],
cmd,
self.logfile,
self.uploadpath,
cwd=self.tempdir,
logerror=1,
append=False,
env=None)
cmd = ['git', 'reset', '--hard', 'asdasd']
call2 = mock.call(self.session,
cmd[0],
cmd,
self.logfile,
self.uploadpath,
cwd=self.tempdir + '/koji',
logerror=1,
append=True,
env=None)
cmd = ['git', 'clone', 'git://default/common.git', 'common']
call3 = mock.call(self.session,
cmd[0],
cmd,
self.logfile,
self.uploadpath,
cwd=self.tempdir,
logerror=1,
append=True,
env=None)
self.log_output.assert_has_calls([call1, call2, call3])
def test_checkout_cvs_common(self):
url = "cvs://default/cvsisdead?rpms/foo/EL3#sometag"
scm = SCM(url)
scm.assert_allowed(self.config)
scm.checkout(self.tempdir, session=self.session,
uploadpath=self.uploadpath, logfile=self.logfile)
self.assertEqual(scm.use_common, True)
self.symlink.assert_called_once()
# expected commands
cmd = ['cvs', '-d', ':pserver:anonymous@default:/cvsisdead', 'checkout',
'-r', 'sometag', 'rpms/foo/EL3']
call1 = mock.call(self.session, cmd[0], cmd, self.logfile, self.uploadpath,
cwd=self.tempdir, logerror=1, append=False, env=None)
cmd = ['cvs', '-d', ':pserver:anonymous@default:/cvsisdead', 'checkout', 'common']
call2 = mock.call(self.session, cmd[0], cmd, self.logfile, self.uploadpath,
cwd=self.tempdir, logerror=1, append=True, env=None)
self.log_output.assert_has_calls([call1, call2])
def test_checkout_error_in_command(self):
url = "git://nocommon/koji.git#asdasd"
scm = SCM(url)
scm.assert_allowed(self.config)
self.log_output.return_value = 1
with self.assertRaises(koji.BuildError):
scm.checkout(self.tempdir, session=self.session,
uploadpath=self.uploadpath, logfile=self.logfile)
self.assertEqual(scm.use_common, False)
self.symlink.assert_not_called()
# expected commands
cmd = ['git', 'clone', '-n', 'git://nocommon/koji.git',
self.tempdir + '/koji']
call1 = mock.call(self.session, cmd[0], cmd, self.logfile,
self.uploadpath, cwd=self.tempdir, logerror=1,
append=False, env=None)
# should have errored after first command
self.log_output.assert_has_calls([call1])
def test_checkout_gitssh_nocommon(self):
url = "git+ssh://user@nocommon/koji.git#asdasd"
scm = SCM(url)
scm.assert_allowed(self.config)
scm.checkout(self.tempdir, session=self.session,
uploadpath=self.uploadpath, logfile=self.logfile)
self.assertEqual(scm.use_common, False)
self.symlink.assert_not_called()
# expected commands
cmd = ['git', 'clone', '-n', 'git+ssh://user@nocommon/koji.git',
self.tempdir + '/koji']
call1 = mock.call(self.session, cmd[0], cmd, self.logfile,
self.uploadpath, cwd=self.tempdir, logerror=1,
append=False, env=None)
cmd = ['git', 'reset', '--hard', 'asdasd']
call2 = mock.call(self.session, cmd[0], cmd, self.logfile,
self.uploadpath, cwd=self.tempdir + '/koji',
logerror=1, append=True, env=None)
self.log_output.assert_has_calls([call1, call2])
def test_get_source_git(self, popen):
popen.return_value.wait.return_value = 0
popen.return_value.communicate = mock.MagicMock()
popen.return_value.communicate.return_value = (six.b('hash '), six.b('any'))
url = "git://default/koji.git#asdasd"
scm = SCM(url)
scm.assert_allowed(self.config)
scm.checkout(self.tempdir, session=self.session,
uploadpath=self.uploadpath, logfile=self.logfile)
source = scm.get_source()
self.assertEqual(source, {'url': url,
'source': 'git://default/koji.git#hash'})
popen.return_value.wait.return_value = 1
with self.assertRaises(koji.GenericError) as cm:
source = scm.get_source()
self.assertEqual(cm.exception.args[0],
'Error getting commit hash for git')
def test_checkout_cvs_common(self):
url = "cvs://default/cvsisdead?rpms/foo/EL3#sometag"
scm = SCM(url)
scm.assert_allowed(self.config)
scm.checkout(self.tempdir, session=self.session,
uploadpath=self.uploadpath, logfile=self.logfile)
self.assertEqual(scm.use_common, True)
self.symlink.assert_called_once()
# expected commands
cmd = ['cvs', '-d', ':pserver:anonymous@default:/cvsisdead', 'checkout',
'-r', 'sometag', 'rpms/foo/EL3']
call1 = mock.call(self.session, cmd[0], cmd, self.logfile,
self.uploadpath, cwd=self.tempdir, logerror=1,
append=False, env=None)
cmd = ['cvs', '-d', ':pserver:anonymous@default:/cvsisdead', 'checkout',
'common']
call2 = mock.call(self.session, cmd[0], cmd, self.logfile,
self.uploadpath, cwd=self.tempdir, logerror=1,
append=True, env=None)
self.log_output.assert_has_calls([call1, call2])
def fetchDockerfile(self, src):
"""
Gets Dockerfile. Roughly corresponds to getSRPM method of build task
"""
scm = SCM(src)
scm.assert_allowed(self.options.allowed_scms)
scmdir = os.path.join(self.workdir, 'sources')
koji.ensuredir(scmdir)
logfile = os.path.join(self.workdir, 'checkout-for-labels.log')
uploadpath = self.getUploadDir()
koji.ensuredir(uploadpath)
# Check out sources from the SCM
sourcedir = scm.checkout(scmdir, self.session, uploadpath, logfile)
fn = os.path.join(sourcedir, 'Dockerfile')
if not os.path.exists(fn):
raise koji.BuildError, "Dockerfile file missing: %s" % fn
return fn
def fetchDockerfile(self, src):
"""
Gets Dockerfile. Roughly corresponds to getSRPM method of build task
"""
scm = SCM(src)
scm.assert_allowed(self.options.allowed_scms)
scmdir = os.path.join(self.workdir, 'sources')
koji.ensuredir(scmdir)
logfile = os.path.join(self.workdir, 'checkout-for-labels.log')
uploadpath = self.getUploadDir()
koji.ensuredir(uploadpath)
# Check out sources from the SCM
sourcedir = scm.checkout(scmdir, self.session, uploadpath, logfile)
fn = os.path.join(sourcedir, 'Dockerfile')
if not os.path.exists(fn):
raise koji.BuildError, "Dockerfile file missing: %s" % fn
return fn
def test_opts(self, getLogger):
config = '''
default:*
nocommon:*:no
srccmd:*:no:fedpkg,sources
nosrc:*:no:
mixed:/foo/*:no
mixed:/bar/*:yes
mixed:/baz/*:no:fedpkg,sources
'''
url = "git://default/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, True)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://nocommon/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://srccmd/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['fedpkg', 'sources'])
url = "git://nosrc/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, None)
url = "git://mixed/foo/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://mixed/bar/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, True)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://mixed/baz/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['fedpkg', 'sources'])
url = "git://mixed/koji.git#1234"
scm = SCM(url)
with self.assertRaises(koji.BuildError):
scm.assert_allowed(config)
url = "git://mixed/foo/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://mixed/bar/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, True)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://mixed/baz/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['fedpkg', 'sources'])
url = "git://mixed/koji.git#1234"
scm = SCM(url)
with self.assertRaises(koji.BuildError):
scm.assert_allowed(config)
def test_assert_allowed_by_both(self):
config = '''
default:*:no:
mixed:/foo/*:yes
mixed:/bar/*:no
mixed:/baz/*:no:centpkg,sources
mixed:/foobar/*:no:
mixed:/foobaz/*:no:centpkg,sources
'''
session = mock.MagicMock()
session.evalPolicy.side_effect = FakePolicy(policy['two']).evalPolicy
url = "git://default/koji.git#1234"
scm = SCM(url)
# match scm_host default :: allow
scm.assert_allowed(allowed=config, session=session, by_config=True, by_policy=True)
self.assertEqual(scm.use_common, False)
self.assertIsNone(scm.source_cmd)
url = "git://mixed/foo/koji.git#1234"
scm = SCM(url)
# match scm_host mixed && match scm_repository /foo/* :: allow
scm.assert_allowed(allowed=config, session=session, by_config=True, by_policy=True)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://mixed/bar/koji.git#1234"
scm = SCM(url)
# match scm_host mixed && match scm_repository /bar/* :: allow use_common
scm.assert_allowed(allowed=config, session=session, by_config=True, by_policy=True)
self.assertEqual(scm.use_common, True)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://mixed/baz/koji.git#1234"
scm = SCM(url)
# match scm_host mixed && match scm_repository /baz/* :: allow fedpkg sources
scm.assert_allowed(allowed=config, session=session, by_config=True, by_policy=True)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['fedpkg', 'sources'])
url = "git://mixed/foobar/koji.git#1234"
scm = SCM(url)
# match scm_host mixed && match scm_repository /foobar/* :: allow use_common fedpkg sources
scm.assert_allowed(allowed=config, session=session, by_config=True, by_policy=True)
self.assertEqual(scm.use_common, True)
self.assertEqual(scm.source_cmd, ['fedpkg', 'sources'])
url = "git://mixed/foobaz/koji.git#1234"
scm = SCM(url)
# match scm_host mixed && match scm_repository /foobaz/* :: allow use_common none
scm.assert_allowed(allowed=config, session=session, by_config=True, by_policy=True)
self.assertEqual(scm.use_common, True)
self.assertIsNone(scm.source_cmd)
def test_opts(self, getLogger):
config = '''
default:*
nocommon:*:no
srccmd:*:no:fedpkg,sources
nosrc:*:no:
mixed:/foo/*:no
mixed:/bar/*:yes
mixed:/baz/*:no:fedpkg,sources
'''
url = "git://default/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, True)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://nocommon/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://srccmd/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['fedpkg', 'sources'])
url = "git://nosrc/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, None)
url = "git://mixed/foo/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://mixed/bar/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, True)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://mixed/baz/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['fedpkg', 'sources'])
url = "git://mixed/koji.git#1234"
scm = SCM(url)
with self.assertRaises(koji.BuildError):
scm.assert_allowed(config)
url = "git://mixed/foo/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://mixed/bar/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, True)
self.assertEqual(scm.source_cmd, ['make', 'sources'])
url = "git://mixed/baz/koji.git#1234"
scm = SCM(url)
scm.assert_allowed(config)
self.assertEqual(scm.use_common, False)
self.assertEqual(scm.source_cmd, ['fedpkg', 'sources'])
url = "git://mixed/koji.git#1234"
scm = SCM(url)
with self.assertRaises(koji.BuildError):
scm.assert_allowed(config)
