Merge ~nacc/git-ubuntu:lp1731554-importer-rework-v2 into git-ubuntu:master

[Nish Aravamudan]

Make jenkins happy.

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

FAILED: Continuous integration, rev:cba2c4e9c38a2b68864425894b8df2a99378e31f
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/15/
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/15/rebuild

review: Needs Fixing (continuous-integration)

Unmerged commits

cba2c4e... by Nish Aravamudan on 2018-06-13

importer: rework algorithm to minimize looping

Basically, our current main importer loop looks like:

for applied in unapplied, applied:
    for dist in debian, ubuntu:
        for new publishes in $dist relative to $applied $dist branches
            import $applied publish
                this updates the branch pointer for the pocket + series
                if dist == 'ubuntu': this also updates the devel pointers

That is a fair amount of branch manipulation that will be discarded (the
series might have multiple publishes). Esp. on the first/reimport import
(worst case).

So instead:

for dist in debian, ubuntu:
    for applied in unapplied, applied:
        for new publishes in $dist relative to $applied $dist branches
            if publish has already been imported: continue
            import $applied publish

update all affected branch pointers,
    where affected is defined by running track of refs we *would* have
    updated in the original algorithm, and we also store the 'last'
    commit that it would have pointed to. This consolidates the branch
    and devel updates into one place as well.
    This also makes the importer algorithm match the spec on some level
    -- update the commit graph by importing only new publishes (which
    would create new import tags and new applied tags, while verifying
    any repeated publish data matches exactly) and then forcibly moving
    branch pointers to where they are "now" in Launchpad. The branch
    pointers are not part of the commit graph, so they change in a
    distinct step.

In my testing, this drops the reimport time for ipsec-tools from ~65
minutes to ~42 minutes consistently. We could probably speed it up more
starting from this base, if need be -- e.g., I'm not sure it makes sense
to to do the import action itself in the loop. Perhaps it's better to
accumulate the set of unique publishes in a set and then iterate that
set in a second loop.

Robie: this does not address your idempotency concern, yet, but I think
the solution is to make changes to importer::import_publishes so that
the order of publication events follows some specific rule. Right now,
it would be if it appears in Debian first, I think.

LP: #1731554

6dded16... by Nish Aravamudan on 2018-06-13

dsc: add compare_dsc method

FIXME: needs tests

c6e098f... by Nish Aravamudan on 2018-05-30

source_information: drop unused parent_{applied,}_head_name

These are no longer used after the importer publishing parent drop.

No functional change.

67662b8... by Nish Aravamudan on 2018-06-01

importer: fix patches-applied error

Used the wrong variable, should be squashed up.

b9ac1c3... by Nish Aravamudan on 2018-04-12

importer: fix importer algorithm to match spec

This is a large change, but the unit tests hopefully give us confidence
here.

The basic algorithm change is once we have the Git tree corresponding to
a DSC, we examine all suitable tags in the following order to determine
if the DSC has already been imported.

Patches-unapplied:
   Any existing import tag (includes reimport tags)
   Any existing upload tag
      - Algorithm change: import tag points directly to upload tag

Patches-applied:
   Any existing applied tag (includes reimport tags)

If a matching Tree tag is found, reuse the tagged Commit

If no matching Tree is found,

Patches-unapplied:
   Commit the Tree and import tag it (which might result in a reimport tag)

Patches-applied:
   Perform our patches-applied algorithm, commiting each interstitial
   tree, then commit the final Tree and applied tag it (which might result
   in a reimport tag)

In all cases, after find or creating an appropriate tag, move the
appropriate branch to point to it.

This is a significant simplification!

LP: #1761331
LP: #1754194
LP: #1754507
LP: #1754706
LP: #1734883
LP: #1761332
LP: #1763778

86a5c28... by Nish Aravamudan on 2018-04-12

importer: remove import tags that just point at upload tags

LP: #1734883

eed3b7c... by Nish Aravamudan on 2018-04-12

importer: fix detection of existing patches-applied imports

LP: #1763778

c1a66ef... by Nish Aravamudan on 2018-04-12

importer: various fixes related to tagged commits

What was before a single object (with the caller having to distinguish
between import and orphan tags) is now a list of objects always.

LP: #1755247

5404fa1... by Nish Aravamudan on 2018-04-12

importer: drop unused variable

No functional change

ffcb48d... by Nish Aravamudan on 2018-04-12

importer: purely cosmetic changes to fit with doc/STYLE.md

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
+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
+   - Create reimport tag
+
+3) No applied tags
+   - Create applied tag
diff --git a/gitubuntu/dsc.py b/gitubuntu/dsc.py
index 1fc3129..91a78ea 100644
--- a/gitubuntu/dsc.py
+++ b/gitubuntu/dsc.py
@@ -84,3 +84,41 @@ class GitUbuntuDsc(Dsc):
     @property
     def all_tarball_paths(self):
         return [self.orig_tarball_path] + list(self.component_tarball_paths.values())
+
+    def _compare_dsc(self, other, field, key):
+        if field not in self or field not in other:
+            return False
+        our_checksums = dict(
+            (entry['name'], (int(entry['size']), entry[key]))
+            for entry in self[field]
+        )
+        their_checksums = dict(
+            (entry['name'], (int(entry['size']), entry[key]))
+            for entry in other[field]
+        )
+        # check that every file in ours is in theirs
+        for name, (size, checksum) in our_checksums.items():
+            if name not in their_checksums:
+                return False
+            if size != their_checksums[name][0] or checksum != their_checksums[name][1]:
+                return False
+        # check that every file in theirs is in ours
+        for name, (size, checksum) in their_checksums.items():
+            if name not in our_checksums:
+                return False
+            if size != our_checksums[name][0] or checksum != our_checksums[name][1]:
+                return False
+        # all files in ours and theirs for this hash match
+        return True
+
+    def compare_dsc(self, other):
+        """Check whether some set of hashes in these two dscs are
+        identical
+        """
+        return any(
+            self._compare_dsc(other, field, key) for field, key in (
+                ('Checksums-Sha256', 'sha256'),
+                ('Checksums-Sha1', 'sha1'),
+                ('Files', 'md5sum'),
+            )
+        )
diff --git a/gitubuntu/git_repository.py b/gitubuntu/git_repository.py
index 2a7d4dd..dc1e390 100644
--- a/gitubuntu/git_repository.py
+++ b/gitubuntu/git_repository.py
@@ -742,9 +742,6 @@ def upload_tag(version, namespace):
 def upstream_tag(version, namespace):
     return '%s/upstream/%s' % (namespace, git_dep14_tag(version))
 
-def orphan_tag(version, namespace):
-    return '%s/orphan/%s' % (namespace, git_dep14_tag(version))
-
 def is_dir_3_0_quilt(_dir=None):
     _dir = _dir if _dir else '.'
     try:
@@ -930,6 +927,25 @@ class GitUbuntuRepository:
             self.git_run(['checkout', '--orphan', 'master'])
 
     @contextmanager
+    def dsc_branch(self, dist, namespace='pkg'):
+        """Context manager wrapping dsc branch manipulation
+
+        In this context, HEAD will point to the dsc branch for
+        @namespace.
+        """
+        dsc_branch_name = '%s/importer/%s/dsc' % (namespace, dist)
+        if not self.raw_repo.lookup_branch(dsc_branch_name):
+            self.create_orphan_branch(
+                dsc_branch_name,
+                'Initial %s dsc branch.' % dist,
+            )
+        with self.temporary_worktree(dsc_branch_name):
+            try:
+                yield
+            except:
+                raise
+
+    @contextmanager
     def pristine_tar_branches(self, dist, namespace='pkg', create=True):
         """Context manager wrapping pristine-tar branch manipulation
 
@@ -1604,16 +1620,15 @@ class GitUbuntuRepository:
                 'Cannot get changelog source package name'
             )
 
-    def get_heads_and_versions(self, head_prefix, namespace):
+    def get_heads_and_versions(self, head_ref_namespace):
         """Extract the last version in debian/changelog of all
-        '<namespace>/<head_prefix>/debian/*' and
-        '<namespace>/<head_prefix>/ubuntu/*' branches.
+        '<namespace>/debian/*' and
+        '<namespace>/ubuntu/*' branches.
         """
         versions = dict()
         errors = False
         for head in self.local_branches:
-            prefix = '%s/%s' % (namespace, head_prefix)
-            if not head.branch_name.startswith(prefix):
+            if not head.branch_name.startswith(head_ref_namespace):
                 continue
             if 'ubuntu/devel' in head.branch_name:
                 continue
@@ -1679,9 +1694,6 @@ class GitUbuntuRepository:
     def get_upstream_tag(self, version, namespace):
         return self.get_tag_reference(upstream_tag(version, namespace))
 
-    def get_orphan_tag(self, version, namespace):
-        return self.get_tag_reference(orphan_tag(version, namespace))
-
     def create_tag(self, commit_hash, tag_name, tag_msg):
         self.git_run(
             [
diff --git a/gitubuntu/importer.py b/gitubuntu/importer.py
index d6b9db8..7b9a40d 100644
--- a/gitubuntu/importer.py
+++ b/gitubuntu/importer.py
@@ -15,7 +15,6 @@
 #	Ubuntu tracking branch, OR match a newer parent version tag in debian
 #	tracking branch.
 #	Import will use the verified parent as the parent commit.
-# If verification fails, then import anyway, but log and use an orphan commit.
 #
 # Results in a set of branches (git heads):
 #    - One per distribution/series/pocket
@@ -25,8 +24,6 @@
 #       + the last imported version from debian/changelog
 
 import argparse
-import functools
-import getpass
 import logging
 import os
 import re
@@ -45,17 +42,15 @@ from gitubuntu.dsc import (
 from gitubuntu.git_repository import (
     GitUbuntuRepository,
     GitUbuntuRepositoryFetchError,
-    orphan_tag,
     applied_tag,
     import_tag,
     reimport_tag,
     applied_reimport_tag,
-    upstream_tag,
     PristineTarError,
     is_dir_3_0_quilt,
 )
+import gitubuntu.importerutils
 from gitubuntu.run import (
-    decode_binary,
     run,
     runq,
     run_gbp,
@@ -204,74 +199,6 @@ def _main_with_repo(
         except GitUbuntuRepositoryFetchError:
             pass
 
-    debian_sinfo = GitUbuntuSourceInformation(
-        'debian',
-        pkgname,
-        os.path.abspath(pullfile),
-        retries,
-        retry_backoffs,
-    )
-
-    ubuntu_sinfo = GitUbuntuSourceInformation(
-        'ubuntu',
-        pkgname,
-        os.path.abspath(pullfile),
-        retries,
-        retry_backoffs,
-    )
-
-    debian_head_versions = (
-        repo.get_heads_and_versions('debian', namespace)
-    )
-    for head_name in sorted(debian_head_versions):
-        _, _, pretty_head_name = head_name.partition('%s/' % namespace)
-        logging.debug('Last imported %s version is %s',
-            pretty_head_name,
-            debian_head_versions[head_name]['version']
-        )
-
-    ubuntu_head_versions = (
-        repo.get_heads_and_versions('ubuntu', namespace)
-    )
-    for head_name in sorted(ubuntu_head_versions):
-        _, _, pretty_head_name = head_name.partition('%s/' % namespace)
-        logging.debug('Last imported %s version is %s',
-            pretty_head_name,
-            ubuntu_head_versions[head_name]['version']
-        )
-
-    if not skip_applied:
-        applied_debian_head_versions = (
-            repo.get_heads_and_versions(
-                'applied/debian', namespace
-            )
-        )
-        for head_name in sorted(applied_debian_head_versions):
-            _, _, pretty_head_name = head_name.partition(
-                '%s/' % namespace
-            )
-            logging.debug('Last applied %s version is %s',
-                pretty_head_name,
-                applied_debian_head_versions[head_name]['version']
-            )
-
-        applied_ubuntu_head_versions = (
-            repo.get_heads_and_versions(
-                'applied/ubuntu', namespace
-            )
-        )
-        for head_name in sorted(applied_ubuntu_head_versions):
-            _, _, pretty_head_name = head_name.partition(
-                '%s/' % namespace
-            )
-            logging.debug('Last applied %s version is %s',
-                pretty_head_name,
-                applied_ubuntu_head_versions[head_name]['version']
-            )
-
-    oldcwd = os.getcwd()
-    os.chdir(repo.local_dir)
-
     if dl_cache is None:
         workdir = os.path.join(repo.git_dir, CACHE_PATH)
     else:
@@ -281,20 +208,22 @@ def _main_with_repo(
 
     parent_overrides = parse_parentfile(parentfile, pkgname)
 
+    oldcwd = os.getcwd()
+    os.chdir(repo.local_dir)
+
     only_debian, history_found = import_publishes(
         repo=repo,
         pkgname=pkgname,
         namespace=namespace,
-        patches_applied=False,
-        debian_head_versions=debian_head_versions,
-        ubuntu_head_versions=ubuntu_head_versions,
-        debian_sinfo=debian_sinfo,
-        ubuntu_sinfo=ubuntu_sinfo,
         active_series_only=active_series_only,
         workdir=workdir,
         skip_orig=skip_orig,
+        skip_applied=skip_applied,
         allow_applied_failures=allow_applied_failures,
         parent_overrides=parent_overrides,
+        pullfile=pullfile,
+        retries=retries,
+        retry_backoffs=retry_backoffs,
     )
 
     if not history_found:
@@ -302,30 +231,6 @@ def _main_with_repo(
                       "Wrong source package name?", pkgname)
         return 1
 
-    if not skip_applied:
-        import_publishes(
-            repo=repo,
-            pkgname=pkgname,
-            namespace=namespace,
-            patches_applied=True,
-            debian_head_versions=applied_debian_head_versions,
-            ubuntu_head_versions=applied_ubuntu_head_versions,
-            debian_sinfo=debian_sinfo,
-            ubuntu_sinfo=ubuntu_sinfo,
-            active_series_only=active_series_only,
-            workdir=workdir,
-            skip_orig=skip_orig,
-            allow_applied_failures=allow_applied_failures,
-            parent_overrides=parent_overrides,
-        )
-
-    update_devel_branches(
-        repo=repo,
-        namespace=namespace,
-        pkgname=pkgname,
-        ubuntu_sinfo=ubuntu_sinfo,
-    )
-
     os.chdir(oldcwd)
 
     repo.garbage_collect()
@@ -489,14 +394,15 @@ def main(
 def get_changelog_for_commit(
     repo,
     tree_hash,
-    changelog_parent_commit,
+    changelog_parent_commits,
 ):
     """Extract changes to debian/changelog in this publish
 
     LP: #1633114 -- favor the changelog parent's diff
     """
     raw_clog_entry = b''
-    if changelog_parent_commit is not None:
+    if len(changelog_parent_commits) == 1:
+        changelog_parent_commit = changelog_parent_commits[0]
         cmd = ['diff-tree', '-p', changelog_parent_commit,
                tree_hash, '--', 'debian/changelog']
         raw_clog_entry, _ = repo.git_run(cmd, decode=False)
@@ -527,11 +433,9 @@ def get_changelog_for_commit(
 def get_import_commit_msg(
     repo,
     version,
-    target_head_name,
     namespace,
     tree_hash,
-    changelog_parent_commit,
-    upload_parent_commit,
+    changelog_parent_commits,
     unapplied_parent_commit,
 ):
     if unapplied_parent_commit:
@@ -540,28 +444,24 @@ def get_import_commit_msg(
         import_type = 'patches-unapplied'
 
     # Do not show importer/ namespace to user
-    _, _, pretty_head_name = target_head_name.partition('%s/' % namespace)
     changelog_entry = get_changelog_for_commit(
         repo,
         tree_hash,
-        changelog_parent_commit
+        changelog_parent_commits,
     )
 
     msg = (
-        b'Import %s version %b to %b\n\nImported using git-ubuntu import.' % (
+        b'Import %s version %b\n\nImported using git-ubuntu import.' % (
             import_type.encode(),
             version.encode(),
-            pretty_head_name.encode(),
         )
     )
 
-    if any([changelog_parent_commit, upload_parent_commit, unapplied_parent_commit]):
+    if changelog_parent_commits or unapplied_parent_commit:
         msg += b'\n'
 
-    if changelog_parent_commit is not None:
+    for changelog_parent_commit in changelog_parent_commits:
         msg += b'\nChangelog parent: %b' % changelog_parent_commit.encode()
-    if upload_parent_commit is not None:
-        msg += b'\nUpload parent: %b' % upload_parent_commit.encode()
     if unapplied_parent_commit is not None:
         msg += b'\nUnapplied parent: %b' % unapplied_parent_commit.encode()
 
@@ -572,11 +472,9 @@ def get_import_commit_msg(
 def _commit_import(
     repo,
     version,
-    target_head_name,
     tree_hash,
     namespace,
-    changelog_parent_commit,
-    upload_parent_commit,
+    changelog_parent_commits,
     unapplied_parent_commit,
     fallback_author,
     fallback_date,
@@ -593,11 +491,10 @@ def _commit_import(
          which the source package contents corresponding to @spi should
          be imported.
     :param version str Changelog version
-    :param target_head_name str Git branch name to import to
     :param namespace str Namespace under which relevant refs can be
          found.
-    :param changelog_parent_commit str Git commit hash of
-         changelog parent.
+    :param changelog_parent_commits list(str) Git commit hashes of
+         changelog parents.
     :param upload_parent_commit str Git commit hash of
          upload parent. Should be None if patches-applied import.
     :param unapplied_parent_commit str Git commit hash of unapplied
@@ -610,18 +507,10 @@ def _commit_import(
     :rtype str
     :returns Hash of created commit
     """
