Merge lp:~jelmer/bzr-builddeb/dep3-patch into lp:bzr-builddeb

[Jelmer Vernooij]

Add a 'bzr dep3-patch' command which can spit out a -p1 patch with a DEP-3 compliant
header, looking at bzr metadata to pre-fill-in as much of the metadata as possible.

Another neat thing to do would be to use this new infrastructure to export a
set of loom threads to a debian/patches directory, but I'll leave that for some
other time.

[James Westby (james-w)]

review: Approve

=== modified file '__init__.py'
--- __init__.py	2011-02-19 20:43:49 +0000
+++ __init__.py	2011-05-08 15:53:28 +0000
@@ -37,6 +37,7 @@
 commands = {
         "bd_do": [],
         "builddeb": ["bd"],
+        "dep3_patch": [],
         "dh_make": ["dh_make"],
         "import_dsc": [],
         "import_upstream": [],

=== modified file 'cmds.py'
--- cmds.py	2011-04-29 22:32:59 +0000
+++ cmds.py	2011-05-08 15:53:28 +0000
@@ -1205,3 +1205,73 @@
         note('Package prepared in %s'
                 % urlutils.unescape_for_display(tree.basedir,
                     self.outf.encoding))
+
+
+class cmd_dep3_patch(Command):
+    """Format the changes in a branch as a DEP-3 patch.
+
+    """
+
+    takes_args = ["location"]
+
+    directory_opt = Option('directory',
+                           help='Packaging tree for which to generate patch.',
+                           short_name='d', type=unicode)
+
+    no_upstream_check_opt = Option('no-upstream-check',
+        help="Don't check whether patch has been merged upstream.")
+
+    takes_options = [directory_opt, "revision", no_upstream_check_opt]
+
+    def run(self, location, directory=".", revision=None, no_upstream_check=False):
+        from bzrlib.plugins.builddeb.dep3 import (
+            determine_applied_upstream,
+            determine_forwarded,
+            describe_origin,
+            gather_bugs_and_authors,
+            write_dep3_patch,
+            )
+        packaging_tree, packaging_branch = BzrDir.open_containing_tree_or_branch(
+            directory)[:2]
+        tree, branch = BzrDir.open_containing_tree_or_branch(location)[:2]
+        branch.lock_read()
+        try:
+            if revision is not None and len(revision) >= 1:
+                revision_id = revision[-1].as_revision_id(branch)
+            else:
+                revision_id = branch.last_revision()
+            graph = branch.repository.get_graph(packaging_branch.repository)
+            if revision is not None and len(revision) == 2:
+                base_revid = revision[0].as_revision_id(branch)
+            else:
+                base_revid = graph.find_unique_lca(revision_id,
+                    packaging_branch.last_revision())
+            interesting_revision_ids = graph.find_unique_ancestors(revision_id, [base_revid])
+            if len(interesting_revision_ids) == 0:
+                raise BzrCommandError("No unmerged revisions")
+            (bugs, authors, last_update) = gather_bugs_and_authors(branch.repository,
+                interesting_revision_ids)
+            config = branch.get_config()
+            description = config.get_user_option("description")
+            if description is None and len(interesting_revision_ids) == 1:
+                # if there's just one revision, use that revisions commits message
+                rev = branch.repository.get_revision(iter(interesting_revision_ids).next())
+                description = rev.message
+            origin = describe_origin(branch, revision_id)
+            if packaging_tree is None:
+                packaging_tree = packaging_branch.basis_tree()
+            builddeb_config = debuild_config(packaging_tree, True)
+            if not no_upstream_check and builddeb_config.upstream_branch:
+                upstream_branch = Branch.open(builddeb_config.upstream_branch)
+                applied_upstream = determine_applied_upstream(upstream_branch, branch,
+                    revision_id)
+                forwarded = determine_forwarded(upstream_branch, branch, revision_id)
+            else:
+                applied_upstream = None
+                forwarded = None
+            write_dep3_patch(self.outf, branch, base_revid,
+                revision_id, bugs=bugs, authors=authors, origin=origin,
+                forwarded=forwarded, applied_upstream=applied_upstream,
+                description=description, last_update=last_update)
+        finally:
+            branch.unlock()

=== modified file 'debian/changelog'
--- debian/changelog	2011-05-06 16:43:16 +0000
+++ debian/changelog	2011-05-08 15:53:28 +0000
@@ -1,3 +1,10 @@
+bzr-builddeb (2.7.5) UNRELEASED; urgency=low
+
+  * New 'bzr dep3-patch' subcommand that can generate DEP-3 compliant
+    patches. LP: #460576
+
+ -- Jelmer Vernooij <[e-mail]>  Sun, 08 May 2011 17:45:14 +0200
+
 bzr-builddeb (2.7.4) unstable; urgency=low
 
   [ Jelmer Vernooij ]

=== added file 'dep3.py'
--- dep3.py	1970-01-01 00:00:00 +0000
+++ dep3.py	2011-05-08 15:53:28 +0000
@@ -0,0 +1,177 @@
+#    dep3.py -- DEP-3 compatible patch formatting
+#    Copyright (C) 2011 Canonical Ltd.
+#
+#    This file is part of bzr-builddeb.
+#
+#    bzr-builddeb is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    bzr-builddeb is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with bzr-builddeb; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+"""DEP-3 style patch formatting."""
+
+from bzrlib import diff
+
+import time
+
+
+def write_dep3_bug_line(f, bug_url, status):
+    """Write a DEP-3 compatible line with a bug link.
+
+    :param f: File-like object to write to
+    :param bug_url: Bug URL
+    :param status: Bug status (e.g. "fixed")
+    """
+    # For the moment, we only care about fixed bugs
+    if status != "fixed":
+        return
+    if bug_url.startswith("http://bugs.debian.org/"):
+        f.write("Bug-Debian: %s\n" % bug_url)
+    else:
+        # FIXME: Filter out Ubuntu bugs on Launchpad
+        f.write("Bug: %s\n" % bug_url)
+
+
+def write_dep3_patch_header(f, description=None, origin=None, forwarded=None,
+        bugs=None, authors=None, revision_id=None, last_update=None,
+        applied_upstream=None):
+    """Write a DEP3 patch header.
+
+    :param f: File-like object to write to
+    :param description: Description of the patch
+    :param origin: Single line describing the origin of the patch
+    :param forwarded: Single line describing whether and how the patch was
+        forwarded
+    :param bugs: Set of bugs fixed in this patch
+    :param authors: Authors of the patch
+    :param revision_id: Relevant bzr revision id
+    :param last_update: Last update timestamp
+    :param applied_upstream: If the patch is applied upstream,
+        an informal string describing where it was merged
+    """
+    # FIXME: Handle line breaks, etc sensibly
+    if description is not None:
+        description = description.strip("\n")
+        description = description.replace("\n\n", "\n.\n")
+        description = description.replace("\n", "\n ")
+        f.write("Description: %s\n" % description)
+    if origin is not None:
+        f.write("Origin: %s\n" % origin)
+    if forwarded is not None:
+        f.write("Forwarded: %s\n" % forwarded)
+    if authors is not None:
+        for author in authors:
+            f.write("Author: %s\n" % author)
+    if bugs is not None:
+        for bug_url, status in bugs:
+            write_dep3_bug_line(f, bug_url, status)
+    if last_update is not None:
+        f.write("Last-Update: %s\n" % time.strftime("%Y-%m-%d",
+            time.gmtime(last_update)))
+    if applied_upstream is not None:
+        f.write("Applied-Upstream: %s\n" % applied_upstream)
+    if revision_id is not None:
+        f.write("X-Bzr-Revision-Id: %s\n" % revision_id)
+    f.write("\n")
+
+
+def gather_bugs_and_authors(repository, interesting_revision_ids):
+    """Gather bug and author information from revisions.
+
+    :param interesting_revision_ids: Iterable of revision ids to check
+    :return: Tuple of bugs, authors and highest found commit timestamp
+    """
+    authors = set()
+    bugs = set()
+    last_update = None
+    for rev in repository.get_revisions(interesting_revision_ids):
+        last_update = max(rev.timestamp, last_update)
+        authors.update(rev.get_apparent_authors())
+        bugs.update(rev.iter_bugs())
+    return (bugs, authors, last_update)
+
+
+def determine_applied_upstream(upstream_branch, feature_branch, feature_revid=None):
+    """Check if a particular revision has been merged upstream.
+
+    :param upstream_branch: Upstream branch object
+    :param feature_branch: Feature branch
+    :param feature_revid: Revision id in feature branch to check,
+        defaults to feature_branch tip.
+    :return: String that can be used for Applied-Upstream field
+    """
+    if feature_revid is None:
+        feature_revid = feature_branch.last_revision()
+    upstream_graph = feature_branch.repository.get_graph(upstream_branch.repository)
+    merger = upstream_graph.find_lefthand_merger(feature_revid,
+        upstream_branch.last_revision())
+    if merger is not None:
+        return "merged in revision %s" % (
+            ".".join(str(x) for x in upstream_branch.revision_id_to_dotted_revno(merger)), )
+    else:
+        return "no"
+
+
+def determine_forwarded(upstream_branch, feature_branch, feature_revid):
+    """See if a branch has been forwarded to upstream.
+
+    :param upstream_branch: Upstream branch object
+    :param feature_branch: Feature branch
+    :param feature_revid: Revision id in feature branch to check
+    :return: String that can be used for Applied-Upstream field
+    """
+    # FIXME: Check for Launchpad merge proposals from feature_branch (or its
+    # public_branch) to upstream_branch
+
+    # Are there any other ways to see that a patch has been forwarded upstream?
+    return None
+
+
+def describe_origin(branch, revid):
+    """Describe a tree for use in the origin field.
+
+    :param branch: Branch to retrieve the revision from
+    :param revid: Revision id
+    """
+    public_branch_url = branch.get_public_branch()
+    if public_branch_url is not None:
+        return "commit, %s, revision: %s" % (
+            public_branch_url,
+            ".".join(str(x) for x in branch.revision_id_to_dotted_revno(revid)), )
+    else:
+        return "commit, revision id: %s" % revid
+
+
+def write_dep3_patch(f, branch, base_revid, target_revid, description=None,
+        origin=None, forwarded=None, applied_upstream=None, bugs=None,
+        authors=None, last_update=None):
+    """Write a DEP-3 compliant patch.
+
+    :param f: File-like object to write to
+    :param repository: Repository to retrieve revisions from
+    :param base_revid: Base revision id
+    :param target_revid: Target revision id
+    :param description: Optional description
+    :param forwarded: Optional information on if/how the patch was forwarded
+    :param applied_upstream: Optional information on how whether the patch
+        was merged upstream
+    :param bugs: Sequence of bug reports related to this patch
+    :param authors: Sequence of authors of this patch
+    :param last_update: Timestamp for last time this patch was updated
+    """
+    write_dep3_patch_header(f, bugs=bugs, authors=authors, last_update=last_update,
+            description=description, revision_id=target_revid, origin=origin,
+            applied_upstream=applied_upstream, forwarded=forwarded)
+    old_tree = branch.repository.revision_tree(base_revid)
+    new_tree = branch.repository.revision_tree(target_revid)
+    diff.show_diff_trees(old_tree, new_tree, f, old_label='old/', new_label='new/')

=== modified file 'tests/__init__.py'
--- tests/__init__.py	2011-02-11 13:35:53 +0000
+++ tests/__init__.py	2011-05-08 15:53:28 +0000
@@ -119,6 +119,7 @@
             'test_bzrtools_import',
             'test_commit_message',
             'test_config',
+            'test_dep3',
             'test_dh_make',
             'test_hooks',
             'test_import_dsc',

=== modified file 'tests/blackbox/__init__.py'
--- tests/blackbox/__init__.py	2010-05-03 03:03:34 +0000
+++ tests/blackbox/__init__.py	2011-05-08 15:53:28 +0000
@@ -18,12 +18,11 @@
 #    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #
 
-from bzrlib.tests import TestUtil
-
 
 def load_tests(standard_tests, module, loader):
   testmod_names = [
           'test_builddeb',
+          'test_dep3',
           'test_do',
           'test_import_dsc',
           'test_import_upstream',

=== added file 'tests/blackbox/test_dep3.py'
--- tests/blackbox/test_dep3.py	1970-01-01 00:00:00 +0000
+++ tests/blackbox/test_dep3.py	2011-05-08 15:53:28 +0000
@@ -0,0 +1,104 @@
+#    test_dep3.py -- Blackbox tests for dep3-patch.
+#    Copyright (C) 2011 Canonical Ltd.
+#
+#    This file is part of bzr-builddeb.
+#
+#    bzr-builddeb is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    bzr-builddeb is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with bzr-builddeb; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+
+"""Blackbox tests for "bzr dep3-patch"."""
+
+
+from bzrlib.tests.blackbox import ExternalBase
+
+import os
+
+
+class TestDep3Patch(ExternalBase):
+
+    def setUp(self):
+        super(TestDep3Patch, self).setUp()
+        self.upstream_tree = self.make_branch_and_tree("upstream")
+        self.upstream_tree.commit(message="initial commit")
+        packaging = self.upstream_tree.bzrdir.sprout("packaging")
+        self.packaging_tree = packaging.open_workingtree()
+        feature = self.upstream_tree.bzrdir.sprout("feature")
+        self.feature_tree = feature.open_workingtree()
+
+    def test_nothing_to_do(self):
+        (out, err) = self.run_bzr("dep3-patch -d packaging feature", retcode=3)
+        self.assertEquals("bzr: ERROR: No unmerged revisions\n", err)
+        self.assertEquals("", out)
+
+    def test_simple(self):
+        # If there is a single revision the commit message from
+        # that revision will be used.
+        self.build_tree_contents([("feature/foo", "bar\n")])
+        self.feature_tree.add("foo")
+        self.feature_tree.commit(message="A message", timestamp=1304850124,
+            timezone=0, authors=["Jelmer <[e-mail]>"], rev_id="therevid")
+        (out, err) = self.run_bzr("dep3-patch -d packaging feature")
+        self.assertEquals(out, "Description: A message\n"
+            "Origin: commit, revision id: therevid\n"
+            "Author: Jelmer <[e-mail]>\n"
+            "Last-Update: 2011-05-08\n"
+            "X-Bzr-Revision-Id: therevid\n"
+            "\n"
+            "=== added file 'foo'\n"
+            "--- old/foo\t1970-01-01 00:00:00 +0000\n"
+            "+++ new/foo\t2011-05-08 10:22:04 +0000\n"
+            "@@ -0,0 +1,1 @@\n"
+            "+bar\n"
+            "\n")
+
+    def test_uses_single_revision_commit(self):
+        # If there is a single revision the commit message from
+        # that revision will be used.
+        self.feature_tree.commit(message="A message", timestamp=1304850124,
+            timezone=0, authors=["Jelmer <[e-mail]>"])
+        (out, err) = self.run_bzr("dep3-patch -d packaging feature")
+        self.assertContainsRe(out, "Description: A message\n")
+
+    def test_uses_config_description(self):
+        config = self.feature_tree.branch.get_config()
+        config.set_user_option("description", "What this does")
+        self.feature_tree.commit(message="a message")
+        (out, err) = self.run_bzr("dep3-patch -d packaging feature")
+        self.assertContainsRe(out, "Description: What this does\n")
+
+    def test_upstream_branch(self):
+        os.mkdir('packaging/.bzr-builddeb/')
+        f = open('packaging/.bzr-builddeb/local.conf', 'wb')
+        try:
+            f.write('[BUILDDEB]\nupstream-branch = %s\n' %
+                    self.upstream_tree.branch.base)
+        finally:
+            f.close()
+        self.feature_tree.commit(message="a message")
+        (out, err) = self.run_bzr("dep3-patch -d packaging feature")
+        self.assertContainsRe(out, "Applied-Upstream: no\n")
+
+    def test_upstream_branch_disabled(self):
+        os.mkdir('packaging/.bzr-builddeb/')
+        f = open('packaging/.bzr-builddeb/local.conf', 'wb')
+        try:
+            f.write('[BUILDDEB]\nupstream-branch = %s\n' %
+                    self.upstream_tree.branch.base)
+        finally:
+            f.close()
+        self.feature_tree.commit(message="a message")
+        (out, err) = self.run_bzr("dep3-patch --no-upstream-check -d packaging feature")
+        self.assertNotContainsRe(out, "Applied-Upstream")

=== added file 'tests/test_dep3.py'
--- tests/test_dep3.py	1970-01-01 00:00:00 +0000
+++ tests/test_dep3.py	2011-05-08 15:53:28 +0000
@@ -0,0 +1,217 @@
+#    test_dep3.py -- Testsuite for builddeb dep3.py
+#    Copyright (C) 2011 Canonical Ltd.
+#
+#    This file is part of bzr-builddeb.
+#
+#    bzr-builddeb is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    bzr-builddeb is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with bzr-builddeb; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+from cStringIO import StringIO
+
+import rfc822
+
+from bzrlib.revision import (
+    NULL_REVISION,
+    )
+from bzrlib.tests import (
+    TestCase,
+    TestCaseWithTransport,
+    )
+
+from bzrlib.plugins.builddeb.dep3 import (
+    describe_origin,
+    determine_applied_upstream,
+    gather_bugs_and_authors,
+    write_dep3_bug_line,
+    write_dep3_patch,
+    write_dep3_patch_header,
+    )
+
+
+class Dep3HeaderTests(TestCase):
+
+    def dep3_header(self, description=None, origin=None, forwarded=None,
+            bugs=None, authors=None, revision_id=None, last_update=None,
+            applied_upstream=None):
+        f = StringIO()
+        write_dep3_patch_header(f, description=description, origin=origin,
+            forwarded=forwarded, bugs=bugs, authors=authors,
+            revision_id=revision_id, last_update=last_update,
+            applied_upstream=applied_upstream)
+        f.seek(0)
+        return rfc822.Message(f)
+
+    def test_description(self):
+        ret = self.dep3_header(description="This patch fixes the foobar")
+        self.assertEquals("This patch fixes the foobar", ret["Description"])
+
+    def test_last_updated(self):
+        ret = self.dep3_header(last_update=1304840034)
+        self.assertEquals("2011-05-08", ret["Last-Update"])
+
+    def test_revision_id(self):
+        ret = self.dep3_header(revision_id="myrevid")
+        self.assertEquals("myrevid", ret["X-Bzr-Revision-Id"])
+
+    def test_authors(self):
+        authors = [
+            "Jelmer Vernooij <[e-mail]>",
+            "James Westby <[e-mail]>"]
+        ret = self.dep3_header(authors=authors)
+        self.assertEquals([
+            ("Jelmer Vernooij", "[e-mail]"),
+            ("James Westby", "[e-mail]")],
+            ret.getaddrlist("Author"))
+
+    def test_origin(self):
+        ret = self.dep3_header(origin="Cherrypick from upstream")
+        self.assertEquals("Cherrypick from upstream",
+            ret["Origin"])
+
+    def test_forwarded(self):
+        ret = self.dep3_header(forwarded="not needed")
+        self.assertEquals("not needed",
+            ret["Forwarded"])
+
+    def test_applied_upstream(self):
+        ret = self.dep3_header(applied_upstream="commit 45")
+        self.assertEquals("commit 45", ret["Applied-Upstream"])
+
+    def test_bugs(self):
+        bugs = [
+            ("http://bugs.debian.org/424242", "fixed"),
+            ("https://bugs.launchpad.net/bugs/20110508", "fixed"),
+            ("http://bugzilla.samba.org/bug.cgi?id=52", "fixed")]
+        ret = self.dep3_header(bugs=bugs)
+        self.assertEquals([
+            "https://bugs.launchpad.net/bugs/20110508",
+            "http://bugzilla.samba.org/bug.cgi?id=52"],
+            ret.getheaders("Bug"))
+        self.assertEquals(["http://bugs.debian.org/424242"],
+            ret.getheaders("Bug-Debian"))
+
+    def test_write_bug_fix_only(self):
+        # non-fixed bug lines are ignored
+        f = StringIO()
+        write_dep3_bug_line(f, "http://bar/", "pending")
+        self.assertEquals("", f.getvalue())
+
+    def test_write_normal_bug(self):
+        f = StringIO()
+        write_dep3_bug_line(f, "http://bugzilla.samba.org/bug.cgi?id=42",
+            "fixed")
+        self.assertEquals("Bug: http://bugzilla.samba.org/bug.cgi?id=42\n",
+            f.getvalue())
+
+    def test_write_debian_bug(self):
+        f = StringIO()
+        write_dep3_bug_line(f, "http://bugs.debian.org/234354", "fixed")
+        self.assertEquals("Bug-Debian: http://bugs.debian.org/234354\n",
+            f.getvalue())
+
+
+class GatherBugsAndAuthors(TestCaseWithTransport):
+
+    def test_none(self):
+        branch = self.make_branch(".")
+        self.assertEquals((set(), set(), None),
+            gather_bugs_and_authors(branch.repository, []))
+
+    def test_multiple_authors(self):
+        tree = self.make_branch_and_tree(".")
+        revid1 = tree.commit(authors=["Jelmer Vernooij <[e-mail]>"],
+                timestamp=1304844311, message="msg")
+        revid2 = tree.commit(authors=["Max Bowsher <[e-mail]>"],
+                timestamp=1304844278, message="msg")
+        self.assertEquals((set(), set([
+            "Jelmer Vernooij <[e-mail]>",
+            "Max Bowsher <[e-mail]>"]), 1304844311),
+            gather_bugs_and_authors(tree.branch.repository, [revid1, revid2]))
+
+    def test_bugs(self):
+        tree = self.make_branch_and_tree(".")
+        revid1 = tree.commit(authors=["Jelmer Vernooij <[e-mail]>"],
+                timestamp=1304844311, message="msg", revprops={"bugs":
+                    "http://bugs.samba.org/bug.cgi?id=2011 fixed\n"})
+        self.assertEquals((
+            set([("http://bugs.samba.org/bug.cgi?id=2011", "fixed")]),
+            set(["Jelmer Vernooij <[e-mail]>"]), 1304844311),
+            gather_bugs_and_authors(tree.branch.repository, [revid1]))
+
+
+class DetermineAppliedUpstreamTests(TestCaseWithTransport):
+
+    def test_not_applied(self):
+        upstream = self.make_branch_and_tree("upstream")
+        feature = self.make_branch_and_tree("feature")
+        feature.commit(message="every bloody emperor")
+        self.addCleanup(feature.lock_read().unlock)
+        self.assertEquals("no",
+            determine_applied_upstream(upstream.branch, feature.branch))
+
+    def test_merged(self):
+        upstream = self.make_branch_and_tree("upstream")
+        upstream.commit(message="initial upstream commit")
+        feature = upstream.bzrdir.sprout("feature").open_workingtree()
+        feature.commit(message="nutter alert")
+        upstream.merge_from_branch(feature.branch)
+        upstream.commit(message="merge feature")
+        self.addCleanup(upstream.lock_read().unlock)
+        self.addCleanup(feature.lock_read().unlock)
+        self.assertEquals("merged in revision 2",
+            determine_applied_upstream(upstream.branch, feature.branch))
+
+
+class DescribeOriginTests(TestCaseWithTransport):
+
+    def test_no_public_branch(self):
+        tree = self.make_branch_and_tree(".")
+        revid1 = tree.commit(message="msg1")
+        self.assertEquals("commit, revision id: %s" % revid1,
+            describe_origin(tree.branch, revid1))
+
+    def test_public_branch(self):
+        tree = self.make_branch_and_tree(".")
+        tree.branch.set_public_branch("http://example.com/public")
+        revid1 = tree.commit(message="msg1")
+        self.assertEquals("commit, http://example.com/public, revision: 1",
+            describe_origin(tree.branch, revid1))
+
+
+class FullDep3PatchTests(TestCaseWithTransport):
+
+    def test_simple(self):
+        f = StringIO()
+        tree = self.make_branch_and_tree(".")
+        self.build_tree_contents([("foo", "data")])
+        tree.add("foo")
+        revid = tree.commit("msg", rev_id="arevid", timestamp=1304849661,
+            timezone=0)
+        write_dep3_patch(f, tree.branch, NULL_REVISION, revid,
+            description="Nutter alert",
+            forwarded="not needed",
+            authors=set(["Jelmer <[e-mail]>"]))
+        self.assertEquals("Description: Nutter alert\n"
+            "Forwarded: not needed\n"
+            "Author: Jelmer <[e-mail]>\n"
+            "X-Bzr-Revision-Id: arevid\n"
+            "\n"
+            "=== added file 'foo'\n"
+            "--- old/foo\t1970-01-01 00:00:00 +0000\n"
+            "+++ new/foo\t2011-05-08 10:14:21 +0000\n"
+            "@@ -0,0 +1,1 @@\n"
+            "+data\n"
+            "\\ No newline at end of file\n"
+            "\n", f.getvalue())