rpm tests: add unit tests for buildpackage-rpm

Signed-off-by: Markus Lehtonen <markus.lehtonen@linux.intel.com>

4 files changed, 757 insertions, 7 deletions

diff --git a/packaging/git-buildpackage.spec b/packaging/git-buildpackage.spec
index 3100b6aa..1b47d0a2 100644
--- a/packaging/git-buildpackage.spec
+++ b/packaging/git-buildpackage.spec
@@ -63,6 +63,7 @@ BuildRequires:  python-nose
 BuildRequires:  git-core
 BuildRequires:  %{man_pkg_name}
 BuildRequires:  %{dpkg_pkg_name}
+BuildRequires:  rpm-build
 BuildRequires:  %{rpm_python_pkg_name}
 BuildRequires:  pristine-tar
 BuildRequires:  unzip
diff --git a/tests/component/rpm/__init__.py b/tests/component/rpm/__init__.py
index dea1c09f..26655756 100644
--- a/tests/component/rpm/__init__.py
+++ b/tests/component/rpm/__init__.py
@@ -46,10 +46,9 @@ class RepoManifest(object):
     def projects_iter(self):
         """Return an iterator over projects"""
         for prj_e in self._doc.getElementsByTagName('project'):
-            branches = {}
+            branches = []
             for br_e in prj_e.getElementsByTagName('branch'):
-                rev = br_e.getAttribute('revision')
-                branches[br_e.getAttribute('name')] = rev
+                branches.append(dict(br_e.attributes.items()))
             yield prj_e.getAttribute('name'), branches
 
 
@@ -67,7 +66,7 @@ class RpmRepoTestBase(ComponentTestBase):
     """Baseclass for tests run in a Git repository with packaging data"""
 
     @classmethod