-    changelog_entry = get_changelog_for_commit(
-        repo,
-        tree_hash,
-        changelog_parent_commit
-    )
-
     parents = []
 
-    if changelog_parent_commit is not None:
-        parents.append(changelog_parent_commit)
-    if upload_parent_commit is not None:
-        parents.append(upload_parent_commit)
+    if changelog_parent_commits:
+        parents.extend(changelog_parent_commits)
     if unapplied_parent_commit is not None:
         parents.append(unapplied_parent_commit)
 
@@ -631,11 +520,9 @@ def _commit_import(
         get_import_commit_msg(
             repo=repo,
             version=version,
-            target_head_name=target_head_name,
             namespace=namespace,
             tree_hash=tree_hash,
-            changelog_parent_commit=changelog_parent_commit,
-            upload_parent_commit=upload_parent_commit,
+            changelog_parent_commits=changelog_parent_commits,
             unapplied_parent_commit=unapplied_parent_commit,
         ),
         fallback_author,
@@ -647,53 +534,76 @@ def _commit_import(
 def commit_unapplied_patches_import(
     repo,
     version,
-    head_name,
     import_tree_hash,
     namespace,
-    changelog_parent_commit,
-    upload_parent_commit,
+    changelog_parent_commits,
     fallback_author,
     fallback_date,
 ):
     return _commit_import(
         repo,
         version,
-        head_name,
         import_tree_hash,
         namespace,
-        changelog_parent_commit,
-        upload_parent_commit,
+        changelog_parent_commits,
         # unapplied trees do not have a distinct unapplied parent
         None,
         fallback_author,
         fallback_date,
     )
 
-def commit_applied_patches_import(
+
+def dsc_imported(
     repo,
-    version,
-    head_name,
-    import_tree_hash,
+    spi,
     namespace,
-    changelog_parent_commit,
-    unapplied_parent_commit,
-    fallback_author,
-    fallback_date,
+    distname,
 ):
-    return _commit_import(
-        repo,
-        version,
-        head_name,
-        import_tree_hash,
-        namespace,
-        changelog_parent_commit,
-        # uploads will be unapplied trees currently, so applied trees
-        # can not have them as direct parents
-        None,
-        unapplied_parent_commit,
-        fallback_author,
-        fallback_date,
-    )
+    # always check if the same dist has a matching dsc
+    with repo.dsc_branch(
+        namespace=namespace,
+        dist=distname,
+    ):
+        cached_dsc_path = os.path.join(
+            os.getcwd(),
+            spi.version,
+            os.path.basename(spi.dsc_pathname),
+        )
+
+        if os.path.exists(cached_dsc_path):
+            # If we have imported this version before, compare the
+            # DSC in the DSC branch to this one
+            imported_dsc = GitUbuntuDsc(cached_dsc_path)
+            return GitUbuntuDsc(spi.dsc_pathname).compare_dsc(imported_dsc)
+
+    # if a debian dsc exists and matches, but an ubuntu dsc does not
+    # exist, import the ubuntu dsc, but signal that a full import is
+    # not necessary
+    if distname == 'ubuntu':
+        with repo.dsc_branch(
+            namespace=namespace,
+            dist='debian',
+        ):
+            imported_dsc_path = os.path.join(
+                os.getcwd(),
+                spi.version,
+                os.path.basename(spi.dsc_pathname),
+            )
+
+            if os.path.exists(imported_dsc_path):
+                # If we have imported this version before, compare the
+                # DSC in the DSC branch to this one
+                imported_dsc = GitUbuntuDsc(imported_dsc_path)
+                if GitUbuntuDsc(spi.dsc_pathname).compare_dsc(imported_dsc):
+                    import_dsc(
+                        repo,
+                        GitUbuntuDsc(spi.dsc_pathname),
+                        namespace,
+                        str(spi.version),
+                        spi.distribution.name.lower(),
+                    )
+                    return True
+    return False
 
 def import_dsc(repo, dsc, namespace, version, dist):
     """Imports the dsc file to importer/{debian,ubuntu}/dsc
@@ -1018,45 +928,40 @@ def get_existing_applied_tags(repo, version, namespace):
 
 def override_parents(parent_overrides, repo, version, namespace):
     """
-    returns: (unapplied, applied) where both elements of the tuple are commit
-        hash strings of the changelog parent to use, incorporating any defined
-        overrides.
-    rtype: tuple(str, str)
+    returns: (unapplied, applied) where both elements of the tuple are
+        lists of commit hash strings of the changelog parent to use,
+        incorporating any defined overrides.
+    rtype: tuple(list(str), list(str))
     """
-    unapplied_changelog_parent_commit = None
-    applied_changelog_parent_commit = None
+    unapplied_changelog_parent_commits = []
+    applied_changelog_parent_commits = []
 
-    unapplied_changelog_parent_tag = repo.get_import_tag(
+    unapplied_changelog_parent_tags = get_existing_import_tags(
+        repo,
         parent_overrides[version]['changelog_parent'],
-        namespace
+        namespace,
     )
-    applied_changelog_parent_tag = repo.get_applied_tag(
+    applied_changelog_parent_tags = get_existing_applied_tags(
+        repo,
         parent_overrides[version]['changelog_parent'],
-        namespace
+        namespace,
     )
-    if unapplied_changelog_parent_tag is not None:
-        # sanity check that version from d/changelog of the
-        # tagged commit matches ours
-        parent_changelog_version, _ = repo.get_changelog_versions_from_treeish(
-            str(unapplied_changelog_parent_tag.peel().id),
-        )
-        if parent_changelog_version != parent_overrides[version]['changelog_parent']:
-            logging.error('Found a tag corresponding to '
-                          'changelog parent override '
-                          'version %s, but d/changelog '
-                          'version (%s) differs. Will '
-                          'orphan commit.' % (
-                          parent_overrides[version]['changelog_parent'],
-                          parent_changelog_version
-                          )
-                         )
-        else:
-            unapplied_changelog_parent_commit = str(unapplied_changelog_parent_tag.peel().id)
-            if applied_changelog_parent_tag is not None:
-                applied_changelog_parent_commit = str(applied_changelog_parent_tag.peel().id)
-            logging.debug('Overriding changelog parent (tag) to %s',
-                repo.tag_to_pretty_name(unapplied_changelog_parent_tag)
-            )
+    # sanity check that version from d/changelog of the
+    # tagged commit matches ours
+    if any(
+        repo.get_changelog_versions_from_treeish(
+            str(tag.peel(pygit2.Tree).id)
+        )[0] == parent_overrides[version]['changelog_parent']
+        for tag in unapplied_changelog_parent_tags
+    ):
+        unapplied_changelog_parent_commits = [
+            str(tag.peel(pygit2.Commit).id)
+            for tag in unapplied_changelog_parent_tags
+        ]
+        applied_changelog_parent_commits = [
+            str(tag.peel(pygit2.Commit).id)
+            for tag in applied_changelog_parent_tags
+        ]
     else:
         if parent_overrides[version]['changelog_parent'] == '-':
             logging.debug('Not setting changelog parent as specified '
@@ -1071,8 +976,8 @@ def override_parents(parent_overrides, repo, version, namespace):
                 )
             )
     return (
-        unapplied_changelog_parent_commit,
-        applied_changelog_parent_commit,
+        unapplied_changelog_parent_commits,
+        applied_changelog_parent_commits,
     )
 
 def _devel_branch_updates(
@@ -1100,7 +1005,7 @@ def _devel_branch_updates(
 
     devel_hash = None
     devel_name = None
-    devel_branch_name = ref_prefix + 'ubuntu/devel'
+    devel_branch_name = "%s/devel" % ref_prefix
 
     for series_name in series_name_list:
         series_devel_hash = None
@@ -1109,7 +1014,7 @@ def _devel_branch_updates(
         # Find highest version publish in these pockets, favoring this
         # order of pockets
         for suff in ['-proposed', '-updates', '-security', '']:
-            name = "%subuntu/%s%s" % (ref_prefix, series_name, suff)
+            name = "%s/%s%s" % (ref_prefix, series_name, suff)
             if name in head_versions:
                 head_commit, head_version = head_versions[name]
                 if version_compare(head_version, series_devel_version) > 0:
@@ -1117,7 +1022,7 @@ def _devel_branch_updates(
                     series_devel_version = head_version
                     series_devel_hash = head_commit
         if series_devel_hash:
-            series_devel_branch_name = '%subuntu/%s-devel' % (
+            series_devel_branch_name = '%s/%s-devel' % (
                 ref_prefix,
                 series_name,
             )
@@ -1132,62 +1037,73 @@ def _devel_branch_updates(
                 devel_name = series_devel_name
                 devel_hash = series_devel_hash
 
-    yield ref_prefix + 'ubuntu/devel', devel_hash
+    yield devel_branch_name, devel_hash
 
 
-def update_devel_branches(
+def update_branches(
+    distname,
+    dist_sinfo,
     repo,
     namespace,
     pkgname,
-    ubuntu_sinfo,
+    updated_head_refs,
 ):
-    """update_devel_branches - move the 'meta' -devel branches to the
-    latest publication in each series
+    """update_branches - move the series+pocket branches to the
+    latest appropriate publication in each series
 
     For all known series in @ubuntu_sinfo, update the
     ubuntu/series-devel branch to the latest version in the series'
     pocket branches.
 
-    Update the ubuntu/devel branch to the latest ubuntu/series-devel
-    branch.
-
-    Do this for both the unapplied and applied branches.
+    If distname is 'ubuntu', ubuntu/<series>-devel branches are also
+    updated, and ubuntu/devel will point to the latest
+    ubuntu/<series>-devel branch.
 
     Arguments:
-    repo - gitubuntu.git_repository.GitUbuntuRepository object
-    pkgname - string source package name
-    namespace - string namespace under which the relevant branch refs
-    can be found
-    ubuntu_sinfo - GitUbuntuSourceInformation object for the ubuntu
-    archive
+    distname str: distribution name (one of 'debian', 'ubuntu')
+    dist_sinfo gitubuntu.source_information.GitUbuntuSourceInformation:
+        Launchpad publication data for a given distribution
+    repo gitubuntu.git_repository.GitUbuntuRepository object: repository
+        to act on
+    namespace str: namespace under which the relevant branch
+        refs can be found
+    pkgname str: source package name
     """
-    for applied_prefix in ['', 'applied/']:
-        head_versions = {
-            ref: (str(target['head'].peel().id), target['version'])
-            for ref, target in repo.get_heads_and_versions(
-                    '%subuntu' % applied_prefix,
-                    namespace=namespace,
-                ).items()
-        }
-        for ref, commit in _devel_branch_updates(
-            ref_prefix=('%s/%s' % (namespace, applied_prefix)),
-            head_versions=head_versions,
-            series_name_list=ubuntu_sinfo.all_series_name_list,
-        ):
-            if commit is None:
-                logging.warn(
-                    "Source package '%s' does not appear to have been published "
-                    "in Ubuntu. No %s created.",
-                    pkgname,
-                    ref,
-                )
-            else:
-                logging.debug(
-                    "Setting %s to '%s'",
-                    ref,
-                    commit,
-                )
-                repo.update_head_to_commit(ref, commit)
+    for ref, commit_hash in updated_head_refs.items():
+        repo.update_head_to_commit(
+            ref,
+            commit_hash,
+        )
+
+    if distname == 'debian':
+        return
+
+    head_versions = {
+        ref: (str(target['head'].peel().id), target['version'])
+        for ref, target in repo.get_heads_and_versions(
+             namespace,
+        ).items()
+    }
+
+    for ref, commit in _devel_branch_updates(
+        ref_prefix=namespace,
+        head_versions=head_versions,
+        series_name_list=dist_sinfo.all_series_name_list
+    ):
+        if commit is None:
+            logging.warn(
+                "Source package '%s' does not appear to have been published "
+                "in Ubuntu. No %s created.",
+                pkgname,
+                ref,
+            )
+        else:
+            logging.debug(
+                "Setting %s to '%s'",
+                ref,
+                commit,
+            )
+            repo.update_head_to_commit(ref, commit)
 
 
 def get_import_tag_msg():
@@ -1294,7 +1210,7 @@ def create_import_tag(repo, commit_hash, version, namespace):
         return repo.get_import_tag(version, namespace)
 
 
-def get_changelog_parent_commit(
+def get_changelog_parent_commits(
     repo,
     namespace,
     parent_overrides,
@@ -1320,44 +1236,52 @@ def get_changelog_parent_commit(
 
     for version in import_tree_versions:
         if patches_applied:
-            changelog_parent_tag = repo.get_applied_tag(
+            changelog_parent_tags = get_existing_applied_tags(
+                repo,
                 version,
                 namespace,
             )
         else:
-            changelog_parent_tag = repo.get_import_tag(
-                version,
-                namespace,
-            ) or repo.get_orphan_tag(
+            changelog_parent_tags = get_existing_import_tags(
+                repo,
                 version,
                 namespace,
             )
 
-        if not changelog_parent_tag:
+        if not changelog_parent_tags:
             continue
 
         # sanity check that version from d/changelog of the
         # tagged parent matches ours
-        changelog_parent_version, _ = repo.get_changelog_versions_from_treeish(
-            str(changelog_parent_tag.peel(pygit2.Tree).id)
-        )
+        changelog_parent_versions = [
+            repo.get_changelog_versions_from_treeish(
+                str(tag.peel(pygit2.Tree).id)
+            )[0] for tag in changelog_parent_tags
+        ]
 
         # if the parent was imported via a parent override
         # itself, assume it is valid without checking its
         # tree's debian/changelog, as it wasn't used
         if (version in parent_overrides or
-            changelog_parent_version == version
-        ):
-            changelog_parent_commit = str(
-                changelog_parent_tag.peel(pygit2.Commit).id
+            any(
+                [changelog_parent_version == version
+                 for changelog_parent_version in changelog_parent_versions]
             )
-
-            logging.debug("Changelog parent (tag) is %s",
-                repo.tag_to_pretty_name(changelog_parent_tag)
+        ):
+            changelog_parent_commits = [
+                str(tag.peel(pygit2.Commit).id)
+                for tag in changelog_parent_tags
+            ]
+
+            logging.debug("Changelog parent(s) (tag(s)) are %s",
+                [
+                    repo.tag_to_pretty_name(tag) for tag in
+                    changelog_parent_tags
+                ]
             )
-            return changelog_parent_commit
+            return changelog_parent_commits
 
-    return None
+    return []
 
 
 def import_unapplied_dsc(
@@ -1366,7 +1290,6 @@ def import_unapplied_dsc(
     namespace,
     dist,
     dsc_pathname,
-    head_name,
     skip_orig,
     parent_overrides,
     fallback_author,
@@ -1382,7 +1305,6 @@ def import_unapplied_dsc(
          found.
     :param dist str Either 'debian' or 'ubuntu' or None
     :param dsc_pathname str Filesystem path to a DSC file
-    :param head_name str Git branch name to import the DSC to
     :param skip_orig bool If True, do not attempt to import orig
          tarballs. Useful for debug import runs to make them as fast as
          possible, or to workaround pristine-tar issues.
@@ -1394,9 +1316,6 @@ def import_unapplied_dsc(
 
     :rtype None
     """
-    unapplied_tip_head = repo.get_head_by_name(head_name)
-    _, _, pretty_head_name = head_name.partition('%s/' % namespace)
-
     import_dsc(
         repo,
         GitUbuntuDsc(dsc_pathname),
@@ -1445,26 +1364,6 @@ def import_unapplied_dsc(
             'source pkg version: {} != changelog version: {}'.format(
                 version, changelog_version))
 
-    unapplied_tip_version = None
-    # check if the version to import has already been imported to
-    # this head
-    if unapplied_tip_head is not None:
-        if repo.treeishs_identical(
-            unapplied_import_tree_hash, str(unapplied_tip_head.peel().id)
-        ):
-            logging.warn('%s is identical to %s',
-                         pretty_head_name, version
-                        )
-            return
-        unapplied_tip_version, _ = repo.get_changelog_versions_from_treeish(
-                             str(unapplied_tip_head.peel().id),
-                                                                 )
-
-    logging.debug('Tip version is %s', unapplied_tip_version)
-
-    unapplied_changelog_parent_commit = None
-    upload_parent_commit = None
-
     if version in parent_overrides:
         logging.debug(
             '%s is specified in the parent override file.',
@@ -1473,7 +1372,7 @@ def import_unapplied_dsc(
 
         try:
             (
-                unapplied_changelog_parent_commit,
+                unapplied_changelog_parent_commits,
                 _
             ) = override_parents(
                 parent_overrides,
@@ -1485,15 +1384,7 @@ def import_unapplied_dsc(
             logging.error("%s" % e)
             return
     else:
-        if version_compare(version, unapplied_tip_version) <= 0:
-            logging.warn(
-                 "Version to import (%s) is not after %s tip (%s)",
-                 version,
-                 pretty_head_name,
-                 unapplied_tip_version,
-            )
-
-        unapplied_changelog_parent_commit = get_changelog_parent_commit(
+        unapplied_changelog_parent_commits = get_changelog_parent_commits(
             repo,
             namespace,
             parent_overrides,
@@ -1501,111 +1392,52 @@ def import_unapplied_dsc(
             patches_applied=False,
         )
 
-    # check if the version to import has already been uploaded to
-    # this head -- we leverage the above code to perform a 'dry-run'
-    # of the import tree, to obtain the changelog parent
+    # we can only now be in this method, if the spi (dsc) has not been
+    # imported before, so we do not need to check for an existing import
+    # tag
+    target_tag = None
     existing_upload_tag = repo.get_upload_tag(version, namespace)
-    existing_import_tag = repo.get_import_tag(version, namespace)
-    existing_orphan_tag = repo.get_orphan_tag(version, namespace)
-    if existing_import_tag:
-        if str(existing_import_tag.peel().tree.id) != unapplied_import_tree_hash:
-            logging.error(
-                "Found import tag %s, but the corresponding tree "
-                "does not match the published version. Will orphan commit.",
-                repo.tag_to_pretty_name(existing_import_tag),
-            )
-            unapplied_changelog_parent_commit = None
-        else:
-            repo.update_head_to_commit(
-                head_name,
-                str(existing_import_tag.peel().id),
-            )
-            return
-    elif existing_orphan_tag:
-        if str(existing_orphan_tag.peel().tree.id) != unapplied_import_tree_hash:
-            raise Exception(
-                "Found orphan tag %s, but the corresponding tree "
-                "does not match the published version. We cannot "
-                "currently support multiple orphan tags for the same "
-                "published version and will now exit.",
-                repo.tag_to_pretty_name(existing_orphan_tag),
-            )
-        else:
-            repo.update_head_to_commit(
-                head_name,
-                str(existing_orphan_tag.peel().id),
-            )
-            return
-    elif existing_upload_tag:
-        if str(existing_upload_tag.peel().tree.id) != unapplied_import_tree_hash:
-            logging.warn(
-                "Found upload tag %s, but the corresponding tree "
-                "does not match the published version. Will import %s as "
-                "normal, ignoring the upload tag.",
-                repo.tag_to_pretty_name(existing_upload_tag),
-                version,
-            )
-        else:
-            upload_parent_commit = str(existing_upload_tag.peel().id)
-
-            if unapplied_changelog_parent_commit is not None:
+    if existing_upload_tag:
+        if str(existing_upload_tag.peel(pygit2.Tree).id) == unapplied_import_tree_hash:
+            for unapplied_changelog_parent_commit in unapplied_changelog_parent_commits:
                 try:
                     repo.git_run(
                         [
                             'merge-base',
                             '--is-ancestor',
                             unapplied_changelog_parent_commit,
-                            upload_parent_commit,
+                            str(existing_upload_tag.peel(pygit2.Commit).id),
                         ],
                         verbose_on_failure=False,
                     )
-                    unapplied_changelog_parent_commit = None
+                    commit_hash = str(existing_upload_tag.peel(pygit2.Commit).id)
+                    target_tag = create_import_tag(repo, commit_hash, version, namespace)
+                    break
                 except CalledProcessError as e:
                     if e.returncode != 1:
                         raise
+            else:
+                logging.warning(
+                    "An upload tag was found for version %s, however it "
+                    "does not have any appropriate Git ancestor (for the "
+                    "prior changelog version). This is currently unsupported "
+                    "and we will not integrate this upload tag.",
+                    version,
+                )
 
-    commit_hash = commit_unapplied_patches_import(
-        repo,
-        version,
-        head_name,
-        unapplied_import_tree_hash,
-        namespace,
-        unapplied_changelog_parent_commit,
-        upload_parent_commit,
-        fallback_author,
-        fallback_date,
-    )
-    logging.debug(
-        "Committed patches-unapplied import of %s as %s in %s",
-        version,
-        commit_hash,
-        pretty_head_name,
-    )
-
-    tag = None
-    if repo.get_import_tag(version, namespace) is None:
-        # Not imported before
-        tag = import_tag(version, namespace)
-    elif (
-        unapplied_changelog_parent_commit is None and
-        upload_parent_commit is None and
-        head_name in repo.local_branch_names
-    ):
-        # No parents and not creating a new branch
-        tag = orphan_tag(version, namespace)
-
-    if tag:
-        logging.debug("Creating tag %s pointing to %s", tag, commit_hash)
-        repo.create_tag(
-            commit_hash=commit_hash,
-            tag_name=tag,
-            tag_msg=get_import_tag_msg(),
+    if not target_tag:
+        commit_hash = commit_unapplied_patches_import(
+            repo=repo,
+            version=version,
+            import_tree_hash=unapplied_import_tree_hash,
+            namespace=namespace,
+            changelog_parent_commits=unapplied_changelog_parent_commits,
+            fallback_author=fallback_author,
+            fallback_date=fallback_date,
         )
+        target_tag = create_import_tag(repo, commit_hash, version, namespace)
 
-    repo.update_head_to_commit(
-        head_name,
-        commit_hash,
-    )
+    return str(target_tag.peel(pygit2.Commit).id)
 
 # imports a package based upon source package information
 def import_unapplied_spi(
@@ -1618,6 +1450,8 @@ def import_unapplied_spi(
     """Imports a publication record from Launchpad into the git
     repository
 
+    Only called if the version has not been imported before
+
     :param repo gitubuntu.GitUbuntuRepository The Git repository into
          which the source package contents corresponding to @spi should
          be imported.
@@ -1632,11 +1466,11 @@ def import_unapplied_spi(
 
     :rtype None
     """
-    pretty_head_name = spi.pretty_head_name
+    logging.info('Importing patches-unapplied %s', spi.version)
 
-    logging.info('Importing patches-unapplied %s to %s',
-        spi.version, pretty_head_name
-    )
+    # This assert feels right, but I think will be wrong for the case of
+    # reimports
+    # assert not repo.get_import_tag(spi.version, namespace)
 
     spi.pull()
 
@@ -1649,13 +1483,12 @@ def import_unapplied_spi(
     if spi.date_published:
         fallback_date = str(spi.date_published)
 
-    import_unapplied_dsc(
+    return import_unapplied_dsc(
         repo=repo,
         version=str(spi.version),
         namespace=namespace,
         dist=spi.distribution.name.lower(),
         dsc_pathname=spi.dsc_pathname,
-        head_name=spi.head_name(namespace),
         skip_orig=skip_orig,
         parent_overrides=parent_overrides,
         fallback_author=fallback_author,
@@ -1668,7 +1501,6 @@ def import_applied_dsc(
     namespace,
     dist,
     dsc_pathname,
-    head_name,
     allow_applied_failures,
     parent_overrides,
     fallback_author,
@@ -1684,7 +1516,6 @@ def import_applied_dsc(
          found.
     :param dist str Either 'debian' or 'ubuntu' or None
     :param dsc_pathname str Filesystem path to a DSC file
-    :param head_name str Git branch name to import the DSC to
     :param allow_applied_failures bool If True, failure to apply quilt
          patches is not fatal.
     :param parent_overrides dict See parse_parentfile.
@@ -1695,12 +1526,18 @@ def import_applied_dsc(
 
     :rtype None
     """
-    applied_tip_head = repo.get_head_by_name(head_name)
-    _, _, pretty_head_name = head_name.partition('%s/' % namespace)
-
-    unapplied_parent_tag = repo.get_import_tag(version, namespace)
-    unapplied_parent_commit = str(unapplied_parent_tag.peel().id)
-    unapplied_import_tree_hash = str(unapplied_parent_tag.peel(pygit2.Tree).id)
+    unapplied_parent_tags = get_existing_import_tags(
+        repo,
+        version,
+        namespace,
+    )
+    unapplied_import_tree_hash = dsc_to_tree_hash(
+        repo.raw_repo,
+        dsc_pathname,
+    )
+    for tag in unapplied_parent_tags:
+        if str(tag.peel(pygit2.Tree).id) == unapplied_import_tree_hash:
+            unapplied_parent_commit = str(tag.peel(pygit2.Commit).id)
 
     # this is the result of all patches being applied
     applied_import_tree_hash = dsc_to_tree_hash(
@@ -1716,37 +1553,21 @@ def import_applied_dsc(
     )
 
     import_tree_versions = repo.get_all_changelog_versions_from_treeish(
-                               unapplied_import_tree_hash
-                                                                       )
+        unapplied_import_tree_hash
+    )
     changelog_version = import_tree_versions[0]
 
-    applied_tip_version = None
-    # check if the version to import has already been imported to
-    # this head
-    if applied_tip_head is not None:
-        if repo.treeishs_identical(
-                unapplied_import_tree_hash, str(applied_tip_head.peel().id)
-            ):
-            logging.warn('%s is identical to %s',
-                         pretty_head_name, version
-                        )
-            return
-        applied_tip_version, _ = repo.get_changelog_versions_from_treeish(
-                             str(applied_tip_head.peel().id),
-                                                                 )
-
-    logging.debug('Tip version is %s', applied_tip_version)
-
-    applied_changelog_parent_commit = None
+    applied_changelog_parent_commits = []
 
     if version in parent_overrides:
-        logging.debug('%s is specified in the parent override file.' %
-                     version
-                    )
+        logging.debug(
+            "%s is specified in the parent override file.",
+            version,
+        )
 
         (
             _,
-            applied_changelog_parent_commit,
+            applied_changelog_parent_commits,
         ) = override_parents(
             parent_overrides,
             repo,
@@ -1754,13 +1575,7 @@ def import_applied_dsc(
             namespace,
          )
     else:
-        if version_compare(version, applied_tip_version) <= 0:
-            logging.warn('Version to import (%s) is not after %s tip (%s)',
-                         version, pretty_head_name, applied_tip_version
-                        )
-
-
-        applied_changelog_parent_commit = get_changelog_parent_commit(
+        applied_changelog_parent_commits = get_changelog_parent_commits(
             repo,
             namespace,
             parent_overrides,
@@ -1768,109 +1583,55 @@ def import_applied_dsc(
             patches_applied=True,
         )
 
-    existing_applied_tag = repo.get_applied_tag(version, namespace)
-    if existing_applied_tag:
-        # XXX: What should be checked here? The result of pushing all
-        # the patches? How to do it most non-destructively? (Might be
-        # able to use our new helper to get treeish after running a
-        # command, in this case, `quilt push -a`)
-        # if str(applied_tag.peel().tree.id) != applied_import_tree_hash:
-        #     logging.error(
-        #         "Found patches-applied import tag %s, but the "
-        #         "corresponding tree does not match the published "
-        #         "version. Will orphan commit.",
-        #        repo.tag_to_pretty_name(applied_tag),
-        #    )
-        #    applied_changelog_parent_commit = None
-        #else:
-        repo.update_head_to_commit(
-            head_name,
-            str(existing_applied_tag.peel().id),
-        )
-        return
-
-    # Assume no patches to apply
-    applied_import_tree_hash = unapplied_import_tree_hash
-    # get tree id from above commit
-    try:
-        for (
-           applied_import_tree_hash,
-           patch_name,
-           patch_desc
-        ) in import_patches_applied_tree(repo, dsc_pathname):
-            # special case for .pc removal
-            if patch_name is None:
-                msg = b'%b.' % (patch_desc.encode())
-            else:
-                if patch_desc is None:
-                    patch_desc = (
-                        "%s\n\nNo DEP3 Subject or Description header found" %
-                         patch_name
-                    )
-                msg = b'%b\n\nGbp-Pq: %b.' % (
-                    patch_desc.encode(),
-                    patch_name.encode()
-                )
-
-            unapplied_parent_commit = repo.commit_tree_hash(
-                applied_import_tree_hash,
-                [unapplied_parent_commit],
-                msg,
-                fallback_author,
-                fallback_date,
-            )
-
-            logging.debug(
-                "Committed patch-application of %s as %s",
-                patch_name, unapplied_parent_commit
-            )
-    except CalledProcessError as e:
-        if allow_applied_failures:
-            return
-        raise
-
-    commit_hash = commit_applied_patches_import(
+    target_tag = None
+    for existing_applied_tag in get_existing_applied_tags(
         repo,
         version,
-        head_name,
-        applied_import_tree_hash,
         namespace,
-        applied_changelog_parent_commit,
-        unapplied_parent_commit,
-        fallback_author,
-        fallback_date,
-    )
-    logging.debug(
-        "Committed patches-applied import of %s as %s in %s",
-        version,
-        commit_hash,
-        pretty_head_name,
-    )
-
-    tag = None
-    if repo.get_applied_tag(version, namespace) is None:
-        # Not imported before
-        tag = applied_tag(version, namespace)
-    elif (
-        applied_changelog_parent_commit is None and
-        unapplied_parent_commit is None and
-        head_name in repo.local_branch_names
     ):
-        # No parents and not creating a new branch
-        tag = orphan_tag(version, namespace)
+        if str(
+            existing_applied_tag.peel(pygit2.Tree).id
+        ) == applied_import_tree_hash:
+            target_tag = existing_applied_tag
+
+    if not target_tag:
+        # Assume no patches to apply
+        applied_import_tree_hash = unapplied_import_tree_hash
+        # get tree id from above commit
+        try:
+            for (
+               applied_import_tree_hash,
+               patch_name,
+               patch_desc
+            ) in import_patches_applied_tree(repo, dsc_pathname):
+                # special case for .pc removal
+                if patch_name is None:
+                    msg = b'%b.' % (patch_desc.encode())
+                else:
+                    if patch_desc is None:
+                        patch_desc = (
+                            "%s\n\nNo DEP3 Subject or Description header found" %
+                             patch_name
+                        )
+                    msg = b'%b\n\nGbp-Pq: %b.' % (
+                        patch_desc.encode(),
+                        patch_name.encode()
+                    )
+                unapplied_parent_commit = repo.commit_tree_hash(
+                    applied_import_tree_hash,
+                    [unapplied_parent_commit] + applied_changelog_parent_commits,
+                    msg,
+                    fallback_author=fallback_author,
+                    fallback_date=fallback_date,
+                )
+        except CalledProcessError as e:
+            if allow_applied_failures:
+                return
+            raise
 
-    if tag:
-        logging.debug("Creating tag %s pointing to %s", tag, commit_hash)
-        repo.create_tag(
-            commit_hash=commit_hash,
-            tag_name=tag,
-            tag_msg=get_import_tag_msg(),
-        )
+        target_tag = create_applied_tag(repo, unapplied_parent_commit, version, namespace)
 
-    repo.update_head_to_commit(
-        head_name,
-        commit_hash,
-    )
+    return str(target_tag.peel(pygit2.Commit).id)
 
 def import_applied_spi(
     repo,
@@ -1894,11 +1655,7 @@ def import_applied_spi(
 
     :rtype None
     """
-    pretty_head_name = spi.pretty_head_name
-
-    logging.info('Importing patches-applied %s to %s' % (spi.version, pretty_head_name))
-
-    spi.pull()
+    logging.info('Importing patches-applied %s', spi.version)
 
     repo.clean_repository_state()
 
@@ -1909,13 +1666,12 @@ def import_applied_spi(
     if spi.date_published:
         fallback_date = str(spi.date_published)
 
-    import_applied_dsc(
+    return import_applied_dsc(
         repo=repo,
         version=str(spi.version),
         namespace=namespace,
         dist=spi.distribution.name.lower(),
         dsc_pathname=spi.dsc_pathname,
-        head_name=spi.applied_head_name(namespace),
         allow_applied_failures=allow_applied_failures,
         parent_overrides=parent_overrides,
         fallback_author=fallback_author,
@@ -1923,15 +1679,14 @@ def import_applied_spi(
     )
 
 
-def import_publishes(
+def import_new_publishes(
     repo,
     pkgname,
+    distname,
+    new_spis,
     namespace,
+    base_namespace,
     patches_applied,
-    debian_head_versions,
-    ubuntu_head_versions,
-    debian_sinfo,
-    ubuntu_sinfo,
     active_series_only,
     workdir,
     skip_orig,
@@ -1940,62 +1695,240 @@ def import_publishes(
 ):
     history_found = False
     only_debian = False
-    srcpkg_information = None
-    if patches_applied:
-        _namespace = namespace
-        namespace = '%s/applied' % namespace
-        import_type = 'patches-applied'
-        import_func =  functools.partial(
-            import_applied_spi,
-            allow_applied_failures=allow_applied_failures,
-        )
+    spi = None
+
+    updated_head_refs = dict()
+    try:
+        for spi in new_spis:
+            history_found = True
+            spi.pull()
+
+            if patches_applied:
+                existing_tags = get_existing_applied_tags(
+                    repo,
+                    spi.version,
+                    namespace,
+                )
+                head_ref_name = gitubuntu.importerutils.applied_head_ref_name(
+                    spi,
+                    namespace,
+                )
+            else:
+                existing_tags = get_existing_import_tags(
+                    repo,
+                    spi.version,
+                    namespace,
+                )
+                head_ref_name = gitubuntu.importerutils.head_ref_name(
+                    spi,
+                    namespace,
+                )
+
+            commit_hash = None
+            # if an identical DSC has already been imported,
+            # then we only need to update our branch tracker, based
+            # upon the import/reimport tag that matches
+            # dsc_to_to_tree_hash
+            if dsc_imported(repo, spi, namespace, distname):
+                existing_dsc_tree_hash = dsc_to_tree_hash(
+                    repo.raw_repo,
+                    spi.dsc_pathname,
+                    patches_applied=patches_applied,
+                )
+                for existing_tag in existing_tags:
+                    if str(
+                        existing_tag.peel(pygit2.Tree).id
+                    ) == existing_dsc_tree_hash:
+                        commit_hash = str(
+                            existing_tag.peel(pygit2.Commit).id
+                        )
+                        break
+
+            if not commit_hash:
+                try:
+                    if patches_applied:
+                        commit_hash = import_applied_spi(
+                            repo=repo,
+                            spi=spi,
+                            namespace=namespace,
+                            allow_applied_failures=allow_applied_failures,
+                            parent_overrides=parent_overrides,
+                        )
+                    else:
+                        commit_hash = import_unapplied_spi(
+                            repo=repo,
+                            spi=spi,
+                            namespace=namespace,
+                            skip_orig=skip_orig,
+                            parent_overrides=parent_overrides,
+                        )
+                except CalledProcessError:
+                    if patches_applied and allow_applied_failures:
+                        continue
+                    raise
+         
+            updated_head_refs[head_ref_name] = commit_hash
+    except Exception as e:
+        if patches_applied:
+            if not spi:
+                msg = "Unable to import patches-applied to %s" % distname
+            else:
+                msg = "Unable to import patches-applied %s to %s" % (
+                    str(spi.version),
+                    distname,
+                )
+                logging.error(msg)
+                logging.error(traceback.format_exc())
+        else:
+            if not spi:
+                msg = "Unable to import patches-unapplied to %s" % distname
+            else:
+                msg = "Unable to import patches-unapplied %s to %s" % (
+                    str(spi.version),
+                    distname,
+                )
+            raise GitUbuntuImportError(msg) from e
     else:
-        _namespace = namespace
-        import_type = 'patches-unapplied'
-        import_func =  functools.partial(
-            import_unapplied_spi,
-            skip_orig=skip_orig,
+        history_found = True
+
+    return history_found, updated_head_refs
+
+
+def import_publishes(
+    repo,
+    pkgname,
+    namespace,
+    active_series_only,
+    workdir,
+    skip_orig,
+    skip_applied,
+    allow_applied_failures,
+    parent_overrides,
+    pullfile,
+    retries,
+    retry_backoffs,
+):
+    only_debian = False
+    history_found = False
+
+    debian_sinfo = GitUbuntuSourceInformation(
+        'debian',
+        pkgname,
+        os.path.abspath(pullfile),
+        retries,
+        retry_backoffs,
+    )
+
+    ubuntu_sinfo = GitUbuntuSourceInformation(
+        'ubuntu',
+        pkgname,
+        os.path.abspath(pullfile),
+        retries,
+        retry_backoffs,
+    )
+
+    for distname, dist_sinfo in (
+        ('debian', debian_sinfo),
+        ('ubuntu', ubuntu_sinfo),
+    ):
+        unapplied_head_namespace = '%s/%s' % (
+            namespace,
+            distname,
         )
-    for distname, versions, dist_sinfo in (
-            ("debian", debian_head_versions, debian_sinfo),
-            ("ubuntu", ubuntu_head_versions, ubuntu_sinfo)):
-        if active_series_only and distname == "debian":
+        unapplied_versions = repo.get_heads_and_versions(
+            head_ref_namespace=unapplied_head_namespace,
+        )
+        gitubuntu.importerutils.debug_log_head_versions(unapplied_versions)
+
+        try:
+            history_found, updated_head_refs = import_new_publishes(
+                repo=repo,
+                pkgname=pkgname,
+                distname=distname,
+                new_spis=dist_sinfo.launchpad_versions_published_after(
+                    unapplied_versions,
+                    unapplied_head_namespace,
+                    workdir,
+                    active_series_only,
+                ),
+                namespace=namespace,
+                base_namespace=unapplied_head_namespace,
+                patches_applied=False,
+                active_series_only=active_series_only,
+                workdir=workdir,
+                skip_orig=skip_orig,
+                allow_applied_failures=None,
+                parent_overrides=parent_overrides,
+            )
+            update_branches(
+                distname,
+                dist_sinfo,
+                repo,
+                unapplied_head_namespace,
+                pkgname,
+                updated_head_refs,
+            )
+        except NoPublicationHistoryException:
+            logging.warning(
+                "No publication history found for %s in %s.",
+                pkgname,
+                distname,
+            )
+            if distname == 'ubuntu':
+                only_debian = True
             continue
+
+        if skip_applied:
+            continue
+
+        applied_head_namespace = '%s/applied/%s' % (
+            namespace,
+            distname,
+        )
+        applied_versions = repo.get_heads_and_versions(
+            head_namespace=applied_head_namespace,
+        )
+        gitubuntu.importerutils.debug_log_head_versions(applied_versions)
+
         try:
-            for srcpkg_information in dist_sinfo.launchpad_versions_published_after(
-                versions,
-                namespace,
+            _, updated_head_refs = import_new_publishes(
+                repo=repo,
+                pkgname=pkgname,
+                distname=distname,
+                new_spis=dist_sinfo.launchpad_versions_published_after(
+                    applied_versions,
+                    applied_head_namespace,
+                    workdir,
+                    active_series_only,
+                ),
+                namespace=namespace,
+                base_namespace=applied_head_namespace,
+                patches_applied=True,
+                active_series_only=active_series_only,
                 workdir=workdir,
-                active_series_only=active_series_only
-            ):
-                history_found = True
-                import_func(
-                    repo=repo,
-                    spi=srcpkg_information,
-                    namespace=_namespace,
-                    parent_overrides=parent_overrides,
-                )
+                skip_orig=None,
+                allow_applied_failures=allow_applied_failures,
+                parent_overrides=parent_overrides,
+            )
+            update_branches(
+                distname,
+                dist_sinfo,
+                repo,
+                applied_head_namespace,
+                pkgname,
+                updated_head_refs,
+            )
         except NoPublicationHistoryException:
-            logging.warning("No publication history found for %s in %s.",
-                pkgname, distname
+            logging.warning(
+                "No publication history found for %s in %s.",
+                pkgname,
+                distname,
             )
             if distname == 'ubuntu':
                 only_debian = True
-        except Exception as e:
-            if srcpkg_information is None:
-                msg = 'Unable to import %s to %s' % (import_type, distname)
-            else:
-                msg = 'Unable to import %s %s to %s' % (import_type,
-                     str(srcpkg_information.version), distname)
-            if not patches_applied:
-                raise GitUbuntuImportError(msg) from e
-            else:
-                logging.error(msg)
-                logging.error(traceback.format_exc())
-        else:
-            history_found = True
+            continue
 
-    return (only_debian, history_found)
+    return only_debian, history_found
 
 
 def parse_args(subparsers=None, base_subparsers=None):
diff --git a/gitubuntu/importer_test.py b/gitubuntu/importer_test.py
index f9537c4..8039911 100644
--- a/gitubuntu/importer_test.py
+++ b/gitubuntu/importer_test.py
@@ -57,9 +57,9 @@ from gitubuntu.test_fixtures import repo
 ])
 def test_devel_branch_updates(head_versions, expected):
     result = target._devel_branch_updates(
-        'prefix/',
-        head_versions,
-        ['yakkety', 'xenial', 'trusty'],
+        ref_prefix='prefix/ubuntu',
+        head_versions=head_versions,
+        series_name_list=['yakkety', 'xenial', 'trusty'],
     )
     assert set(result) == set(expected.items())
 
@@ -70,50 +70,38 @@ def test_get_import_tag_msg():
 
 
 @pytest.mark.parametrize(
-    'head_name_value, changelog_parent_commit, upload_parent_commit, unapplied_parent_commit, expected',
+    'changelog_parent_commits, unapplied_parent_commit, expected',
     [
         (
-            'importer/ubuntu/trusty',
-            None,
-            None,
+            [],
             None,
-            b'Import patches-unapplied version 1-1 to ubuntu/trusty\n\nImported using git-ubuntu import.',
+            b'Import patches-unapplied version 1-1\n\nImported using git-ubuntu import.',
         ),
         (
-            'importer/ubuntu/trusty',
-            '123456',
+            ['123456'],
             None,
-            None,
-            b'Import patches-unapplied version 1-1 to ubuntu/trusty\n\nImported using git-ubuntu import.\n\nChangelog parent: 123456',
+            b'Import patches-unapplied version 1-1\n\nImported using git-ubuntu import.\n\nChangelog parent: 123456',
         ),
         (
-            'importer/ubuntu/trusty',
-            None,
+            [],
             '123456',
-            None,
-            b'Import patches-unapplied version 1-1 to ubuntu/trusty\n\nImported using git-ubuntu import.\n\nUpload parent: 123456',
+            b'Import patches-applied version 1-1\n\nImported using git-ubuntu import.\n\nUnapplied parent: 123456',
         ),
         (
-            'importer/ubuntu/trusty',
-            None,
-            None,
-            '123456',
-            b'Import patches-applied version 1-1 to ubuntu/trusty\n\nImported using git-ubuntu import.\n\nUnapplied parent: 123456',
+            ['123456'],
+            '789123',
+            b'Import patches-applied version 1-1\n\nImported using git-ubuntu import.\n\nChangelog parent: 123456\nUnapplied parent: 789123'
         ),
         (
-            'importer/ubuntu/trusty',
-            '123456',
-            '789123',
+            ['123456', '789123'],
             '456789',
-            b'Import patches-applied version 1-1 to ubuntu/trusty\n\nImported using git-ubuntu import.\n\nChangelog parent: 123456\nUpload parent: 789123\nUnapplied parent: 456789'
+            b'Import patches-applied version 1-1\n\nImported using git-ubuntu import.\n\nChangelog parent: 123456\nChangelog parent: 789123\nUnapplied parent: 456789'
         ),
     ],
 )
 def test_get_import_commit_msg(
     repo,
-    head_name_value,
-    changelog_parent_commit,
-    upload_parent_commit,
+    changelog_parent_commits,
     unapplied_parent_commit,
     expected,
 ):
@@ -134,11 +122,9 @@ def test_get_import_commit_msg(
     assert target.get_import_commit_msg(
         repo,
         publish_spec.version,
-        head_name_value,
         'importer',
         publish_tree_hash,
-        changelog_parent_commit,
-        upload_parent_commit,
+        changelog_parent_commits,
         unapplied_parent_commit,
     ) == expected
 
@@ -489,7 +475,7 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
     )
 
 
[e-mail]('input_data, parent_overrides, changelog_versions, patches_applied, expected_ref',
[e-mail]('input_data, parent_overrides, changelog_versions, patches_applied, expected_refs',
     [
         (
             repo_builder.Repo(
@@ -500,7 +486,33 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
             {},
             ['1-2', '1-1',],
             False,
-            None,
+            [],
+        ),
+        (
+            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'),
+                },
+            ),
+            {},
+            ['1-2', '1-1'],
+            False,
+            ['refs/tags/importer/import/1-1'],
         ),
         (
             repo_builder.Repo(
@@ -516,17 +528,36 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
                         ),
                         name='import',
                     ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    file_contents={
+                                        'debian/random': 'reimport tag',
+                                    },
+                                )
+                            )
+                        ),
+                        name='reimport',
+                    ),
                 ],
                 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('reimport'),
                 },
             ),
             {},
             ['1-2', '1-1'],
             False,
-            'refs/tags/importer/import/1-1',
+            [
+                'refs/tags/importer/reimport/import/1-1/0',
+                'refs/tags/importer/reimport/import/1-1/1',
+            ],
         ),
         (
             repo_builder.Repo(
@@ -552,7 +583,7 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
             {},
             ['1-3', '1-2', '1-1'],
             False,
-            'refs/tags/importer/import/1-1',
+            ['refs/tags/importer/import/1-1'],
         ),
         (
             repo_builder.Repo(
@@ -563,7 +594,33 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
             {},
             ['1-2', '1-1',],
             True,
-            None,
+            [],
+        ),
+        (
+            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'),
+                },
+            ),
+            {},
+            ['1-2', '1-1'],
+            True,
+            ['refs/tags/importer/applied/1-1'],
         ),
         (
             repo_builder.Repo(
@@ -579,17 +636,36 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
                         ),
                         name='applied',
                     ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    file_contents={
+                                        'debian/random': 'reimport tag',
+                                    },
+                                )
+                            )
+                        ),
+                        name='reimport',
+                    ),
                 ],
                 branches={
                 },
                 tags={
                     'importer/applied/1-1': repo_builder.Placeholder('applied'),
+                    'importer/reimport/applied/1-1/0': repo_builder.Placeholder('applied'),
+                    'importer/reimport/applied/1-1/1': repo_builder.Placeholder('reimport'),
                 },
             ),
             {},
             ['1-2', '1-1'],
             True,
-            'refs/tags/importer/applied/1-1',
+            [
+                'refs/tags/importer/reimport/applied/1-1/0',
+                'refs/tags/importer/reimport/applied/1-1/1',
+            ],
         ),
         (
             repo_builder.Repo(
@@ -615,28 +691,30 @@ def test_create_applied_tag(repo, input_data, expected_changes, test_refs):
             {},
             ['1-3', '1-2', '1-1'],
             True,
-            'refs/tags/importer/applied/1-1',
+            ['refs/tags/importer/applied/1-1'],
         ),
     ],
 )
-def test_get_changelog_parent_commit(
+def test_get_changelog_parent_commits(
     repo,
     input_data,
     parent_overrides,
     changelog_versions,
     patches_applied,
-    expected_ref,
+    expected_refs,
 ):
     input_data.write(repo.raw_repo)
-    assert target.get_changelog_parent_commit(
+    assert target.get_changelog_parent_commits(
         repo,
         'importer',
         parent_overrides,
         changelog_versions,
         patches_applied,
     ) == (
-        str(repo.raw_repo.lookup_reference(expected_ref).peel(pygit2.Commit).id)
-        if expected_ref else expected_ref
+        [
+            str(repo.raw_repo.lookup_reference(expected_ref).peel(pygit2.Commit).id)
+            for expected_ref in expected_refs
+        ] if expected_refs else expected_refs
     )
 
 @patch('gitubuntu.git_repository.GitUbuntuRepository.add_base_remotes')
@@ -697,3 +775,1685 @@ 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()
+
+
[e-mail](
+    'name, input_data, expected_changes, compare_refs, exist_refs, xfail', [
+        (
+            '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'
+                    ),
+                ],
+                branches={
+                    'importer/ubuntu/trusty-proposed': repo_builder.Placeholder('import'),
+                },
+                tags={
+                    'importer/import/1-1': repo_builder.Placeholder('import'),
+                },
+            ),
+            {
+                'commit_list_to_add': [],
+                'tags_to_add': {},
+                'branches_to_update': {
+                     'importer/ubuntu/trusty': repo_builder.Placeholder('import'),
+                },
+            },
+            [
+                #'refs/heads/importer/ubuntu/trusty-proposed',
+                #'refs/heads/importer/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+            ],
+            [
+                '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',
+            ],
+            False,
+        ),
+        (
+            'Case 1 - reimport tag',
+            repo_builder.Repo(
+                commit_list=[
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    file_contents={
+                                        'debian/random': 'import tag contents',
+                                    },
+                                )
+                            )
+                        ),
+                        name='import',
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                )
+                            )
+                        ),
+                        name='reimport',
+                    ),
+                ],
+                branches={
+                    'importer/ubuntu/trusty-proposed': repo_builder.Placeholder('import'),
+                },
+                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('reimport'),
+                },
+            ),
+            {
+                'commit_list_to_add': [],
+                'tags_to_add': {},
+                'branches_to_update': {
+                     'importer/ubuntu/trusty': repo_builder.Placeholder('reimport'),
+                },
+            },
+            [
+                #'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',
+            ],
+            [
+                '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',
+            ],
+            False,
+        ),
+        (
+            'Case 2',
+            repo_builder.Repo(
+                commit_list=[
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    file_contents={
+                                        'debian/random': 'The import tag contents',
+                                    },
+                                )
+                            )
+                        ),
+                        name='import'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                )
+                            )
+                        ),
+                        name='upload'
+                    ),
+                ],
+                branches={
+                    'importer/ubuntu/trusty-proposed': repo_builder.Placeholder('import'),
+                },
+                tags={
+                    'importer/import/1-1': repo_builder.Placeholder('import'),
+                    'importer/upload/1-1': repo_builder.Placeholder('upload'),
+                },
+            ),
+            {
+                'commit_list_to_add': [
+                ],
+                'tags_to_add': {
+                    'importer/reimport/import/1-1/0': repo_builder.Placeholder('import'),
+                    'importer/reimport/import/1-1/1': repo_builder.Placeholder('upload'),
+                },
+                'branches_to_update': {
+                     'importer/ubuntu/trusty': repo_builder.Placeholder('upload'),
+                },
+            },
+            [
+                #'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',
+            ],
+            [
+                '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',
+            ],
+            False,
+        ),
+        (
+            'Case 3',
+            repo_builder.Repo(
+                commit_list=[
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    file_contents={
+                                        'debian/random': 'The import tag contents',
+                                    },
+                                )
+                            )
+                        ),
+                        name='import'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    file_contents={
+                                        'debian/random': 'The upload tag contents',
+                                    },
+                                )
+                            )
+                        ),
+                        name='upload'
+                    ),
+                ],
+                branches={
+                    'importer/ubuntu/trusty-proposed': repo_builder.Placeholder('import'),
+                },
+                tags={
+                    'importer/import/1-1': repo_builder.Placeholder('import'),
+                    'importer/upload/1-1': repo_builder.Placeholder('upload'),
+                },
+            ),
+            {
+                'commit_list_to_add': [
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                )
+                            )
+                        ),
+                        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': {
+                     'importer/ubuntu/trusty': repo_builder.Placeholder('reimport'),
+                },
+            },
+            [
+                #'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',
+            ],
+            [
+                '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',
+            ],
+            False,
+        ),
+        (
+            'Case 4',
+            repo_builder.Repo(
+                commit_list=[
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    file_contents={
+                                        'debian/random': 'The import tag contents',
+                                    },
+                                )
+                            )
+                        ),
+                        name='import'
+                    ),
+                ],
+                branches={
+                    'importer/ubuntu/trusty-proposed': repo_builder.Placeholder('import'),
+                },
+                tags={
+                    'importer/import/1-1': repo_builder.Placeholder('import'),
+                },
+            ),
+            {
+                'commit_list_to_add': [
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                )
+                            )
+                        ),
+                        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': {
+                     'importer/ubuntu/trusty': repo_builder.Placeholder('reimport'),
+                },
+            },
+            [
+                #'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',
+            ],
+            [
+                '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',
+            ],
+            False,
+        ),
+        (
+            'Case 5',
+            repo_builder.Repo(
+                commit_list=[
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                )
+                            )
+                        ),
+                        name='upload'
+                    ),
+                ],
+                branches={
+                },
+                tags={
+                    'importer/upload/1-1': repo_builder.Placeholder('upload'),
+                },
+            ),
+            {
+                'commit_list_to_add': [
+                ],
+                'tags_to_add': {
+                    'importer/import/1-1': repo_builder.Placeholder('upload'),
+                },
+                'branches_to_update': {
+                     'importer/ubuntu/trusty': repo_builder.Placeholder('upload'),
+                },
+            },
+            [
+                #'refs/heads/importer/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/upload/1-1',
+            ],
+            [
+                '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',
+            ],
+            False,
+        ),
+        (
+            'Case 6',
+            repo_builder.Repo(
+                commit_list=[
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    file_contents={
+                                        'debian/random': 'The upload tag contents',
+                                    },
+                                )
+                            )
+                        ),
+                        name='upload'
+                    ),
+                ],
+                branches={
+                },
+                tags={
+                    'importer/upload/1-1': repo_builder.Placeholder('upload'),
+                },
+            ),
+            {
+                'commit_list_to_add': [
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                )
+                            )
+                        ),
+                        name='publish'
+                    ),
+                ],
+                'tags_to_add': {
+                    'importer/import/1-1': repo_builder.Placeholder('publish'),
+                },
+                'branches_to_update': {
+                     'importer/ubuntu/trusty': repo_builder.Placeholder('publish'),
+                },
+            },
+            [
+                #'refs/heads/importer/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/upload/1-1',
+            ],
+            [
+                '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',
+            ],
+            False,
+        ),
+        (
+            'Case 7',
+            repo_builder.Repo(
+                commit_list=[
+                ],
+                branches={
+                },
+                tags={
+                },
+            ),
+            {
+                'commit_list_to_add': [
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                )
+                            )
+                        ),
+                        name='publish'
+                    ),
+                ],
+                'tags_to_add': {
+                    'importer/import/1-1': repo_builder.Placeholder('publish'),
+                },
+                'branches_to_update': {
+                     'importer/ubuntu/trusty': repo_builder.Placeholder('publish'),
+                },
+            },
+            [
+                #'refs/heads/importer/ubuntu/trusty',
+                'refs/tags/importer/import/1-1'
+            ],
+            [
+                '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',
+            ],
+            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,
+    name,
+    input_data,
+    expected_changes,
+    compare_refs,
+    exist_refs,
+    xfail,
+):
+    # 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(
+        version='1-1',
+        native=False,
+    )
+    publish_source = source_builder.Source(publish_spec)
+
+    # copy before write, so that placeholders are still present
+    expected_result = input_data.copy(**expected_changes)
+
+    # Ensure reproducible commit hashes
+    with 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',
+        },
+    ):
+        input_data.write(repo.raw_repo)
+
+        with publish_source as dsc_path:
+            spi = Mock()
+            spi.dsc_pathname = dsc_path
+            spi.distribution.name = 'Ubuntu'
+            spi.version = publish_spec.version
+            # avoid automatic parenting for head_name to make the assertion later
+            # easier
+            head_name = Mock(name='head_name')
+            head_name.return_value = 'importer/ubuntu/trusty'
+            spi.head_name = head_name
+            spi.date_published = '1970-01-01T00:00:00Z'
+            target.import_unapplied_spi(
+                repo=repo,
+                spi=spi,
+                namespace='importer',
+                skip_orig=False,
+                parent_overrides={},
+            )
+
+        # test that some refs are the same
+        assert repo_comparator.equals(
+            repoA=repo.raw_repo,
+            repoB=expected_result,
+            test_refs=compare_refs,
+        ) or xfail
+
+        # test that some refs exist
+        for ref in exist_refs:
+            assert repo.raw_repo.lookup_reference(ref) or xfail
+
+        # test that no other refs exist
+        #assert not (
+        #    set(repo.raw_repo.listall_references()) ^
+        #    (set(compare_refs) | set(exist_refs))
+        #) or xfail
+
+        if xfail:
+            pytest.xfail(xfail)
+
+
+@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,
+):
+    # 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_data = repo_builder.Repo(
+        commit_list=[
+        ],
+        branches={
+        },
+        tags={
+        },
+    )
+    expected_changes = {
+        'commit_list_to_add': [
+            repo_builder.Commit(
+                tree=repo_builder.SourceTree(
+                    source_builder.Source(
+                        source_builder.SourceSpec(
+                            version='1-1',
+                            native=False,
+                            has_patches=True,
+                        )
+                    )
+                ),
+                name='publish'
+            ),
+        ],
+        'tags_to_add': {
+            'importer/import/1-1': repo_builder.Placeholder('publish'),
+        },
+        'branches_to_update': {
+             'importer/ubuntu/trusty': repo_builder.Placeholder('publish'),
+        },
+    }
+    test_refs = [
+        #'refs/heads/importer/ubuntu/trusty',
+        'refs/tags/importer/import/1-1'
+    ]
+
+    publish_spec = source_builder.SourceSpec(
+        version='1-1',
+        native=False,
+        has_patches=True,
+    )
+    publish_source = source_builder.Source(publish_spec)
+
+    # copy before write, so that placeholders are still present
+    expected_result = input_data.copy(**expected_changes)
+
+    with 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',
+        },
+    ):
+        input_data.write(repo.raw_repo)
+
+        with publish_source as dsc_path:
+            spi = Mock()
+            spi.dsc_pathname = dsc_path
+            spi.distribution.name = 'Ubuntu'
+            spi.version = publish_spec.version
+            # avoid automatic parenting for head_name to make the assertion later
+            # easier
+            head_name = Mock(name='head_name')
+            head_name.return_value = 'importer/ubuntu/trusty'
+            spi.head_name = head_name
+            spi.date_published = '1970-01-01T00:00:00Z'
+            # 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=spi,
+                namespace='importer',
+                skip_orig=False,
+                parent_overrides={},
+            )
+
+            assert repo_comparator.equals(
+                repoA=repo.raw_repo,
+                repoB=expected_result,
+                test_refs=test_refs,
+            )
+
+
[e-mail](
+    'input_data, expected_changes, changelog_versions, test_refs, xfail',  [
+        (
+            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'),
+                },
+            ),
+            {
+                'commit_list_to_add': [
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    changelog_versions=['1-2', '1-1'],
+                                    native=False,
+                                )
+                            )
+                        ),
+                        parents=[repo_builder.Placeholder('import')],
+                        name='publish'
+                    ),
+                ],
+                'tags_to_add': {
+                    'importer/import/1-2': repo_builder.Placeholder('publish'),
+                },
+                'branches_to_update': {
+                },
+            },
+            ['1-2', '1-1'],
+            [
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/import/1-2',
+            ],
+            False,
+        ),
+        (
+            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'),
+                },
+            ),
+            {
+                'commit_list_to_add': [
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    changelog_versions=['1-3', '1-2', '1-1'],
+                                    native=False,
+                                )
+                            )
+                        ),
+                        parents=[repo_builder.Placeholder('import')],
+                        name='publish'
+                    ),
+                ],
+                'tags_to_add': {
+                    'importer/import/1-3': repo_builder.Placeholder('publish'),
+                },
+                'branches_to_update': {
+                },
+            },
+            ['1-3', '1-2', '1-1'],
+            [
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/import/1-3',
+            ],
+            False,
+        ),
+        (
+            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'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    file_contents={
+                                        'debian/random': 'Reimport tag contents',
+                                    },
+                                )
+                            )
+                        ),
+                        name='reimport'
+                    ),
+                ],
+                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('reimport'),
+                },
+            ),
+            {
+                'commit_list_to_add': [
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    changelog_versions=['1-2', '1-1'],
+                                    native=False,
+                                )
+                            )
+                        ),
+                        parents=[
+                            repo_builder.Placeholder('import'),
+                            repo_builder.Placeholder('reimport'),
+                        ],
+                        name='publish'
+                    ),
+                ],
+                'tags_to_add': {
+                    'importer/import/1-2': repo_builder.Placeholder('publish'),
+                },
+                'branches_to_update': {
+                },
+            },
+            ['1-2', '1-1'],
+            [
+                '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',
+            ],
+            False,
+        ),
+    ]
+)
+@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_data,
+    expected_changes,
+    changelog_versions,
+    test_refs,
+    xfail,
+):
+    # 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(
+        changelog_versions=changelog_versions,
+        native=False,
+    )
+    publish_source = source_builder.Source(publish_spec)
+
+    # copy before write, so that placeholders are still present
+    expected_result = input_data.copy(**expected_changes)
+
+    with 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',
+        },
+    ):
+        input_data.write(repo.raw_repo)
+
+        with publish_source as dsc_path:
+            spi = Mock()
+            spi.dsc_pathname = dsc_path
+            spi.distribution.name = 'Ubuntu'
+            spi.version = publish_spec.version
+            # avoid automatic parenting for head_name to make the assertion later
+            # easier
+            head_name = Mock(name='head_name')
+            head_name.return_value = 'importer/ubuntu/trusty'
+            spi.head_name = head_name
+            spi.date_published = '1970-01-01T00:00:00Z'
+            # 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=spi,
+                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
+            assert repo_comparator.equals(
+                repoA=repo.raw_repo,
+                repoB=expected_result,
+                test_refs=test_refs,
+            ) or xfail
+
+            if xfail:
+                pytest.xfail(xfail)
+
+
+@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,
+):
+    # 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_data = repo_builder.Repo(
+        commit_list=[
+            repo_builder.Commit(
+                tree=repo_builder.SourceTree(
+                    source_builder.Source(
+                        source_builder.SourceSpec(
+                            version='1-1',
+                            native=False,
+                        )
+                    )
+                ),
+                name='import1-1'
+            ),
+            repo_builder.Commit(
+                tree=repo_builder.SourceTree(
+                    source_builder.Source(
+                        source_builder.SourceSpec(
+                            version='1-2',
+                            native=False,
+                        )
+                    )
+                ),
+                name='import1-2'
+            ),
+        ],
+        branches={
+        },
+        tags={
+            'importer/import/1-1': repo_builder.Placeholder('import1-1'),
+            'importer/import/1-2': repo_builder.Placeholder('import1-2'),
+        },
+    )
+
+    expected_changes = {
+        'commit_list_to_add': [
+            repo_builder.Commit(
+                tree=repo_builder.SourceTree(
+                    source_builder.Source(
+                        source_builder.SourceSpec(
+                            changelog_versions=['2-1', '1-1'],
+                            native=False,
+                        )
+                    )
+                ),
+                parents=[repo_builder.Placeholder('import1-2')],
+                name='publish'
+            ),
+        ],
+        'tags_to_add': {
+            'importer/import/2-1': repo_builder.Placeholder('publish'),
+        },
+        'branches_to_update': {
+        },
+    }
+
+    test_refs = [
+        'refs/tags/importer/import/1-1',
+        'refs/tags/importer/import/1-2',
+        'refs/tags/importer/import/2-1',
+    ]
+
+    publish_spec = source_builder.SourceSpec(
+        changelog_versions=['2-1', '1-1'],
+        native=False,
+    )
+    publish_source = source_builder.Source(publish_spec)
+
+    # copy before write, so that placeholders are still present
+    expected_result = input_data.copy(**expected_changes)
+
+    with 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',
+        },
+    ):
+        input_data.write(repo.raw_repo)
+
+        with publish_source as dsc_path:
+            spi = Mock()
+            spi.dsc_pathname = dsc_path
+            spi.distribution.name = 'Ubuntu'
+            spi.version = publish_spec.version
+            # avoid automatic parenting for head_name to make the assertion later
+            # easier
+            head_name = Mock(name='head_name')
+            head_name.return_value = 'importer/ubuntu/trusty'
+            spi.head_name = head_name
+            spi.date_published = '1970-01-01T00:00:00Z'
+            # 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=spi,
+                namespace='importer',
+                skip_orig=False,
+                parent_overrides={'2-1': {'changelog_parent': '1-2'}},
+            )
+
+            assert repo_comparator.equals(
+                repoA=repo.raw_repo,
+                repoB=expected_result,
+                test_refs=test_refs,
+            )
+
+
+def test_import_unapplied_spi_parent_override_failure(repo):
+    input_data = repo_builder.Repo(
+        commit_list=[
+            repo_builder.Commit(
+                tree=repo_builder.SourceTree(
+                    source_builder.Source(
+                        source_builder.SourceSpec(
+                            version='1-1',
+                            native=False,
+                        )
+                    )
+                ),
+                name='import1-1'
+            ),
+        ],
+        branches={
+        },
+        tags={
+            'importer/import/1-1': repo_builder.Placeholder('import1-1'),
+        },
+    )
+
+    input_data.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](
+    'name, input_data, expected_changes, test_refs, xfail', [
+        (
+            '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,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=False,
+                        ),
+                        name='unapplied'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=True,
+                        ),
+                        name='applied'
+                    ),
+                ],
+                branches={
+                    'importer/ubuntu/trusty': repo_builder.Placeholder('unapplied'),
+                    'importer/applied/ubuntu/trusty': repo_builder.Placeholder('applied'),
+                },
+                tags={
+                    'importer/import/1-1': repo_builder.Placeholder('unapplied'),
+                    'importer/applied/1-1': repo_builder.Placeholder('applied'),
+                },
+            ),
+            {
+                'commit_list_to_add': [],
+                'tags_to_add': {},
+                'branches_to_update': {},
+            },
+            [
+                #'refs/heads/importer/ubuntu/trusty',
+                #'refs/heads/importer/applied/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/applied/1-1',
+            ],
+            False,
+        ),
+        (
+            'Case 2',
+            repo_builder.Repo(
+                commit_list=[
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                    file_contents={
+                                        'debian/random': 'import tag contents'
+                                    },
+                                )
+                            ),
+                            patches_applied=False,
+                        ),
+                        name='unapplied'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=False,
+                        ),
+                        name='unapplied_reimport'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                    file_contents={
+                                        'debian/random': 'import tag contents'
+                                    },
+                                )
+                            ),
+                            patches_applied=True,
+                        ),
+                        name='applied'
+                    ),
+                ],
+                branches={
+                    'importer/ubuntu/trusty': repo_builder.Placeholder('unapplied'),
+                },
+                tags={
+                    'importer/import/1-1': repo_builder.Placeholder('unapplied'),
+                    'importer/reimport/import/1-1/0': repo_builder.Placeholder('unapplied'),
+                    'importer/reimport/import/1-1/1': repo_builder.Placeholder('unapplied_reimport'),
+                    'importer/applied/1-1': repo_builder.Placeholder('applied'),
+                },
+            ),
+            {
+                'commit_list_to_add': [
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=True,
+                        ),
+                        parents=[repo_builder.Placeholder('unapplied_reimport')],
+                        name='applied_reimport'
+                    ),
+                ],
+                'tags_to_add': {
+                    'importer/reimport/applied/1-1/0': repo_builder.Placeholder('applied'),
+                    'importer/reimport/applied/1-1/1': repo_builder.Placeholder('applied_reimport'),
+                },
+                'branches_to_update': {
+                     'importer/applied/ubuntu/trusty': repo_builder.Placeholder('applied_reimport'),
+                },
+            },
+            [
+                #'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',
+            ],
+            False,
+        ),
+        (
+            'Case 3',
+            repo_builder.Repo(
+                commit_list=[
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=False,
+                        ),
+                        name='unapplied'
+                    ),
+                ],
+                branches={
+                    'importer/ubuntu/trusty': repo_builder.Placeholder('unapplied'),
+                },
+                tags={
+                    'importer/import/1-1': repo_builder.Placeholder('unapplied'),
+                },
+            ),
+            {
+                'commit_list_to_add': [
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=True,
+                        ),
+                        parents=[repo_builder.Placeholder('unapplied')],
+                        name='applied'
+                    ),
+                ],
+                'tags_to_add': {
+                    'importer/applied/1-1': repo_builder.Placeholder('applied')
+                },
+                'branches_to_update': {
+                     'importer/applied/ubuntu/trusty': repo_builder.Placeholder('applied'),
+                },
+            },
+            [
+                #'refs/heads/importer/ubuntu/trusty',
+                #'refs/heads/importer/applied/ubuntu/trusty',
+                'refs/tags/importer/import/1-1',
+                'refs/tags/importer/applied/1-1'
+            ],
+            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,
+    name,
+    input_data,
+    expected_changes,
+    test_refs,
+    xfail,
+):
+    # 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(
+        version='1-1',
+        native=False,
+        has_patches=True,
+    )
+    publish_source = source_builder.Source(publish_spec)
+
+    # copy before write, so that placeholders are still present
+    expected_result = input_data.copy(**expected_changes)
+
+    # Ensure reproducible commit hashes
+    with 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',
+        },
+    ):
+        input_data.write(repo.raw_repo)
+
+        with publish_source as dsc_path:
+            spi = Mock()
+            spi.dsc_pathname = dsc_path
+            spi.distribution.name = 'Ubuntu'
+            spi.version = publish_spec.version
+            # avoid automatic parenting for head_name to make the assertion later
+            # easier
+            applied_head_name = Mock(name='applied_head_name')
+            applied_head_name.return_value = 'importer/applied/ubuntu/trusty'
+            spi.applied_head_name = applied_head_name
+            spi.date_published = '1970-01-01T00:00:00Z'
+            target.import_applied_spi(
+                repo=repo,
+                spi=spi,
+                namespace='importer',
+                allow_applied_failures=False,
+                parent_overrides={},
+            )
+
+            assert repo_comparator.equals(
+                repoA=repo.raw_repo,
+                repoB=expected_result,
+                test_refs=test_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,
+            ) or xfail
+
+            if xfail:
+                pytest.xfail(xfail)
+
+
+# test:
+# if only one import tag exists, then it is the parent
+# if two import tags exist, then only the are all parents
+# corresponding applied tags are also a parent?
[e-mail](
+    'input_data, expected_ancestor_commits, expected_parent_commits, xfail', [
+        (
+            repo_builder.Repo(
+                commit_list=[
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=False,
+                        ),
+                        name='unapplied1'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    changelog_versions=['1-2', '1-1'],
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=False,
+                        ),
+                        parents=[repo_builder.Placeholder('unapplied1')],
+                        name='unapplied2'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=True,
+                        ),
+                        name='applied1'
+                    ),
+                ],
+                branches={},
+                tags={
+                    'importer/import/1-1': repo_builder.Placeholder('unapplied1'),
+                    'importer/import/1-2': repo_builder.Placeholder('unapplied2'),
+                    'importer/applied/1-1': repo_builder.Placeholder('applied1'),
+                },
+            ),
+            [
+                'refs/tags/importer/import/1-2',
+            ],
+            [
+                'refs/tags/importer/applied/1-1',
+            ],
+            False,
+        ),
+        (
+            repo_builder.Repo(
+                commit_list=[
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=False,
+                        ),
+                        name='unapplied1'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    changelog_versions=['1-2', '1-1'],
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=False,
+                        ),
+                        parents=[repo_builder.Placeholder('unapplied1')],
+                        name='unapplied2'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    changelog_versions=['1-2', '1-1'],
+                                    native=False,
+                                    has_patches=True,
+                                    file_contents={
+                                        'debian/random': 'reimport tag',
+                                    },
+                                )
+                            ),
+                            patches_applied=False,
+                        ),
+                        parents=[repo_builder.Placeholder('unapplied1')],
+                        name='unapplied2reimport'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=True,
+                        ),
+                        name='applied1'
+                    ),
+                ],
+                branches={},
+                tags={
+                    'importer/import/1-1': repo_builder.Placeholder('unapplied1'),
+                    'importer/import/1-2': repo_builder.Placeholder('unapplied2'),
+                    'importer/reimport/import/1-2/0': repo_builder.Placeholder('unapplied2'),
+                    'importer/reimport/import/1-2/1': repo_builder.Placeholder('unapplied2reimport'),
+                    'importer/applied/1-1': repo_builder.Placeholder('applied1'),
+                },
+            ),
+            [
+                'refs/tags/importer/import/1-2',
+            ],
+            [
+                'refs/tags/importer/applied/1-1',
+            ],
+            False,
+        ),
+        (
+            repo_builder.Repo(
+                commit_list=[
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=False,
+                        ),
+                        name='unapplied1'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                    file_contents={
+                                        'debian/random': 'reimport contents',
+                                    },
+                                )
+                            ),
+                            patches_applied=False,
+                        ),
+                        name='unapplied1_reimport'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    changelog_versions=['1-2', '1-1'],
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=False,
+                        ),
+                        parents=[repo_builder.Placeholder('unapplied1')],
+                        name='unapplied2'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                )
+                            ),
+                            patches_applied=True,
+                        ),
+                        name='applied1'
+                    ),
+                    repo_builder.Commit(
+                        tree=repo_builder.SourceTree(
+                            source_builder.Source(
+                                source_builder.SourceSpec(
+                                    version='1-1',
+                                    native=False,
+                                    has_patches=True,
+                                    file_contents={
+                                        'debian/random': 'reimport contents',
+                                    },
+                                )
+                            ),
+                            patches_applied=True,
+                        ),
+                        name='applied1_reimport'
+                    ),
+                ],
+                branches={},
+                tags={
+                    'importer/import/1-1': repo_builder.Placeholder('unapplied1'),
+                    'importer/reimport/import/1-1/0': repo_builder.Placeholder('unapplied1'),
+                    'importer/reimport/import/1-1/1': repo_builder.Placeholder('unapplied1_reimport'),
+                    'importer/import/1-2': repo_builder.Placeholder('unapplied2'),
+                    'importer/applied/1-1': repo_builder.Placeholder('applied1'),
+                    'importer/reimport/applied/1-1/0': repo_builder.Placeholder('applied1'),
+                    'importer/reimport/applied/1-1/1': repo_builder.Placeholder('applied1_reimport'),
+                },
+            ),
+            [
+                'refs/tags/importer/import/1-2',
+            ],
+            [
+                'refs/tags/importer/reimport/applied/1-1/0',
+                'refs/tags/importer/reimport/applied/1-1/1',
+            ],
+            False,
+        ),
+    ],
+)
+@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_data,
+    expected_ancestor_commits,
+    expected_parent_commits,
+    xfail,
+):
+    """Test that import_applied_spi correctly parents the new commit
+
+    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'
+
+    publish_spec = source_builder.SourceSpec(
+        changelog_versions=['1-2', '1-1'],
+        native=False,
+        has_patches=True,
+    )
+    publish_source = source_builder.Source(publish_spec)
+
+    # Ensure reproducible commit hashes
+    with 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',
+        },
+    ):
+        input_data.write(repo.raw_repo)
+
+        with publish_source as dsc_path:
+            spi = Mock()
+            spi.dsc_pathname = dsc_path
+            spi.distribution.name = 'Ubuntu'
+            spi.version = publish_spec.version
+            # avoid automatic parenting for head_name to make the assertion later
+            # easier
+            applied_head_name = Mock(name='applied_head_name')
+            applied_head_name.return_value = 'importer/applied/ubuntu/trusty'
+            spi.applied_head_name = applied_head_name
+            spi.date_published = '1970-01-01T00:00:00Z'
+            target.import_applied_spi(
+                repo=repo,
+                spi=spi,
+                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:
+                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
+            ) or xfail
+
+            if xfail:
+                pytest.xfail(xfail)
diff --git a/gitubuntu/importerutils.py b/gitubuntu/importerutils.py
new file mode 100644
index 0000000..8df2ea5
--- /dev/null
+++ b/gitubuntu/importerutils.py
@@ -0,0 +1,50 @@
+import logging
+
+def debug_log_head_versions(head_versions):
+    """Emit debug logging about the version in Git branches
+
+    :param head_versions dict a dictionary of dictionaries, keyed by Git
+        branch names, where each elemetn is a dictionary with elements
+        'version' (a string package version) and 'head' (a pygit2.Branch
+        object)
+    :rtype None
+    """
+    for head_name in sorted(head_versions):
+        logging.debug('Last imported %s version is %s',
+            head_name,
+            head_versions[head_name]['version']
+        )
+
+
+def head_ref_name(spi, ref_namespace):
+    """Obtain the patches-unapplied Git ref name a spi would import to
+
+    :param gitubuntu.source_information.GitUbuntuSourcePackageInformation spi
+        The source package to examine 
+    :param ref_namespace str The namespace the resulting Git ref should be in
+
+    :rtype str
+    """
+    if spi.pocket.lower() == 'release':
+        pocket_suffix = ''
+    else:
+        pocket_suffix = '-' + spi.pocket.lower()
+
+    return '%s/%s/%s%s' % (
+        ref_namespace,
+        spi.distribution.name.lower(),
+        spi.series.name.lower(),
+        pocket_suffix,
+    )
+
+
+def applied_head_ref_name(spi, ref_namespace):
+    """Obtain the patches-unapplied Git ref name a spi would import to
+
+    :param gitubuntu.source_information.GitUbuntuSourcePackageInformation spi
+        The source package to examine 
+    :param ref_namespace str The namespace the resulting Git ref should be in
+
+    :rtype str
+    """
+    return head_ref_name(spi, '%s/applied' % ref_namespace)
diff --git a/gitubuntu/importlocal.py b/gitubuntu/importlocal.py
index 778a673..386919c 100644
--- a/gitubuntu/importlocal.py
+++ b/gitubuntu/importlocal.py
@@ -98,7 +98,6 @@ def main(
         namespace=namespace,
         dist=None,
         dsc_pathname=dsc_path,
-        head_name=None,
         skip_orig=skip_orig,
         parent_overrides=parent_overrides,
         fallback_author=None,
@@ -111,7 +110,6 @@ def main(
         namespace=namespace,
         dist=None,
         dsc_pathname=dsc_path,
-        head_name=None,
         allow_applied_failures=False,
         parent_overrides=parent_overrides,
         fallback_author=None,
diff --git a/gitubuntu/importppa.py b/gitubuntu/importppa.py
index 024143f..668c01f 100644
--- a/gitubuntu/importppa.py
+++ b/gitubuntu/importppa.py
@@ -14,6 +14,7 @@ from gitubuntu.importer import (
     import_unapplied_spi,
     import_applied_spi,
 )
+from gitubuntu.importerutils import debug_log_head_versions
 from gitubuntu.source_information import (
     GitUbuntuSourceInformation,
     NoPublicationHistoryException,
@@ -67,26 +68,14 @@ def main(
     )
 
     ubuntu_head_versions = repo.get_heads_and_versions(
-        'ubuntu',
-        namespace,
+        '%s/ubuntu' % namespace
     )
-    for head_name in sorted(ubuntu_head_versions):
-        _, _, pretty_head_name = head_name.partition('%s/', namespace)
-        logging.debug('Last imported %s version is %s',
-            pretty_head_name,
-            ubuntu_head_versions[head_name]['version']
-        )
+    debug_log_head_versions(ubuntu_head_versions)
 
     applied_ubuntu_head_versions = repo.get_heads_and_versions(
-        'applied/ubuntu',
-        namespace,
+        '%s/applied/ubuntu' % namespace
     )
-    for head_name in sorted(applied_ubuntu_head_versions):
-        _, _, pretty_head_name = head_name.partition('%s/', namespace)
-        logging.debug('Last applied %s version is %s',
-            pretty_head_name,
-            applied_ubuntu_head_versions[head_name]['version']
-        )
+    debug_log_head_versions(applied_ubuntu_head_versions)
 
     oldcwd = os.getcwd()
     os.chdir(repo.local_dir)
diff --git a/gitubuntu/source_information.py b/gitubuntu/source_information.py
index 9e8f172..f287954 100644
--- a/gitubuntu/source_information.py
+++ b/gitubuntu/source_information.py
@@ -9,6 +9,8 @@ _LP_LOGIN_AUTH = None
 _lp_service = 'production'
 _lp_api_version = 'devel'
 
+import gitubuntu.importerutils
+
 try:
     pkg = 'python3-distro-info'
     from distro_info import DebianDistroInfo, UbuntuDistroInfo
@@ -134,8 +136,18 @@ class GitUbuntuPPASourcePackage(UbuntuSourcePackage):
 
 
 class GitUbuntuSourcePackageInformation:
-    def __init__(self, spphr, dist_name, retries=0, retry_backoffs=[],
-                 workdir=None, dsc=None, files=list()):
+    def __init__(
+        self,
+        spphr,
+        dist_name,
+        retries=0,
+        retry_backoffs=[],
+        workdir=None,
+        dsc=None,
+        files=None,
+    ):
+        if not files:
+            files = list()
         self._spphr = spphr
         self._dist_name = dist_name
         self._pkgname = self.spphr.source_package_name
@@ -154,13 +166,15 @@ class GitUbuntuSourcePackageInformation:
 
         # do this here, in case files is passed
         if workdir and not os.path.isdir(workdir):
-             os.makedirs(workdir, exist_ok=True)
-
-        self._archive_srcpkg = func(package=self._pkgname,
-                                    version=self._version,
-                                    workdir=workdir,
-                                    quiet=True,
-                                    dscfile=dsc)
+            os.makedirs(workdir, exist_ok=True)
+
+        self._archive_srcpkg = func(
+            package=self._pkgname,
+            version=self._version,
+            workdir=workdir,
+            quiet=True,
+            dscfile=dsc,
+        )
         for f in files:
             self._archive_srcpkg._download_file(f, f.split('/')[-1])
 
@@ -205,62 +219,6 @@ class GitUbuntuSourcePackageInformation:
         return self._spphr.pocket
 
     @property
-    def pretty_head_name(self):
-        if self._spphr.pocket.lower() == 'release':
-            head_name = '%s/%s' % (
-            self.distribution.name.lower(),
-            self.series.name.lower(),
-            )
-        else:
-            head_name = '%s/%s-%s' % (
-            self.distribution.name.lower(),
-            self.series.name.lower(),
-            self.pocket.lower()
-            )
-        return head_name
-
-    def head_name(self, prefix):
-        if self._spphr.pocket.lower() == 'release':
-            head_name = '%s/%s/%s' % (
-            prefix,
-            self.distribution.name.lower(),
-            self.series.name.lower(),
-            )
-        else:
-            head_name = '%s/%s/%s-%s' % (
-            prefix,
-            self.distribution.name.lower(),
-            self.series.name.lower(),
-            self.pocket.lower()
-            )
-        return head_name
-
-    def applied_head_name(self, prefix):
-       return self.head_name('%s/applied' % prefix)
-
-    def parent_head_name(self, prefix):
-        if self.parent_series == None:
-            return None
-        if self.pocket.lower() == 'release':
-            # release pockets descend from prior series
-            head_name = '%s/%s/%s' % (
-            prefix,
-            self.distribution.name.lower(),
-            self.parent_series.name.lower()
-            )
-        else:
-            # non-release pockets descend from release
-            head_name = '%s/%s/%s' % (
-            prefix,
-            self.distribution.name.lower(),
-            self.series.name.lower()
-            )
-        return head_name
-
-    def parent_applied_head_name(self, prefix):
-        return self.parent_head_name('%s/applied' % prefix)
-
-    @property
     def dsc(self):
         return self._archive_srcpkg.dsc
 
@@ -298,11 +256,16 @@ class GitUbuntuSourceInformation(object):
     _stable_series_list = None
     _current_series = None
 
-    def __init__(self, dist_name, pkgname=None,
-                 pull_overrides_filename='/dev/null',
-                 retries=0,
-                 retry_backoffs=[]
-                ):
+    def __init__(
+        self,
+        dist_name,
+        pkgname=None,
+        pull_overrides_filename='/dev/null',
+        retries=0,
+        retry_backoffs=None,
+    ):
+        if not retry_backoffs:
+            retry_backoffs = []
         self.launchpad = launchpad_login()
         self.dist_name = dist_name
         if self.dist_name.startswith('ppa:'):
@@ -327,18 +290,6 @@ class GitUbuntuSourceInformation(object):
         self.retries = retries
         self.retry_backoffs = retry_backoffs
 
-    @staticmethod
-    def _head_version_is_equal(head_versions, namespace, spi):
-        try:
-            if (head_versions[spi.head_name(namespace)]['version'] == spi.version and
-                (spi.date_published is None or
-                 int(spi.date_published.timestamp()) == head_versions[spi.head_name(namespace)]['head'].peel().commit_time)
-                ):
-                 return True
-            return False
-        except KeyError:
-            return False
-
     @property
     def current_series(self):
         if self.dist_name.startswith('ppa:'):
@@ -405,19 +356,25 @@ class GitUbuntuSourceInformation(object):
     def all_series_name_list(self):
         return [r.name for r in self.all_series]
 
-    def get_corrected_spi(self, srcpkg, workdir=None):
-       try:
-           pull_override = self.pull_overrides[srcpkg.source_package_version]
-           dsc = pull_override['dsc']
-           files = pull_override['files']
-       except KeyError:
-           dsc = None
-           files = list()
-       return GitUbuntuSourcePackageInformation(srcpkg, self.dist_name,
-           self.retries, self.retry_backoffs, workdir=workdir,
-           dsc=dsc, files=files)
-
-    def launchpad_version_is_published(self, version, workdir=None):
+    def get_corrected_spi(self, srcpkg, workdir):
+        try:
+            pull_override = self.pull_overrides[srcpkg.source_package_version]
+            dsc = pull_override['dsc']
+            files = pull_override['files']
+        except KeyError:
+            dsc = None
+            files = list()
+        return GitUbuntuSourcePackageInformation(
+            srcpkg,
+            self.dist_name,
+            self.retries,
+            self.retry_backoffs,
+            workdir=workdir,
+            dsc=dsc,
+            files=files,
+        )
+
+    def launchpad_version_is_published(self, version):
         spph = self.archive.getPublishedSources(
             exact_match=True,
             source_name=self.pkgname,
@@ -426,13 +383,16 @@ class GitUbuntuSourceInformation(object):
         )
         return len(spph) != 0
 
-    def launchpad_versions_published(self, workdir=None,
-        sorted_by_version=False, series=None
+    def launchpad_versions_published(
+        self,
+        workdir=None,
+        sorted_by_version=False,
+        series=None,
     ):
         args = {
-                'exact_match':True,
-                'source_name':self.pkgname,
-               }
+            'exact_match':True,
+            'source_name':self.pkgname,
+        }
         if not sorted_by_version:
             args['order_by_date'] = True
         if series:
@@ -440,18 +400,50 @@ class GitUbuntuSourceInformation(object):
 
         spph = self.archive.getPublishedSources(**args)
         if len(spph) == 0:
-            raise NoPublicationHistoryException("Is %s published in %s?" %
-                                                (self.pkgname, self.dist_name))
+            raise NoPublicationHistoryException(
+                "Is %s published in %s?" % (
+                    self.pkgname,
+                    self.dist_name,
+                )
+            )
 
         for srcpkg in spph:
             yield self.get_corrected_spi(srcpkg, workdir)
 
-    def launchpad_versions_published_after(self, head_versions, namespace, workdir=None, active_series_only=False):
+    def launchpad_versions_published_after(
+        self,
+        head_versions,
+        head_ref_namespace,
+        workdir=None,
+        active_series_only=False,
+    ):
+        """Provide Launchpad publishing information after a certain
+        publishing event
+
+        :param head_versions dict Dictionary of dictionaries, keyed by
+            Git branch names, where each element is a dictionary with
+            elements 'version' and 'head'
+        :param head_ref_namespace str Git ref namespace corresponding to
+            the branches in @head_versions
+        :param workdir str Filesystem path to store the downloaded
+            source package(s) in
+        :param active_series_only bool Only publishing records from
+            active series should be considered
+
+        @head_versions[<branch>]['head'] is a pygit2.Branch object
+        @head_versions[<branch>]['version'] is the string version of the
+            top debian/changelog in the corresponding Git branch.
+
+        :rtype iterable
+        :returns iterable over GitUbuntuSourcePackageInformation
+            objects, one per Launchpad publishing record after
+            @head_version
+        """
         args = {
-                'exact_match':True,
-                'source_name':self.pkgname,
-                'order_by_date':True,
-               }
+            'exact_match':True,
+            'source_name':self.pkgname,
+            'order_by_date':True,
+        }
 
         # we have the date of the commit too, so we can double-check
         # that it matches
@@ -472,14 +464,33 @@ class GitUbuntuSourceInformation(object):
         # Sanity check that the passed in srcpkg name has a publication
         # history
         if len(spph) == 0:
-            raise NoPublicationHistoryException("Is %s published in %s?" %
-                                                (self.pkgname, self.dist_name))
-        if len(head_versions) > 0:
+            raise NoPublicationHistoryException(
+                "Is %s published in %s?" % (
+                    self.pkgname,
+                    self.dist_name,
+                )
+            )
+        if head_versions:
             _spph = list()
             for spphr in spph:
-                spi = GitUbuntuSourcePackageInformation(spphr, self.dist_name,
-                                                        workdir=workdir)
-                if self._head_version_is_equal(head_versions, namespace, spi):
+                spi = GitUbuntuSourcePackageInformation(
+                    spphr,
+                    self.dist_name,
+                    workdir=workdir,
+                )
+                head_version = head_versions[
+                    gitubuntu.importerutils.head_ref_name(
+                        spi,
+                        head_ref_namespace,
+                    )
+                ]
+                if (
+                    head_version['version'] == str(spi.version) and
+                    spi.date_published and
+                    int(spi.date_published.timestamp()) == head_version[
+                        'head'
+                    ].peel().commit_time
+                ):
                     break
                 _spph.append(spphr)
             spph = _spph