def test_misc_options(self): """Test various options of git-import-srpm""" srpm = os.path.join(DATA_DIR, 'gbp-test2-2.0-0.src.rpm') eq_(mock_import(['--no-pristine-tar', '--packaging-branch=pack', '--upstream-branch=orig', '--packaging-dir=packaging', '--packaging-tag=ver_%(upstreamversion)s-rel_%(release)s', '--upstream-tag=orig/%(upstreamversion)s', '--author-is-committer', srpm]), 0) # Check repository state repo = GitRepository('gbp-test2') files = {'Makefile', 'README', 'dummy.sh', 'packaging/bar.tar.gz', 'packaging/foo.txt', 'packaging/gbp-test2.spec', 'packaging/gbp-test2-alt.spec', 'packaging/my.patch', 'packaging/my2.patch', 'packaging/my3.patch'} self._check_repo_state(repo, 'pack', ['pack', 'orig'], files) eq_(len(repo.get_commits()), 2) # Check packaging dir eq_(len(repo.get_commits(paths='packaging')), 1) # Check tags tags = repo.get_tags() eq_(set(tags), set(['orig/2.0', 'ver_2.0-rel_0'])) # Check git committer/author info = repo.get_commit_info('pack') eq_(info['author'].name, 'Markus Lehtonen') eq_(info['author'].email, '*****@*****.**') eq_(info['author'].name, info['committer'].name) eq_(info['author'].email, info['committer'].email)
def test_tagging_native(self): """Test tagging of native packages with import-srpm""" srpm = os.path.join(DATA_DIR, 'gbp-test-native-1.0-1.src.rpm') # Invalid packaging tag keywords eq_( mock_import([ '--no-pristine-tar', '--packaging-tag=%(foo)s', srpm, '--native' ]), 1) self._check_log(-1, ".*Missing value 'foo' in {.*") # Try with good keywords, with --skip-packaging-tag. # Upstream tag format should not matter eq_( mock_import([ '--no-pristine-tar', '--vendor=foo', '--native', '--skip-packaging-tag', '--packaging-tag=%(vendor)s/%(version)s', '--upstream-tag=%(foo)s', srpm ]), 0) repo = GitRepository('gbp-test-native') eq_(len(repo.get_tags()), 0) # Run again, now creating packaging tag eq_( mock_import([ '--no-pristine-tar', '--vendor=foo', '--native', '--packaging-tag=%(vendor)s/%(version)s', '--upstream-tag=%(foo)s', srpm ]), 0) eq_(repo.describe('HEAD'), 'foo/1.0-1')
def test_multiple_versions(self): """Test importing of multiple versions""" srpms = [ os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm'), os.path.join(DATA_DIR, 'gbp-test-1.0-1.other.src.rpm'), os.path.join(DATA_DIR, 'gbp-test-1.1-1.src.rpm') ] eq_(mock_import(['--no-pristine-tar', srpms[0]]), 0) repo = GitRepository('gbp-test') self._check_repo_state(repo, 'master', ['master', 'upstream']) eq_(len(repo.get_commits()), 2) # Try to import same version again eq_(mock_import([srpms[1]]), 0) eq_(len(repo.get_commits()), 2) eq_(len(repo.get_commits(until='upstream')), 1) eq_(mock_import(['--no-pristine-tar', '--allow-same-version', srpms[1]]), 0) # Added new version of packaging eq_(len(repo.get_commits()), 3) eq_(len(repo.get_commits(until='upstream')), 1) # Import new version eq_(mock_import(['--no-pristine-tar', srpms[2]]), 0) files = {'Makefile', 'README', 'bar.tar.gz', 'dummy.sh', 'foo.txt', 'gbp-test.spec', 'my.patch', 'my2.patch', 'my3.patch'} self._check_repo_state(repo, 'master', ['master', 'upstream'], files) eq_(len(repo.get_commits()), 5) eq_(len(repo.get_commits(until='upstream')), 2) # Check number of tags eq_(len(repo.get_tags('upstream/*')), 2) eq_(len(repo.get_tags('packaging/*')), 3)
def test_invalid_config_file(self): """Test invalid config file""" # Create dummy invalid config file and try to import (should fail) GitRepository.create('.') with open('.gbp.conf', 'w') as conffd: conffd.write('foobar\n') eq_(mock_import(['foo']), 1) self._check_log(0, 'gbp:error: File contains no section headers.')
def test_basic_import_pristine_tar(self): """Test importing of non-native src.rpm, with pristine-tar""" srpm = os.path.join(DATA_DIR, "gbp-test-1.0-1.src.rpm") eq_(mock_import(["--pristine-tar", srpm]), 0) # Check repository state repo = GitRepository("gbp-test") self._check_repo_state(repo, "master", ["master", "upstream", "pristine-tar"]) # Two commits: upstream and packaging files eq_(len(repo.get_commits()), 2)
def test_import_no_orig_src(self): """Test importing of (native) srpm without orig tarball""" srpm = os.path.join(DATA_DIR, 'gbp-test-native2-2.0-0.src.rpm') eq_(mock_import([srpm]), 0) # Check repository state repo = GitRepository('gbp-test-native2') self._check_repo_state(repo, 'master', ['master']) # Only one commit: packaging files eq_(len(repo.get_commits()), 1)
def test_invalid_config_file(self): """Test invalid config file""" # Create dummy invalid config file and run pq-rpm GitRepository.create('.') with open('.gbp.conf', 'w') as conffd: conffd.write('foobar\n') eq_(mock_pq(['foo']), 1) self._check_log(0, 'gbp:error: Invalid config file: File contains no ' 'section headers.')
def test_basic_native_import(self): """Test importing of native src.rpm""" srpm = os.path.join(DATA_DIR, "gbp-test-native-1.0-1.src.rpm") eq_(mock_import(["--native", srpm]), 0) # Check repository state files = {".gbp.conf", "Makefile", "README", "dummy.sh", "packaging/gbp-test-native.spec"} repo = GitRepository("gbp-test-native") self._check_repo_state(repo, "master", ["master"], files) # Only one commit: the imported source tarball eq_(len(repo.get_commits()), 1)
def test_basic_import_pristine_tar(self): """Test importing of non-native src.rpm, with pristine-tar""" srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm') eq_(mock_import(['--pristine-tar', srpm]), 0) # Check repository state repo = GitRepository('gbp-test') self._check_repo_state(repo, 'master', ['master', 'upstream', 'pristine-tar']) # Two commits: upstream and packaging files eq_(len(repo.get_commits()), 2)
def test_basic_native_import(self): """Test importing of native src.rpm""" srpm = os.path.join(DATA_DIR, 'gbp-test-native-1.0-1.src.rpm') eq_(mock_import(['--native', srpm]), 0) # Check repository state files = {'.gbp.conf', 'Makefile', 'README', 'dummy.sh', 'packaging/gbp-test-native.spec'} repo = GitRepository('gbp-test-native') self._check_repo_state(repo, 'master', ['master'], files) # Only one commit: the imported source tarball eq_(len(repo.get_commits()), 1)
def test_basic_import(self): """Test importing of non-native src.rpm""" srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm') eq_(mock_import(['--no-pristine-tar', srpm]), 0) # Check repository state repo = GitRepository('gbp-test') files = {'Makefile', 'README', 'bar.tar.gz', 'dummy.sh', 'foo.txt', 'gbp-test.spec', 'my.patch', 'my2.patch', 'my3.patch'} self._check_repo_state(repo, 'master', ['master', 'upstream'], files) # Two commits: upstream and packaging files eq_(len(repo.get_commits()), 2)
def test_basic_import2(self): """Import package with multiple spec files and full url patch""" srpm = os.path.join(DATA_DIR, 'gbp-test2-2.0-0.src.rpm') eq_(mock_import(['--no-pristine-tar', srpm]), 0) # Check repository state repo = GitRepository('gbp-test2') files = {'Makefile', 'README', 'bar.tar.gz', 'dummy.sh', 'foo.txt', 'gbp-test2.spec', 'gbp-test2-alt.spec', 'my.patch', 'my2.patch', 'my3.patch'} self._check_repo_state(repo, 'master', ['master', 'upstream'], files) # Two commits: upstream and packaging files eq_(len(repo.get_commits()), 2)
def test_basic_import_orphan(self): """ Test importing of non-native src.rpm to separate packaging and development branches """ srpm = os.path.join(DATA_DIR, "gbp-test2-2.0-0.src.rpm") eq_(mock_import(["--no-pristine-tar", "--orphan-packaging", srpm]), 0) # Check repository state repo = GitRepository("gbp-test2") files = {"bar.tar.gz", "foo.txt", "gbp-test2.spec", "gbp-test2-alt.spec", "my.patch", "my2.patch", "my3.patch"} self._check_repo_state(repo, "master", ["master", "upstream"], files) # Only one commit: the packaging files eq_(len(repo.get_commits()), 1)
def test_basic_import_orphan(self): """ Test importing of non-native src.rpm to separate packaging and development branches """ srpm = os.path.join(DATA_DIR, 'gbp-test2-2.0-0.src.rpm') eq_(mock_import(['--no-pristine-tar', '--orphan-packaging', srpm]), 0) # Check repository state repo = GitRepository('gbp-test2') files = {'bar.tar.gz', 'foo.txt', 'gbp-test2.spec', 'gbp-test2-alt.spec', 'my.patch', 'my2.patch', 'my3.patch'} self._check_repo_state(repo, 'master', ['master', 'upstream'], files) # Only one commit: the packaging files eq_(len(repo.get_commits()), 1)
def test_import_compressed_patches(self): """Test importing of non-native src.rpm with compressed patches""" srpm = os.path.join(DATA_DIR, 'gbp-test-1.1-2.src.rpm') eq_(mock_import([srpm]), 0) # Check repository state repo = GitRepository('gbp-test') files = set([ 'Makefile', 'README', 'AUTHORS', 'NEWS', 'bar.tar.gz', 'dummy.sh', 'foo.txt', 'gbp-test.spec', 'my.patch', 'mydir/myfile.txt' ]) self._check_repo_state(repo, 'master', ['master', 'upstream'], files) # Four commits: upstream, packaging files, three patches and the removal # of imported patches eq_(len(repo.get_commits()), 6)
def test_basic_import(self): """Test importing of non-native src.rpm""" srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm') eq_(mock_import(['--no-pristine-tar', srpm]), 0) # Check repository state repo = GitRepository('gbp-test') files = set([ 'Makefile', 'README', 'bar.tar.gz', 'dummy.sh', 'foo.txt', 'gbp-test.spec', 'my.patch', 'mydir/myfile.txt' ]) self._check_repo_state(repo, 'master', ['master', 'upstream'], files) # Four commits: upstream, packaging files, one patch and the removal # of imported patches eq_(len(repo.get_commits()), 4)
def parse_config_files(self): """ Parse the possible config files and set appropriate values default values """ parser = configparser.SafeConfigParser() # Fill in the built in values self.config = dict(self.__class__.defaults) # Update with the values from the defaults section. This is needed # in case the config file doesn't have a [<command>] section at all config_files = self.get_config_files() try: repo = GitRepository(".") except GitRepositoryError: repo = None # Read all config files for filename in config_files: self._read_config_file(parser, repo, filename) self.config.update(dict(parser.defaults())) # Make sure we read any legacy sections prior to the real subcommands # section i.e. read [gbp-pull] prior to [pull] if (self.command.startswith('gbp-') or self.command.startswith('git-')): cmd = self.command[4:] oldcmd = self.command if parser.has_section(oldcmd): self.config.update(dict(parser.items(oldcmd, raw=True))) gbp.log.warn("Old style config section [%s] found " "please rename to [%s]" % (oldcmd, cmd)) else: cmd = self.command for prefix in ['gbp', 'git']: oldcmd = '%s-%s' % (prefix, self.command) if parser.has_section(oldcmd): self.config.update(dict(parser.items(oldcmd, raw=True))) gbp.log.warn("Old style config section [%s] found " "please rename to [%s]" % (oldcmd, cmd)) # Update with command specific settings if parser.has_section(cmd): # Don't use items() until we got rid of the compat sections # since this pulls in the defaults again self.config.update(dict(parser._sections[cmd].items())) for section in self.sections: if parser.has_section(section): self.config.update(dict(parser._sections[section].items())) else: raise configparser.NoSectionError( "Mandatory section [%s] does not exist." % section) # filter can be either a list or a string, always build a list: if self.config['filter']: if self.config['filter'].startswith('['): self.config['filter'] = eval(self.config['filter']) else: self.config['filter'] = [self.config['filter']] else: self.config['filter'] = []
def test_invalid_args(self): """See that pq-rpm fails gracefully when called with invalid args""" GitRepository.create('.') # Test empty args eq_(mock_pq([]), 1) self._check_log(0, 'gbp:error: No action given.') self._clear_log() # Test invalid command eq_(mock_pq(['mycommand']), 1) self._check_log(0, "gbp:error: Unknown action 'mycommand'") self._clear_log() # Test invalid cmdline options with assert_raises(SystemExit): mock_pq(['--invalid-arg=123'])
def test_import_to_existing(self): """Test importing to an existing repo""" srpm = os.path.join(DATA_DIR, "gbp-test-1.0-1.src.rpm") # Create new repo repo = GitRepository.create("myrepo") os.chdir("myrepo") shutil.copy2(".git/HEAD", "foobar") repo.add_files(".") repo.commit_all("First commit") # Test importing to non-clean repo shutil.copy2(".git/HEAD", "foobaz") eq_(mock_import(["--create-missing", srpm]), 1) self._check_log(0, "gbp:error: Repository has uncommitted changes") self._clear_log() os.unlink("foobaz") # The first import should fail because upstream branch is missing eq_(mock_import([srpm]), 1) self._check_log(-1, "Also check the --create-missing-branches") eq_(mock_import(["--no-pristine-tar", "--create-missing", srpm]), 0) self._check_repo_state(repo, "master", ["master", "upstream"]) # Four commits: our initial, upstream and packaging files eq_(len(repo.get_commits()), 3) # The import should fail because missing packaging-branch srpm = os.path.join(DATA_DIR, "gbp-test-1.1-1.src.rpm") eq_(mock_import(["--packaging-branch=foo", srpm]), 1) self._check_log(-1, "Also check the --create-missing-branches")
def setup_class(cls): """Initializations only made once per test run""" super(RpmRepoTestBase, cls).setup_class() cls.manifest = RepoManifest( os.path.join(RPM_TEST_DATA_DIR, 'test-repo-manifest.xml')) cls.orig_repos = {} for prj, brs in cls.manifest.projects_iter(): repo = GitRepository.create( os.path.join(cls._tmproot, '%s.repo' % prj)) try: repo.add_remote_repo('origin', RPM_TEST_DATA_DIR, fetch=True) except GitRepositoryError: # Workaround for older git working on submodules initialized # with newer git gitfile = os.path.join(RPM_TEST_DATA_DIR, '.git') if os.path.isfile(gitfile): with open(gitfile) as fobj: link = fobj.readline().replace('gitdir:', '').strip() link_dir = os.path.join(RPM_TEST_DATA_DIR, link) repo.remove_remote_repo('origin') repo.add_remote_repo('origin', link_dir, fetch=True) else: raise # Fetch all remote refs of the orig repo, too repo.fetch('origin', tags=True, refspec='refs/remotes/*:refs/upstream/*') for branch, rev in six.iteritems(brs): repo.create_branch(branch, rev) repo.force_head('master', hard=True) cls.orig_repos[prj] = repo
def setup_class(cls): """Initializations only made once per test run""" super(RpmRepoTestBase, cls).setup_class() cls.manifest = RepoManifest(os.path.join(RPM_TEST_DATA_DIR, 'test-repo-manifest.xml')) cls.orig_repos = {} for prj, brs in cls.manifest.projects_iter(): repo = GitRepository.create(os.path.join(cls._tmproot, '%s.repo' % prj)) try: repo.add_remote_repo('origin', RPM_TEST_DATA_DIR, fetch=True) except GitRepositoryError: # Workaround for older git working on submodules initialized # with newer git gitfile = os.path.join(RPM_TEST_DATA_DIR, '.git') if os.path.isfile(gitfile): with open(gitfile) as fobj: link = fobj.readline().replace('gitdir:', '').strip() link_dir = os.path.join(RPM_TEST_DATA_DIR, link) repo.remove_remote_repo('origin') repo.add_remote_repo('origin', link_dir, fetch=True) else: raise # Fetch all remote refs of the orig repo, too repo.fetch('origin', tags=True, refspec='refs/remotes/*:refs/upstream/*') for branch, rev in brs.iteritems(): repo.create_branch(branch, rev) repo.force_head('master', hard=True) cls.orig_repos[prj] = repo
def test_import_to_existing(self): """Test importing to an existing repo""" srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm') # Create new repo repo = GitRepository.create('myrepo') os.chdir('myrepo') shutil.copy2('.git/HEAD', 'foobar') repo.add_files('.') repo.commit_all('First commit') # Test importing to non-clean repo shutil.copy2('.git/HEAD', 'foobaz') eq_(mock_import(['--create-missing', srpm]), 1) self._check_log(0, 'gbp:error: Repository has uncommitted changes') self._clear_log() os.unlink('foobaz') # The first import should fail because upstream branch is missing eq_(mock_import([srpm]), 1) self._check_log(-1, 'Also check the --create-missing-branches') eq_(mock_import(['--no-pristine-tar', '--create-missing', srpm]), 0) self._check_repo_state(repo, 'master', ['master', 'upstream']) # Four commits: our initial, upstream, packaging files, one patch, # and the removal of imported patches eq_(len(repo.get_commits()), 5) # The import should fail because missing packaging-branch srpm = os.path.join(DATA_DIR, 'gbp-test-1.1-1.src.rpm') eq_(mock_import(['--packaging-branch=foo', srpm]), 1) self._check_log(-1, 'Also check the --create-missing-branches')
def test_noninteractive(self): """Test non-interactive mode""" repo = GitRepository.create('testrepo') orig = os.path.join(DATA_DIR, 'gbp-test-native-1.0.zip') orig_renamed = os.path.join(os.path.abspath('.'), 'foo.zip') shutil.copy(orig, orig_renamed) os.chdir('testrepo') # Guessing name and version should fail eq_(mock_import(['--no-interactive', orig_renamed]), 1) self._check_log(-1, "gbp:error: Couldn't determine upstream package") # Guessing from the original archive should succeed eq_(mock_import(['--no-interactive', '--merge', orig], stdin_data=''), 0) files = [ '.gbp.conf', 'Makefile', 'README', 'dummy.sh', 'packaging/gbp-test-native.spec' ] self._check_repo_state(repo, 'master', ['master', 'upstream'], files) eq_(len(repo.get_commits(until='master')), 1) # Import "new" version, this time package name should be taken from spec eq_(mock_import(['--no-interactive', orig_renamed], stdin_data=''), 1) self._check_log(-1, "gbp:error: Couldn't determine upstream version")
def main(argv): retval = 0 (options, args) = parse_args(argv) if not options: return 1 if len(args) < 2: gbp.log.err("Need a repository to clone.") return 1 else: source = args[1] clone_to, auto_name = (os.path.curdir, True) if len(args) < 3 else (args[2], False) try: GitRepository(clone_to) gbp.log.err("Can't run inside a git repository.") return 1 except GitRepositoryError: pass try: repo = DebianGitRepository.clone(clone_to, source, options.depth, auto_name=auto_name) os.chdir(repo.path) # Reparse the config files of the cloned repository so we pick up the # branch information from there: (options, args) = parse_args(argv) # Track all branches: if options.all: remotes = repo.get_remote_branches() for remote in remotes: local = remote.replace("origin/", "", 1) if not repo.has_branch(local) and \ local != "HEAD": repo.create_branch(local, remote) else: # only track gbp's default branches branches = [ options.debian_branch, options.upstream_branch ] if options.pristine_tar: branches += [ repo.pristine_tar_branch ] gbp.log.debug('Will track branches: %s' % branches) for branch in branches: remote = 'origin/%s' % branch if repo.has_branch(remote, remote=True) and \ not repo.has_branch(branch): repo.create_branch(branch, remote) repo.set_branch(options.debian_branch) except GitRepositoryError as err: gbp.log.err("Git command failed: %s" % err) retval = 1 except GbpError as err: if len(err.__str__()): gbp.log.err(err) retval = 1 return retval
def _init_repo_with_dummy_packaging(): """Create a dummy packaging branch with one commit""" repo = GitRepository.create('.') shutil.copy2('.git/HEAD', 'foobar') repo.add_files('.') repo.commit_all('First commit') return repo
def test_pristine_import_to_bare(self): """Test importing inside bare git repository""" repo = GitRepository.create('.', bare=True) orig = os.path.join(DATA_DIR, 'gbp-test-1.0.tar.bz2') eq_(mock_import([orig]), 0) # No pristine-tar branch should be present self._check_repo_state(repo, None, ['upstream'])
def test_import_to_existing(self): """Test importing to an existing repo""" srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm') # Create new repo repo = GitRepository.create('myrepo') os.chdir('myrepo') shutil.copy2('.git/HEAD', 'foobar') repo.add_files('.') repo.commit_all('First commit') # Test importing to non-clean repo shutil.copy2('.git/HEAD', 'foobaz') eq_(mock_import(['--create-missing', srpm]), 1) self._check_log(0, 'gbp:error: Repository has uncommitted changes') self._clear_log() os.unlink('foobaz') # The first import should fail because upstream branch is missing eq_(mock_import([srpm]), 1) self._check_log(-1, 'Also check the --create-missing-branches') eq_(mock_import(['--no-pristine-tar', '--create-missing', srpm]), 0) self._check_repo_state(repo, 'master', ['master', 'upstream']) # Four commits: our initial, upstream and packaging files eq_(len(repo.get_commits()), 3) # The import should fail because missing packaging-branch srpm = os.path.join(DATA_DIR, 'gbp-test-1.1-1.src.rpm') eq_(mock_import(['--packaging-branch=foo', srpm]), 1) self._check_log(-1, 'Also check the --create-missing-branches')
def test_invalid_args(self): """ See that import-orig-rpm fails gracefully when called with invalid args """ repo = GitRepository.create('.') origs = [ os.path.join(DATA_DIR, 'gbp-test-1.0.tar.bz2'), os.path.join(DATA_DIR, 'gbp-test-1.1.tar.bz2') ] # Test multiple archives eq_(mock_import([] + origs), 1) self._check_log(0, 'gbp:error: More than one archive specified') self._clear_log() # Test invalid archive false_orig = os.path.join(RPM_TEST_DATA_DIR, 'gbp-test-1.0-1.src.rpm') eq_(mock_import([false_orig], 'foo\n1\n'), 1) self._check_log(0, "gbp:error: Unsupported archive format") self._clear_log() # Test non-existing archive eq_(mock_import(['none.tar.bz2'], 'foo\n1\n'), 1) self._check_log(0, "gbp:error: UpstreamSource: unable to find") self._clear_log() # Check that nothing is in the repo self._check_repo_state(repo, None, []) # Test invalid cmdline options assert_raises(SystemExit, mock_import, ['--invalid-arg=123']) """
def test_misc_options(self): """Test various options of git-import-srpm""" srpm = os.path.join(DATA_DIR, 'gbp-test2-2.0-0.src.rpm') eq_(mock_import(['--no-pristine-tar', '--packaging-branch=pack', '--upstream-branch=orig', '--packaging-dir=packaging', '--packaging-tag=ver_%(upstreamversion)s-rel_%(release)s', '--upstream-tag=orig/%(upstreamversion)s', '--author-is-committer', srpm]), 0) # Check repository state repo = GitRepository('gbp-test2') files = {'Makefile', 'README', 'dummy.sh', 'packaging/bar.tar.gz', 'packaging/foo.txt', 'packaging/gbp-test2.spec', 'packaging/gbp-test2-alt.spec', 'packaging/my.patch', 'packaging/my2.patch', 'packaging/my3.patch'} self._check_repo_state(repo, 'pack', ['pack', 'orig'], files) eq_(len(repo.get_commits()), 2) # Check packaging dir eq_(len(repo.get_commits(paths='packaging')), 1) # Check tags tags = repo.get_tags() eq_(set(tags), set(['orig/2.0', 'ver_2.0-rel_0'])) # Check git committer/author info = repo.get_commit_info('pack') eq_(info['author'].name, 'Markus Lehtonen') eq_(info['author'].email, '*****@*****.**') eq_(info['author'].name, info['committer'].name) eq_(info['author'].email, info['committer'].email) # Create a new commit by committing an empty tree commit = repo.commit_tree('4b825dc642cb6eb9a060e54bf8d69288fbee4904', msg="Empty commit", parents=[]) repo.create_tag('foo/1.0', msg="New tag", commit=commit) # Just blindly import another package on top of this to test more options os.chdir('gbp-test2') srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm') eq_(mock_import(['--upstream-vcs-tag=foo/%(version)s', '--upstream-branch=orig', '--packaging-branch=pack', srpm]), 0) parents = repo.get_commits(until='orig', num=1, options='--format=%P')[0].split() eq_(len(parents), 2) ok_(commit in parents) ok_(repo.rev_parse('orig/2.0^{}') in parents)
def test_misc_options(self): """Test various options of git-import-srpm""" srpm = os.path.join(DATA_DIR, "gbp-test2-2.0-0.src.rpm") eq_( mock_import( [ "--no-pristine-tar", "--packaging-branch=pack", "--upstream-branch=orig", "--packaging-dir=packaging", "--packaging-tag=ver_%(upstreamversion)s-rel_%(release)s", "--upstream-tag=orig/%(upstreamversion)s", "--author-is-committer", srpm, ] ), 0, ) # Check repository state repo = GitRepository("gbp-test2") files = { "Makefile", "README", "dummy.sh", "packaging/bar.tar.gz", "packaging/foo.txt", "packaging/gbp-test2.spec", "packaging/gbp-test2-alt.spec", "packaging/my.patch", "packaging/my2.patch", "packaging/my3.patch", } self._check_repo_state(repo, "pack", ["pack", "orig"], files) eq_(len(repo.get_commits()), 2) # Check packaging dir eq_(len(repo.get_commits(paths="packaging")), 1) # Check tags tags = repo.get_tags() eq_(set(tags), set(["orig/2.0", "ver_2.0-rel_0"])) # Check git committer/author info = repo.get_commit_info("pack") eq_(info["author"].name, "Markus Lehtonen") eq_(info["author"].email, "*****@*****.**") eq_(info["author"].name, info["committer"].name) eq_(info["author"].email, info["committer"].email)
def test_target_dir(self): """Test importing to target dir""" srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm') eq_(mock_import(['--no-pristine-tar', srpm, 'targetdir']), 0) # Check repository state assert os.path.exists('targetdir') repo = GitRepository('targetdir') self._check_repo_state(repo, 'master', ['master', 'upstream'])
def test_import_zip(self): """Test importing of zip archive""" repo = GitRepository.create('.') # Import zip with, no master branch should be present orig = os.path.join(DATA_DIR, 'gbp-test-native-1.0.zip') eq_(mock_import([orig]), 0) self._check_repo_state(repo, None, ['upstream'], []) eq_(repo.get_tags(), ['upstream/1.0'])
def test_tagging(self): """Test tag options of import-srpm""" srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm') # Invalid packaging tag keywords eq_(mock_import(['--no-pristine-tar', '--packaging-tag=%(foo)s', srpm]), 1) self._check_log(-1, ".*Missing value 'foo' in *.*") # Remove upstream tag repo = GitRepository('gbp-test') repo.delete_tag('upstream/1.0') # Invalid upstream tag keywords eq_(mock_import(['--no-pristine-tar', '--upstream-tag=%(foo)s', srpm]), 1) self._check_log(-1, ".*Missing value 'foo' in.*") # Try with good keywords, with --skip-packaging-tag eq_(mock_import(['--no-pristine-tar', '--vendor=foo', '--skip-packaging-tag', '--packaging-tag=%(vendor)s/%(version)s', '--upstream-tag=upst/%(version)s', srpm]), 0) eq_(repo.describe('upstream'), 'upst/1.0') eq_(len(repo.get_tags()), 1) # Re-import, creating packaging tag eq_(mock_import(['--no-pristine-tar', '--vendor=foo', '--packaging-tag=%(vendor)s/%(version)s', '--upstream-tag=upst/%(version)s', srpm]), 0) eq_(repo.describe('HEAD'), 'foo/1.0-1') eq_(len(repo.get_tags()), 2)
def test_filter(self): """Test filter option""" srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm') eq_(mock_import(['--no-pristine-tar', '--filter=README', '--filter=mydir', srpm]), 0) # Check repository state repo = GitRepository('gbp-test') files = set(['Makefile', 'dummy.sh', 'bar.tar.gz', 'foo.txt', 'gbp-test.spec', 'my.patch', 'my2.patch', 'my3.patch']) self._check_repo_state(repo, 'master', ['master', 'upstream'], files)
def test_hook_error(self): """Test postimport hook failure""" repo = GitRepository.create('.') orig = os.path.join(DATA_DIR, 'gbp-test-1.0.tar.bz2') eq_(mock_import(['--postimport=_notexist.sh', '--merge', orig]), 1) self._check_log(-2, "gbp:error: '_notexist.sh' failed:") self._check_log(-1, 'gbp:error: Import of %s failed' % orig) # Other parts of the import should've succeeded self._check_repo_state(repo, 'master', ['master', 'upstream'])
def test_unsupported_archive(self): """Test importing of src.rpm with a zip source archive""" srpm = os.path.join(DATA_DIR, 'gbp-test-native-1.0-1.src.rpm') eq_(mock_import(['--pristine-tar', srpm]), 0) # Check repository state repo = GitRepository('gbp-test-native') self._check_repo_state(repo, 'master', ['master', 'upstream']) # Check that a warning is printed self._check_log(-1, "gbp:warning: Ignoring pristine-tar")
def test_basic_import_to_bare_repo(self): """Test importing of srpm to a bare git repository""" srpm = os.path.join(DATA_DIR, "gbp-test-1.0-1.src.rpm") # Create new repo repo = GitRepository.create("myrepo", bare=True) os.chdir("myrepo") eq_(mock_import([srpm]), 0) self._check_repo_state(repo, "master", ["master", "upstream"]) # Patch import to bare repos not supported -> only 2 commits eq_(len(repo.get_commits(until="master")), 2)
def test_basic_import_to_bare_repo(self): """Test importing of srpm to a bare git repository""" srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm') # Create new repo repo = GitRepository.create('myrepo', bare=True) os.chdir('myrepo') eq_(mock_import([srpm]), 0) self._check_repo_state(repo, 'master', ['master', 'upstream']) # Patch import to bare repos not supported -> only 2 commits eq_(len(repo.get_commits(until='master')), 2)
def test_invalid_config_file(self): """Test invalid config file""" # Create and commit dummy invalid config file repo = GitRepository.create(".") with open(".gbp.conf", "w") as conffd: conffd.write("foobar\n") repo.add_files(".gbp.conf") repo.commit_all("Add conf") eq_(mock_gbp([]), 1) self._check_log(0, "gbp:error: File contains no section headers.")
def test_invalid_config_file(self): """Test invalid config file""" # Create and commit dummy invalid config file repo = GitRepository.create('.') with open('.gbp.conf', 'w') as conffd: conffd.write('foobar\n') repo.add_files('.gbp.conf') repo.commit_all('Add conf') eq_(mock_gbp([]), 1) self._check_log(0, 'gbp:error: File contains no section headers.')
def test_basic_import(self): """Test importing of non-native src.rpm""" srpm = os.path.join(DATA_DIR, "gbp-test-1.0-1.src.rpm") eq_(mock_import(["--no-pristine-tar", srpm]), 0) # Check repository state repo = GitRepository("gbp-test") files = { "Makefile", "README", "bar.tar.gz", "dummy.sh", "foo.txt", "gbp-test.spec", "my.patch", "my2.patch", "my3.patch", } self._check_repo_state(repo, "master", ["master", "upstream"], files) # Two commits: upstream and packaging files eq_(len(repo.get_commits()), 2)
def import_debian_tarball(cls, debian=DEFAULT_OVERLAY, opts=None): """Import a 3.0 (quilt) debian dir for overlay mode""" repo = GitRepository.create(os.path.split('/')[-1].split('_')[0]) UnpackTarArchive(debian, repo.path)() repo.add_files('.') repo.commit_files('.', msg="debian dir") expected_branches = ['master'] ComponentTestBase._check_repo_state(repo, 'master', expected_branches) eq_(len(repo.get_commits()), 1) os.chdir(repo.path) return repo
def test_import_dir(self): """Test importing of directories""" eq_(mock_import(['--no-pristine-tar', 'gbp-test-1.0-1-unpack']), 0) # Check repository state repo = GitRepository('gbp-test') self._check_repo_state(repo, 'master', ['master', 'upstream']) # Check that importing dir with multiple spec files fails eq_(mock_import(['multi-unpack']), 1) self._check_log(-1, 'gbp:error: Failed determine spec file: ' 'Multiple spec files found')
def test_branch_update(self): """Check that the working copy is kept in sync with branch HEAD""" repo = GitRepository.create('.') orig1 = os.path.join(DATA_DIR, 'gbp-test-1.0.tar.bz2') orig2 = os.path.join(DATA_DIR, 'gbp-test-1.1.tar.bz2') eq_(mock_import(['--merge', orig1]), 0) repo.set_branch('upstream') eq_(mock_import([orig2]), 0) files = ['Makefile', 'README', 'dummy.sh'] self._check_repo_state(repo, 'upstream', ['master', 'upstream'], files) eq_(len(repo.get_commits(until='upstream')), 2)
def test_basic_import2(self): """Import package with multiple spec files and full url patch""" srpm = os.path.join(DATA_DIR, "gbp-test2-2.0-0.src.rpm") eq_(mock_import(["--no-pristine-tar", srpm]), 0) # Check repository state repo = GitRepository("gbp-test2") files = { "Makefile", "README", "bar.tar.gz", "dummy.sh", "foo.txt", "gbp-test2.spec", "gbp-test2-alt.spec", "my.patch", "my2.patch", "my3.patch", } self._check_repo_state(repo, "master", ["master", "upstream"], files) # Two commits: upstream and packaging files eq_(len(repo.get_commits()), 2)
def test_multiple_versions(self): """Test importing of multiple versions""" srpms = [ os.path.join(DATA_DIR, "gbp-test-1.0-1.src.rpm"), os.path.join(DATA_DIR, "gbp-test-1.0-1.other.src.rpm"), os.path.join(DATA_DIR, "gbp-test-1.1-1.src.rpm"), ] eq_(mock_import(["--no-pristine-tar", srpms[0]]), 0) repo = GitRepository("gbp-test") self._check_repo_state(repo, "master", ["master", "upstream"]) eq_(len(repo.get_commits()), 2) # Try to import same version again eq_(mock_import([srpms[1]]), 0) eq_(len(repo.get_commits()), 2) eq_(len(repo.get_commits(until="upstream")), 1) eq_(mock_import(["--no-pristine-tar", "--allow-same-version", srpms[1]]), 0) # Added new version of packaging eq_(len(repo.get_commits()), 3) eq_(len(repo.get_commits(until="upstream")), 1) # Import new version eq_(mock_import(["--no-pristine-tar", srpms[2]]), 0) files = { "Makefile", "README", "bar.tar.gz", "dummy.sh", "foo.txt", "gbp-test.spec", "my.patch", "my2.patch", "my3.patch", } self._check_repo_state(repo, "master", ["master", "upstream"], files) eq_(len(repo.get_commits()), 5) eq_(len(repo.get_commits(until="upstream")), 2) # Check number of tags eq_(len(repo.get_tags("upstream/*")), 2) eq_(len(repo.get_tags("packaging/*")), 3)
def test_tagging_native(self): """Test tagging of native packages with import-srpm""" srpm = os.path.join(DATA_DIR, 'gbp-test-native-1.0-1.src.rpm') # Invalid packaging tag keywords eq_(mock_import(['--no-pristine-tar', '--packaging-tag=%(foo)s', srpm, '--native']), 1) self._check_log(-1, ".*Missing value 'foo' in {.*") # Try with good keywords, with --skip-packaging-tag. # Upstream tag format should not matter eq_(mock_import(['--no-pristine-tar', '--vendor=foo', '--native', '--skip-packaging-tag', '--packaging-tag=%(vendor)s/%(version)s', '--upstream-tag=%(foo)s', srpm]), 0) repo = GitRepository('gbp-test-native') eq_(len(repo.get_tags()), 0) # Run again, now creating packaging tag eq_(mock_import(['--no-pristine-tar', '--vendor=foo', '--native', '--packaging-tag=%(vendor)s/%(version)s', '--upstream-tag=%(foo)s', srpm]), 0) eq_(repo.describe('HEAD'), 'foo/1.0-1')
def main(argv): dirs = dict(top=os.path.abspath(os.curdir)) dscs = [] ret = 0 verbose = False dsc_key = cmp_to_key(DscCompareVersions()) use_debsnap = False try: import_args = argv[1:] if '--verbose' in import_args: verbose = True gbp.log.setup(False, verbose) if '--ignore-repo-config' in import_args: set_gbp_conf_files() import_args.remove('--ignore-repo-config') # Not using Configparser since we want to pass all unknown options # unaltered to gbp import-dsc if '--debsnap' in import_args: use_debsnap = True import_args.remove('--debsnap') if import_args == []: print_help() raise GbpError pkg = import_args[-1] import_args = import_args[:-1] else: for arg in argv[::-1]: if arg.endswith('.dsc'): dscs.append(DscFile.parse(arg)) import_args.remove(arg) if not use_debsnap and not dscs: print_help() raise GbpError if use_debsnap: dirs['tmp'] = os.path.abspath(tempfile.mkdtemp()) dscs = [DscFile.parse(f) for f in fetch_snapshots(pkg, dirs['tmp'])] dscs.sort(key=dsc_key) importer = GitImportDsc(import_args) try: repo = GitRepository('.') (clean, out) = repo.is_clean() if not clean: gbp.log.err("Repository has uncommitted changes, " "commit these first: ") raise GbpError(out) else: dirs['pkg'] = dirs['top'] except GitRepositoryError: # no git repository there yet dirs['pkg'] = os.path.join(dirs['top'], dscs[0].pkg) if importer.importdsc(dscs[0]): raise GbpError("Failed to import '%s'" % dscs[0].dscfile) os.chdir(dirs['pkg']) for dsc in dscs[1:]: if importer.importdsc(dsc): raise GbpError("Failed to import '%s'" % dscs[0].dscfile) except KeyboardInterrupt: ret = 1 gbp.log.err("Interrupted. Aborting.") except (GbpError, gbpc.CommandExecFailed, GitRepositoryError) as err: if str(err): gbp.log.err(err) ret = 1 finally: if 'tmp' in dirs: gbpc.RemoveTree(dirs['tmp'])() os.chdir(dirs['top']) if not ret: gbp.log.info('Everything imported under %s' % dirs['pkg']) return ret
def main(argv): retval = 0 (options, args) = parse_args(argv) if not options: return 1 gbp.log.setup(options.color, options.verbose, options.color_scheme) if len(args) < 2: gbp.log.err("No action given.") return 1 else: action = args[1] if args[1] in ["export", "import", "rebase", "drop", "switch"]: pass elif args[1] in ["apply"]: if len(args) != 3: gbp.log.err("No patch name given.") return 1 else: patchfile = args[2] else: gbp.log.err("Unknown action '%s'." % args[1]) return 1 try: repo = GitRepository(os.path.curdir) except GitRepositoryError: gbp.log.err("%s is not a git repository" % (os.path.abspath('.'))) return 1 try: current = repo.get_branch() if action == "export": export_patches(repo, current, options) elif action == "import": series = SERIES_FILE tries = options.time_machine if (options.time_machine > 0) else 1 import_quilt_patches(repo, current, series, tries, options.force) current = repo.get_branch() gbp.log.info("Patches listed in '%s' imported on '%s'" % (series, current)) elif action == "drop": drop_pq(repo, current) elif action == "rebase": rebase_pq(repo, current) elif action == "apply": patch = Patch(patchfile) maintainer = get_maintainer_from_control(repo) apply_single_patch(repo, current, patch, maintainer, options.topic) elif action == "switch": switch_pq(repo, current) except CommandExecFailed: retval = 1 except (GbpError, GitRepositoryError) as err: if len(err.__str__()): gbp.log.err(err) retval = 1 return retval