def dump_tree(repo, export_dir, treeish, with_submodules, recursive=True):
"""Dump a git tree-ish to output_dir"""
if not os.path.exists(export_dir):
os.makedirs(export_dir)
if recursive:
paths = ''
else:
paths = [
nam for _mod, typ, _sha, nam in repo.list_tree(treeish)
if typ == 'blob'
]
try:
data = repo.archive('tar', '', None, treeish, paths)
untar_data(export_dir, data)
if recursive and with_submodules and repo.has_submodules():
repo.update_submodules()
for (subdir, commit) in repo.get_submodules(treeish):
gbp.log.info("Processing submodule %s (%s)" %
(subdir, commit[0:8]))
subrepo = GitRepository(os.path.join(repo.path, subdir))
prefix = [subdir, subdir[2:]][subdir.startswith("./")] + '/'
data = subrepo.archive('tar', prefix, None, treeish)
untar_data(export_dir, data)
except GitRepositoryError as err:
gbp.log.err("Git error when dumping tree: %s" % err)
return False
return True
def test_specify_upstream(self, srcrpm):
"""Test --upstream command line option."""
eq_(GBS(argv=["gbs", "import", "--upstream-branch=upstream",
srcrpm]), None)
repo = GitRepository("./ail")
eq_(repo.get_local_branches(), ['master', 'pristine-tar', 'upstream'])
eq_(repo.get_tags(), ['upstream/0.2.29', 'vendor/0.2.29-2.3'])
def test_set_author_name_email(self, srcrpm):
"""Test --author-name and --author-email command line options."""
eq_(GBS(argv=["gbs", "import", "--author-name=test",
"[email protected]",
srcrpm]), None)
repo = GitRepository("./app-core")
eq_(repo.get_local_branches(), ['master', 'pristine-tar', 'upstream'])
eq_(repo.get_tags(), ['upstream/1.2', 'vendor/1.2-19.3'])
def test_import_spec(self, srcdir):
"""Test importing from spec."""
eq_(GBS(argv=["gbs", "import",
os.path.join(srcdir, 'bluez.spec')]), None)
repo = GitRepository("./bluez")
eq_(repo.get_local_branches(), ['master', 'pristine-tar', 'upstream'])
# No packging tag as patch-import fails
eq_(repo.get_tags(), ['upstream/4.87'])
eq_(len(repo.get_commits(until='master')), 2)
def git_archive_submodules(repo,
treeish,
output,
tmpdir_base,
prefix,
comp_type,
comp_level,
comp_opts,
format='tar'):
"""
Create a source tree archive with submodules.
Since git-archive always writes an end of tarfile trailer we concatenate
the generated archives using tar and compress the result.
Exception handling is left to the caller.
"""
prefix = sanitize_prefix(prefix)
tempdir = tempfile.mkdtemp(dir=tmpdir_base, prefix='git-archive_')
main_archive = os.path.join(tempdir, "main.%s" % format)
submodule_archive = os.path.join(tempdir, "submodule.%s" % format)
try:
# generate main (tmp) archive
repo.archive(format=format,
prefix=prefix,
output=main_archive,
treeish=treeish)
# generate each submodule's arhive and append it to the main archive
for (subdir, commit) in repo.get_submodules(treeish):
tarpath = [subdir, subdir[2:]][subdir.startswith("./")]
subrepo = GitRepository(os.path.join(repo.path, subdir))
gbp.log.debug("Processing submodule %s (%s)" %
(subdir, commit[0:8]))
subrepo.archive(format=format,
prefix='%s%s/' % (prefix, tarpath),
output=submodule_archive,
treeish=commit)
if format == 'tar':
CatenateTarArchive(main_archive)(submodule_archive)
elif format == 'zip':
CatenateZipArchive(main_archive)(submodule_archive)
# compress the output
if comp_type:
compress(comp_type, ['--stdout', '-%s' % comp_level] + comp_opts +
[main_archive], output)
else:
shutil.move(main_archive, output)
finally:
shutil.rmtree(tempdir)
def test_import_in_submodule(self, repo):
"""
Test that importing works if repo is a git submodule (#674015)
"""
parent_repo = GitRepository.create('../parent')
parent_repo.add_submodule(repo.path)
parent_repo.update_submodules(init=True, recursive=True)
submodule = GitRepository(
os.path.join(parent_repo.path, 'hello-debhelper'))
ok_(submodule.path.endswith, 'parent/hello-debhelper')
os.chdir(submodule.path)
orig = self._orig('2.8')
submodule.create_branch('upstream', 'origin/upstream')
ok_(import_orig(['arg0', '--no-interactive', orig]) == 0)
def test_import_in_submodule(self, repo):
"""
Test that importing works if repo is a git submodule (#674015)
"""
parent_repo = GitRepository.create('../parent')
parent_repo.add_submodule(repo.path)
parent_repo.update_submodules(init=True, recursive=True)
submodule = GitRepository(os.path.join(parent_repo.path,
'hello-debhelper'))
ok_(submodule.path.endswith, 'parent/hello-debhelper')
os.chdir(submodule.path)
orig = self._orig('2.8')
submodule.create_branch('upstream', 'origin/upstream')
ok_(import_orig(['arg0', '--no-interactive', orig]) == 0)
def test_guess_spec_repo(self):
"""Test guess_spec_repo() and spec_from_repo() functions"""
# Create dummy repository with some commits
repo = GitRepository.create(self.tmpdir)
with open(os.path.join(repo.path, 'foo.txt'), 'w') as fobj:
fobj.write('bar\n')
repo.add_files('foo.txt')
repo.commit_all('Add dummy file')
os.mkdir(os.path.join(repo.path, 'packaging'))
shutil.copy(os.path.join(SPEC_DIR, 'gbp-test.spec'),
os.path.join(repo.path, 'packaging'))
repo.add_files('packaging/gbp-test.spec')
repo.commit_all('Add spec file')
# Spec not found
with assert_raises(NoSpecError):
guess_spec_repo(repo, 'HEAD~1', recursive=True)
with assert_raises(NoSpecError):
guess_spec_repo(repo, 'HEAD', recursive=False)
# Spec found
spec = guess_spec_repo(repo, 'HEAD', 'packaging', recursive=False)
spec = guess_spec_repo(repo, 'HEAD', recursive=True)
eq_(spec.specfile, 'gbp-test.spec')
eq_(spec.specdir, 'packaging')
eq_(spec.specpath, 'packaging/gbp-test.spec')
# Test spec_from_repo()
with assert_raises(NoSpecError):
spec_from_repo(repo, 'HEAD~1', 'packaging/gbp-test.spec')
spec = spec_from_repo(repo, 'HEAD', 'packaging/gbp-test.spec')
eq_(spec.specfile, 'gbp-test.spec')
def test_initial_import_fail_create_upstream_tag(self, RepoMock):
repo = GitRepository.create(self.pkg)
os.chdir(self.pkg)
orig = self._orig('2.6')
ok_(import_orig(['arg0', '--no-interactive', orig]) == 1)
self._check_repo_state(repo, None, [], tags=[])
def test_guess_spec_repo(self):
"""Test guess_spec_repo() and spec_from_repo() functions"""
# Create dummy repository with some commits
repo = GitRepository.create(self.tmpdir)
with open(os.path.join(repo.path, 'foo.txt'), 'w') as fobj:
fobj.write('bar\n')
repo.add_files('foo.txt')
repo.commit_all('Add dummy file')
os.mkdir(os.path.join(repo.path, 'packaging'))
shutil.copy(os.path.join(SPEC_DIR, 'gbp-test.spec'),
os.path.join(repo.path, 'packaging'))
repo.add_files('packaging/gbp-test.spec')
repo.commit_all('Add spec file')
# Spec not found
with assert_raises(NoSpecError):
guess_spec_repo(repo, 'HEAD~1', recursive=True)
with assert_raises(NoSpecError):
guess_spec_repo(repo, 'HEAD', recursive=False)
# Spec found
spec = guess_spec_repo(repo, 'HEAD', 'packaging', recursive=False)
spec = guess_spec_repo(repo, 'HEAD', recursive=True)
eq_(spec.specfile, 'gbp-test.spec')
eq_(spec.specdir, 'packaging')
eq_(spec.specpath, 'packaging/gbp-test.spec')
# Test spec_from_repo()
with assert_raises(NoSpecError):
spec_from_repo(repo, 'HEAD~1', 'packaging/gbp-test.spec')
spec = spec_from_repo(repo, 'HEAD', 'packaging/gbp-test.spec')
eq_(spec.specfile, 'gbp-test.spec')
def create_orig_repo(cls, name):
"""Create test repo"""
repo_path = os.path.join(cls.workdir, name)
repo = GitRepository.create(repo_path)
# First, commit sources only and create branch 'sources'
sources = [src for src in os.listdir(TEST_DATA_DIR)
if not src in ['packaging', 'debian']]
repo.add_files(sources, work_tree=TEST_DATA_DIR)
repo.commit_staged('Initial version')
# Make one new commit
cls.update_repository_file(repo, 'foo.txt', 'new data\n')
repo.create_branch('source')
# Create branch with rpm packaging only
repo.add_files('packaging', work_tree=TEST_DATA_DIR)
repo.commit_staged('Add rpm packaging files')
repo.create_branch('rpm')
# Master has both debian and rpm packaging
repo.add_files('debian', work_tree=TEST_DATA_DIR)
repo.commit_staged('Add debian packaging files')
# Create branch with deb packaging only
repo.create_branch('deb', 'source')
repo.set_branch('deb')
repo.add_files('debian', work_tree=TEST_DATA_DIR)
repo.commit_staged('Add deb packaging files')
repo.set_branch('master')
repo.force_head('master', hard=True)
return repo
def setup_module():
"""One setup for all tests."""
ENV["cwd"] = os.getcwd()
tmp = tempfile.mkdtemp(prefix="test-gbs-changelog-")
shutil.copy('.gbs.conf', tmp)
os.chdir(tmp)
ENV["dir"] = tmp
# Create git repo
repo = GitRepository.create('.')
author = repo.get_author_info()
ENV["repo"] = repo
ENV["name"] = author.name
ENV["email"] = author.email
# Make 3 commits
for num in (1, 2, 3):
with open("file", "w") as fobj:
fobj.write("content %d" % num)
time.sleep(1) # Sleep to make commit timestamps differ
repo.add_files(repo.path, untracked=True)
repo.commit_files(files="file", msg="change %d" % num)
ENV["date"] = datetime.datetime.now().strftime("%a %b %d %Y")
commits = sorted(repo.get_commits(options=['--pretty=format:%at %H']),
reverse=True)
ENV["commits"] = [item.split()[-1] for item in commits]
def test_guess_spec_repo(self):
"""Test guess_spec_repo() and spec_from_repo() functions"""
# Create dummy repository with some commits
repo = GitRepository.create(self.tmpdir)
with open(os.path.join(repo.path, "foo.txt"), "w") as fobj:
fobj.write("bar\n")
repo.add_files("foo.txt")
repo.commit_all("Add dummy file")
os.mkdir(os.path.join(repo.path, "packaging"))
shutil.copy(os.path.join(SPEC_DIR, "gbp-test.spec"), os.path.join(repo.path, "packaging"))
repo.add_files("packaging/gbp-test.spec")
repo.commit_all("Add spec file")
# Spec not found
with assert_raises(NoSpecError):
guess_spec_repo(repo, "HEAD~1", recursive=True)
with assert_raises(NoSpecError):
guess_spec_repo(repo, "HEAD", recursive=False)
# Spec found
spec = guess_spec_repo(repo, "HEAD", "packaging", recursive=False)
spec = guess_spec_repo(repo, "HEAD", recursive=True)
eq_(spec.specfile, "gbp-test.spec")
eq_(spec.specdir, "packaging")
eq_(spec.specpath, "packaging/gbp-test.spec")
# Test spec_from_repo()
with assert_raises(NoSpecError):
spec_from_repo(repo, "HEAD~1", "packaging/gbp-test.spec")
spec = spec_from_repo(repo, "HEAD", "packaging/gbp-test.spec")
eq_(spec.specfile, "gbp-test.spec")
def setup_module():
"""One setup for all tests."""
ENV["cwd"] = os.getcwd()
tmp = tempfile.mkdtemp(prefix="test-gbs-changelog-")
shutil.copy(".gbs.conf", tmp)
os.chdir(tmp)
ENV["dir"] = tmp
# Create git repo
repo = GitRepository.create(".")
author = repo.get_author_info()
ENV["repo"] = repo
ENV["name"] = author.name
ENV["email"] = author.email
# Make 3 commits
for num in (1, 2, 3):
with open("file", "w") as fobj:
fobj.write("content %d" % num)
time.sleep(1) # Sleep to make commit timestamps differ
repo.add_files(repo.path, untracked=True)
repo.commit_files(files="file", msg="change %d" % num)
ENV["date"] = datetime.datetime.now().strftime("%a %b %d %Y")
commits = sorted(repo.get_commits(options=["--pretty=format:%at %H"]), reverse=True)
ENV["commits"] = [item.split()[-1] for item in commits]
def create_orig_repo(cls, name):
"""Create test repo"""
repo_path = os.path.join(cls.workdir, name)
repo = GitRepository.create(repo_path)
# First, commit sources only and create branch 'sources'
sources = [
src for src in os.listdir(TEST_DATA_DIR)
if not src in ['packaging', 'debian']
]
repo.add_files(sources, work_tree=TEST_DATA_DIR)
repo.commit_staged('Initial version')
# Make one new commit
cls.update_repository_file(repo, 'foo.txt', 'new data\n')
repo.create_branch('source')
# Create branch with rpm packaging only
repo.add_files('packaging', work_tree=TEST_DATA_DIR)
repo.commit_staged('Add rpm packaging files')
repo.create_branch('rpm')
# Master has both debian and rpm packaging
repo.add_files('debian', work_tree=TEST_DATA_DIR)
repo.commit_staged('Add debian packaging files')
# Create branch with deb packaging only
repo.create_branch('deb', 'source')
repo.set_branch('deb')
repo.add_files('debian', work_tree=TEST_DATA_DIR)
repo.commit_staged('Add deb packaging files')
repo.set_branch('master')
repo.force_head('master', hard=True)
return repo
def test_initial_import(self):
"""Test that importing into an empty repo works"""
repo = GitRepository.create(self.pkg)
os.chdir(self.pkg)
orig = self._orig('2.6')
ok_(import_orig(['arg0', '--no-interactive', '--pristine-tar', orig]) == 0)
self._check_repo_state(repo, 'master', self.def_branches,
tags=['upstream/2.6'])
def test_initial_import(self):
"""Test that importing into an empty repo works"""
repo = GitRepository.create(self.pkg)
os.chdir(self.pkg)
orig = self._orig('2.6')
ok_(import_orig(['arg0', '--no-interactive', '--pristine-tar', orig]) == 0)
self._check_repo_state(repo, 'master', self.def_branches,
tags=['upstream/2.6'])
def test_download(self):
"""Test that importing via download works"""
repo = GitRepository.create(self.pkg)
os.chdir(self.pkg)
orig = self._download_url('2.6')
ok_(import_orig(['arg0', '--no-interactive', '--pristine-tar', orig]) == 0)
self._check_repo_state(repo, 'master', self.def_branches,
tags=['upstream/2.6'])
def test_running_from_git_tree(self, srcrpm):
"""Test running gbs import from git tree."""
# Create empty git repo
repo = GitRepository.create("./repo_dir")
os.chdir(repo.path)
eq_(GBS(argv=["gbs", "import", srcrpm]), None)
eq_(repo.get_local_branches(), ['master', 'pristine-tar', 'upstream'])
eq_(repo.get_tags(), ['upstream/0.2.29', 'vendor/0.2.29-2.5'])
def test_download(self):
"""Test that importing via download works"""
repo = GitRepository.create(self.pkg)
os.chdir(self.pkg)
orig = self._download_url('2.6')
ok_(import_orig(['arg0', '--no-interactive', '--pristine-tar', orig]) == 0)
self._check_repo_state(repo, 'master', self.def_branches,
tags=['upstream/2.6'])
def test_initial_import_fail_create_debian_branch(self):
repo = GitRepository.create(self.pkg)
os.chdir(self.pkg)
orig = self._orig('2.6')
with patch('gbp.git.repository.GitRepository.create_branch',
side_effect=GitRepositoryError('this is a create branch error mock')):
ok_(import_orig(['arg0', '--no-interactive', '--pristine-tar', orig]) == 1)
self._check_repo_state(repo, None, [], tags=[])
def _read_git_mailinfo(self):
"""
Read patch information into a structured form
using I{git mailinfo}
"""
self.info = {}
self.long_desc = ''
body = tempfile.NamedTemporaryFile(prefix='gbp_')
# No patch yet, file name information only
if not os.path.exists(self.path):
return
# The patch description might contain UTF-8 while the actual patch is ascii.
# To unconfuse git-mailinfo stop at the patch separator
toparse = []
for line in open(self.path, 'rb'):
if line == b'---\n':
break
toparse.append(line)
input = b''.join(toparse)
if input.strip():
out, err, ret = GitRepository.git_inout(
command='mailinfo',
args=['-k', body.name, '/dev/null'],
input=input,
extra_env=None,
cwd=None,
capture_stderr=True)
if ret != 0:
raise GbpError("Failed to read patch header of '%s': %s" %
(self.path, err))
else:
out = b''
# Header
for line in out.decode().split('\n'):
if ':' in line:
rfc_header, value = line.split(" ", 1)
header = rfc_header[:-1].lower()
self.info[header] = value.strip()
# Body
try:
self.long_desc = "".join(
[l.decode("utf-8", "backslashreplace") for l in body])
except (IOError, UnicodeDecodeError) as msg:
raise GbpError("Failed to read patch header of '%s': %s" %
(self.path, msg))
finally:
body.close()
if os.path.exists(body.name):
os.unlink(body.name)
def test_initial_import_fail_create_upstream_tag(self, RepoMock):
"""
Test that we can rollback from a failure to create the upstream
tag on initial import
"""
repo = GitRepository.create(self.pkg)
os.chdir(repo.path)
orig = self._orig('2.6')
ok_(import_orig(['arg0', '--no-interactive', orig]) == 1)
self._check_repo_state(repo, None, [], tags=[])
def test_initial_import_fail_create_upstream_tag(self, RepoMock):
"""
Test that we can rollback from a failure to create the upstream
tag on initial import
"""
repo = GitRepository.create(self.pkg)
os.chdir(repo.path)
orig = self._orig('2.6')
ok_(import_orig(['arg0', '--no-interactive', orig]) == 1)
self._check_repo_state(repo, None, [], tags=[])
def test_update(self):
repo = GitRepository.create(self.pkg)
os.chdir(self.pkg)
dsc = self._dsc('2.6-2')
ok_(import_dsc(['arg0', '--pristine-tar', dsc]) == 0)
self._check_repo_state(repo, 'master', ['master', 'upstream', 'pristine-tar'])
self._orig('2.8')
self._check_repo_state(repo, 'master', ['master', 'upstream', 'pristine-tar'],
tags=['debian/2.6-2', 'upstream/2.6'])
def _read_git_mailinfo(self):
"""
Read patch information into a structured form
using I{git mailinfo}
"""
self.info = {}
self.long_desc = ''
body = tempfile.NamedTemporaryFile(prefix='gbp_')
# No patch yet, file name information only
if not os.path.exists(self.path):
return
# The patch description might contain UTF-8 while the actual patch is ascii.
# To unconfuse git-mailinfo stop at the patch separator
toparse = []
for line in open(self.path, 'rb'):
if line == b'---\n':
break
toparse.append(line)
input = b''.join(toparse)
if input.strip():
out, err, ret = GitRepository.git_inout(command='mailinfo',
args=['-k', body.name, '/dev/null'],
input=input,
extra_env=None,
cwd=None,
capture_stderr=True)
if ret != 0:
raise GbpError("Failed to read patch header of '%s': %s" %
(self.path, err))
else:
out = b''
# Header
for line in out.decode().split('\n'):
if ':' in line:
rfc_header, value = line.split(" ", 1)
header = rfc_header[:-1].lower()
self.info[header] = value.strip()
# Body
try:
self.long_desc = "".join([l.decode("utf-8", "backslashreplace") for l in body])
except (IOError, UnicodeDecodeError) as msg:
raise GbpError("Failed to read patch header of '%s': %s" %
(self.path, msg))
finally:
body.close()
if os.path.exists(body.name):
os.unlink(body.name)
def test_tag_exists(self):
"""Test that importing an already imported version fails"""
repo = GitRepository.create(self.pkg)
os.chdir(self.pkg)
orig = self._orig('2.6')
# First import
ok_(import_orig(['arg0', '--no-interactive', '--pristine-tar', orig]) == 0)
heads = self.rem_refs(repo, self.def_branches)
# Second import must fail
ok_(import_orig(['arg0', '--no-interactive', '--pristine-tar', orig]) == 1)
self._check_log(0, "gbp:error: Upstream tag 'upstream/2.6' already exists")
# Check that the second import didn't change any refs
self.check_refs(repo, heads)
def test_tag_exists(self):
"""Test that importing an already importet version fails"""
repo = GitRepository.create(self.pkg)
os.chdir(self.pkg)
orig = self._orig('2.6')
# First import
ok_(import_orig(['arg0', '--no-interactive', '--pristine-tar', orig]) == 0)
heads = self.rem_refs(repo, self.def_branches)
# Second import must fail
ok_(import_orig(['arg0', '--no-interactive', '--pristine-tar', orig]) == 1)
self._check_log(0, "gbp:error: Upstream tag 'upstream/2.6' already exists")
# Check that the second import didn't change any refs
self.check_refs(repo, heads)
def test_initial_import_fail_create_debian_branch(self):
"""
Test that we can rollback from creating the Debian branch on
initial import
"""
repo = GitRepository.create(self.pkg)
os.chdir(self.pkg)
orig = self._orig('2.6')
with patch('gbp.git.repository.GitRepository.create_branch',
side_effect=GitRepositoryError('this is a create branch error mock')):
ok_(import_orig(['arg0', '--no-interactive', '--pristine-tar', orig]) == 1)
self._check_repo_state(repo, None, [], tags=[])
def setup(self):
"""Test case setup"""
# Change to a temporary directory
self.tmpdir = os.path.abspath(
tempfile.mkdtemp(prefix='test_', dir=self.workdir))
os.chdir(self.tmpdir)
# Use cache in our tmpdir
suffix = os.path.basename(self.tmpdir).replace('test', '')
self.cachedir = os.path.join(self.workdir, 'cache' + suffix)
os.environ['OBS_GIT_BUILDPACKAGE_REPO_CACHE_DIR'] = self.cachedir
# Create temporary "orig" repository
repo_dir = os.path.join(self.workdir, 'orig' + suffix)
shutil.copytree(self._template_repo.path, repo_dir)
self.orig_repo = GitRepository(repo_dir)
def test_empty_repo(self):
"""Make sure we can import into an empty repository"""
dsc = self._dsc30('2.6-2')
repo = GitRepository.create("hello-debhelper")
self._check_repo_state(repo, None, [])
os.chdir('hello-debhelper')
assert import_dsc([
'arg0', '--verbose', '--no-pristine-tar', '--debian-branch=pk4',
'--upstream-branch=upstream', dsc
]) == 0
self._check_repo_state(repo, 'pk4', ['pk4', 'upstream'])
commits, expected = len(repo.get_commits()), 2
ok_(commits == expected,
"Found %d commit instead of %d" % (commits, expected))
def test_empty_repo(self):
"""Make sure we can import into an empty repository"""
dsc = self._dsc30('2.6-2')
repo = GitRepository.create("hello-debhelper")
self._check_repo_state(repo, None, [])
os.chdir('hello-debhelper')
assert import_dsc(['arg0',
'--verbose',
'--no-pristine-tar',
'--debian-branch=pk4',
'--upstream-branch=upstream',
dsc]) == 0
self._check_repo_state(repo, 'pk4', ['pk4', 'upstream'])
commits, expected = len(repo.get_commits()), 2
ok_(commits == expected, "Found %d commit instead of %d" % (commits, expected))
def create_orig_repo(cls, name):
"""Create test repo"""
orig_repo = GitRepository.create(os.path.join(cls.workdir, name))
# First, add everything else except for packaging
files = os.listdir(TEST_DATA_DIR)
files.remove('packaging')
orig_repo.add_files(files, work_tree=TEST_DATA_DIR)
orig_repo.commit_staged('Initial version')
# Then, add packaging files
orig_repo.add_files('packaging', work_tree=TEST_DATA_DIR)
orig_repo.commit_staged('Add packaging files')
orig_repo.create_tag('v0.1', msg='Version 0.1')
orig_repo.force_head('master', hard=True)
# Make new commit
cls.update_repository_file(orig_repo, 'foo.txt', 'new data\n')
return orig_repo
def test_update_fail_create_upstream_tag(self):
repo = GitRepository.create(self.pkg)
os.chdir(self.pkg)
dsc = self._dsc('2.6-2')
ok_(import_dsc(['arg0', '--pristine-tar', dsc]) == 0)
self._check_repo_state(repo, 'master', ['master', 'upstream', 'pristine-tar'])
heads = self.rem_refs(repo, self.def_branches)
orig = self._orig('2.8')
with patch('gbp.git.repository.GitRepository.create_tag',
side_effect=GitRepositoryError('this is a create tag error mock')):
ok_(import_orig(['arg0', '--no-interactive', '--pristine-tar', orig]) == 1)
self._check_repo_state(repo, 'master', ['master', 'upstream', 'pristine-tar'],
tags=['debian/2.6-2', 'upstream/2.6'])
self.check_refs(repo, heads)
def test_update_fail_merge(self):
"""
Test that we can recover from a failed merge
"""
repo = GitRepository.create(self.pkg)
os.chdir(self.pkg)
dsc = self._dsc('2.6-2')
ok_(import_dsc(['arg0', '--pristine-tar', dsc]) == 0)
self._check_repo_state(repo, 'master', ['master', 'upstream', 'pristine-tar'])
heads = self.rem_refs(repo, self.def_branches)
orig = self._orig('2.8')
with patch('gbp.scripts.import_orig.debian_branch_merge',
side_effect=GitRepositoryError('this is a fail merge error mock')):
ok_(import_orig(['arg0', '--no-interactive', '--pristine-tar', orig]) == 1)
self._check_repo_state(repo, 'master', ['master', 'upstream', 'pristine-tar'],
tags=['debian/2.6-2', 'upstream/2.6'])
self.check_refs(repo, heads)
def test_import_srcrpm(self, srcrpm):
"""Test importing from source rpm."""
eq_(GBS(argv=["gbs", "import", srcrpm]), None)
repo = GitRepository("./ail")
eq_(repo.get_local_branches(), ['master', 'pristine-tar', 'upstream'])
eq_(repo.get_tags(), ['upstream/0.2.29', 'vendor/0.2.29-2.3'])
def get_info_from_repo(dir_path):
'''Get info object of HEAD patch of git tree'''
repo = GitRepository(dir_path)
info = repo.get_commit_info('HEAD')
return info
def get_info_from_repo(dir_path):
'''Get info object of HEAD patch of git tree'''
repo = GitRepository(dir_path)
info = repo.get_commit_info('HEAD')
return info
