Merge ~racb/git-ubuntu:importer-add-tests into git-ubuntu:master

[Robie Basak]

Make jenkins happy

Add tests, some of which are xfail pending future changes.

[Server Team CI bot (server-team-bot)]

FAILED: Continuous integration, rev:a1c88d7eca4aaf6d235332efa7cd26b8238b35bb
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/409/
Executed test runs:
    SUCCESS: VM Setup
    SUCCESS: Build
    FAILED: Unit Tests

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/409/rebuild

review: Needs Fixing (continuous-integration)

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:6fc24f6fe4f178cffbb4930c0c93958f12423f75
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/410/
Executed test runs:
    SUCCESS: VM Setup
    SUCCESS: Build
    SUCCESS: Unit Tests
    SUCCESS: Integration Tests
    IN_PROGRESS: Declarative: Post Actions

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/410/rebuild

review: Approve (continuous-integration)

[Andreas Hasenack (ahasenack)]

I'll have to continue tomorrow, these tests are complex to grasp.

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:d99073ccf1c0a3e067fbbfc6341731ee9219b291
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/411/
Executed test runs:
    SUCCESS: VM Setup
    SUCCESS: Build
    SUCCESS: Unit Tests
    SUCCESS: Integration Tests
    IN_PROGRESS: Declarative: Post Actions

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/411/rebuild

review: Approve (continuous-integration)

[Nish Aravamudan (nacc)]

On Tue, May 22, 2018 at 6:48 AM, Robie Basak <email address hidden>
wrote:

>
>
> Diff comments:
>
> > diff --git a/doc/SPECIFICATION.importer b/doc/SPECIFICATION.importer
> > new file mode 100644
> > index 0000000..8c7f80c
> > --- /dev/null
> > +++ b/doc/SPECIFICATION.importer
> > @@ -0,0 +1,72 @@
> > +When importing a publishing record, there are two potential logical
> > +consequences:
> > +
> > + 1) Some new commit is created, with an associated tag; and/or
> > + 2) Some branch is adjusted to point at some commit
> > +
> > +In the following, existing tags may be 'import', 'upload' or 'applied'.
> > +Based upon SPECIFICATION.tags, 'import' and 'applied' tags are lists
> > +tags, which might be a single import tag or a list of reimport tags for
>

Should this be "lists of tags"?
>

Yep, typo. Want me to just push on top?

> > +any given version.
> > +
> > +If an existing tag with the same Git tree is found as a new publish
> > +event, we should reuse the tag, and adjust the corresponding branch to
> > +the same tagged commit.
> > +
> > +If no existing tag with same Git tree is found, a new import/applied tag
> > +should be created, as appropriate, and the corresponding branch should
> > +be adjusted to the the new tagged commit.
> > +
> > +If a new commit is created, appropriate commit parents are found in the
> > +existing Git commit graph. A changelog parent is the nearest (reverse
> > +chronologically) tagged version from debian/changelog of the publishing
> > +record.
> > +
> > +For patches-unapplied imports, parents are:
> > + 1) import-tagged changelog parents.
> > +
> > +For patches-applied imports, parents are:
> > + 1) applied-tagged changelog parents
> > + 2) import-tagged patches-unapplied commit of the same version as
> > + this publishing record.
> > +
> > +Logically, therefore, it is assumed for any given version that the
> > +patches-unapplied import occurs before the patches-applied import.
> > +
> > +Specific patches-unapplied cases, where in the following a tag exists
> > +for a specific version:
> > +
> > +1) An existing import tag (or reimport tag) with the same Git tree
> > + - Reuse import tag
> > +
> > +2) An existing import tag with a different Git tree and an existing
> > + upload tag with the same Git tree
> > + - Reuse upload tag, create reimport tag
> > +
> > +3) An existing import tag with a different Git tree and an existing
> > + upload tag with a different Git tree
> > + - Create reimport tag
> > +
> > +4) An existing import tag with a different Git tree and no upload tag
> > + - Create reimport tag
> > +
> > +5) No import tag and an existing upload tag with the same Git tree
> > + - Reuse upload tag, create import tag
> > +
> > +6) No import tag and an existing upload tag with a different Git tree
> > + - Create import tag
> > +
> > +7) No import tags or upload tags
> > + - Create import tag
> > +
> > +Specific patches-applied cases, where in the following a tag exists
> > +for a specific version:
> > +
> > +1) An existing applied tag (or reimport tag) with the same Git tree
> > + - Reuse applied tag
> > +
> > +2) An existing applied tag with a different Git tree
> > ...

[Robie Basak (racb)]

After a long absence I'm looking at making progress on the specification, tests and importer changes again. Nish, what's the level of involvement you'd like right now? I will happily take over if you're unavailable.

For now, I noticed something, comment inline, in part as a note to myself. I'm not intending to send you work without talking to you first and I'd be happy to fix up these review comments myself given how long it's been.

If you want less involvement Nish, I'm not sure yet if I intend to adjust this branch, or cherry-pick into a new one to land this work in more pieces. If you'd like more involvement, let's coordinate to avoid any wasted effort. Thanks!

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:ece36b58b615c4843b99779eefc032c75479ffea
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/397/
Executed test runs:
    SUCCESS: VM Setup
    SUCCESS: Build
    SUCCESS: Unit Tests
    IN_PROGRESS: Declarative: Post Actions

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/397//rebuild

review: Approve (continuous-integration)

[Bryce Harrington (bryce)]

Since this changeset is entirely just test code, there should be no risk to production code.

The xfail_strict=true is noteworthy in that it potentially could break CI if there were inconsistently marked xfail tests, but CI has passed so this is not a concern. It enforces a conventional understanding of xfail, so it's a good change to have in the testsuite. I've doublechecked each of the xfail cases has an LP# associated with it, and reviewed each bug report and test case.

Additional comments below. Main one is suggesting addition of a helper routine mk_commit() to refactor some repetitive setup code. Mostly copyedits and verbage suggestions beyond that.

I'm still working on wrapping my head around the test cases themselves, so will have more feedback to come.

review: Needs Fixing

[Bryce Harrington (bryce)]

A bit more feedback, and I think I finally follow the mechanics of the test cases. A few more refactoring suggestions, some spelling copyedits, and I spotted an incorrect documentation for one of the test cases.

One thing I've not verified is if this covers all the necessary cases for the importer's logic. But I figure it's not like we can't keep adding to this, and expect there will be more cases to add as you delve into the importer logic. The main thing is that this gives a strong structure to add onto.

Also, while I've run the tests for this branch in the past, I haven't done so recently. I did check that jenkins appears to be running them:

#394 gitubuntu/importer_test.py .............................
#397 gitubuntu/importer_test.py ................................x...xx

The first corresponds to current trunk, the second this branch; the increase in tests and the xfails in the second case confirm to me the tests were run and passed.

review: Needs Fixing

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:5e9c1e9fcb5503d18f3c2b56aac86b15d38d29e8
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/424/
Executed test runs:
    SUCCESS: VM Setup
    SUCCESS: Build
    SUCCESS: Unit Tests
    IN_PROGRESS: Declarative: Post Actions

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/424//rebuild

review: Approve (continuous-integration)

[Robie Basak (racb)]

Thank you for the review!

Some of your suggested refactorings also apply to tests already present,
so for consistency, particular as some of your requests were for the
purposes of consistency, I have also made matching consistency changes
to tests that were already there. To make this practical I have had to
do some heavy rebasing. Most of the consistency-type refactorings are
squashed into the main "Add importer tests" commit now. Changes to the
previously existing tests appear before "Add importer tests" in the
patchset and are individually committed and documented. Other review
changes I've left separate for your review convenience, ready to squash
with --autosquash before merging.

On Tue, Nov 05, 2019 at 04:15:47AM -0000, Bryce Harrington wrote:
> > +# When importing a publishing record, there are two potential logical
> > +# consequences:
> > +#
> > +# 1) Some new commit is created, with an associated tag; and/or
> > +# 2) Some branch is adjusted to point at some commit
> > +#
> > +# If an existing tag with the same Git tree is found as a new publish
> > +# event, we should reuse the tag, and adjust the corresponding branch to
> > +# the same tagged commit.
> > +#
> > +# If no existing tag with same Git tree is found, a new tree and a new
>
> s/b "with the same"

Fixed in commit 196ec89.

> > +# import/applied tag that points to it should be created, as appropriate,
> > +# and the corresponding branch should be adjusted to the the new tagged
> > +# commit.
> > +#
> > +# If a new commit is created, appropriate commit parents are found in the
> > +# existing Git commit graph. A changelog parent is the nearest (reverse
> > +# chronologically) tagged version from debian/changelog of the publishing
> > +# record.
>
> s/b "from the debian/changelog of"

Fixed in commit 196ec89.