-    def setup_class(cls):
+    def setup_class(cls, mangle_branch_names=True):
         """Initializations only made once per test run"""
         super(RpmRepoTestBase, cls).setup_class()
         cls.manifest = RepoManifest(os.path.join(RPM_TEST_DATA_DIR,
@@ -93,9 +92,17 @@ class RpmRepoTestBase(ComponentTestBase):
             # 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)
+            master_branch = 'master'
+            for branch in brs:
+                if mangle_branch_names:
+                    branch_name = branch['name']
+                else:
+                    branch_name = branch['orig_name']
+                    if branch['name'] == 'master':
+                        master_branch = branch_name
+                repo.create_branch(branch_name, branch['revision'])
+            repo.set_branch(master_branch)
+            repo.force_head('HEAD', hard=True)
             cls.orig_repos[prj] = repo
 
     @classmethod
diff --git a/tests/component/rpm/data b/tests/component/rpm/data
-Subproject bae44ddc98ae0ed15ae078cb7c2fc597dee48da
+Subproject ff090c1cf946e3df67795ce3c1437ec6246dbf3
diff --git a/tests/component/rpm/test_buildpackage_rpm.py b/tests/component/rpm/test_buildpackage_rpm.py
new file mode 100644
index 00000000..3060f84b
--- /dev/null
+++ b/tests/component/rpm/test_buildpackage_rpm.py
@@ -0,0 +1,742 @@
+# vim: set fileencoding=utf-8 :
+#
+# (C) 2013 Intel Corporation <markus.lehtonen@linux.intel.com>
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+"""Unit tests for the gbp-buildpackage-rpm tool"""
+
+import glob
+import mock
+import os
+import re
+import shutil
+import stat
+import subprocess
+from nose.tools import assert_raises, eq_, ok_ # pylint: disable=E0611
+
+from gbp.git import GitRepository
+from gbp.scripts.buildpackage_rpm import main as gbp_rpm
+
+from tests.component.rpm import RpmRepoTestBase, RPM_TEST_DATA_DIR
+from tests.testutils import ls_dir, ls_tar, ls_zip
+
+# Disable "Method could be a function warning"
+#   pylint: disable=R0201
+# Disable "Too many public methods"
+#   pylint: disable=R0904
+
+
+DATA_DIR = os.path.join(RPM_TEST_DATA_DIR, 'rpm')
+ORIG_DATA_DIR = os.path.join(RPM_TEST_DATA_DIR, 'orig')
+
+MOCK_NOTIFICATIONS = []
+
+
+def mock_gbp(args):
+    """Wrapper for gbp-buildpackage-rpm"""
+    return gbp_rpm(['arg0', '--git-notify=off'] + args +
+                   ['-ba', '--clean', '--target=noarch', '--nodeps'])
+
+def mock_notify(summary, message, notify_opt):
+    """Mock notification system"""
+    # Auto will succeed
+    if notify_opt.is_auto():
+        MOCK_NOTIFICATIONS.append((summary, message))
+        return True
+    # Otherwise fail
+    return False
+
+
+class TestGbpRpm(RpmRepoTestBase):
+    """Basic tests for git-rpm-ch"""
+
+    @staticmethod
+    def ls_rpm(rpm):
+        """List the contents of an rpm package"""
+        args = ['rpm', '-q', '--qf',
+                '[%{FILEDIGESTS %{FILEMODES} %{FILENAMES}\n]', '-p']
+        popen = subprocess.Popen(args + [rpm], stdout=subprocess.PIPE,
+                                 stderr=subprocess.PIPE)
+        stdout, stderr = popen.communicate()
+        if popen.returncode:
+            raise Exception("Failed to get file metadata for %s: %s" %
+                            (rpm, stderr))
+        return sorted([(nam, mod, dig) for dig, mod, nam in
+                        [lin.split(None, 2) for lin in stdout.splitlines()]])
+
+    @staticmethod
+    def check_rpms(directory):
+        """Check build results"""
+        # Only check files, at least for now
+        files = glob.glob(directory + '/*rpm')
+        assert files, "No rpms (%s)found in %s" % (files, directory)
+        for path in files:
+            ref_file = os.path.join(DATA_DIR, os.path.basename(path))
+            eq_(TestGbpRpm.ls_rpm(path), TestGbpRpm.ls_rpm(ref_file))
+
+    @staticmethod
+    def check_and_rm_file(filepath, content):
+        """Check file content and remove it"""
+        with open(filepath) as fobj:
+            eq_(fobj.read(), content)
+        os.unlink(filepath)
+
+    @classmethod
+    def setup_class(cls, **kwargs):
+        """Setup unit tests"""
+        # Don't mangle branch names so that we're able to build the packages
+        super(TestGbpRpm, cls).setup_class(mangle_branch_names=False, **kwargs)
+
+    def test_invalid_args(self):
+        """Check graceful exit when called with invalid args"""
+        GitRepository.create('.')
+        with assert_raises(SystemExit):
+            mock_gbp(['--git-invalid-arg'])
+
+    def test_outside_repo(self):
+        """Run outside a git repository"""
+        eq_(mock_gbp([]), 1)
+        self._check_log(0, 'gbp:error: %s is not a git repository' %
+                            os.path.abspath('.'))
+
+    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_native_build(self):
+        """Basic test of native pkg"""
+        self.init_test_repo('gbp-test-native')
+        eq_(mock_gbp([]), 0)
+        self.check_rpms('../rpmbuild/RPMS/*')
+        shutil.rmtree('../rpmbuild')
+
+        eq_(mock_gbp(['--git-native=off']), 2)
+        self._check_log(0, 'gbp:error: Invalid upstream treeish upstream/')
+
+    def test_native_build2(self):
+        """Basic test of another native pkg"""
+        self.init_test_repo('gbp-test-native2')
+        eq_(mock_gbp([]), 0)
+        self.check_rpms('../rpmbuild/RPMS/*')
+
+    def test_non_native_build(self):
+        """Basic test of non-native pkg"""
+        self.init_test_repo('gbp-test')
+        eq_(mock_gbp([]), 0)
+        self.check_rpms('../rpmbuild/RPMS/*')
+
+    def test_option_native(self):
+        """Test the --git-native option"""
+        self.init_test_repo('gbp-test2')
+        eq_(mock_gbp([]), 0)
+        self.check_rpms('../rpmbuild/RPMS/*')
+        shutil.rmtree('../rpmbuild')
+
+        # Building this pkg should succeed, but no patches generated,
+        # only one "manually maintained" patch
+        eq_(mock_gbp(['--git-native=on']), 0)
+        self.check_rpms('../rpmbuild/RPMS/*')
+        eq_(len(glob.glob('../rpmbuild/SOURCES/*patch')), 1)
+
+    def test_options_ignore(self):
+        """Test the --git-ignore-[new|untracked] options"""
+        self.init_test_repo('gbp-test-native')
+
+        # Create an untracked file
+        with open('untracked-file', 'w') as fobj:
+            fobj.write('this file is not tracked\n')
+
+        eq_(mock_gbp([]), 1)
+        eq_(mock_gbp(['--git-ignore-untracked']), 0)
+        self.check_rpms('../rpmbuild/RPMS/*')
+
+        # Modify tracked file
+        with open('README', 'a') as fobj:
+            fobj.write('new stuff\n')
+
+        eq_(mock_gbp(['--git-ignore-untracked']), 1)
+        eq_(mock_gbp(['--git-ignore-new']), 0)
+
+    @mock.patch('gbp.notifications.notify', mock_notify)
+    def test_option_notify(self):
+        """Test the --git-notify option"""
+        self.init_test_repo('gbp-test-native')
+
+        eq_(mock_gbp(['--git-notify=auto']), 0)
+        summary, message = MOCK_NOTIFICATIONS.pop()
+        ok_(re.match(r'Gbp-rpm successful', summary), summary)
+        ok_(re.match(r'Build of \S+ \S+ succeeded', message), message)
+
+        # Mock-notification will fail with "on" setting
+        eq_(mock_gbp(['--git-notify=on']), 1)
+        self._check_log(-1, "gbp:error: Failed to send notification")
+
+        # No notification when "off"
+        eq_(mock_gbp(['--git-notify=off']), 0)
+        eq_(len(MOCK_NOTIFICATIONS), 0)
+
+    def test_option_tmp_dir(self):
+        """Test the --git-tmp-dir option"""
+        self.init_test_repo('gbp-test-native')
+
+        eq_(mock_gbp(['--git-tmp-dir=../gbptmp', '--git-no-build']), 0)
+        ok_(os.path.isdir('../gbptmp'))
+
+        # Check tmpdir access/creation error
+        os.chmod('../gbptmp', 0)
+        try:
+            eq_(mock_gbp(['--git-tmp-dir=../gbptmp/foo', '--git-no-build']), 1)
+        finally:
+            os.chmod('../gbptmp', stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
+
+    def test_tagging(self):
+        """Test tagging options"""
+        repo = self.init_test_repo('gbp-test-native')
+
+        # Build and tag
+        eq_(mock_gbp(['--git-tag', '--git-packaging-tag=rel-tag']), 0)
+        self.check_rpms('../rpmbuild/RPMS/*')
+        ok_(repo.has_tag('rel-tag'))
+        sha = repo.rev_parse('HEAD')
+        eq_(sha, repo.rev_parse('rel-tag^0'))
+        self.check_rpms('../rpmbuild/RPMS/*')
+
+        # Should fail if the tag already exists
+        eq_(mock_gbp(['--git-tag', '--git-packaging-tag=rel-tag']), 1)
+
+        # Re-tag
+        eq_(mock_gbp(['--git-retag', '--git-packaging-tag=rel-tag']), 1)
+        self._check_log(-1, "gbp:error: '--git-retag' needs either '--git-tag'")
+
+        eq_(mock_gbp(['--git-tag', '--git-packaging-tag=rel-tag',
+                     '--git-retag', '--git-export=HEAD^']), 0)
+        ok_(repo.has_tag('rel-tag'))
+        sha2 = repo.rev_parse('HEAD^')
+        ok_(sha2 != sha)
+        eq_(sha2, repo.rev_parse('rel-tag^0'))
+
+        # Tag-only
+        shutil.rmtree('../rpmbuild')
+        eq_(mock_gbp(['--git-tag-only', '--git-packaging-tag=rel-tag2']), 0)
+        ok_(not os.path.exists('../rpmbuild'))
+        ok_(repo.has_tag('rel-tag2'))
+
+        # Valid tag format string keys
+        tag_keys = ['upstreamversion', 'release', 'version', 'vendor',
+                    'nowtime', 'authortime', 'committime',
+                    'nowtimenum', 'authortimenum', 'committimenum']
+        # Should fail if the fag format has invalid keys (foo here)
+        tag_fmt = '_'.join(['%(' + key + ')s' for key in tag_keys + ['foo']])
+        eq_(mock_gbp(['--git-tag', '--git-packaging-tag=%(foo)s']), 1)
+        # Remove 'foo' and should succeed
+        tag_fmt = '_'.join(['%(' + key + ')s' for key in tag_keys])
+        eq_(mock_gbp(['--git-tag-only', '--git-packaging-tag=%s' % tag_fmt]), 0)
+        # New tag with same format should succeed when '*num' keys are present
+        eq_(mock_gbp(['--git-tag-only', '--git-packaging-tag=%s' % tag_fmt]), 0)
+
+    def test_option_upstream_tree(self):
+        """Test the --git-upstream-tree option"""
+        repo = self.init_test_repo('gbp-test')
+
+        # Dummy update to upstream branch
+        pkg_branch = repo.get_branch()
+        upstr_branch = 'srcdata/gbp-test/upstream'
+        orig_files = ['gbp-test/' + path for \
+                path in self.ls_tree(repo, upstr_branch)] + ['gbp-test']
+        repo.set_branch(upstr_branch)
+        with open('new-file', 'w') as fobj:
+            fobj.write('New file\n')
+        with open('new-file2', 'w') as fobj:
+            fobj.write('New file 2\n')
+        repo.add_files(['new-file', 'new-file2'])
+        repo.commit_files('new-file', 'New content')
+        repo.commit_files('new-file2', 'New content 2')
+        repo.set_branch(pkg_branch)
+
+        # TAG (default) does not contain the new files
+        eq_(mock_gbp([]), 0)
+        tar_files = ls_tar('../rpmbuild/SOURCES/gbp-test-1.1.tar.bz2')
+        self.check_files(orig_files, tar_files)
+        shutil.rmtree('../rpmbuild')
+
+        # Branch contains them both
+        eq_(mock_gbp(['--git-upstream-tree=BRANCH']), 0)
+        tar_files = ls_tar('../rpmbuild/SOURCES/gbp-test-1.1.tar.bz2')
+        self.check_files(orig_files +
+                         ['gbp-test/new-file', 'gbp-test/new-file2'], tar_files)
+        shutil.rmtree('../rpmbuild')
+
+        # The first "extra-commit" in upstream contains only one new file
+        eq_(mock_gbp(['--git-upstream-tree=%s^' % upstr_branch]), 0)
+        tar_files = ls_tar('../rpmbuild/SOURCES/gbp-test-1.1.tar.bz2')
+        self.check_files(orig_files + ['gbp-test/new-file'], tar_files)
+        shutil.rmtree('../rpmbuild')
+
+        # Test invalid upstream treeish
+        eq_(mock_gbp(['--git-upstream-tree=TAG',
+                      '--git-upstream-tag=invalid-tag']), 2)
+        self._check_log(-1, ".*Invalid upstream treeish invalid-tag")
+        eq_(mock_gbp(['--git-upstream-tree=BRANCH', '--git-native=no',
+                      '--git-upstream-branch=invalid-branch']), 2)
+        self._check_log(-1, ".*invalid-branch is not a valid branch")
+        eq_(mock_gbp(['--git-upstream-tree=invalid-tree']), 2)
+        self._check_log(-1, ".*Invalid treeish object")
+
+    def test_option_orig_prefix(self):
+        """Test the --git-orig-prefix option"""
+        repo = self.init_test_repo('gbp-test')
+
+        # Building with invalid prefix should fail
+        eq_(mock_gbp(['--git-orig-prefix=foo']), 1)
+        upstr_branch = 'srcdata/gbp-test/upstream'
+        ref_files = ['foo/' + path for path in self.ls_tree(repo, upstr_branch)]
+        tar_files = ls_tar('../rpmbuild/SOURCES/gbp-test-1.1.tar.bz2', False)
+        self.check_files(tar_files, ref_files)
+
+        # Test invalid keys
+        eq_(mock_gbp(['--git-orig-prefix=%(foo)s', '--git-no-build']), 1)
+        self._check_log(-1, ".*Unknown key 'foo' in orig prefix format")
+
+    def test_pristine_tar(self):
+        """Test pristine-tar"""
+        repo = self.init_test_repo('gbp-test')
+
+        # Pristine-tar checkout fails when no pristine-tar branch
+        eq_(mock_gbp(['--git-pristine-tar',
+                      '--git-export=srcdata/gbp-test/release/1.1-2']), 1)
+        self._check_log(-1, ".*Couldn't checkout")
+
+        # Create pristine-tar branch and try again
+        repo.create_branch('pristine-tar', 'srcdata/gbp-test/pristine_tar')
+        eq_(mock_gbp(['--git-pristine-tar',
+                      '--git-export=srcdata/gbp-test/release/1.1-2']), 0)
+        self.check_rpms('../rpmbuild/RPMS/*')
+
+    def test_pristine_tar_commit(self):
+        """Test committing upstream tarball to pristine-tar"""
+        repo = self.init_test_repo('gbp-test')
+
+        eq_(repo.has_branch('pristine-tar'), False)
+        eq_(mock_gbp(['--git-pristine-tar-commit',
+                      '--git-export=srcdata/gbp-test/release/1.0-1']), 0)
+        eq_(len(repo.get_commits(until='pristine-tar')), 1)
+        shutil.rmtree('../rpmbuild')
+
+        # Using --git-pristine-tar and --git-pristine-tar-commit should be ok
+        eq_(mock_gbp(['--git-pristine-tar', '--git-pristine-tar-commit']), 0)
+        eq_(len(repo.get_commits(until='pristine-tar')), 2)
+        shutil.rmtree('../rpmbuild')
+
+        # Second time no pristine-tar should not be commited
+        eq_(mock_gbp(['--git-pristine-tar-commit']), 0)
+        eq_(len(repo.get_commits(until='pristine-tar')), 2)
+
+    def test_tarball_dir(self):
+        """Test a separate tarball cache"""
+        self.init_test_repo('gbp-test')
+
+        # Create and populate tarball cache
+        tarball_dir = '../tarballs'
+        os.mkdir(tarball_dir)
+        shutil.copy2(os.path.join(ORIG_DATA_DIR, 'gbp-test-1.0.tar.bz2'),
+                     tarball_dir)
+
+        # Test build when tarball is found from cache
+        eq_(mock_gbp(['--git-export=srcdata/gbp-test/release/1.0-1',
+                      '--git-tarball-dir=%s' % tarball_dir]), 0)
+        ok_(os.path.islink(os.path.join('..', 'rpmbuild', 'SOURCES',
+                                        'gbp-test-1.0.tar.bz2')))
+
+        # Test build when tarball is not found from cache
+        eq_(mock_gbp(['--git-export=srcdata/gbp-test/release/1.1-2',
+                      '--git-tarball-dir=%s' % tarball_dir]), 0)
+        ok_(os.path.isfile(os.path.join('..', 'rpmbuild', 'SOURCES',
+                                        'gbp-test-1.1.tar.bz2')))
+
+    def test_packaging_branch_options(self):
+        """Test the --packaging-branch and --ignore-branch cmdline options"""
+        repo = self.init_test_repo('gbp-test-native')
+
+        eq_(mock_gbp(['--git-packaging-branch=foo']), 1)
+        self._check_log(-2, "gbp:error: You are not on branch 'foo'")
+
+        eq_(mock_gbp(['--git-packaging-branch=foo', '--git-ignore-branch']), 0)
+
+        # Test building when not on any branch
+        repo.set_branch(repo.rev_parse('HEAD'))
+        eq_(mock_gbp(['--git-no-build']), 1)
+        eq_(mock_gbp(['--git-ignore-branch', '--git-no-build']), 0)
+
+    def test_option_submodules(self):
+        """Test the --git-submodules option"""
+        repo = self.init_test_repo('gbp-test')
+
+        # Create submodule to upstream branch
+        sub_repo = self.orig_repos['gbp-test-native']
+        pkg_branch = repo.get_branch()
+        upstr_branch = 'srcdata/gbp-test/upstream'
+        repo.set_branch(upstr_branch)
+        repo.add_submodule(sub_repo.path)
+        repo.commit_all('Add submodule')
+        repo.set_branch(pkg_branch)
+
+        sub_files = self.ls_tree(sub_repo, 'HEAD')
+        upstr_files = ['gbp-test/' + path for
+                            path in self.ls_tree(repo, upstr_branch)]
+
+        # Test the "no" option
+        eq_(mock_gbp(['--git-no-submodules', '--git-upstream-tree=%s' %
+                      upstr_branch, '--git-ignore-untracked']), 0)
+        tar_files = ls_tar('../rpmbuild/SOURCES/gbp-test-1.1.tar.bz2', False)
+        self.check_files(upstr_files, tar_files)
+        shutil.rmtree('../rpmbuild')
+
+        # Test the "yes" option
+        eq_(mock_gbp(['--git-submodules', '--git-upstream-tree=%s' %
+                      upstr_branch, '--git-ignore-untracked']), 0)
+        tar_files = ls_tar('../rpmbuild/SOURCES/gbp-test-1.1.tar.bz2', False)
+        ref_files = upstr_files + ['gbp-test/gbp-test-native.repo/' + path for
+                                        path in sub_files]
+        self.check_files(ref_files, tar_files)
+        shutil.rmtree('../rpmbuild')
+
+        # Test submodule failure
+        shutil.rmtree('gbp-test-native.repo')
+        repo.create('gbp-test-native.repo')
+        eq_(mock_gbp(['--git-submodules', '--git-upstream-tree=%s' %
+                      upstr_branch, '--git-ignore-untracked']), 2)
+
+    def test_option_submodules_native(self):
+        """Test the --git-submodules option for native packages"""
+        repo = self.init_test_repo('gbp-test-native')
+
+        # Create submodule
+        sub_repo = self.orig_repos['gbp-test-native2']
+        repo.add_submodule(sub_repo.path)
+        repo.commit_all('Add submodule')
+
+        sub_files = self.ls_tree(sub_repo, 'HEAD')
+        master_files = ['gbp-test-native-1.0/' + path for
+                            path in self.ls_tree(repo, 'HEAD')]
+
+        # Test
+        eq_(mock_gbp(['--git-submodules']), 0)
+        zip_files = ls_zip('../rpmbuild/SOURCES/gbp-test-native-1.0.zip', False)
+        ref_files = master_files + \
+                    ['gbp-test-native-1.0/gbp-test-native2.repo/' + path for
+                                        path in sub_files]
+        self.check_files(ref_files, zip_files)
+
+        # Test submodule failure
+        shutil.rmtree('gbp-test-native2.repo')
+        repo.create('gbp-test-native2.repo')
+        eq_(mock_gbp(['--git-submodules', '--git-ignore-untracked']), 1)
+
+    def test_option_builder(self):
+        """Test --git-builder option and it's args"""
+        self.init_test_repo('gbp-test-native')
+        base_args = ['arg0', '--git-notify=off']
+
+        # Try rpmbuild with default args
+        eq_(gbp_rpm(base_args + ['--git-builder=rpmbuild', '--nodeps']), 0)
+
+        # Build without builder args
+        builder_script = 'echo -n $* > builder_args.txt'
+        eq_(gbp_rpm(base_args + ['--git-builder=%s' % builder_script]), 0)
+        with open('../rpmbuild/builder_args.txt') as fobj:
+            args = fobj.read()
+        eq_(args, 'gbp-test-native.spec')
+
+        # Build with builder args
+        eq_(gbp_rpm(base_args + ['--git-builder=%s' % builder_script,
+                                 '--arg1', '--arg2']), 0)
+        with open('../rpmbuild/builder_args.txt') as fobj:
+            args = fobj.read()
+        eq_(args, '--arg1 --arg2 gbp-test-native.spec')
+
+    def test_option_builder_osc(self):
+        """Test --git-builder=osc"""
+        self.init_test_repo('gbp-test-native')
+        eq_(mock_gbp(['--git-builder=osc', '--git-no-build']), 0)
+
+        eq_(set(os.listdir('../rpmbuild')),
+            set(os.listdir('./packaging') + ['gbp-test-native-1.0.zip']))
+
+    def test_option_cleaner(self):
+        """Test --git-cleaner option"""
+        self.init_test_repo('gbp-test-native')
+
+        # Make repo dirty
+        with open('untracked-file', 'w') as fobj:
+            fobj.write('this file is not tracked\n')
+
+        # Build on dirty repo should fail
+        eq_(mock_gbp([]), 1)
+
+        # Build should succeed with cleaner
+        eq_(mock_gbp(['--git-cleaner=rm untracked-file']), 0)
+
+    def test_hook_options(self):
+        """Test different hook options"""
+        self.init_test_repo('gbp-test-native')
+
+        cleaner = 'echo -n cleaner >> ../hooks'
+        postexport = 'echo -n postexport >> $GBP_TMP_DIR/../hooks'
+        prebuild = 'echo -n prebuild >> $GBP_BUILD_DIR/../hooks'
+        postbuild = 'echo -n postbuild >> $GBP_BUILD_DIR/../hooks'
+        posttag = 'echo -n posttag >> ../hooks'
+        args = ['--git-cleaner=%s' % cleaner,
+                '--git-postexport=%s' % postexport,
+                '--git-prebuild=%s' % prebuild,
+                '--git-postbuild=%s' % postbuild,
+                '--git-posttag=%s' % posttag]
+
+        # Only cleaner and posttag is run when tagging
+        eq_(mock_gbp(args + ['--git-tag-only', '--git-packaging-tag=tag1']), 0)
+        self.check_and_rm_file('../hooks', 'cleanerposttag')
+
+        # Prebuild is not run when only exporting
+        eq_(mock_gbp(args + ['--git-no-build']), 0)
+        self.check_and_rm_file('../hooks', 'cleanerpostexport')
+        shutil.rmtree('../rpmbuild')
+
+        # Export and build scripts are run when not tagging
+        eq_(mock_gbp(args), 0)
+        self.check_and_rm_file('../hooks', 'cleanerpostexportprebuildpostbuild')
+        shutil.rmtree('../rpmbuild')
+
+        # All hooks are run when building
+        eq_(mock_gbp(args + ['--git-tag', '--git-packaging-tag=tag2']), 0)
+        self.check_and_rm_file('../hooks',
+                               'cleanerpostexportprebuildpostbuildposttag')
+        shutil.rmtree('../rpmbuild')
+
+        # Run with hooks disabled
+        eq_(mock_gbp(args + ['--git-no-hooks']), 0)
+        ok_(not os.path.exists('../hooks'))
+
+    def test_option_export_only(self):
+        """Test the (deprecated) --git-export-only option"""
+        self.init_test_repo('gbp-test-native')
+        eq_(mock_gbp(['--git-export-only']), 0)
+        self._check_log(-1, ".*Deprecated option '--git-export-only'")
+
+    def test_builddir_options(self):
+        """Test the options related to different build directories"""
+        self.init_test_repo('gbp-test-native')
+
+        eq_(mock_gbp(['--git-export-dir=../foo',
+                      '--git-rpmbuild-builddir=build',
+                      '--git-rpmbuild-buildrootdir=buildroot',
+                      '--git-rpmbuild-rpmdir=rpm',
+                      '--git-rpmbuild-sourcedir=source',
+                      '--git-rpmbuild-specdir=spec',
+                      '--git-rpmbuild-srpmdir=srpm']), 0)
+
+        # Check all directories
+        eq_(set(os.listdir('../foo')),
+            set(['build', 'buildroot', 'rpm', 'source', 'spec', 'srpm']))
+
+        # Test export dir creation error (gbp will not create dir hierarchy)
+        eq_(mock_gbp(['--git-export-dir=../bar/foo']), 1)
+        self._check_log(-1, ".*gbp:error: Cannot create dir")
+
+    def test_export_failure(self):
+        """Test export dir permission problems"""
+        self.init_test_repo('gbp-test-native')
+        s_rwx = stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC
+
+        # Pre-create all files
+        eq_(mock_gbp(['--git-no-build']), 0)
+
+        # Error in exporting packaging files
+        os.chmod('../rpmbuild/SOURCES', 0)
+        try:
+            eq_(mock_gbp(['--git-no-build']), 1)
+        finally:
+            os.chmod('../rpmbuild/SOURCES', s_rwx)
+        self._check_log(-1, ".*Error exporting files")
+
+        # Error in creating archive
+        os.chmod('../rpmbuild/SOURCES/gbp-test-native-1.0.zip', 0)
+        try:
+            eq_(mock_gbp(['--git-no-build']), 1)
+        finally:
+            os.chmod('../rpmbuild/SOURCES/gbp-test-native-1.0.zip', s_rwx)
+        self._check_log(-1, ".*Error creating ../rpmbuild/SOURCES/.*.zip")
+
+    def test_option_export(self):
+        """Test the --git-export-option"""
+        repo = self.init_test_repo('gbp-test')
+
+        # Test exporting of some other commit than HEAD
+        eq_(mock_gbp(['--git-export=srcdata/gbp-test/release/1.0-1']), 0)
+        eq_(os.listdir('../rpmbuild/RPMS/noarch'),
+                       ['gbp-test-1.0-1.noarch.rpm'])
+        self.check_rpms('../rpmbuild/RPMS/*')
+
+        # Modify one tracked file, create one untracked and one ignored file
+        with open('foo.txt', 'a') as fobj:
+            fobj.write('staged')
+            fobj.flush()
+            repo.add_files('foo.txt')
+            fobj.write('unstaged')
+        with open('untracked', 'w') as fobj:
+            fobj.write('untracked')
+        with open('ignored.tmp', 'w') as fobj:
+            fobj.write('ignored')
+
+        base_args = ['--git-ignore-new', '--git-no-build']
+        # Test exporting of git index
+        foo_txt_index = repo.show('HEAD:foo.txt') + 'staged'
+        eq_(mock_gbp(base_args + ['--git-export=INDEX']), 0)
+        self.check_and_rm_file('../rpmbuild/SOURCES/foo.txt', foo_txt_index)
+        ok_(not os.path.exists('../rpmbuild/SOURCES/untracked'))
+        ok_(not os.path.exists('../rpmbuild/SOURCES/ignored.tmp'))
+        shutil.rmtree('../rpmbuild')
+
+        # Test exporting of working copy (tracked files only)
+        eq_(mock_gbp(base_args + ['--git-export=WC.TRACKED']), 0)
+        foo_txt_wc = repo.show('HEAD:foo.txt') + 'staged' + 'unstaged'
+        self.check_and_rm_file('../rpmbuild/SOURCES/foo.txt', foo_txt_wc)
+        ok_(not os.path.exists('../rpmbuild/SOURCES/untracked'))
+        ok_(not os.path.exists('../rpmbuild/SOURCES/ignored.tmp'))
+        shutil.rmtree('../rpmbuild')
+
+        # Test exporting of working copy (include untracked files)
+        eq_(mock_gbp(base_args + ['--git-export=WC.UNTRACKED']), 0)
+        self.check_and_rm_file('../rpmbuild/SOURCES/foo.txt', foo_txt_wc)
+        self.check_and_rm_file('../rpmbuild/SOURCES/untracked', 'untracked')
+        ok_(not os.path.exists('../rpmbuild/SOURCES/ignored.tmp'))
+        shutil.rmtree('../rpmbuild')
+
+        # Test exporting of working copy (include all files)
+        eq_(mock_gbp(base_args + ['--git-export=WC']), 0)
+        self.check_and_rm_file('../rpmbuild/SOURCES/foo.txt', foo_txt_wc)
+        self.check_and_rm_file('../rpmbuild/SOURCES/untracked', 'untracked')
+        self.check_and_rm_file('../rpmbuild/SOURCES/ignored.tmp', 'ignored')
+        shutil.rmtree('../rpmbuild')
+
+        # Test exporting an invalid treeish
+        eq_(mock_gbp(base_args + ['--git-export=invalid-treeish']), 1)
+        self._check_log(-1, "gbp:error: Failed to determine export treeish")
+
+    def test_option_spec_file(self):
+        """Test the --git-spec-file cmdline option"""
+        repo = self.init_test_repo('gbp-test2')
+
+        eq_(mock_gbp(['--git-spec-file=foo.spec']), 1)
+        self._check_log(-1, "gbp:error: Can't parse spec: Git error")
+
+        eq_(mock_gbp(['--git-spec-file=auto']), 1)
+        self._check_log(-1, "gbp:error: Can't parse spec: Multiple spec files")
+
+        eq_(mock_gbp(['--git-spec-file=packaging/gbp-test2.spec']), 0)
+
+        # No spec file found error
+        repo.set_branch('srcdata/gbp-test2/upstream')
+        eq_(mock_gbp([]), 1)
+        self._check_log(-1, ".*Can't parse spec: No spec file found")
+
+    def test_option_packaging_dir(self):
+        """Test the --git-packaging-dir cmdline option"""
+        self.init_test_repo('gbp-test-native')
+
+        eq_(mock_gbp(['--git-packaging-dir=foo']), 1)
+        self._check_log(-1, "gbp:error: Can't parse spec: No spec file found")
+
+        # Packaging dir should be taken from spec file if it is defined
+        eq_(mock_gbp(['--git-packaging-dir=foo',
+                      '--git-spec-file=packaging/gbp-test-native.spec']), 0)
+
+    def test_option_spec_vcs_tag(self):
+        """Test the --git-spec-vcs-tag cmdline option"""
+        repo = self.init_test_repo('gbp-test-native')
+
+        eq_(mock_gbp(['--git-spec-vcs-tag=foobar-%(commit)s']), 0)
+        sha1 = repo.rev_parse('HEAD')
+        num_tags = 0
+        with open('../rpmbuild/SPECS/gbp-test-native.spec') as fobj:
+            for line in fobj.readlines():
+                if line.startswith('VCS: '):
+                    ok_(re.match(r'VCS:\s+foobar-%s\n$' % sha1, line))
+                    num_tags += 1
+        eq_(num_tags, 1)
+
+        # Test invalid key
+        eq_(mock_gbp(['--git-spec-vcs-tag=%(invalid-key)s']), 1)
+        self._check_log(-1, ".*Unknown key 'invalid-key' in vcs tag format")
+
+    def test_patch_export_options(self):
+        """Test patch export options"""
+        repo = self.init_test_repo('gbp-test2')
+
+        # Test no-patch-export
+        base_args = ['--git-builder=osc', '--git-no-build']
+        eq_(mock_gbp(base_args + ['--git-no-patch-export']), 0)
+        ref_files = self.ls_tree(repo, 'HEAD:packaging')
+        ref_files.add('gbp-test2-2.0.tar.gz')
+        eq_(ls_dir('../rpmbuild', False), ref_files)
+        shutil.rmtree('../rpmbuild')
+
+        # No patches should be generated if patch-export-rev is upstream version
+
+        # Test patch compression and numbering
+        eq_(mock_gbp(base_args + ['--git-no-patch-numbers',
+                                  '--git-patch-export-compress=1']), 0)
+        new_files = ls_dir('../rpmbuild', False) - ref_files
+        ok_(len(new_files) > 0)
+        for fname in new_files:
+            # Patches should start with an alphabet and be compressed with gz
+            ok_(re.match(r'^[a-zA-Z]\S*.patch.gz$', fname), fname)
+
+    def test_devel_branch_support(self):
+        """Test patch-generation from q/development branch"""
+        repo = self.init_test_repo('gbp-test')
+        pq_br = 'srcdata/gbp-test/pq/master'
+
+        # Patch export with no apparent pq branch should fail
+        eq_(mock_gbp(['--git-patch-export']), 2)
+        self._check_log(-1, r".*Start commit \S+ not an ancestor of end commit")
+
+        # With valid pq branch patch export should succeeded
+        eq_(mock_gbp(['--git-patch-export', '--git-pq-branch=%s' % pq_br]), 0)
+        self.check_rpms('../rpmbuild/RPMS/*')
+        shutil.rmtree('../rpmbuild')
+        eq_(mock_gbp(['--git-patch-export', '--git-pq-branch=%s' % pq_br,
+                      '--git-export=srcdata/gbp-test/master']), 0)
+        self.check_rpms('../rpmbuild/RPMS/*')
+        shutil.rmtree('../rpmbuild')
+
+        # With pq branch but with wrong patch-export rev build should fail
+        eq_(mock_gbp(['--git-patch-export', '--git-pq-branch=%s' % pq_br,
+                      '--git-patch-export-rev=HEAD']), 2)
+        self._check_log(-1, r".*Start commit \S+ not an ancestor of end commit")
+
+        # Patch-export should be auto-enabled when on pq branch
+        repo.set_branch(pq_br)
+        eq_(mock_gbp(['--git-pq-branch=%s' % pq_br, '--git-ignore-branch']), 0)
+        self.check_rpms('../rpmbuild/RPMS/*')
+        shutil.rmtree('../rpmbuild')
+
+        # Fail when (apparently) on pq branch but no packaging branch found
+        eq_(mock_gbp(['--git-pq-branch=%s' % pq_br, '--git-ignore-branch',
+                      '--git-packaging-branch=foo']), 1)