> > [e-mail](
> > + 'name, input_repo, expected_changes, compare_refs, exist_refs, reuse', [
> > + # 1) An existing import tag (or reimport tag) with the same Git tree
> > + # - Reuse import tag
> > + pytest.param(
> > + 'Case 1',
> > + repo_builder.Repo(
> > + commit_list=[
> > + repo_builder.Commit(
> > + tree=repo_builder.SourceTree(
> > + source_builder.Source(
> > + source_builder.SourceSpec(
> > + version='1-1',
> > + native=False,
> > + )
> > + )
> > + ),
> > + name='import'
> > + ),
>
> This stanza of code to create a commit is repeated throughout this
> test suite with slight alterations. I think the tests would read
> easier if this was generated by a helper routine. I'm imagining
> something like:
>
> def mk_commit(name, with_file=False):
> file_contents = None
> if with_file:
> file_contents = {
> 'debian/random': 'The {} tag contents'.format( name ),
> }
>
> return repo_builder.Commit(
> tree=repo_builder.SourceTree(
> ...

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:68d61822e69cb4849a43298f32e19a202968c06b
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/427/
Executed test runs:
    SUCCESS: VM Setup
    SUCCESS: Build
    SUCCESS: Unit Tests
    IN_PROGRESS: Declarative: Post Actions

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/427//rebuild

review: Approve (continuous-integration)

[Bryce Harrington (bryce)]

This looks good and is nearly ready to land.

This is a quite healthy refactoring, that makes the test cases significantly more readable. The count of lines being deleted is a good sign.

I found one typo and one whitespace issue (below) but those are super minor niggles, feel free to ignore them or just fix as you land if you want.

I've verified the main suggests from the previous review are addressed, and I like how this has turned out. I've done a full read-thru of the patch and didn't spot any other issues to flag, codewise. If any further code errors exist they can get addressed as they surface.

I've run tests against the branch in lxc:

- [√] python3 ./setup.py check
- [√] python3 ./setup.py build
- [x] pytest-3 .

There are a just couple test failures on the importer and tag tests, that aren't present on the master branch:

git-ubuntu-eoan+19.10:~/src/GitUbuntu/review-mp375096-importer-add-tests/usd-importer$ pytest-3 .
=========================================================== test session starts ============================================================
platform linux -- Python 3.7.5rc1, pytest-3.10.1, py-1.8.0, pluggy-0.12.0
rootdir: /home/bryce/src/GitUbuntu/review-mp375096-importer-add-tests/usd-importer, inifile: pytest.ini
collected 218 items

gitubuntu/apt_repo_test.py ....................... [ 10%]
gitubuntu/git_repository_test.py .......................................................... [ 37%]
gitubuntu/importer_service_test.py ............ [ 42%]
gitubuntu/importer_tag_test.py .xxxxx...xF [ 47%]
gitubuntu/importer_test.py ................................x..Fxx [ 65%]
gitubuntu/integration_test.py .. [ 66%]
gitubuntu/repo_builder_test.py .......................... [ 77%]
gitubuntu/scriptutils_test.py ...... [ 80%]
gitubuntu/source_builder_test.py ..................... [ 90%]
gitubuntu/source_information_test.py ..................... [100%]

Full output of the test log is here: https://paste.ubuntu.com/p/4d54ckwFtv/

I've been poking at it myself but am not sure what the failure is. Guessing at least one failure is maybe due to date formatting, and might merely be a locale issue? Since jenkins isn't seeing failures I can't rule out that it's not something with my container setup.

review: Needs Fixing

[Robie Basak (racb)]

The verbose pytest output is quite tricky to read, so I spent a while going through it. The two failures are separated at line 852. Both of the test failures appear to have the same cause: a RuntimeError raised because a generator raised a StopIteration. This is caused by quilt returning an exit code of 2 at importer.py:942.

It looks like the behaviour changed according to https://www.python.org/dev/peps/pep-0479/#transition-plan, so I think that the difference in your environment is just that you are using a newer version of Python than our CI (and the snap).

There is an underlying bug here: it's incorrect for a generator to raise a StopIteration; it should just return when done (and this was the case with older versions of Python too). But given that this definitely doesn't affect production (as the snap's version is fixed), CI would catch it if this changes, and these are your only identified test failures, I think it's OK to land this branch as-is. We can fix the failures in your test environment by replaces the StopIteration raises with returns in the generators in a separate branch.

I've fixed the typos, so I think this is ready to land. Thank you for the reviews!

[Robie Basak (racb)]

Final branch candidate to land rebased and force pushed.

Bryce, could you confirm you're happy with my assessment in the previous comment and this is OK to land, please?

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:b5ac84c74cb0a9d64a1f7adc1fc5f12af3cd6ed3
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/429/
Executed test runs:
    SUCCESS: VM Setup
    SUCCESS: Build
    SUCCESS: Unit Tests
    IN_PROGRESS: Declarative: Post Actions

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/429//rebuild

review: Approve (continuous-integration)

[Bryce Harrington (bryce)]

Yep, thanks for investigating, I did suspect it was something specific to my environment (the lxc container is eoan-based, I do need to redo it.) In fact I'm certain I've looked into the StopIteration issue once before (Nish chimed in on my comments about it on one of the bugs), and I seem to recall having similar ideas on a fix for it. I agree it can be treated as a separate problem. Land away!

review: Approve

[Bryce Harrington (bryce)]

For reference, the StopIteration bug I mentioned looking at previously is https://bugs.launchpad.net/usd-importer/+bug/1847133

diff --git a/gitubuntu/git_repository_test.py b/gitubuntu/git_repository_test.py
index 64c6876..01d3525 100644
--- a/gitubuntu/git_repository_test.py
+++ b/gitubuntu/git_repository_test.py
@@ -558,44 +558,21 @@ def test_repo_derive_env_change(repo):
         (
             'Common case',
             Repo(
-                commit_list=[
-                    Commit(
-                        tree=SourceTree(
-                            Source(
-                                SourceSpec(
-                                    version='1-1',
-                                    native=False,
-                                )
-                            ),
-                        ),
-                        name='old/debian',
+                commits=[
+                    Commit.from_spec(
+                        name='old/debian'
                     ),
-                    Commit(
-                        tree=SourceTree(
-                            Source(
-                                SourceSpec(
-                                    changelog_versions=['1-1ubuntu1', '1-1',],
-                                    native=False,
-                                )
-                            ),
-                        ),
-                        parents=[Placeholder('old/debian'),],
+                    Commit.from_spec(
+                        parents=[Placeholder('old/debian')],
                         name='old/ubuntu',
+                        changelog_versions=['1-1ubuntu1', '1-1'],
                     ),
-                    Commit(
-                        tree=SourceTree(
-                            Source(
-                                SourceSpec(
-                                    changelog_versions=['2-1', '1-1',],
-                                    native=False,
-                                )
-                            ),
-                        ),
-                        parents=[Placeholder('old/debian'),],
+                    Commit.from_spec(
+                        parents=[Placeholder('old/debian')],
                         name='new/debian',
+                        changelog_versions=['2-1', '1-1'],
                     ),
                 ],
-                branches={},
                 tags={
                     'pkg/import/1-1': Placeholder('old/debian'),
                     'pkg/import/1-1ubuntu1': Placeholder('old/ubuntu'),
@@ -609,56 +586,26 @@ def test_repo_derive_env_change(repo):
         (
             'Ubuntu delta based on a NMU',
             Repo(
-                commit_list=[
-                    Commit(
-                        tree=SourceTree(
-                            Source(
-                                SourceSpec(
-                                    version='1-1',
-                                    native=False,
-                                )
-                            ),
-                        ),
-                        name='fork_point',
+                commits=[
+                    Commit.from_spec(
+                        name='fork_point'
                     ),
-                    Commit(
-                        tree=SourceTree(
-                            Source(
-                                SourceSpec(
-                                    changelog_versions=['1-1.1', '1-1',],
-                                    native=False,
-                                )
-                            ),
-                        ),
+                    Commit.from_spec(
                         parents=[Placeholder('fork_point')],
                         name='old/debian',
+                        changelog_versions=['1-1.1', '1-1'],
                     ),
-                    Commit(
-                        tree=SourceTree(
-                            Source(
-                                SourceSpec(
-                                    changelog_versions=['1-1.1ubuntu1', '1-1.1', '1-1',],
-                                    native=False,
-                                )
-                            ),
-                        ),
-                        parents=[Placeholder('old/debian'),],
+                    Commit.from_spec(
+                        parents=[Placeholder('old/debian')],
                         name='old/ubuntu',
+                        changelog_versions=['1-1.1ubuntu1', '1-1.1', '1-1'],
                     ),
-                    Commit(
-                        tree=SourceTree(
-                            Source(
-                                SourceSpec(
-                                    changelog_versions=['2-1', '1-1',],
-                                    native=False,
-                                )
-                            ),
-                        ),
-                        parents=[Placeholder('fork_point'),],
+                    Commit.from_spec(
+                        parents=[Placeholder('fork_point')],
                         name='new/debian',
+                        changelog_versions=['2-1', '1-1'],
                     ),
                 ],
-                branches={},
                 tags={
                     'pkg/import/1-1': Placeholder('fork_point'),
                     'pkg/import/1-1.1': Placeholder('old/debian'),
@@ -673,56 +620,26 @@ def test_repo_derive_env_change(repo):
         (
             'Ubuntu upstream version head of Debian',
             Repo(
-                commit_list=[
-                    Commit(
-                        tree=SourceTree(
-                            Source(
-                                SourceSpec(
-                                    version='1-1',
-                                    native=False,
-                                )
-                            ),
-                        ),
-                        name='old/debian',
+                commits=[
+                    Commit.from_spec(
+                        name='old/debian'
                     ),
-                    Commit(
-                        tree=SourceTree(
-                            Source(
-                                SourceSpec(
-                                    changelog_versions=['1-1ubuntu1', '1-1',],
-                                    native=False,
-                                )
-                            ),
-                        ),
-                        parents=[Placeholder('old/debian'),],
+                    Commit.from_spec(
+                        parents=[Placeholder('old/debian')],
                         name='mid_ubuntu',
+                        changelog_versions=['1-1ubuntu1', '1-1'],
                     ),
-                    Commit(
-                        tree=SourceTree(
-                            Source(
-                                SourceSpec(
-                                    changelog_versions=['2-0ubuntu1', '1-1ubuntu1', '1-1',],
-                                    native=False,
-                                )
-                            ),
-                        ),
-                        parents=[Placeholder('mid_ubuntu'),],
+                    Commit.from_spec(
+                        parents=[Placeholder('mid_ubuntu')],
                         name='old/ubuntu',
+                        changelog_versions=['2-0ubuntu1', '1-1ubuntu1', '1-1'],
                     ),
-                    Commit(
-                        tree=SourceTree(
-                            Source(
-                                SourceSpec(
-                                    changelog_versions=['3-1', '1-1',],
-                                    native=False,
-                                )
-                            ),
-                        ),
-                        parents=[Placeholder('old/debian'),],
+                    Commit.from_spec(
+                        parents=[Placeholder('old/debian')],
                         name='new/debian',
+                        changelog_versions=['3-1', '1-1'],
                     ),
                 ],
-                branches={},
                 tags={
                     'pkg/import/1-1': Placeholder('old/debian'),
                     'pkg/import/1-1ubuntu1': Placeholder('mid_ubuntu'),
diff --git a/gitubuntu/importer_tag_test.py b/gitubuntu/importer_tag_test.py
new file mode 100644
index 0000000..901ab10
--- /dev/null
+++ b/gitubuntu/importer_tag_test.py
@@ -0,0 +1,744 @@
+# This file contains tests additional to importer_test.py grouped here because
+# they are considerable on their own.
+
+from unittest.mock import (
+    patch,
+)
+
+import pygit2
+import pytest
+
+import gitubuntu.repo_builder as repo_builder
+from gitubuntu.repo_builder import Commit, Placeholder
+import gitubuntu.repo_comparator as repo_comparator
+import gitubuntu.source_builder as source_builder
+
+import gitubuntu.importer as target
+
+from gitubuntu.test_fixtures import repo
+from gitubuntu.importer_test import MockSPI, patch_get_commit_environment
+
+
+# When importing a publishing record, there are two potential logical
+# consequences:
+#
+#    1) Some new commit is created, with an associated tag; and/or
+#    2) Some branch is adjusted to point at some commit
+#
+# If an existing tag with the same Git tree is found as a new publish
+# event, we should reuse the tag, and adjust the corresponding branch to
+# the same tagged commit.
+#
+# If no existing tag with the same Git tree is found, a new tree and a new
+# import/applied tag that points to it should be created, as appropriate, and
+# the corresponding branch should be adjusted to the the new tagged commit.
+#
+# If a new commit is created, appropriate commit parents are found in the
+# existing Git commit graph. A changelog parent is the nearest (reverse
+# chronologically) tagged version from the debian/changelog of the publishing
+# record.
+
[e-mail](
+    [
+        'input_repo',
+        'expected_output_refs',
+        'validation_repo_delta',
+        'validation_repo_expected_identical_refs',
+        'reuse',
+    ],
+    [
+        # 1) An existing import tag (or reimport tag) with the same Git tree
+        #   - Reuse import tag
+        pytest.param(
+            # input_repo:
+            repo_builder.Repo(
+                commits=[Commit.from_spec(name='import')],
+                branches={
+                    'importer/ubuntu/trusty-proposed': Placeholder('import'),
+                },
+                tags={'importer/import/1-1': Placeholder('import')},
+            ),
+            # expected_output_refs:
+            [
+                'refs/heads/do-not-push',
+                'refs/tags/importer/upstream/ubuntu/1.gz',
+                'refs/heads/importer/importer/ubuntu/dsc',
+                'refs/heads/importer/importer/ubuntu/pristine-tar',
+            ],
+            # validation_repo_delta:
+            {
+                'update_branches': {
+                     'importer/ubuntu/trusty': Placeholder('import'),
+                },
+            },
+            # validation_repo_expected_identical_refs:
+            [
+                'refs/heads/importer/ubuntu/trusty-proposed',
+                'refs/heads/importer/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+            ],
+            # reuse:
+            True,
+        ),
+        pytest.param(
+            # input_repo:
+            repo_builder.Repo(
+                commits=[
+                    Commit.from_spec(
+                        name='import',
+                        mutate='import tag contents',
+                    ),
+                    Commit.from_spec(name='reimport'),
+                ],
+                branches={
+                    'importer/ubuntu/trusty-proposed': Placeholder('import'),
+                },
+                tags={
+                    'importer/import/1-1': Placeholder('import'),
+                    'importer/reimport/import/1-1/0': Placeholder('import'),
+                    'importer/reimport/import/1-1/1': Placeholder('reimport'),
+                },
+            ),
+            # expected_output_refs:
+            [
+                'refs/heads/do-not-push',
+                'refs/tags/importer/upstream/ubuntu/1.gz',
+                'refs/heads/importer/importer/ubuntu/dsc',
+                'refs/heads/importer/importer/ubuntu/pristine-tar',
+            ],
+            # validation_repo_delta:
+            {
+                'update_branches': {
+                     'importer/ubuntu/trusty': Placeholder('reimport'),
+                },
+            },
+            # validation_repo_expected_identical_refs:
+            [
+                'refs/heads/importer/ubuntu/trusty-proposed',
+                'refs/heads/importer/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/reimport/import/1-1/0',
+                'refs/tags/importer/reimport/import/1-1/1',
+            ],
+            # reuse:
+            True,
+
+            marks=pytest.mark.xfail(reason='LP: #1761331'),
+        ),
+
+        # 2) An existing import tag with a different Git tree and an existing
+        #    upload tag with the same Git tree
+        #    - Reuse upload tag, create reimport tag
+        pytest.param(
+            # input_repo:
+            repo_builder.Repo(
+                commits=[
+                    Commit.from_spec(
+                        name='import',
+                        mutate='The import tag contents',
+                    ),
+                    Commit.from_spec(name='upload'),
+                ],
+                branches={
+                    'importer/ubuntu/trusty-proposed': Placeholder('import'),
+                },
+                tags={
+                    'importer/import/1-1': Placeholder('import'),
+                    'importer/upload/1-1': Placeholder('upload'),
+                },
+            ),
+            # expected_output_refs:
+            [
+                'refs/heads/do-not-push',
+                'refs/tags/importer/upstream/ubuntu/1.gz',
+                'refs/heads/importer/importer/ubuntu/dsc',
+                'refs/heads/importer/importer/ubuntu/pristine-tar',
+            ],
+            # validation_repo_delta:
+            {
+                'update_tags': {
+                    'importer/reimport/import/1-1/0': Placeholder('import'),
+                    'importer/reimport/import/1-1/1': Placeholder('upload'),
+                },
+                'update_branches': {
+                     'importer/ubuntu/trusty': Placeholder('upload'),
+                },
+            },
+            # validation_repo_expected_identical_refs:
+            [
+                'refs/heads/importer/ubuntu/trusty-proposed',
+                'refs/heads/importer/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/upload/1-1',
+                'refs/tags/importer/reimport/import/1-1/0',
+                'refs/tags/importer/reimport/import/1-1/1',
+            ],
+            # reuse:
+            True,
+
+            marks=pytest.mark.xfail(reason='LP: #1754194'),
+        ),
+
+        # 3) An existing import tag with a different Git tree and an existing
+        #    upload tag with a different Git tree
+        #    - Create reimport tag
+        pytest.param(
+            # input_repo:
+            repo_builder.Repo(
+                commits=[
+                    Commit.from_spec(
+                        name='import',
+                        mutate='The import tag contents',
+                    ),
+                    Commit.from_spec(
+                        name='import',
+                        mutate='The upload tag contents',
+                    ),
+                ],
+                branches={
+                    'importer/ubuntu/trusty-proposed': Placeholder('import'),
+                },
+                tags={
+                    'importer/import/1-1': Placeholder('import'),
+                    'importer/upload/1-1': Placeholder('upload'),
+                },
+            ),
+            # expected_output_refs:
+            [
+                'refs/heads/do-not-push',
+                'refs/tags/importer/upstream/ubuntu/1.gz',
+                'refs/heads/importer/importer/ubuntu/dsc',
+                'refs/heads/importer/importer/ubuntu/pristine-tar',
+            ],
+            # validation_repo_delta:
+            {
+                'add_commits': [Commit.from_spec(name='reimport')],
+                'update_tags': {
+                    'importer/reimport/import/1-1/0': Placeholder('import'),
+                    'importer/reimport/import/1-1/1': Placeholder('reimport'),
+                },
+                'update_branches': {
+                     'importer/ubuntu/trusty': Placeholder('reimport'),
+                },
+            },
+            # validation_repo_expected_identical_refs:
+            [
+                'refs/heads/importer/ubuntu/trusty-proposed',
+                'refs/heads/importer/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/upload/1-1',
+                'refs/tags/importer/reimport/import/1-1/0',
+                'refs/tags/importer/reimport/import/1-1/1',
+            ],
+            # reuse:
+            False,
+
+            marks=pytest.mark.xfail(reason='LP: #1754507'),
+        ),
+
+        # 4) An existing import tag with a different Git tree and no upload tag
+        #    - Create reimport tag
+        pytest.param(
+            # input_repo:
+            repo_builder.Repo(
+                commits=[
+                    Commit.from_spec(
+                        name='import',
+                        mutate='The import tag contents',
+                    ),
+                ],
+                branches={
+                    'importer/ubuntu/trusty-proposed': Placeholder('import'),
+                },
+                tags={'importer/import/1-1': Placeholder('import')},
+            ),
+            # expected_output_refs:
+            [
+                'refs/heads/do-not-push',
+                'refs/tags/importer/upstream/ubuntu/1.gz',
+                'refs/heads/importer/importer/ubuntu/dsc',
+                'refs/heads/importer/importer/ubuntu/pristine-tar',
+            ],
+            # validation_repo_delta:
+            {
+                'add_commits': [Commit.from_spec(name='reimport')],
+                'update_tags': {
+                    'importer/reimport/import/1-1/0': Placeholder('import'),
+                    'importer/reimport/import/1-1/1': Placeholder('reimport'),
+                },
+                'update_branches': {
+                     'importer/ubuntu/trusty': Placeholder('reimport'),
+                },
+            },
+            # validation_repo_expected_identical_refs:
+            [
+                'refs/heads/importer/ubuntu/trusty-proposed',
+                'refs/heads/importer/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/reimport/import/1-1/0',
+                'refs/tags/importer/reimport/import/1-1/1',
+            ],
+            # reuse:
+            False,
+
+            marks=pytest.mark.xfail(reason='LP: #1754706'),
+        ),
+
+        # 5) No import tag and an existing upload tag with the same Git tree
+        #    - Reuse upload tag, create import tag
+        pytest.param(
+            # input_repo:
+            repo_builder.Repo(
+                commits=[Commit.from_spec(name='upload')],
+                tags={'importer/upload/1-1': Placeholder('upload')},
+            ),
+            # expected_output_refs:
+            [
+                'refs/heads/do-not-push',
+                'refs/tags/importer/upstream/ubuntu/1.gz',
+                'refs/heads/importer/importer/ubuntu/dsc',
+                'refs/heads/importer/importer/ubuntu/pristine-tar',
+            ],
+            # validation_repo_delta:
+            {
+                'update_tags': {
+                    'importer/import/1-1': Placeholder('upload'),
+                },
+                'update_branches': {
+                     'importer/ubuntu/trusty': Placeholder('upload'),
+                },
+            },
+            # validation_repo_expected_identical_refs:
+            [
+                'refs/heads/importer/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/upload/1-1',
+            ],
+            # reuse:
+            True,
+
+            marks=pytest.mark.xfail(reason='LP: #1734883'),
+        ),
+
+        # 6) No import tag and an existing upload tag with a different Git tree
+        #    - Create import tag
+        pytest.param(
+            # input_repo:
+            repo_builder.Repo(
+                commits=[
+                    Commit.from_spec(
+                        name='upload',
+                        mutate='The upload tag contents',
+                    ),
+                ],
+                tags={'importer/upload/1-1': Placeholder('upload')},
+            ),
+            # expected_output_refs:
+            [
+                'refs/heads/do-not-push',
+                'refs/tags/importer/upstream/ubuntu/1.gz',
+                'refs/heads/importer/importer/ubuntu/dsc',
+                'refs/heads/importer/importer/ubuntu/pristine-tar',
+            ],
+            # validation_repo_delta:
+            {
+                'add_commits': [
+                    Commit.from_spec(
+                        name='publish',
+                        message='Test commit (new)',
+                    ),
+                ],
+                'update_tags': {
+                    'importer/import/1-1': Placeholder('publish'),
+                },
+                'update_branches': {
+                    'importer/ubuntu/trusty': Placeholder('publish'),
+                },
+            },
+            # validation_repo_expected_identical_refs:
+            [
+                'refs/heads/importer/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/upload/1-1',
+            ],
+            # reuse:
+            False,
+        ),
+
+        # 7) No import tags or upload tags
+        #    - Create import tag
+        pytest.param(
+            # input_repo:
+            repo_builder.Repo(),
+            # expected_output_refs:
+            [
+                'refs/heads/do-not-push',
+                'refs/tags/importer/upstream/ubuntu/1.gz',
+                'refs/heads/importer/importer/ubuntu/dsc',
+                'refs/heads/importer/importer/ubuntu/pristine-tar',
+            ],
+            # validation_repo_delta:
+            {
+                'add_commits': [
+                    Commit.from_spec(
+                        name='publish',
+                        message='Test commit (new)',
+                    ),
+                ],
+                'update_tags': {
+                    'importer/import/1-1': Placeholder('publish'),
+                },
+                'update_branches': {
+                     'importer/ubuntu/trusty': Placeholder('publish'),
+                },
+            },
+            # validation_repo_expected_identical_refs:
+            [
+                'refs/heads/importer/ubuntu/trusty',
+                'refs/tags/importer/import/1-1'
+            ],
+            # reuse:
+            False,
+        ),
+    ]
+)
+@patch('gitubuntu.importer.get_import_tag_msg')
+@patch('gitubuntu.importer.get_import_commit_msg')
+def test_import_unapplied_spi_tags(
+    get_import_commit_msg_mock,
+    get_import_tag_msg_mock,
+    repo,
+    input_repo,
+    expected_output_refs,
+    validation_repo_delta,
+    validation_repo_expected_identical_refs,
+    reuse,
+):
+    """Test that unapplied tags are correctly created, adjusted and/or reused
+
+    :param unittest.mock.Mock get_import_commit_msg_mock: mock of the function
+        that determines the commit message to use for a given import
+    :param unittest.mock.Mock get_import_tag_msg_mock: mock of the function
+        that determines the tag message to use for a given import
+    :param repo gitubuntu.git_repository.GitUbuntuRepository: fixture to hold a
+        temporary output repository
+    :param repo_builder.Repo input_repo: input repository data
+    :param list(str) expected_output_refs: refs that must exist in the output
+        repository
+    :param dict validation_repo_delta: how to transform the input
+        repository into a "validation repository", expressed as a dict to
+        provide as **kwargs to gitubuntu.repo_builder.Repo.copy() against the
+        input repository. The validation repository is then used for the
+        purposes of comparison against the output repository.
+    :param list(str) validation_repo_expected_identical_refs: refs that must be
+        identical between the validation repository and the output repository
+    :param bool reuse: if set, the output ref importer/ubuntu/trusty must be
+        one supplied by the input repository (assumed to have a commit message
+        of "Test commit") and not one created by the importer in this run
+        (arranged by this test to have a different commit message)
+
+    The input repository data is written into the output repository and then a
+    fake non-native source package publication of version 1-1 in the Trusty
+    release pocket is imported into it by calling import_unapplied_spi()
+    directly. expected_output_refs, validation_repo_expected_identical_refs and
+    reuse are then asserted. It is further asserted that no other refs exist in
+    the output repository except for those listed in expected_output_refs and
+    validation_repo_expected_identical_refs.
+    """
+    # Match the repo_builder objects
+    get_import_tag_msg_mock.return_value = 'Test tag'
+    # Importantly, the following commit message must not be the same as the
+    # commit messages used by the test input repository commits, so that we can
+    # later detect the difference between commits that were already there and
+    # new commits created by the importer for the purposes of asserting the
+    # reuse parameter correctly.
+    get_import_commit_msg_mock.return_value = b'Test commit (new)'
+
+    input_repo.write(repo.raw_repo)
+
+    publish_spec = source_builder.SourceSpec(
+        version='1-1',
+        native=False,
+    )
+
+    with patch_get_commit_environment(repo):
+        with source_builder.Source(publish_spec) as dsc_path:
+            target.import_unapplied_spi(
+                repo=repo,
+                spi=MockSPI(dsc_path, publish_spec.version),
+                namespace='importer',
+                skip_orig=False,
+                parent_overrides={},
+            )
+
+    if reuse:
+        # Test that the previous commit was reused. In this case, the
+        # commit message should be one created by the repo_builder.Commit()
+        # default, and not one created by the importer.
+        tip_ref = repo.raw_repo.lookup_reference(
+            'refs/heads/importer/ubuntu/trusty'
+        )
+        message = tip_ref.peel(pygit2.Commit).message
+        assert message == 'Test commit'
+
+    validation_repo = input_repo.copy(**validation_repo_delta)
+
+    # Verify validation_repo_expected_identical_refs
+    assert repo_comparator.equals(
+        repoA=repo.raw_repo,
+        repoB=validation_repo,
+        test_refs=validation_repo_expected_identical_refs,
+    )
+
+    # Verify expected_output_refs
+    for ref in expected_output_refs:
+        assert repo.raw_repo.lookup_reference(ref)
+
+    # Verify that no other refs exist
+    all_expected_output_refs = (
+        frozenset(validation_repo_expected_identical_refs) |
+        frozenset(expected_output_refs)
+    )
+    all_actual_output_refs = frozenset(repo.raw_repo.listall_references())
+    assert all_expected_output_refs == all_actual_output_refs
+
+
[e-mail](
+    [
+        'input_repo',
+        'validation_repo_delta',
+        'validation_repo_expected_treewise_refs',
+        'reuse',
+    ],
+    [
+        # 1) An existing applied tag (or reimport tag) with the same Git tree
+        #    - Reuse applied tag
+        pytest.param(
+            # input_repo:
+            repo_builder.Repo(
+                commits=[
+                    Commit.from_spec(name='unapplied', has_patches=True),
+                    Commit.from_spec(name='applied', patches_applied=True),
+                ],
+                branches={
+                    'importer/ubuntu/trusty': Placeholder('unapplied'),
+                    'importer/applied/ubuntu/trusty': Placeholder('applied'),
+                },
+                tags={
+                    'importer/import/1-1': Placeholder('unapplied'),
+                    'importer/applied/1-1': Placeholder('applied'),
+                },
+            ),
+            # validation_repo_delta:
+            {
+                # no output repository delta
+            },
+            # validation_repo_expected_treewise_refs:
+            [
+                'refs/heads/importer/ubuntu/trusty',
+                'refs/heads/importer/applied/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/applied/1-1',
+            ],
+            # reuse:
+            True,
+        ),
+
+        # 2) An existing applied tag with a different Git tree
+        #    - Create reimport tag
+        pytest.param(
+            # input_repo:
+            repo_builder.Repo(
+                commits=[
+                    Commit.from_spec(
+                        name='unapplied',
+                        has_patches=True,
+                        mutate='import tag contents',
+                    ),
+                    Commit.from_spec(
+                        name='unapplied_reimport',
+                        has_patches=True,
+                    ),
+                    Commit.from_spec(
+                        name='applied',
+                        patches_applied=True,
+                        mutate='import tag contents',
+                    )
+                ],
+                branches={'importer/ubuntu/trusty': Placeholder('unapplied')},
+                tags={
+                    'importer/import/1-1':
+                        Placeholder('unapplied'),
+                    'importer/reimport/import/1-1/0':
+                        Placeholder('unapplied'),
+                    'importer/reimport/import/1-1/1':
+                        Placeholder('unapplied_reimport'),
+                    'importer/applied/1-1':
+                        Placeholder('applied'),
+                },
+            ),
+            # validation_repo_delta:
+            {
+                'add_commits': [
+                    Commit.from_spec(
+                        name='applied_reimport',
+                        patches_applied=True,
+                        parents=[Placeholder('unapplied_reimport')],
+                    ),
+                ],
+                'update_tags': {
+                    'importer/reimport/applied/1-1/0':
+                        Placeholder('applied'),
+                    'importer/reimport/applied/1-1/1':
+                        Placeholder('applied_reimport'),
+                },
+                'update_branches': {
+                     'importer/applied/ubuntu/trusty':
+                        Placeholder('applied_reimport'),
+                },
+            },
+            # validation_repo_expected_treewise_refs:
+            [
+                'refs/heads/importer/ubuntu/trusty',
+                'refs/heads/importer/applied/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/reimport/import/1-1/0',
+                'refs/tags/importer/reimport/import/1-1/1',
+                'refs/tags/importer/applied/1-1',
+                'refs/tags/importer/reimport/applied/1-1/0',
+                'refs/tags/importer/reimport/applied/1-1/1',
+            ],
+            # reuse:
+            False,
+
+            marks=pytest.mark.xfail(reason='LP: #1755247'),
+        ),
+
+        # 3) No applied tags
+        #    - Create applied tag
+        pytest.param(
+            # input_repo:
+            repo_builder.Repo(
+                commits=[Commit.from_spec(name='unapplied', has_patches=True)],
+                branches={'importer/ubuntu/trusty': Placeholder('unapplied')},
+                tags={'importer/import/1-1': Placeholder('unapplied')},
+            ),
+            # validation_repo_delta:
+            {
+                'add_commits': [
+                    Commit.from_spec(
+                        name='applied',
+                        patches_applied=True,
+                        parents=[Placeholder('unapplied')],
+                    ),
+                ],
+                'update_tags': {
+                    'importer/applied/1-1': Placeholder('applied')
+                },
+                'update_branches': {
+                     'importer/applied/ubuntu/trusty': Placeholder('applied'),
+                },
+            },
+            # validation_repo_expected_treewise_refs:
+            [
+                'refs/heads/importer/ubuntu/trusty',
+                'refs/heads/importer/applied/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/applied/1-1'
+            ],
+            # reuse:
+            False,
+        ),
+    ]
+)
+@patch('gitubuntu.importer.get_import_tag_msg')
+@patch('gitubuntu.importer.get_import_commit_msg')
+def test_import_applied_spi_tags(
+    get_import_commit_msg_mock,
+    get_import_tag_msg_mock,
+    repo,
+    input_repo,
+    validation_repo_delta,
+    validation_repo_expected_treewise_refs,
+    reuse,
+):
+    """Test that applied tags are correctly created, adjusted and/or reused
+
+    :param unittest.mock.Mock get_import_commit_msg_mock: mock of the function
+        that determines the commit message to use for a given import
+    :param unittest.mock.Mock get_import_tag_msg_mock: mock of the function
+        that determines the tag message to use for a given import
+    :param repo gitubuntu.git_repository.GitUbuntuRepository: fixture to hold a
+        temporary output repository
+    :param repo_builder.Repo input_repo: input repository data
+    :param dict validation_repo_delta: how to transform the input repository
+        into a "validation repository", expressed as a dict to
+        provide as **kwargs to gitubuntu.repo_builder.Repo.copy() against the
+        input repository. The validation repository is then used for the
+        purposes of comparison against the output repository.
+    :param list(str) validation_repo_expected_treewise_refs: refs whose trees
+        must be identical between the validation repository and the output
+        repository
+    :param bool reuse: if set, the output ref importer/ubuntu/trusty must be
+        one supplied by the input repository (assumed to have a commit message
+        of "Test commit") and not one created by the importer in this run
+        (arranged by this test to have a different commit message)
+
+    The input repository data is written into the output repository and then a
+    fake non-native source package publication of version 1-1 in the Trusty
+    release pocket is imported into it by calling import_applied_spi()
+    directly. reuse and validation_repo_expected_treewise_refs are then
+    asserted.
+
+    This is similar to test_unapplied_spi_tags except that it calls
+    import_applied_spi() instead of import_unapplied_spi() and only treewise
+    ref comparisons are made.
+    """
+    # Match the repo_builder objects
+    get_import_tag_msg_mock.return_value = 'Test tag'
+    # Importantly, the following commit message must not be the same as the
+    # commit messages used by the test input repository commits, so that we can
+    # later detect the difference between commits that were already there and
+    # new commits created by the importer for the purposes of asserting the
+    # reuse parameter correctly.
+    get_import_commit_msg_mock.return_value = b'Test commit (new)'
+
+    input_repo.write(repo.raw_repo)
+
+    publish_spec = source_builder.SourceSpec(
+        version='1-1',
+        native=False,
+        has_patches=True,
+    )
+
+    with patch_get_commit_environment(repo):
+        with source_builder.Source(publish_spec) as dsc_path:
+            target.import_applied_spi(
+                repo=repo,
+                spi=MockSPI(dsc_path, publish_spec.version),
+                namespace='importer',
+                allow_applied_failures=False,
+                parent_overrides={},
+            )
+
+    if reuse:
+        # Test that the previous commit was reused. In this case,
+        # the commit message should be one created by the
+        # repo_builder.Commit() default, and not one created by the
+        # importer.
+        tip_ref = repo.raw_repo.lookup_reference(
+            'refs/heads/importer/ubuntu/trusty'
+        )
+        message = tip_ref.peel(pygit2.Commit).message
+        assert message == 'Test commit'
+
+    validation_repo = input_repo.copy(**validation_repo_delta)
+    assert repo_comparator.equals(
+        repoA=repo.raw_repo,
+        repoB=validation_repo,
+        test_refs=validation_repo_expected_treewise_refs,
+        # this should be Commit, but we do not have a method yet
+        # to obtain the stage-wise `quilt push` commits for a
+        # patches-applied import
+        comparison_type=repo_comparator.RepoComparisonType.Tree,
+    )
diff --git a/gitubuntu/importer_test.py b/gitubuntu/importer_test.py
index f9537c4..0ce014a 100644
--- a/gitubuntu/importer_test.py
+++ b/gitubuntu/importer_test.py
@@ -12,6 +12,7 @@ import tempfile
 import pygit2
 
 import gitubuntu.repo_builder as repo_builder
+from gitubuntu.repo_builder import Placeholder
 import gitubuntu.repo_comparator as repo_comparator
 import gitubuntu.source_builder as source_builder
 
@@ -120,10 +121,7 @@ def test_get_import_commit_msg(
     target.get_changelog_for_commit = Mock()
     target.get_changelog_for_commit.return_value = b''
 
-    publish_spec = source_builder.SourceSpec(
-        version='1-1',
-        native=False,
-    )
+    publish_spec = source_builder.SourceSpec()
     publish_source = source_builder.Source(publish_spec)
 
     publish_oid = repo_builder.SourceTree(publish_source).write(repo.raw_repo)
@@ -144,42 +142,27 @@ def test_get_import_commit_msg(
 
 
 @pytest.mark.parametrize(
-    'input_data, expected', [
+    'input_repo, expected', [
         (
-            repo_builder.Repo(
-                commit_list=[],
-                branches={},
-                tags={},
-            ),
+            repo_builder.Repo(),
             [],
         ),
         (
             repo_builder.Repo(
-                commit_list=[],
-                branches={},
-                tags={
-                    'importer/import/1-1': repo_builder.Commit(repo_builder.Tree({})),
-                },
+                tags={'importer/import/1-1': repo_builder.Commit()},
             ),
             ['refs/tags/importer/import/1-1'],
         ),
         (
             repo_builder.Repo(
-                commit_list=[
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='import'
-                    ),
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='reimport1'
-                    ),
+                commits=[
+                    repo_builder.Commit(name='import'),
+                    repo_builder.Commit(name='reimport1'),
                 ],
-                branches={},
                 tags={
-                    'importer/import/1-1': repo_builder.Commit(repo_builder.Tree({})),
-                    'importer/reimport/import/1-1/0': repo_builder.Commit(repo_builder.Tree({})),
-                    'importer/reimport/import/1-1/1': repo_builder.Commit(repo_builder.Tree({})),
+                    'importer/import/1-1': repo_builder.Commit(),
+                    'importer/reimport/import/1-1/0': repo_builder.Commit(),
+                    'importer/reimport/import/1-1/1': repo_builder.Commit(),
                 },
             ),
             [
@@ -189,8 +172,8 @@ def test_get_import_commit_msg(
         ),
     ],
 )
-def test_get_existing_import_tags(repo, input_data, expected):
-    input_data.write(repo.raw_repo)
+def test_get_existing_import_tags(repo, input_repo, expected):
+    input_repo.write(repo.raw_repo)
 
     assert [
         ref.name for ref in
@@ -199,42 +182,27 @@ def test_get_existing_import_tags(repo, input_data, expected):
 
 
 @pytest.mark.parametrize(
-    'input_data, expected', [
+    'input_repo, expected', [
         (
-            repo_builder.Repo(
-                commit_list=[],
-                branches={},
-                tags={},
-            ),
+            repo_builder.Repo(),
             [],
         ),
         (
             repo_builder.Repo(
-                commit_list=[],
-                branches={},
-                tags={
-                    'importer/applied/1-1': repo_builder.Commit(repo_builder.Tree({})),
-                },
+                tags={'importer/applied/1-1': repo_builder.Commit()},
             ),
             ['refs/tags/importer/applied/1-1'],
         ),
         (
             repo_builder.Repo(
-                commit_list=[
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='applied'
-                    ),
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='reimport1'
-                    ),
+                commits=[
+                    repo_builder.Commit(name='applied'),
+                    repo_builder.Commit(name='reimport1'),
                 ],
-                branches={},
                 tags={
-                    'importer/applied/1-1': repo_builder.Commit(repo_builder.Tree({})),
-                    'importer/reimport/applied/1-1/0': repo_builder.Commit(repo_builder.Tree({})),
-                    'importer/reimport/applied/1-1/1': repo_builder.Commit(repo_builder.Tree({})),
+                    'importer/applied/1-1': repo_builder.Commit(),
+                    'importer/reimport/applied/1-1/0': repo_builder.Commit(),
+                    'importer/reimport/applied/1-1/1': repo_builder.Commit(),
                 },
             ),
             [
@@ -244,8 +212,8 @@ def test_get_existing_import_tags(repo, input_data, expected):
         ),
     ],
 )
-def test_get_existing_applied_tags(repo, input_data, expected):
-    input_data.write(repo.raw_repo)
+def test_get_existing_applied_tags(repo, input_repo, expected):
+    input_repo.write(repo.raw_repo)
 
     assert [
         ref.name for ref in
@@ -254,24 +222,20 @@ def test_get_existing_applied_tags(repo, input_data, expected):
 
 
 @pytest.mark.parametrize(
-    'input_data, expected_changes, test_refs', [
+    [
+        'input_repo',
+        'validation_repo_delta',
+        'validation_repo_expected_identical_refs',
+    ],
+    [
         (
-            repo_builder.Repo(
-                commit_list=[],
-                branches={},
-                tags={},
-            ),
+            repo_builder.Repo(),
             {
-                'commit_list_to_add': [
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='import'
-                    ),
+                'add_commits': [
+                    repo_builder.Commit(name='import'),
                 ],
-                'tags_to_add': {
-                    'importer/import/1-1': repo_builder.Placeholder('import'),
-                },
-                'branches_to_update': {
+                'update_tags': {
+                    'importer/import/1-1': Placeholder('import'),
                 },
             },
             [
@@ -280,29 +244,16 @@ def test_get_existing_applied_tags(repo, input_data, expected):
         ),
         (
             repo_builder.Repo(
-                commit_list=[
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='import'
-                    ),
-                ],
-                branches={},
-                tags={
-                    'importer/import/1-1': repo_builder.Placeholder('import'),
-                },
+                commits=[repo_builder.Commit(name='import')],
+                tags={'importer/import/1-1': Placeholder('import')},
             ),
             {
-                'commit_list_to_add': [
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='reimport'
-                    ),
+                'add_commits': [
+                    repo_builder.Commit(name='reimport'),
                 ],
-                'tags_to_add': {
-                    'importer/reimport/import/1-1/0': repo_builder.Placeholder('import'),
-                    'importer/reimport/import/1-1/1': repo_builder.Placeholder('reimport'),
-                },
-                'branches_to_update': {
+                'update_tags': {
+                    'importer/reimport/import/1-1/0': Placeholder('import'),
+                    'importer/reimport/import/1-1/1': Placeholder('reimport'),
                 },
             },
             [
@@ -313,34 +264,22 @@ def test_get_existing_applied_tags(repo, input_data, expected):
         ),
         (
             repo_builder.Repo(
-                commit_list=[
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='import'
-                    ),
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='reimport1'
-                    ),
+                commits=[
+                    repo_builder.Commit(name='import'),
+                    repo_builder.Commit(name='reimport1'),
                 ],
-                branches={},
                 tags={
-                    'importer/import/1-1': repo_builder.Placeholder('import'),
-                    'importer/reimport/import/1-1/0': repo_builder.Placeholder('import'),
-                    'importer/reimport/import/1-1/1': repo_builder.Placeholder('reimport1'),
+                    'importer/import/1-1': Placeholder('import'),
+                    'importer/reimport/import/1-1/0': Placeholder('import'),
+                    'importer/reimport/import/1-1/1': Placeholder('reimport1'),
                 },
             ),
             {
-                'commit_list_to_add': [
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='reimport2'
-                    ),
+                'add_commits': [
+                    repo_builder.Commit(name='reimport2'),
                 ],
-                'tags_to_add': {
-                    'importer/reimport/import/1-1/2': repo_builder.Placeholder('reimport2'),
-                },
-                'branches_to_update': {
+                'update_tags': {
+                    'importer/reimport/import/1-1/2': Placeholder('reimport2'),
                 },
             },
             [
@@ -352,45 +291,55 @@ def test_get_existing_applied_tags(repo, input_data, expected):
         ),
     ],
 )
-def test_create_import_tag(repo, input_data, expected_changes, test_refs):
-    publish_commit_str = str(repo.raw_repo.get(repo_builder.Commit(
-        repo_builder.Tree({})
-    ).write(repo.raw_repo)).peel(pygit2.Commit).id)
-
-    # copy before write, so that placeholders are still present
-    expected_result = input_data.copy(**expected_changes)
+def test_create_import_tag(
+    repo,
+    input_repo,
+    validation_repo_delta,
+    validation_repo_expected_identical_refs,
+):
+    """
+    Unit test that create_import_tag creates the correct import tag
 
-    input_data.write(repo.raw_repo)
+    :param repo gitubuntu.git_repository.GitUbuntuRepository: fixture to hold a
+        temporary output repository
+    :param repo_builder.Repo input_repo: input repository data
+    :param dict validation_repo_delta: how to transform the input repository
+        into a "validation repository", expressed as a dict to
+        provide as **kwargs to gitubuntu.repo_builder.Repo.copy() against the
+        input repository. The validation repository is then used for the
+        purposes of comparison against the output repository.
+    :param list(str) validation_repo_expected_identical_refs: refs that must be
+        identical between the validation repository and the output repository
+    """
+    publish_commit_str = str(
+        repo.raw_repo.get(
+            repo_builder.Commit().write(repo.raw_repo)
+        ).peel(pygit2.Commit).id
+    )
+    input_repo.write(repo.raw_repo)
 
     target.create_import_tag(repo, publish_commit_str, '1-1', 'importer')
 
+    validation_repo = input_repo.copy(**validation_repo_delta)
     assert repo_comparator.equals(
         repoA=repo.raw_repo,
-        repoB=expected_result,
-        test_refs=test_refs,
+        repoB=validation_repo,
+        test_refs=validation_repo_expected_identical_refs,
     )
 
 
 @pytest.mark.parametrize(
-    'input_data, expected_changes, test_refs', [
+    [
+        'input_repo',
+        'validation_repo_delta',
+        'validation_repo_expected_identical_refs',
+    ],
+    [
         (
-            repo_builder.Repo(
-                commit_list=[],
-                branches={},
-                tags={},
-            ),
+            repo_builder.Repo(),
             {
-                'commit_list_to_add': [
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='import'
-                    ),
-                ],
-                'tags_to_add': {
-                    'importer/applied/1-1': repo_builder.Placeholder('import'),
-                },
-                'branches_to_update': {
-                },
+                'add_commits': [repo_builder.Commit(name='import')],
+                'update_tags': {'importer/applied/1-1': Placeholder('import')},
             },
             [
                 'refs/tags/importer/applied/1-1',
@@ -398,29 +347,14 @@ def test_create_import_tag(repo, input_data, expected_changes, test_refs):
         ),
         (
             repo_builder.Repo(
-                commit_list=[
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='import'
-                    ),
-                ],
-                branches={},
-                tags={
-                    'importer/applied/1-1': repo_builder.Placeholder('import'),
-                },
+                commits=[repo_builder.Commit(name='import')],
+                tags={'importer/applied/1-1': Placeholder('import')},
             ),
             {
-                'commit_list_to_add': [
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='reimport'
-                    ),
-                ],
-                'tags_to_add': {
-                    'importer/reimport/applied/1-1/0': repo_builder.Placeholder('import'),
-                    'importer/reimport/applied/1-1/1': repo_builder.Placeholder('reimport'),
-                },
-                'branches_to_update': {
+                'add_commits': [repo_builder.Commit(name='reimport')],
+                'update_tags': {
+                    'importer/reimport/applied/1-1/0': Placeholder('import'),
+                    'importer/reimport/applied/1-1/1': Placeholder('reimport'),
                 },
             },
             [
@@ -431,34 +365,22 @@ def test_create_import_tag(repo, input_data, expected_changes, test_refs):
         ),
         (
             repo_builder.Repo(
-                commit_list=[
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='import'
-                    ),
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='reimport1'
-                    ),
+                commits=[
+                    repo_builder.Commit(name='import'),
+                    repo_builder.Commit(name='reimport1'),
                 ],
-                branches={},
                 tags={
-                    'importer/applied/1-1': repo_builder.Placeholder('import'),
-                    'importer/reimport/applied/1-1/0': repo_builder.Placeholder('import'),
-                    'importer/reimport/applied/1-1/1': repo_builder.Placeholder('reimport1'),
+                    'importer/applied/1-1': Placeholder('import'),
+                    'importer/reimport/applied/1-1/0': Placeholder('import'),
+                    'importer/reimport/applied/1-1/1': Placeholder('reimport1'),
                 },
             ),
             {
-                'commit_list_to_add': [
-                    repo_builder.Commit(
-                        tree=repo_builder.Tree({}),
-                        name='reimport2'
-                    ),
+                'add_commits': [
+                    repo_builder.Commit(name='reimport2')
                 ],
-                'tags_to_add': {
-                    'importer/reimport/applied/1-1/2': repo_builder.Placeholder('reimport2'),
-                },
-                'branches_to_update': {
+                'update_tags': {
+                    'importer/reimport/applied/1-1/2': Placeholder('reimport2'),
                 },
             },
             [
@@ -470,33 +392,55 @@ def test_create_import_tag(repo, input_data, expected_changes, test_refs):
         ),
     ],
 )
-def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
-    publish_commit_str = str(repo.raw_repo.get(repo_builder.Commit(
-        repo_builder.Tree({})
-    ).write(repo.raw_repo)).peel(pygit2.Commit).id)
+def test_create_applied_tag(
+    repo,
+    input_repo,
+    validation_repo_delta,
+    validation_repo_expected_identical_refs,
+):
+    """
+    Unit test that create_applied_tag creates the correct import tag
 
-    # copy before write, so that placeholders are still present
-    expected_result = input_data.copy(**expected_changes)
+    :param repo gitubuntu.git_repository.GitUbuntuRepository: fixture to hold a
+        temporary output repository
+    :param repo_builder.Repo input_repo: input repository data
+    :param dict validation_repo_delta: how to transform the input repository
+        into a "validation repository", expressed as a dict to
+        provide as **kwargs to gitubuntu.repo_builder.Repo.copy() against the
+        input repository. The validation repository is then used for the
+        purposes of comparison against the output repository.
+    :param list(str) validation_repo_expected_identical_refs: refs that must be
+        identical between the validation repository and the output repository
+    """
+    publish_commit_str = str(
+        repo.raw_repo.get(
+            repo_builder.Commit().write(repo.raw_repo)
+        ).peel(pygit2.Commit).id
+    )
 
-    input_data.write(repo.raw_repo)
+    input_repo.write(repo.raw_repo)
 
     target.create_applied_tag(repo, publish_commit_str, '1-1', 'importer')
 
+    validation_repo = input_repo.copy(**validation_repo_delta)
     assert repo_comparator.equals(
         repoA=repo.raw_repo,
-        repoB=expected_result,
-        test_refs=test_refs,
+        repoB=validation_repo,
+        test_refs=validation_repo_expected_identical_refs,
     )
 
 
[e-mail]('input_data, parent_overrides, changelog_versions, patches_applied, expected_ref',
[e-mail](
+    [
+        'input_repo',
+        'parent_overrides',
+        'changelog_versions',
+        'patches_applied',
+        'expected_ref',
+    ],
     [
         (
-            repo_builder.Repo(
-                commit_list=[],
-                branches={},
-                tags={},
-            ),
+            repo_builder.Repo(),
             {},
             ['1-2', '1-1',],
             False,
@@ -504,24 +448,8 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
         ),
         (
             repo_builder.Repo(
-                commit_list=[
-                    repo_builder.Commit(
-                        tree=repo_builder.SourceTree(
-                            source_builder.Source(
-                                source_builder.SourceSpec(
-                                    version='1-1',
-                                    native=False,
-                                )
-                            )
-                        ),
-                        name='import',
-                    ),
-                ],
-                branches={
-                },
-                tags={
-                    'importer/import/1-1': repo_builder.Placeholder('import'),
-                },
+                commits=[repo_builder.Commit.from_spec(name='import')],
+                tags={'importer/import/1-1': Placeholder('import')},
             ),
             {},
             ['1-2', '1-1'],
@@ -530,24 +458,8 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
         ),
         (
             repo_builder.Repo(
-                commit_list=[
-                    repo_builder.Commit(
-                        tree=repo_builder.SourceTree(
-                            source_builder.Source(
-                                source_builder.SourceSpec(
-                                    version='1-1',
-                                    native=False,
-                                )
-                            )
-                        ),
-                        name='import',
-                    ),
-                ],
-                branches={
-                },
-                tags={
-                    'importer/import/1-1': repo_builder.Placeholder('import'),
-                },
+                commits=[repo_builder.Commit.from_spec(name='import')],
+                tags={'importer/import/1-1': Placeholder('import')},
             ),
             {},
             ['1-3', '1-2', '1-1'],
@@ -555,11 +467,7 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
             'refs/tags/importer/import/1-1',
         ),
         (
-            repo_builder.Repo(
-                commit_list=[],
-                branches={},
-                tags={},
-            ),
+            repo_builder.Repo(),
             {},
             ['1-2', '1-1',],
             True,
@@ -567,24 +475,8 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
         ),
         (
             repo_builder.Repo(
-                commit_list=[
-                    repo_builder.Commit(
-                        tree=repo_builder.SourceTree(
-                            source_builder.Source(
-                                source_builder.SourceSpec(
-                                    version='1-1',
-                                    native=False,
-                                )
-                            )
-                        ),
-                        name='applied',
-                    ),
-                ],
-                branches={
-                },
-                tags={
-                    'importer/applied/1-1': repo_builder.Placeholder('applied'),
-                },
+                commits=[repo_builder.Commit.from_spec(name='applied')],
+                tags={'importer/applied/1-1': Placeholder('applied')},
             ),
             {},
             ['1-2', '1-1'],
@@ -593,24 +485,8 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
         ),
         (
             repo_builder.Repo(
-                commit_list=[
-                    repo_builder.Commit(
-                        tree=repo_builder.SourceTree(
-                            source_builder.Source(
-                                source_builder.SourceSpec(
-                                    version='1-1',
-                                    native=False,
-                                )
-                            )
-                        ),
-                        name='applied',
-                    ),
-                ],
-                branches={
-                },
-                tags={
-                    'importer/applied/1-1': repo_builder.Placeholder('applied'),
-                },
+                commits=[repo_builder.Commit.from_spec(name='applied')],
+                tags={'importer/applied/1-1': Placeholder('applied')},
             ),
             {},
             ['1-3', '1-2', '1-1'],
@@ -621,13 +497,13 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
 )
 def test_get_changelog_parent_commit(
     repo,
-    input_data,
+    input_repo,
     parent_overrides,
     changelog_versions,
     patches_applied,
     expected_ref,
 ):
-    input_data.write(repo.raw_repo)
+    input_repo.write(repo.raw_repo)
     assert target.get_changelog_parent_commit(
         repo,
         'importer',
@@ -697,3 +573,633 @@ def test_importer_close_repository_on_exception(main_with_repo_mock):
     with pytest.raises(MockError):
         target.main(pkgname='dummy', owner='dummy', repo=repo)
     repo.close.assert_called()
+
+
+def patch_get_commit_environment(repo):
+    """Patch a repository to use constant metadata
+
+    :param GitUbuntuRepository repo: the repository whose behaviour will be
+        patched.
+    :rtype: contextmanager
+    :returns: a context manager that, when entered, will cause the repository
+        object to use constant metadata for created commits when metadata is
+        looked up against a treeish.
+    """
+    return patch.object(
+        repo,
+        'get_commit_environment',
+        return_value={
+            'GIT_AUTHOR_NAME':'Test Builder',
+            'GIT_AUTHOR_EMAIL':'[e-mail]',
+            'GIT_AUTHOR_DATE':'1970-01-01T00:00:00Z',
+            'GIT_COMMITTER_NAME':'Test Builder',
+            'GIT_COMMITTER_EMAIL':'[e-mail]',
+            'GIT_COMMITTER_DATE':'1970-01-01T00:00:00Z',
+        },
+    )
+
+
+def MockSPI(dsc_path, version):
+    """Construct a Mock SourcePackageInformation object
+
+    In the following test cases we often need a Mock object with sufficient
+    property information to enable an import. This function constructs such an
+    object.
+
+    :param str dsc_path: the path to a dsc file. This will be returned by the
+        dsc_pathname attribute.
+    :param str version: the package version string. This will be returned by
+        the version attribute.
+    :rtype: Mock
+    :returns: a Mock object ready to use
+    """
+    spi = Mock()
+    spi.dsc_pathname = dsc_path
+    spi.distribution_name = 'Ubuntu'
+    spi.version = version
+    spi.date_published = '1970-01-01T00:00:00Z'
+    head_name = Mock(name='head_name')
+    head_name.return_value = 'importer/ubuntu/trusty'
+    spi.head_name = head_name
+    applied_head_name = Mock(name='applied_head_name')
+    applied_head_name.return_value = 'importer/applied/ubuntu/trusty'
+    spi.applied_head_name = applied_head_name
+    return spi
+
+
+@patch('gitubuntu.importer.get_import_tag_msg')
+@patch('gitubuntu.importer.get_import_commit_msg')
+def test_import_unapplied_spi_quilt_patches(
+    get_import_commit_msg_mock,
+    get_import_tag_msg_mock,
+    repo,
+):
+    """Test that a package with quilt patches is imported with correct
+    unapplied refs
+
+    :param unittest.mock.Mock get_import_commit_msg_mock: mock of the function
+        that determines the commit message to use for a given import
+    :param unittest.mock.Mock get_import_tag_msg_mock: mock of the function
+        that determines the tag message to use for a given import
+    :param repo gitubuntu.git_repository.GitUbuntuRepository: fixture to hold a
+        temporary output repository
+    """
+    # Match the repo_builder objects
+    get_import_tag_msg_mock.return_value = 'Test tag'
+    get_import_commit_msg_mock.return_value = b'Test commit'
+
+    publish_spec = source_builder.SourceSpec(has_patches=True)
+
+    input_repo = repo_builder.Repo()
+    input_repo.write(repo.raw_repo)
+    expected_result = repo_builder.Repo(
+        commits=[
+            repo_builder.Commit(
+                tree=repo_builder.SourceTree(
+                    source_builder.Source(publish_spec)
+                ),
+                name='publish'
+            ),
+        ],
+        tags={'importer/import/1-1': Placeholder('publish')},
+        branches={'importer/ubuntu/trusty': Placeholder('publish')},
+    )
+
+    with patch_get_commit_environment(repo):
+        with source_builder.Source(publish_spec) as dsc_path:
+            # import_unapplied_spi currently assumes it is called from the
+            # repository directory (pristine-tar and other commands rely on
+            # this)
+            target.import_unapplied_spi(
+                repo=repo,
+                spi=MockSPI(dsc_path, publish_spec.version),
+                namespace='importer',
+                skip_orig=False,
+                parent_overrides={},
+            )
+
+    assert repo_comparator.equals(
+        repoA=repo.raw_repo,
+        repoB=expected_result,
+        test_refs=[
+            'refs/heads/importer/ubuntu/trusty',
+            'refs/tags/importer/import/1-1',
+        ],
+    )
+
+
[e-mail](
+    [
+        'input_repo',
+        'changelog_versions',
+        'validation_repo_delta',
+        'validation_repo_expected_identical_refs',
+    ],
+    [
+        pytest.param(
+            repo_builder.Repo(
+                commits=[repo_builder.Commit.from_spec(name='import')],
+                tags={'importer/import/1-1': Placeholder('import')},
+            ),
+            ['1-2', '1-1'],
+            {
+                'add_commits': [
+                    repo_builder.Commit.from_spec(
+                        name='publish',
+                        parents=[Placeholder('import')],
+                        changelog_versions=['1-2', '1-1'],
+                    ),
+                ],
+                'update_tags': {'importer/import/1-2': Placeholder('publish')},
+            },
+            [
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/import/1-2',
+            ],
+        ),
+        pytest.param(
+            repo_builder.Repo(
+                commits=[repo_builder.Commit.from_spec(name='import')],
+                tags={'importer/import/1-1': Placeholder('import')},
+            ),
+            ['1-3', '1-2', '1-1'],
+            {
+                'add_commits': [
+                    repo_builder.Commit.from_spec(
+                        parents=[Placeholder('import')],
+                        name='publish',
+                        changelog_versions=['1-3', '1-2', '1-1'],
+                    ),
+                ],
+                'update_tags': {'importer/import/1-3': Placeholder('publish')},
+            },
+            [
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/import/1-3',
+            ],
+        ),
+        pytest.param(
+            repo_builder.Repo(
+                commits=[
+                    repo_builder.Commit.from_spec(name='import'),
+                    repo_builder.Commit.from_spec(
+                        name='reimport',
+                        mutate='Reimport tag contents',
+                    ),
+                ],
+                tags={
+                    'importer/import/1-1': Placeholder('import'),
+                    'importer/reimport/import/1-1/0': Placeholder('import'),
+                    'importer/reimport/import/1-1/1': Placeholder('reimport'),
+                },
+            ),
+            ['1-2', '1-1'],
+            {
+                'add_commits': [
+                    repo_builder.Commit.from_spec(
+                        parents=[
+                            Placeholder('import'),
+                            Placeholder('reimport'),
+                        ],
+                        name='publish',
+                        changelog_versions=['1-2', '1-1'],
+                    ),
+                ],
+                'update_tags': {'importer/import/1-2': Placeholder('publish')},
+            },
+            [
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/reimport/import/1-1/0',
+                'refs/tags/importer/reimport/import/1-1/1',
+                'refs/tags/importer/import/1-2',
+            ],
+            marks=pytest.mark.xfail(reason='LP: #1761332'),
+        ),
+    ]
+)
+@patch('gitubuntu.importer.get_import_tag_msg')
+@patch('gitubuntu.importer.get_import_commit_msg')
+def test_import_unapplied_spi_parenting(
+    get_import_commit_msg_mock,
+    get_import_tag_msg_mock,
+    repo,
+    input_repo,
+    changelog_versions,
+    validation_repo_delta,
+    validation_repo_expected_identical_refs,
+):
+    """Test that unapplied import commits have the correct parents
+
+    :param unittest.mock.Mock get_import_commit_msg_mock: mock of the function
+        that determines the commit message to use for a given import
+    :param unittest.mock.Mock get_import_tag_msg_mock: mock of the function
+        that determines the tag message to use for a given import
+    :param repo gitubuntu.git_repository.GitUbuntuRepository: fixture to hold a
+        temporary output repository
+    :param repo_builder.Repo input_repo: input repository data
+    :param list(str) changelog_versions: the versions in the changelog of a
+        fake package to test import
+    :param dict validation_repo_delta: how to transform the input
+        repository into a "validation repository", expressed as a dict to
+        provide as **kwargs to gitubuntu.repo_builder.Repo.copy() against the
+        input repository. The validation repository is then used for the
+        purposes of comparison against the output repository.
+    :param list(str) validation_repo_expected_identical_refs: refs that must be
+        identical between the validation repository and the output repository
+
+    Verify that if an import of a package is made into input_repo where the
+    package being imported has the given changelog_versions, then the output
+    repository has commits with the parents we expect. This is tested by
+    comparing specific output references against the validation repository.
+    """
+
+    # Match the repo_builder objects
+    get_import_tag_msg_mock.return_value = 'Test tag'
+    get_import_commit_msg_mock.return_value = b'Test commit'
+
+    input_repo.write(repo.raw_repo)
+
+    publish_spec = source_builder.SourceSpec(
+        changelog_versions=changelog_versions,
+    )
+
+    with patch_get_commit_environment(repo):
+        with source_builder.Source(publish_spec) as dsc_path:
+            # import_unapplied_spi currently assumes it is called from the
+            # repository directory (pristine-tar and other commands rely on
+            # this)
+            target.import_unapplied_spi(
+                repo=repo,
+                spi=MockSPI(dsc_path, publish_spec.version),
+                namespace='importer',
+                skip_orig=False,
+                parent_overrides={},
+            )
+
+    # we would like to check the commit hashes, but we cannot
+    # currently, as the commit messages are specific to the importer
+    # and not codified
+    validation_repo = input_repo.copy(**validation_repo_delta)
+    assert repo_comparator.equals(
+        repoA=repo.raw_repo,
+        repoB=validation_repo,
+        test_refs=validation_repo_expected_identical_refs,
+    )
+
+
+@patch('gitubuntu.importer.get_import_tag_msg')
+@patch('gitubuntu.importer.get_import_commit_msg')
+def test_import_unapplied_spi_parent_override(
+    get_import_commit_msg_mock,
+    get_import_tag_msg_mock,
+    repo,
+):
+    """Test import_unapplied_spi() parent_override functionality
+
+    Test that if parent_overrides is used in the import_unapplied_spi call then
+    the resulting commit correctly uses the overridden parents specified.
+
+    :param unittest.mock.Mock get_import_commit_msg_mock: mock of the function
+        that determines the commit message to use for a given import
+    :param unittest.mock.Mock get_import_tag_msg_mock: mock of the function
+        that determines the tag message to use for a given import
+    :param repo gitubuntu.git_repository.GitUbuntuRepository: fixture to hold a
+        temporary output repository
+    :param repo_builder.Repo input_repo: input repository data
+    """
+    # Match the repo_builder objects
+    get_import_tag_msg_mock.return_value = 'Test tag'
+    get_import_commit_msg_mock.return_value = b'Test commit'
+
+    input_repo = repo_builder.Repo(
+        commits=[
+            repo_builder.Commit.from_spec(name='import1-1', version='1-1'),
+            repo_builder.Commit.from_spec(name='import1-2', version='1-2'),
+        ],
+        tags={
+            'importer/import/1-1': Placeholder('import1-1'),
+            'importer/import/1-2': Placeholder('import1-2'),
+        },
+    )
+    input_repo.write(repo.raw_repo)
+
+    publish_spec = source_builder.SourceSpec(
+        changelog_versions=['2-1', '1-1'],
+    )
+
+    with patch_get_commit_environment(repo):
+        with source_builder.Source(publish_spec) as dsc_path:
+            # import_unapplied_spi currently assumes it is called from the
+            # repository directory (pristine-tar and other commands rely on
+            # this)
+            target.import_unapplied_spi(
+                repo=repo,
+                spi=MockSPI(dsc_path, publish_spec.version),
+                namespace='importer',
+                skip_orig=False,
+                parent_overrides={'2-1': {'changelog_parent': '1-2'}},
+            )
+
+    validation_repo = input_repo.copy(
+        add_commits=[
+            repo_builder.Commit.from_spec(
+                parents=[Placeholder('import1-2')],
+                name='publish',
+                changelog_versions=['2-1', '1-1'],
+            ),
+        ],
+        update_tags={
+            'importer/import/2-1': Placeholder('publish'),
+        },
+    )
+    validation_repo_expected_identical_refs = [
+        'refs/tags/importer/import/1-1',
+        'refs/tags/importer/import/1-2',
+        'refs/tags/importer/import/2-1',
+    ]
+    assert repo_comparator.equals(
+        repoA=repo.raw_repo,
+        repoB=validation_repo,
+        test_refs=validation_repo_expected_identical_refs,
+    )
+
+
+def test_import_unapplied_spi_parent_override_failure(repo):
+    """
+    Test override_parents ParentOverrideError raise
+
+    When a parent override is specified but the specified version doesn't have
+    an import tag, an exception should be raised.
+
+    :param repo gitubuntu.git_repository.GitUbuntuRepository: fixture to hold a
+        temporary output repository
+    """
+    repo_builder.Repo(
+        commits=[repo_builder.Commit.from_spec(name='import1-1')],
+        tags={'importer/import/1-1': Placeholder('import1-1')},
+    ).write(repo.raw_repo)
+
+    with pytest.raises(target.ParentOverrideError):
+        target.override_parents(
+            parent_overrides={'2-1': {'changelog_parent': '1-2'}},
+            repo=repo,
+            version='2-1',
+            namespace='importer',
+        )
+
+
[e-mail](
+    'input_repo, expected_ancestor_commits, expected_parent_commits', [
+        # In general, these tests do not set applied commit parents in the
+        # input repository since we have no mechanism to do that correctly, but
+        # this doesn't matter for the purposes of these tests.
+
+        # if only one import tag exists, then it is the parent
+        pytest.param(
+            repo_builder.Repo(
+                commits=[
+                    repo_builder.Commit.from_spec(
+                        name='unapplied1',
+                        has_patches=True,
+                    ),
+                    repo_builder.Commit.from_spec(
+                        parents=[Placeholder('unapplied1')],
+                        name='unapplied2',
+                        changelog_versions=['1-2', '1-1'],
+                        has_patches=True,
+                    ),
+                    repo_builder.Commit.from_spec(
+                        name='applied1',
+                        patches_applied=True,
+                    ),
+                ],
+                # no branches: technically not possible but branches are not
+                # relevant to the test
+                branches={},
+                tags={
+                    'importer/import/1-1': Placeholder('unapplied1'),
+                    'importer/import/1-2': Placeholder('unapplied2'),
+                    'importer/applied/1-1': Placeholder('applied1'),
+                },
+            ),
+            ['refs/tags/importer/import/1-2'],
+            ['refs/tags/importer/applied/1-1'],
+        ),
+
+        # if multiple import tags exist, then do they all end up as parents?
+        pytest.param(
+            repo_builder.Repo(
+                commits=[
+                    repo_builder.Commit.from_spec(
+                        name='unapplied1',
+                        has_patches=True,
+                    ),
+                    repo_builder.Commit.from_spec(
+                        parents=[Placeholder('unapplied1')],
+                        name='unapplied2',
+                        changelog_versions=['1-2', '1-1'],
+                        has_patches=True,
+                    ),
+                    repo_builder.Commit.from_spec(
+                        parents=[Placeholder('unapplied1')],
+                        name='unapplied2reimport',
+                        changelog_versions=['1-2', '1-1'],
+                        has_patches=True,
+                        mutate='reimport tag',
+                    ),
+                    repo_builder.Commit.from_spec(
+                        name='applied1',
+                        patches_applied=True,
+                    ),
+                ],
+                # no branches: technically not possible but branches are not
+                # relevant to the test
+                branches={},
+                tags={
+                    'importer/import/1-1':
+                        Placeholder('unapplied1'),
+                    'importer/import/1-2':
+                        Placeholder('unapplied2'),
+                    'importer/reimport/import/1-2/0':
+                        Placeholder('unapplied2'),
+                    'importer/reimport/import/1-2/1':
+                        Placeholder('unapplied2reimport'),
+                    'importer/applied/1-1':
+                        Placeholder('applied1'),
+                },
+            ),
+            [
+                'refs/tags/importer/reimport/import/1-2/0',
+                'refs/tags/importer/reimport/import/1-2/1',
+            ],
+            [
+                'refs/tags/importer/applied/1-1',
+            ],
+            marks=pytest.mark.xfail(reason='LP: #1755247'),
+        ),
+
+        # do we correctly create a reimport tag because a different import
+        # already exists?
+        pytest.param(
+            repo_builder.Repo(
+                commits=[
+                    repo_builder.Commit.from_spec(
+                        name='unapplied1',
+                        has_patches=True,
+                    ),
+                    repo_builder.Commit.from_spec(
+                        name='unapplied1_reimport',
+                        has_patches=True,
+                        mutate='reimport contents',
+                    ),
+                    repo_builder.Commit.from_spec(
+                        parents=[Placeholder('unapplied1')],
+                        name='unapplied2',
+                        changelog_versions=['1-2', '1-1'],
+                        has_patches=True,
+                    ),
+                    repo_builder.Commit.from_spec(
+                        name='applied1',
+                        patches_applied=True,
+                    ),
+                    repo_builder.Commit.from_spec(
+                        name='applied1_reimport',
+                        patches_applied=True,
+                        mutate='reimport contents',
+                    ),
+                ],
+                # no branches: technically not possible but branches are not
+                # relevant to the test
+                branches={},
+                tags={
+                    'importer/import/1-1':
+                        Placeholder('unapplied1'),
+                    'importer/reimport/import/1-1/0':
+                        Placeholder('unapplied1'),
+                    'importer/reimport/import/1-1/1':
+                        Placeholder('unapplied1_reimport'),
+                    'importer/import/1-2':
+                        Placeholder('unapplied2'),
+                    'importer/applied/1-1':
+                        Placeholder('applied1'),
+                    'importer/reimport/applied/1-1/0':
+                        Placeholder('applied1'),
+                    'importer/reimport/applied/1-1/1':
+                        Placeholder('applied1_reimport'),
+                },
+            ),
+            [
+                'refs/tags/importer/reimport/import/1-2/0',
+                'refs/tags/importer/reimport/import/1-2/1',
+            ],
+            [
+                'refs/tags/importer/reimport/applied/1-1/0',
+                'refs/tags/importer/reimport/applied/1-1/1',
+            ],
+            marks=pytest.mark.xfail(reason='LP: #1755247'),
+        ),
+    ],
+)
+@patch('gitubuntu.importer.get_import_tag_msg')
+@patch('gitubuntu.importer.get_import_commit_msg')
+def test_import_applied_spi_parenting(
+    get_import_commit_msg_mock,
+    get_import_tag_msg_mock,
+    repo,
+    input_repo,
+    expected_ancestor_commits,
+    expected_parent_commits,
+):
+    """Test that applied import commits have the right parents
+
+    :param unittest.mock.Mock get_import_commit_msg_mock: mock of the function
+        that determines the commit message to use for a given import
+    :param unittest.mock.Mock get_import_tag_msg_mock: mock of the function
+        that determines the tag message to use for a given import
+    :param repo gitubuntu.git_repository.GitUbuntuRepository: fixture to hold a
+        temporary output repository
+    :param repo_builder.Repo input_repo: input repository data
+    :param list(str) expected_ancestor_commits: list of commit-ish strings that
+        must be ancestors of the 'applied/1-2' tag following the applied import
+    :param list(str) expected_parent_commits: list of commit-ish strings that
+        must be parents of the 'applied/1-2' tag following the applied import.
+
+    A fake package with version '1-2' that has a changelog parent of '1-1' is
+    imported on top of the provided input_repo. The test fails if any
+    of the expected_ancestor_commits or expected_parent_commits are not
+    present.
+
+    This test is ugly because we do not yet have a programmatic way
+    to get the interstitial commits of the patch applications.
+    """
+    # Match the repo_builder objects
+    get_import_tag_msg_mock.return_value = 'Test tag'
+    get_import_commit_msg_mock.return_value = b'Test commit'
+
+    input_repo.write(repo.raw_repo)
+
+    publish_spec = source_builder.SourceSpec(
+        changelog_versions=['1-2', '1-1'],
+        has_patches=True,
+    )
+
+    with patch_get_commit_environment(repo):
+        with source_builder.Source(publish_spec) as dsc_path:
+            target.import_applied_spi(
+                repo=repo,
+                spi=MockSPI(dsc_path, publish_spec.version),
+                namespace='importer',
+                allow_applied_failures=False,
+                parent_overrides={},
+            )
+
+    applied_tag = repo.raw_repo.lookup_reference(
+        'refs/tags/importer/applied/1-2',
+    )
+    applied_commit = applied_tag.peel(pygit2.Commit)
+    applied_commit_parents = applied_commit.parents
+
+    # convert refs to commits
+    expected_ancestor_commit_hashes = [
+        str(
+            repo.raw_repo.lookup_reference(
+                expected_ancestor
+            ).peel(pygit2.Commit).id
+        )
+        for expected_ancestor in expected_ancestor_commits
+    ]
+    expected_parent_commit_hashes = [
+        str(
+            repo.raw_repo.lookup_reference(
+                expected_parent
+            ).peel(pygit2.Commit).id
+        )
+        for expected_parent in expected_parent_commits
+    ]
+
+    missing_ancestor_commit_hashes = []
+    for ancestor_commit_hash in expected_ancestor_commit_hashes:
+        # We use merge_base as an ancestry test. If a merge base against an
+        # expected ancestor isn't the expected ancestor itself, then it isn't
+        # an ancestor.
+        merge_base = repo.raw_repo.merge_base(
+            repo.raw_repo.get(ancestor_commit_hash).id,
+            applied_commit.id,
+        )
+        if str(
+            repo.raw_repo.get(merge_base).peel(pygit2.Commit).id
+        ) != ancestor_commit_hash:
+            missing_ancestor_commit_hashes.append(ancestor_commit_hash)
+
+    missing_parent_commit_hashes = []
+    for parent_commit_hash in expected_parent_commit_hashes:
+        for parent in applied_commit_parents:
+            if str(parent.id) == parent_commit_hash:
+                break
+        else:
+            missing_parent_commit_hashes.append(parent_commit_hash)
+
+    assert (
+        not missing_ancestor_commit_hashes and
+        not missing_parent_commit_hashes
+    )
diff --git a/gitubuntu/repo_builder.py b/gitubuntu/repo_builder.py
index 94bc62a..c779c71 100644
--- a/gitubuntu/repo_builder.py
+++ b/gitubuntu/repo_builder.py
@@ -1,21 +1,10 @@
 import binascii
 import copy
-import functools
-import tempfile
-import unittest
 
 import pygit2
-import pytest
 
 import gitubuntu.importer
-from gitubuntu.test_fixtures import (
-    repo,
-    pygit2_repo,
-)
-
-# Only for tests; can move to repo_builder_test when the move is done
-import gitubuntu.git_repository
-from gitubuntu.source_builder import Source
+from gitubuntu.source_builder import Source, SourceSpec
 
 
 """Build test git repositories as data structures
@@ -206,12 +195,62 @@ class SourceTree(NamedMixin, WriteMixin):
 
 
 class Commit(NamedMixin, WriteMixin):
-    def __init__(self, tree, parents=None, message=None, **kwargs):
+    def __init__(self, tree=None, parents=None, message=None, **kwargs):
+        """Construct a Commit object
+
+        :param Tree tree: the tree contained by the commit. If None, an empty
+            tree is used.
+        :param list(Commit) parents: the commit objects that are the parents of
+            this commit. The list may be empty if the commit is to have no
+            parent.
+        :param str message: the commit message.
+        :param **kwargs: other parameters supplied to superclasses.
+        """
         super().__init__(**kwargs)
-        self.tree = tree
+        self.tree = tree or Tree({})
         self.parents = parents or []
         self.message = 'Test commit' if message is None else message
 
+    @classmethod
+    def from_spec(
+        cls,
+        parents=None,
+        message=None,
+        name=None,
+        patches_applied=False,
+        **kwargs,
+    ):
+        """Construct a Commit object containing a test source package
+
+        :param list(Commit) parents: the commit objects that are the parents of
+            this commit. The list may be empty if the commit is to have no
+            parent.
+        :param str message: the commit message.
+        :param str name: the value for the name attribute of the constructed
+            object, used for matching with Placeholder objects after
+            construction.
+        :param bool patches_applied: whether the tree inside the commit should
+            have patches applied. Passed to the SourceTree constructor. If
+            True, then the test source package is generated with patches using
+            the has_patches argument to the SourceSpec constructor, unless
+            overridden by kwargs.
+        :param **kwargs: additional parameters are passed to the SourceSpec
+            constructor to customise the test source package used for the tree
+            of the commit.
+        """
+        spec_args = {'has_patches': patches_applied}
+        spec_args.update(kwargs)
+
+        return cls(
+            tree=SourceTree(
+                Source(SourceSpec(**spec_args)),
+                patches_applied=patches_applied,
+            ),
+            parents=parents,
+            message=message,
+            name=name,
+        )
+
     def replace(self, old, new):
         for i, parent in enumerate(self.parents):
             if parent is old:
@@ -248,10 +287,10 @@ class Repo:
     This is affectively a commit container that exists for the
     convenience of writing them to a git repository at once.
     """
-    def __init__(self, commit_list, branches=None, tags=None):
+    def __init__(self, commits=None, branches=None, tags=None):
         """Construct a Repo instance
 
-        :param list(Commit) commit_list: the commits this Repo should
+        :param list(Commit) commits: the commits this Repo should
             contain. These may be related to each other with parenting
             relationships, but do not have to be.
         :param dict(str: Commit or Placeholder) branches: the branches
@@ -262,7 +301,7 @@ class Repo:
             should contain. A tag has a name and a target to point to.
             The target can be a Commit object or Placeholder object.
         """
-        self.commit_list = commit_list
+        self.commit_list = commits or list()
         self.branches = branches or dict()
         self.tags = tags or dict()
 
@@ -308,11 +347,28 @@ class Repo:
         for _, tag in self.tags.items():
             yield self, tag
 
-    def copy(self, commit_list_to_add, branches_to_update, tags_to_add):
+    def copy(self, add_commits=None, update_branches=None, update_tags=None):
+        """Clone the Repo, optionally with some changes
+
+        :param list(Commit) add_commits: commits to add to the cloned Repo
+        :param dict(str: Commit or Placeholder) branches: branches to update in
+            the cloned Repo.
+        :param dict(str: Commit or Placeholder) tags: tags to update in the
+            cloned Repo.
+
+        "update" is in the sense of a dict object's update method: this allows
+        for both the definition of new branches and tags, and updates to
+        existing branches and tags.
+
+        There is currently no facility to delete branches or tags.
+        """
         new_repo = copy.deepcopy(self)
-        new_repo.commit_list.extend(commit_list_to_add)
-        new_repo.branches.update(branches_to_update)
-        new_repo.tags.update(tags_to_add)
+        if add_commits:
+            new_repo.commit_list.extend(add_commits)
+        if update_branches:
+            new_repo.branches.update(update_branches)
+        if update_tags:
+            new_repo.tags.update(update_tags)
         return new_repo
 
 
@@ -336,227 +392,3 @@ def replace_placeholders(top):
     for parent, obj in top.walk():
         if isinstance(obj, Placeholder):
             parent.replace(obj, find_node(top, obj.target_name))
-
-
-class TestObjectCreation(unittest.TestCase):
-    def setUp(self):
-        self.git_dir = tempfile.TemporaryDirectory()
-        self.repo = pygit2.init_repository(self.git_dir.name)
-
-    def tearDown(self):
-        self.repo = None
-        self.git_dir.cleanup()
-
-    def testBlobCreation(self):
-        ref = Blob(b'foo').write(self.repo)
-        assert self.repo.get(ref).data == b'foo'
-
-    def testExecutableBlobTreeCreation(self):
-        tree_ref = Tree({'foo': ExecutableBlob(b'bar')}).write(self.repo)
-        tree_entry = self.repo.get(tree_ref)['foo']
-        assert self.repo.get(tree_entry.id).data == b'bar'
-        assert tree_entry.filemode == pygit2.GIT_FILEMODE_BLOB_EXECUTABLE
-
-    def testSymlinkTreeCreation(self):
-        tree_ref = Tree({'foo': Symlink(b'bar')}).write(self.repo)
-        tree_entry = self.repo.get(tree_ref)['foo']
-        assert tree_entry.filemode == pygit2.GIT_FILEMODE_LINK
-
-    def testCommitCreation(self):
-        tree = Tree({'foo': Blob(b'bar')})
-        tree_ref = tree.write(self.repo)
-        commit_ref = Commit(tree).write(self.repo)
-        commit = self.repo.get(commit_ref)
-        assert commit.tree_id == tree_ref
-
-    def testCommitMessage(self):
-        ref = Commit(Tree({}), message='foo').write(self.repo)
-        commit = self.repo.get(ref)
-        assert commit.message == 'foo'
-
-    def testCommitParents(self):
-        tree = Tree({})
-        top = Commit(tree, message='top')
-        top_ref = top.write(self.repo)
-        child_a = Commit(tree, parents=[top], message='child_a')
-        child_a_ref = child_a.write(self.repo)
-        child_b = Commit(tree, parents=[top], message='child_b')
-        child_b_ref = child_b.write(self.repo)
-        merge = Commit(tree, parents=[child_a, child_b], message='merge')
-        merge_ref = merge.write(self.repo)
-
-        merge_commit = self.repo.get(merge_ref)
-        assert merge_commit.parent_ids == [child_a_ref, child_b_ref]
-
-        child_a_commit = self.repo.get(child_a_ref)
-        assert child_a_commit.parent_ids == [top_ref]
-
-        top_commit = self.repo.get(top_ref)
-        assert top_commit.parent_ids == []
-
-    def testNameSearch(self):
-        inner_tree = Tree({'foo': Blob(b'bar', name='blob')}, name='inner')
-        outer_tree = Tree({'baz': inner_tree}, name='outer')
-        commit = Commit(outer_tree, name='commit')
-        assert find_node(commit, 'commit') is commit
-        assert find_node(commit, 'inner') is inner_tree
-        assert find_node(commit, 'outer') is outer_tree
-        assert isinstance(find_node(commit, 'blob'), Blob)
-        with pytest.raises(KeyError):
-            find_node(commit, 'absent')
-
-    def testRepo(self):
-        graph = Repo([
-            Commit(Tree({}), parents=[Placeholder('parent')]),
-            Commit(Tree({}), name='parent'),
-        ])
-        child_ref = graph.write(self.repo)
-        child = self.repo.get(child_ref)
-        assert child.parent_ids == [graph.commit_list[1].write(self.repo)]
-
-    def testRepoBranchesTags(self):
-        graph = Repo(
-            commit_list=[
-                Commit(
-                    Tree({}),
-                    parents=[Placeholder('parent')],
-                    name='child',
-                ),
-                Commit(Tree({}), name='parent'),
-            ],
-            branches={
-                'branch1': Placeholder('parent'),
-                'branch2': Commit(Tree({'foo': Blob(b'qux')})),
-            },
-            tags={
-                'tag1': Placeholder('child'),
-                'tag2': Commit(Tree({'foo': Blob(b'quz')})),
-            },
-        )
-        child_ref = graph.write(self.repo)
-        child = self.repo.get(child_ref)
-        assert self.repo.lookup_reference(
-            'refs/heads/branch1'
-        ).peel(pygit2.Commit).id == graph.commit_list[1].write(self.repo)
-        assert self.repo.lookup_reference('refs/heads/branch2')
-        assert self.repo.lookup_reference(
-            'refs/tags/tag1'
-        ).peel(pygit2.Commit).id == graph.commit_list[0].write(self.repo)
-        assert self.repo.lookup_reference('refs/tags/tag2')
-        assert child.parent_ids == [graph.commit_list[1].write(self.repo)]
-
-
-def test_source_tree(pygit2_repo):
-    commit_str = Commit(SourceTree(Source())).write(pygit2_repo)
-    commit = pygit2_repo.get(commit_str)
-    assert gitubuntu.git_repository.follow_symlinks_to_blob(
-        repo=pygit2_repo,
-        treeish_object=commit,
-        path='debian/changelog',
-    )
-
-
[e-mail]('cls', [
-    functools.partial(Blob, b'qux'),
-    functools.partial(ExecutableBlob, b'qux'),
-    functools.partial(Symlink, 'target'),
-    functools.partial(Tree, {}),
-    functools.partial(SourceTree, {}),
-])
-def test_replace_placeholders(cls):
-    common_blob = cls(name='name')
-    top = Tree({'foo': common_blob, 'bar': Placeholder('name')})
-    assert top.entries['foo'] is not top.entries['bar']
-    replace_placeholders(top)
-    assert top.entries['foo'] is top.entries['bar']
-    assert isinstance(top.entries['bar'], type(common_blob))
-
-
-# The following test uses replace directly, because
-# replace_placeholders' use of find_node will raise its own KeyError.
[e-mail]('testobj', [
-    Tree({}),
-    Commit(Tree({})),
-    Repo(commit_list=[]),
-])
-def test_replace_missing_placeholder(testobj):
-    commit = Commit(Tree({}))
-    with pytest.raises(KeyError):
-        testobj.replace(Placeholder('name'), commit)
-
-
-def test_repo_placeholder():
-    empty_tree = Tree({})
-    graph = Repo(
-        commit_list=[
-            Commit(empty_tree, message='top', name='top'),
-            Commit(
-                empty_tree,
-                message='child',
-                parents=[Placeholder('top')],
-                name='child',
-            ),
-        ],
-        branches={
-            'branch1': Placeholder('top'),
-            'branch2': Placeholder('child'),
-        },
-        tags={
-            'tag1': Placeholder('child'),
-            'tag2': Placeholder('top'),
-        },
-    )
-    replace_placeholders(graph)
-    assert graph.commit_list[1].parents[0] is graph.commit_list[0]
-    assert graph.branches['branch1'] is graph.commit_list[0]
-    assert graph.branches['branch2'] is graph.commit_list[1]
-    assert graph.tags['tag2'] is graph.commit_list[0]
-    assert graph.tags['tag1'] is graph.commit_list[1]
-
-
-def test_copy():
-    graph = Repo(
-        commit_list=[
-            Commit(Tree({}), message='top', name='top'),
-            Commit(
-                Tree({}),
-                message='child',
-                parents=[Placeholder('top')],
-                name='child',
-            ),
-        ],
-        branches={
-            'branch1': Placeholder('top'),
-            'branch2': Placeholder('child'),
-        },
-        tags={
-            'tag1': Placeholder('child'),
-        },
-    )
-    copy_graph = graph.copy(
-        commit_list_to_add=[
-             Commit(Tree({}), message='new', name='new'),
-        ],
-        branches_to_update={
-            'branch2': Placeholder('new'),
-            'branch3': Placeholder('new'),
-        },
-        tags_to_add={
-            'tag2': Placeholder('new'),
-            'tag3': Placeholder('top'),
-        }
-    )
-    replace_placeholders(graph)
-    replace_placeholders(copy_graph)
-
-    assert graph.commit_list[1].parents[0] is graph.commit_list[0]
-    assert graph.branches['branch1'] is graph.commit_list[0]
-    assert graph.tags['tag1'] is graph.commit_list[1]
-
-    assert copy_graph.commit_list[2].message == 'new'
-    assert copy_graph.branches['branch1'] is copy_graph.commit_list[0]
-    assert copy_graph.branches['branch2'] is copy_graph.commit_list[2]
-    assert copy_graph.branches['branch3'] is copy_graph.commit_list[2]
-    assert copy_graph.tags['tag1'] is copy_graph.commit_list[1]
-    assert copy_graph.tags['tag2'] is copy_graph.commit_list[2]
-    assert copy_graph.tags['tag3'] is copy_graph.commit_list[0]
diff --git a/gitubuntu/repo_builder_test.py b/gitubuntu/repo_builder_test.py
new file mode 100644
index 0000000..bfe053f
--- /dev/null
+++ b/gitubuntu/repo_builder_test.py
@@ -0,0 +1,284 @@
+import functools
+import tempfile
+import unittest
+from unittest.mock import sentinel
+
+import pygit2
+import pytest
+
+import gitubuntu.git_repository
+from gitubuntu.repo_builder import (
+    Blob,
+    Commit,
+    ExecutableBlob,
+    Placeholder,
+    Repo,
+    Source,
+    SourceTree,
+    Symlink,
+    Tree,
+    find_node,
+    replace_placeholders,
+)
+from gitubuntu.test_fixtures import (
+    repo,
+    pygit2_repo,
+)
+
+
+class TestObjectCreation(unittest.TestCase):
+    def setUp(self):
+        self.git_dir = tempfile.TemporaryDirectory()
+        self.repo = pygit2.init_repository(self.git_dir.name)
+
+    def tearDown(self):
+        self.repo = None
+        self.git_dir.cleanup()
+
+    def testBlobCreation(self):
+        ref = Blob(b'foo').write(self.repo)
+        assert self.repo.get(ref).data == b'foo'
+
+    def testExecutableBlobTreeCreation(self):
+        tree_ref = Tree({'foo': ExecutableBlob(b'bar')}).write(self.repo)
+        tree_entry = self.repo.get(tree_ref)['foo']
+        assert self.repo.get(tree_entry.id).data == b'bar'
+        assert tree_entry.filemode == pygit2.GIT_FILEMODE_BLOB_EXECUTABLE
+
+    def testSymlinkTreeCreation(self):
+        tree_ref = Tree({'foo': Symlink(b'bar')}).write(self.repo)
+        tree_entry = self.repo.get(tree_ref)['foo']
+        assert tree_entry.filemode == pygit2.GIT_FILEMODE_LINK
+
+    def testCommitCreation(self):
+        tree = Tree({'foo': Blob(b'bar')})
+        tree_ref = tree.write(self.repo)
+        commit_ref = Commit(tree).write(self.repo)
+        commit = self.repo.get(commit_ref)
+        assert commit.tree_id == tree_ref
+
+    def testCommitMessage(self):
+        ref = Commit(Tree({}), message='foo').write(self.repo)
+        commit = self.repo.get(ref)
+        assert commit.message == 'foo'
+
+    def testCommitParents(self):
+        tree = Tree({})
+        top = Commit(tree, message='top')
+        top_ref = top.write(self.repo)
+        child_a = Commit(tree, parents=[top], message='child_a')
+        child_a_ref = child_a.write(self.repo)
+        child_b = Commit(tree, parents=[top], message='child_b')
+        child_b_ref = child_b.write(self.repo)
+        merge = Commit(tree, parents=[child_a, child_b], message='merge')
+        merge_ref = merge.write(self.repo)
+
+        merge_commit = self.repo.get(merge_ref)
+        assert merge_commit.parent_ids == [child_a_ref, child_b_ref]
+
+        child_a_commit = self.repo.get(child_a_ref)
+        assert child_a_commit.parent_ids == [top_ref]
+
+        top_commit = self.repo.get(top_ref)
+        assert top_commit.parent_ids == []
+
+    def testNameSearch(self):
+        inner_tree = Tree({'foo': Blob(b'bar', name='blob')}, name='inner')
+        outer_tree = Tree({'baz': inner_tree}, name='outer')
+        commit = Commit(outer_tree, name='commit')
+        assert find_node(commit, 'commit') is commit
+        assert find_node(commit, 'inner') is inner_tree
+        assert find_node(commit, 'outer') is outer_tree
+        assert isinstance(find_node(commit, 'blob'), Blob)
+        with pytest.raises(KeyError):
+            find_node(commit, 'absent')
+
+    def testRepo(self):
+        graph = Repo([
+            Commit(Tree({}), parents=[Placeholder('parent')]),
+            Commit(Tree({}), name='parent'),
+        ])
+        child_ref = graph.write(self.repo)
+        child = self.repo.get(child_ref)
+        assert child.parent_ids == [graph.commit_list[1].write(self.repo)]
+
+    def testRepoBranchesTags(self):
+        graph = Repo(
+            commits=[
+                Commit(
+                    Tree({}),
+                    parents=[Placeholder('parent')],
+                    name='child',
+                ),
+                Commit(Tree({}), name='parent'),
+            ],
+            branches={
+                'branch1': Placeholder('parent'),
+                'branch2': Commit(Tree({'foo': Blob(b'qux')})),
+            },
+            tags={
+                'tag1': Placeholder('child'),
+                'tag2': Commit(Tree({'foo': Blob(b'quz')})),
+            },
+        )
+        child_ref = graph.write(self.repo)
+        child = self.repo.get(child_ref)
+        assert self.repo.lookup_reference(
+            'refs/heads/branch1'
+        ).peel(pygit2.Commit).id == graph.commit_list[1].write(self.repo)
+        assert self.repo.lookup_reference('refs/heads/branch2')
+        assert self.repo.lookup_reference(
+            'refs/tags/tag1'
+        ).peel(pygit2.Commit).id == graph.commit_list[0].write(self.repo)
+        assert self.repo.lookup_reference('refs/tags/tag2')
+        assert child.parent_ids == [graph.commit_list[1].write(self.repo)]
+
+
+def test_source_tree(pygit2_repo):
+    commit_str = Commit(SourceTree(Source())).write(pygit2_repo)
+    commit = pygit2_repo.get(commit_str)
+    assert gitubuntu.git_repository.follow_symlinks_to_blob(
+        repo=pygit2_repo,
+        treeish_object=commit,
+        path='debian/changelog',
+    )
+
+
[e-mail]('cls', [
+    functools.partial(Blob, b'qux'),
+    functools.partial(ExecutableBlob, b'qux'),
+    functools.partial(Symlink, 'target'),
+    functools.partial(Tree, {}),
+    functools.partial(SourceTree, {}),
+])
+def test_replace_placeholders(cls):
+    common_blob = cls(name='name')
+    top = Tree({'foo': common_blob, 'bar': Placeholder('name')})
+    assert top.entries['foo'] is not top.entries['bar']
+    replace_placeholders(top)
+    assert top.entries['foo'] is top.entries['bar']
+    assert isinstance(top.entries['bar'], type(common_blob))
+
+
+# The following test uses replace directly, because
+# replace_placeholders' use of find_node will raise its own KeyError.
[e-mail]('testobj', [
+    Tree({}),
+    Commit(Tree({})),
+    Repo(),
+])
+def test_replace_missing_placeholder(testobj):
+    commit = Commit(Tree({}))
+    with pytest.raises(KeyError):
+        testobj.replace(Placeholder('name'), commit)
+
+
+def test_repo_placeholder():
+    empty_tree = Tree({})
+    graph = Repo(
+        commits=[
+            Commit(empty_tree, message='top', name='top'),
+            Commit(
+                empty_tree,
+                message='child',
+                parents=[Placeholder('top')],
+                name='child',
+            ),
+        ],
+        branches={
+            'branch1': Placeholder('top'),
+            'branch2': Placeholder('child'),
+        },
+        tags={
+            'tag1': Placeholder('child'),
+            'tag2': Placeholder('top'),
+        },
+    )
+    replace_placeholders(graph)
+    assert graph.commit_list[1].parents[0] is graph.commit_list[0]
+    assert graph.branches['branch1'] is graph.commit_list[0]
+    assert graph.branches['branch2'] is graph.commit_list[1]
+    assert graph.tags['tag2'] is graph.commit_list[0]
+    assert graph.tags['tag1'] is graph.commit_list[1]
+
+
+def test_copy():
+    graph = Repo(
+        commits=[
+            Commit(Tree({}), message='top', name='top'),
+            Commit(
+                Tree({}),
+                message='child',
+                parents=[Placeholder('top')],
+                name='child',
+            ),
+        ],
+        branches={
+            'branch1': Placeholder('top'),
+            'branch2': Placeholder('child'),
+        },
+        tags={
+            'tag1': Placeholder('child'),
+        },
+    )
+    copy_graph = graph.copy(
+        add_commits=[
+             Commit(Tree({}), message='new', name='new'),
+        ],
+        update_branches={
+            'branch2': Placeholder('new'),
+            'branch3': Placeholder('new'),
+        },
+        update_tags={
+            'tag2': Placeholder('new'),
+            'tag3': Placeholder('top'),
+        }
+    )
+    replace_placeholders(graph)
+    replace_placeholders(copy_graph)
+
+    assert graph.commit_list[1].parents[0] is graph.commit_list[0]
+    assert graph.branches['branch1'] is graph.commit_list[0]
+    assert graph.tags['tag1'] is graph.commit_list[1]
+
+    assert copy_graph.commit_list[2].message == 'new'
+    assert copy_graph.branches['branch1'] is copy_graph.commit_list[0]
+    assert copy_graph.branches['branch2'] is copy_graph.commit_list[2]
+    assert copy_graph.branches['branch3'] is copy_graph.commit_list[2]
+    assert copy_graph.tags['tag1'] is copy_graph.commit_list[1]
+    assert copy_graph.tags['tag2'] is copy_graph.commit_list[2]
+    assert copy_graph.tags['tag3'] is copy_graph.commit_list[0]
+
+
+def test_commit_from_spec_parents():
+    """Argument parents should end up in Commit object parents attribute"""
+    commit = Commit.from_spec(parents=sentinel.parents).parents
+    assert commit == sentinel.parents
+
+
+def test_commit_from_spec_message():
+    """Argument message should end up in Commit object message attribute"""
+    commit =  Commit.from_spec(message=sentinel.message).message
+    assert commit == sentinel.message
+
+
+def test_commit_from_spec_name():
+    """Argument name should end up in Commit object name attribute"""
+    assert Commit.from_spec(name=sentinel.name).name == sentinel.name
+
+
[e-mail]('patches_applied', [True, False])
+def test_commit_from_spec_patches_applied(patches_applied):
+    """Check behaviour of patches_applied argument"""
+    commit = Commit.from_spec(patches_applied=patches_applied)
+    # Underlying SourceTree object should now have a matching patches_applied
+    # attribute
+    assert commit.tree.patches_applied == patches_applied
+    # Underlying SourceSpec object should now have a matching has_patches
+    # attribute
+    assert commit.tree.source.spec.has_patches == patches_applied
+
+
+def test_commit_from_spec_kwargs():
+    """Arbitrary arguments should result in adjusted behaviour in SourceSpec"""
+    assert Commit.from_spec(native=True).tree.source.spec.native
diff --git a/gitubuntu/source_builder.py b/gitubuntu/source_builder.py
index 024b569..dac9670 100644
--- a/gitubuntu/source_builder.py
+++ b/gitubuntu/source_builder.py
@@ -62,11 +62,12 @@ NEW_FILE_PATCH_TEMPLATE = """
 
 class SourceSpec:
     """A high level abstraction of the attributes of a test source package"""
-    version = '1'
-    native = True
+    version = '1-1'
+    native = False
     has_patches = False
     changelog_versions = None
     file_contents = None
+    mutate = False
     reserved_files = [
         'debian/changelog',
         'debian/control',
@@ -88,6 +89,8 @@ class SourceSpec:
             package should contain the specified file names with the
             specified contents.  This is used to control the tree hashes
             of generated source packages.
+        :param mutate: if bool(mutate) is True, then this will add a file
+            called debian/mutate containing the data str(mutate).
 
         Keyword arguments to the constructor map directly to class instances
         properties. Properties may be manipulated after construction.
@@ -112,8 +115,8 @@ class SourceSpec:
 
             # If the version was not explicitly set, toggle the default for
             # non-native packages
-            if 'version' not in kwargs and not self.native:
-                self.version = '1-1'
+            if 'version' not in kwargs and self.native:
+                self.version = '1'
 
             if self.native and '-' in self.version:
                 raise ValueError("Version must not have a '-' in a native package")
@@ -198,7 +201,10 @@ class SourceFiles:
         :returns: a mapping of filename to content
         :rtype: dict(str, str)
         """
-        return self.spec.file_contents
+        result = dict(self.spec.file_contents)
+        if self.spec.mutate:
+            result['debian/mutate'] = str(self.spec.mutate)
+        return result
 
     @property
     def source_format(self):
diff --git a/gitubuntu/source_builder_test.py b/gitubuntu/source_builder_test.py
index e18e05f..9131a98 100644
--- a/gitubuntu/source_builder_test.py
+++ b/gitubuntu/source_builder_test.py
@@ -53,12 +53,12 @@ def test_source_is_created():
 
 
 def test_source_create_with_version(repo):
-    version = get_spec_changelog_version(repo, version='3')
+    version = get_spec_changelog_version(repo, version='3', native=True)
     assert version == '3'
 
 
 def test_source_create_with_versions(repo):
-    source_spec = target.SourceSpec(changelog_versions=['3', '4'])
+    source_spec = target.SourceSpec(changelog_versions=['3', '4'], native=True)
     with target.Source(source_spec) as f:
         tree_hash = importer.dsc_to_tree_hash(repo.raw_repo, f)
         changelog = repo.get_changelog_from_treeish(tree_hash)
@@ -110,6 +110,19 @@ def test_source_create_fails_with_absolute_path(repo):
             pass
 
 
+def test_source_mutate():
+    """mutate kwarg results in a debian/mutate file
+
+    If mutate is used, then a file called 'debian/mutate' should be generated
+    with the same contents.
+    """
+    source = target.Source(target.SourceSpec(mutate='foo'))
+
+    # It is sufficient to just verify spec_files contains what we want here as
+    # the spec_files functionality is checked in a separate test already.
+    assert source.files.spec_files['debian/mutate'] == 'foo'
+
+
 @pytest.mark.parametrize('native,expected', [
     (True, b"3.0 (native)\n"),
     (False, b"3.0 (quilt)\n"),
@@ -124,7 +137,7 @@ def test_source_native_source_format(repo, native, expected):
         assert blob.data == expected
 
 def test_source_quilt_no_patches(repo):
-    with target.Source(target.SourceSpec(native=False)) as dsc_path:
+    with target.Source(target.SourceSpec()) as dsc_path:
         top = dsc_path_to_tree(repo, dsc_path)
         debian_entry = top['debian']
         assert debian_entry.type == 'tree'
@@ -134,7 +147,7 @@ def test_source_quilt_no_patches(repo):
 
 
 def test_source_quilt_with_patches(repo):
-    spec = target.SourceSpec(native=False, has_patches=True)
+    spec = target.SourceSpec(has_patches=True)
     with target.Source(spec) as dsc_path:
         top = dsc_path_to_tree(repo, dsc_path)
         expected_files = ['series', 'a', 'b']
@@ -155,7 +168,7 @@ def test_source_quilt_with_patches(repo):
 
 
 def test_source_quilt_with_patches_applied(repo):
-    spec = target.SourceSpec(native=False, has_patches=True)
+    spec = target.SourceSpec(has_patches=True)
     with target.Source(spec) as dsc_path:
         top = dsc_path_to_tree(repo, dsc_path, patches_applied=True)
         expected_files = [
diff --git a/pytest.ini b/pytest.ini
new file mode 100644
index 0000000..d61d029
--- /dev/null
+++ b/pytest.ini
@@ -0,0 +1,2 @@
+[pytest]
+xfail_strict=true