Merge lp:~oddbloke/pqm/merge-directives into lp:pqm

[Dan Watkins]

[Robert Collins (lifeless)]

overall good.

A few issues:

 - uses more shell tests rather than python unit tests
 - the new Command class won't render correctly in the web GUI
 - I don't like the merge_callback lambda usage, its unobvious and doesn't seem necessary.

overall - resubmit

review: Disapprove

[Dan Watkins (oddbloke)]

To address Robert's issues:

> - uses more shell tests rather than python unit tests
I'm not sure what the Python tests are missing. If you could give me some suggestions, I'd be happy to put them into practice.

> - the new Command class won't render correctly in the web GUI
Fixed.

> - I don't like the merge_callback lambda usage, its unobvious and doesn't seem necessary.
I agree. Fixed. In the process, replay merge became its own Command (rather than being a part of CommandRunner) to stop my head exploding because of the broken merge abstraction we had.

[Robert Collins (lifeless)]

On Sun, 2008-08-24 at 03:29 +0000, Daniel Watkins wrote:
> To address Robert's issues:
>
> > - uses more shell tests rather than python unit tests
> I'm not sure what the Python tests are missing. If you could give me some suggestions, I'd be happy to put them into practice.

Well, there are new shell tests; either they are redundant (in which
case, remove em :)) or they test something not tested in the python
tests (in which case move them into python tests).

> > - the new Command class won't render correctly in the web GUI
> Fixed.
>
> > - I don't like the merge_callback lambda usage, its unobvious and doesn't seem necessary.
> I agree. Fixed. In the process, replay merge became its own Command (rather than being a part of CommandRunner) to stop my head exploding because of the broken merge abstraction we had.

Cool - thanks.

-Rob

--
GPG key available at: <http://www.robertcollins.net/keys.txt>.

[Tim Penhey (thumper)]

Were you going to remove the shell tests?

[Dan Watkins (oddbloke)]

On Wed, 2008-11-26 at 06:40 +0000, Tim Penhey wrote:
> Were you going to remove the shell tests?
I believe the intent is to replace them with Python unit tests, in time.

[Tim Penhey (thumper)]

On Wed, 26 Nov 2008 22:51:31 Daniel Watkins wrote:
> On Wed, 2008-11-26 at 06:40 +0000, Tim Penhey wrote:
> > Were you going to remove the shell tests?
>
> I believe the intent is to replace them with Python unit tests, in
> time.

OK, I'll look to include this in my integration branch shortly (not
tonight).

[Robert Collins (lifeless)]

Needs conflicts fixing at minimum.

review: Needs Resubmitting

Unmerged revisions

181. By Dan Watkins on 2008-08-23

Readded replay merge as ReplayMergeCommand.

180. By Dan Watkins on 2008-08-23

Removed use of merge_callback.

179. By Dan Watkins on 2008-08-23

Refactored merge code from Command to MergeCommand.

178. By Dan Watkins on 2008-08-23

Removed replay legacy command.

177. By Dan Watkins on 2008-08-23

ExtendedMergeCommands now work with the UI correctly.

176. By Dan Watkins on 2008-08-23

Merged pqm.dev r183.

175. By Dan Watkins on 2008-07-17

Fixed failing tests.

174. By Dan Watkins on 2008-07-17

Merged pqm.dev r182, without fixing tests.

173. By Dan Watkins on 2008-07-09

Fixed issues with PGP headers and footers in merge directive mail.

172. By Dan Watkins on 2008-07-09

Modified test to step around issues with detecting which VCS a branch uses.

=== modified file '.bzrignore'
--- .bzrignore	2009-08-30 02:09:42 +0000
+++ .bzrignore	2010-05-04 16:39:23 +0000
@@ -8,6 +8,7 @@
 configure
 autotools/*
 tests/.gnupg/*
+./bzr
 twistd.log*
 tests/workdir
 bzr

=== modified file 'pqm/__init__.py'
--- pqm/__init__.py	2010-04-20 12:11:40 +0000
+++ pqm/__init__.py	2010-05-04 16:39:23 +0000
@@ -25,9 +25,21 @@
 import re
 import stat
 import string
+from StringIO import StringIO
 import sys
 
+<<<<<<< TREE
 from pqm.core import do_mkdir
+=======
+from bzrlib import (
+    errors,
+    merge_directive,
+    testament,
+    )
+
+from PQMConfigParser import ConfigParser
+
+>>>>>>> MERGE-SOURCE
 from pqm.errors import PQMException, PQMTlaFailure
 from pqm.script import Script
 
@@ -420,20 +432,85 @@
         return output
 
     def do_star_merge(self, sender, from_branch, local_dir):
+<<<<<<< TREE
         import bzrlib.errors
+=======
+        return self._do_bzr_merge(sender, None, None, local_dir, from_branch,
+        None)
+
+    def do_bzr_merge(self, sender, revision_id, testament_sha1,
+                     local_dir, from_branch=None, bundle=None):
+        if None in (revision_id, testament_sha1):
+            raise PQMTlaFailure(sender, ['required argument missing'])
+        return self._do_bzr_merge(sender, revision_id, testament_sha1,
+                                  local_dir, from_branch, bundle)
+
+    def _do_bzr_merge(self, sender, revision_id, testament_sha1, local_dir,
+                      from_branch, bundle):
+        from bzrlib.branch import Branch
+        from bzrlib.bundle.apply_bundle import install_bundle
+        from bzrlib.bundle import serializer as bundle_serializer
+        from bzrlib.merge import Merger, Merge3Merger
+>>>>>>> MERGE-SOURCE
         from bzrlib.workingtree import WorkingTree
         tree = WorkingTree.open(local_dir)
         tree.lock_write()
         try:
+<<<<<<< TREE
             try:
                 return self._do_star_merge(sender, from_branch, local_dir, tree)
             except bzrlib.errors.UnrelatedBranches:
                 raise PQMTlaFailure(sender,
                     ['Branches have no common ancestor, and no merge base'
                      ' revision was specified.'])
+=======
+            merger = Merger(tree.branch, this_tree=tree)
+            merger.check_basis(True)
+            if from_branch is None and bundle is None:
+                raise PQMTlaFailure(sender,
+                    ['Either a branch or a bundle must be supplied'])
+
+            if bundle is not None:
+                other_branch = tree.branch
+                reader = bundle_serializer.read_bundle(StringIO(bundle))
+                install_bundle(other_branch.repository, reader)
+            else:
+                other_branch = Branch.open(from_branch)
+            if testament_sha1 is not None:
+                my_testament = testament.StrictTestament3.from_revision(
+                    other_branch.repository, revision_id)
+                if my_testament.as_sha1() != testament_sha1:
+                    raise PQMTlaFailure(sender,
+                        ['Revision testament mismatch: "%s" is not %s.' %
+                         (my_testament.as_sha1(), testament_sha1)])
+            if revision_id is None:
+                revision_id = other_branch.last_revision()
+            merger.set_other_revision(revision_id, other_branch)
+            merger.find_base()
+            if merger.base_rev_id == merger.other_rev_id:
+                raise PQMTlaFailure(sender, ['Nothing to merge.'])
+            merger.backup_files = False
+            merger.merge_type = Merge3Merger
+            merger.set_interesting_files(None)
+            merger.show_base = False
+            merger.reprocess = False
+            conflicts = merger.do_merge()
+            merger.set_pending()
+            if conflicts:
+                error_lines = ['Conflicts during merge: %s' % conflicts]
+                tree.lock_read()
+                try:
+                    for conflict in tree.conflicts():
+                        error_lines.append(str(conflict))
+                finally:
+                    tree.unlock()
+                raise PQMTlaFailure(sender, error_lines)
+            return ["merge successful"]
+>>>>>>> MERGE-SOURCE
         finally:
             tree.unlock()
 
+<<<<<<< TREE
     def _do_star_merge(self, sender, from_branch, local_dir, tree):
         from bzrlib.merge import Merger, Merge3Merger
         from bzrlib.tag import _merge_tags_if_possible
@@ -462,6 +539,8 @@
         _merge_tags_if_possible(merger.other_branch, tree.branch)
         return ["merge successful"]
         
+=======
+>>>>>>> MERGE-SOURCE
     def make_local_dir(self, sender, branch_spec, output_dir):
         from bzrlib.branch import Branch, BranchReferenceFormat
         import bzrlib.bzrdir as bzrdir

=== modified file 'pqm/script.py'
--- pqm/script.py	2010-04-21 22:38:26 +0000
+++ pqm/script.py	2010-05-04 16:39:23 +0000
@@ -36,6 +36,8 @@
 import config_manager
 import subunit.test_results
 
+from bzrlib import merge_directive
+import bzrlib.errors
 from pqm.errors import PQMCmdFailure, PQMException, PQMTlaFailure
 
 
@@ -192,6 +194,7 @@
     pgp_re = re.compile('^-----BEGIN PGP.*MESSAGE')
     pgp_end_re = re.compile('^-----BEGIN PGP SIG')
     # parser for merge recognition
+    replay_re = re.compile('^replay (\S+/\S+)\s+(\S+/\S+)\s*$')
     star_re = re.compile('^star-merge (\S+/\S+)\s+(\S+/\S+)\s*$')
     # parse matcher for the debug command
     debug_re = re.compile('^debug')
@@ -293,18 +296,59 @@
             result.append(line)
         return result
 
+    def getRawLines(self):
+        if not self.readComplete:
+            self._read()
+        return self.msg.get_payload().splitlines(True)
+
     def getCommands(self):
         """Get the actual command lines from the script."""
         self.logger.info("parsing commands")
         result = []
         legacy_lines = []
+        try:
+            md_lines = []
+            to_skip = 0
+            for line in self.getRawLines():
+                if to_skip:
+                    to_skip -= 1
+                    continue
+                if self.pgp_re.match(line):
+                    to_skip = 2
+                    continue
+                if self.pgp_end_re.match(line):
+                    break
+                md_lines.append(line)
+            directive = merge_directive.MergeDirective.from_lines(md_lines)
+        except bzrlib.errors.NotAMergeDirective:
+            pass
+        else:
+            result.append(ExtendedMergeCommand(self,
+                                               self._branch_spec_handler,
+                                               self._configp,
+                                               directive.revision_id,
+                                               directive.testament_sha1,
+                                               directive.message,
+                                               directive.target_branch,
+                                               directive.source_branch,
+                                               directive.get_raw_bundle(),
+                                       ))
+            return result
+
         for line in self.getLines():
             if not self.isCommand(line):
                 continue
             # identify and construct commands
+<<<<<<< TREE
             star_match = EmailScript.star_re.match(line)
             debug_match = EmailScript.debug_re.match(line)
             any_match = star_match or debug_match
+=======
+            debug_match = Script.debug_re.match(line)
+            replay_match = Script.replay_re.match(line)
+            star_match = Script.star_re.match(line)
+            any_match = debug_match or replay_match or star_match
+>>>>>>> MERGE-SOURCE
             if any_match and legacy_lines:
                 result.append(CommandRunner(self,
                                             self._branch_spec_handler,
@@ -323,8 +367,18 @@
             elif debug_match:
                 result.append(DebugCommand(self,
                                            self._branch_spec_handler,
+<<<<<<< TREE
                                            self._configp,
                                            self.manager))
+=======
+                                           self._configp))
+            elif replay_match:
+                result.append(ReplayMergeCommand(self,
+                                                 self._branch_spec_handler,
+                                                 self._configp,
+                                                 replay_match.group(1),
+                                                 replay_match.group(2)))
+>>>>>>> MERGE-SOURCE
             else:
                 legacy_lines.append(line)
         if legacy_lines:
@@ -621,6 +675,7 @@
             for top in os.listdir(possible_dir):
                 self.rm_rf(os.path.join(possible_dir, top))
 
+<<<<<<< TREE
     def do_merge(self, from_repo_revision, to_repo_revision, merge_name,
                  merge_method, line):
         # Record the start time for elapsed time calculation.
@@ -688,6 +743,8 @@
             # Launchpad notices merges 
             self.reported = True
 
+=======
+>>>>>>> MERGE-SOURCE
     def get_arch_impl(self):
         # TODO: Tim Penhey, 2008-05-28
         # Get rid of the imports from pqm module itself.
@@ -946,6 +1003,7 @@
     def run(self):
         super(MergeCommand, self).run()
         self.cleanup_wd()
+<<<<<<< TREE
         self.lp_mp = None
         if self.launchpad is None:
             self.from_branch_lp = None
@@ -988,6 +1046,112 @@
             self.manager.logger.error("Exception handling merge", exc_info=1)
             self.fail_operation("Exception processing merge: %s" % e)
         return CommandResult(self.successful, self.unrecognized, self.output, not self.reported)
+=======
+        self.do_merge(from_repo_revision=self.from_branch,
+                      to_repo_revision=self.to_branch,
+                      merge_name='star-merge',
+                      line='merge %s %s' % (self.from_branch, self.to_branch))
+        return self.successful, self.unrecognized, self.output
+>>>>>>> MERGE-SOURCE
+
+    def _do_merge(self, sender, dir):
+        return self.get_vcs().do_star_merge(sender, self.from_branch, dir)
+
+    def do_merge(self, from_repo_revision, to_repo_revision, merge_name,
+                 line):
+        sender = self.script.getSender()
+        # Star-merge
+        self.check_target(to_repo_revision, line)
+        to_repo_revision, config = self.getBranchConfig(to_repo_revision)
+        self.set_current_vcs(from_repo_revision, to_repo_revision)
+        self.validate_revision(from_repo_revision)
+        self.validate_revision(to_repo_revision)
+        self.check_commit_regex(to_repo_revision, config)
+        self.script.logger.info("current cwd is %s", os.getcwd())
+        self.script.logger.info("getting working dir for %s", to_repo_revision)
+        dir = self.get_wd(sender, to_repo_revision, config)
+        origdir = os.getcwd()
+        merge_line = 'Executing %s %s at %s' % (merge_name,
+                                                from_repo_revision,
+                                                time.strftime('%c'))
+        self.log_with_status(self.script.logger, merge_line)
+        self.output += [
+            '\n',
+            merge_line,
+            '\n',
+            ]
+        self.wrap_command(self._do_merge, line, sender, dir)
+        self.run_precommit(to_repo_revision, config, line, dir)
+        os.chdir(origdir)
+        self.log_with_status(self.script.logger, "success: %s", line)
+        self.successful.append(line)
+        self.output += ['\n', '%s succeeded at %s' % (merge_name, time.strftime('%c')), '\n']
+        self.get_vcs().commit(sender, dir, self.commitmsg, to_repo_revision, config)
+
+
+class ExtendedMergeCommand(MergeCommand):
+
+    def __init__(self, script, branch_spec_handler, configp, revision_id,
+                 testament_sha1, message, to_branch, from_branch=None,
+                 bundle=None):
+
+        MergeCommand.__init__(self, script, branch_spec_handler, configp,
+                              from_branch, to_branch)
+        self.revision_id = revision_id
+        self.testament_sha1 = testament_sha1
+        self.message = message
+        self.from_branch = from_branch
+        self.bundle = bundle
+
+    def asHTML(self):
+        print self.from_branch
+        if self.from_branch is not None:
+            s = " (%s)" % (str(self.from_branch),)
+        else:
+            s = ""
+        return cgi.escape("Merge from bundle%s" % (s,))
+
+    def run(self):
+        super(MergeCommand, self).run()
+        self.cleanup_wd()
+        if self.message is not None:
+            self.commitmsg = self.message
+        line = 'merge %s %s' % (self.from_branch, self.to_branch)
+        self.do_merge(self.from_branch, self.to_branch, 'bzr-merge', line)
+        return self.successful, self.unrecognized, self.output
+
+    def _do_merge(self, sender, dir):
+        return self.get_vcs().do_bzr_merge(sender, self.revision_id,
+                                           self.testament_sha1, dir,
+                                           self.from_branch, self.bundle)
+
+    def __eq__(self, other):
+        return (super(ExtendedMergeCommand, self).__eq__(other) and
+                isinstance(other, ExtendedMergeCommand) and
+                self.revision_id == other.revision_id and
+                self.testament_sha1 == other.testament_sha1 and
+                self.message == other.message and
+                self.bundle == other.bundle)
+
+
+class ReplayMergeCommand(MergeCommand):
+
+    def asHTML(self):
+        return cgi.escape("Replay %s %s" % (self.from_branch,
+                                            self.to_branch))
+
+    def run(self):
+        super(MergeCommand, self).run()
+        self.cleanup_wd()
+        self.do_merge(from_repo_revision=self.from_branch,
+                      to_repo_revision=self.to_branch,
+                      merge_name='replay',
+                      line='replay %s %s' % (self.from_branch,
+                                             self.to_branch))
+        return self.successful, self.unrecognized, self.output
+
+    def _do_merge(self, sender, dir):
+        return self.get_vcs().do_replay(sender, self.from_branch, dir)
 
 
 class PrecommitCommand(Command):
@@ -1121,7 +1285,6 @@
 
 class CommandRunner(Command):
     """This runs commands as lines one at a time."""
-    replay_re = re.compile('^replay (\S+/\S+)\s+(\S+/\S+)\s*$')
     repo_cache_re = re.compile('^repo-cache-revision (\S+/\S+)\s*$')
     repo_uncache_re = re.compile('^repo-uncache-revision (\S+/\S+)\s*$')
     tag_re = re.compile('^tag (\S+/\S+)\s+(\S+/\S+)\s*$')
@@ -1204,7 +1367,6 @@
         # its a command of some sort
         start_time = datetime.now()
         patch_match = self.patch_re.match(line)
-        replay_match = self.replay_re.match(line)
         repo_cache_match=self.repo_cache_re.match(line)
         repo_uncache_match=self.repo_uncache_re.match(line)
         tag_match=self.tag_re.match(line)
@@ -1221,12 +1383,6 @@
             self.accumulating_patch = True
         elif self.accumulating_patch:
             self.patch_content.append(line)
-        elif replay_match:
-            self.do_merge(from_repo_revision=replay_match.group(1),
-                          to_repo_revision=replay_match.group(2),
-                          merge_name='replay',
-                          merge_method="do_replay",
-                          line=line)
         elif repo_cache_match:
             # Cache a revision
             repo_revision = repo_cache_match.group(1)

=== modified file 'pqm/tests/test_pqm.py'
--- pqm/tests/test_pqm.py	2010-04-19 02:40:26 +0000
+++ pqm/tests/test_pqm.py	2010-05-04 16:39:23 +0000
@@ -12,9 +12,18 @@
 from pqm.core import PatchQueueManager
 from pqm.errors import PQMCmdFailure, PQMException
 from pqm.PQMConfigParser import ConfigParser
+<<<<<<< TREE
 from pqm.script import (
     Command, CommandRunner, DebugCommand, EmailScript, MergeCommand)
 
+=======
+from pqm.script import (Command,
+                        CommandRunner,
+                        DebugCommand,
+                        ExtendedMergeCommand,
+                        MergeCommand,
+                       )
+>>>>>>> MERGE-SOURCE
 
 sample_message = dedent("""\
     From: [e-mail]
@@ -117,6 +126,51 @@
     workdir=test-workdir
     """)
 
+sample_merge_directive = """\
+From [e-mail]  Sun Mar 11 20:19:38 2007
+Return-Path: <[e-mail]>
+X-Original-To: abentley
+Delivered-To: [e-mail]
+Received: from localhost.localdomain (localhost.localdomain [127.0.0.1])
+        by localhost.localdomain (Postfix) with ESMTP id 6E01032E9F5
+        for <abentley>; Sun, 11 Mar 2007 20:19:38 -0400 (EDT)
+To: [e-mail]
+From: John Citizen <[e-mail]>
+Subject: This is my second commit message
+Message-Id: <[e-mail]>
+Date: Sun, 11 Mar 2007 20:19:38 -0400 (EDT)
+
+# Bazaar merge directive format 1
+# revision_id: [e-mail]-20070312001559-\\
+#   9jdb99jgb8dn1k5b
+# message: Please merge this commit
+# target_branch: http://example.com/target
+# source_branch: http://example.com/source
+# testament_sha1: 5cd628553ec98c056bd7eff4b8b72fce9961c53b
+# timestamp: 2007-03-11 20:19:37 -0400
+#
+# Bazaar revision bundle v0.9
+#
+# message:
+#   This is my second commit message
+# committer: John Citizen <[e-mail]>
+# date: Sun 2007-03-11 20:15:59.841000080 -0400
+
+=== modified directory  // last-changed:[e-mail]-20070312001559
+... -9jdb99jgb8dn1k5b
+# revision id: [e-mail]-20070312001559-9jdb99jgb8dn1k5b
+# sha1: 5cd628553ec98c056bd7eff4b8b72fce9961c53b
+# inventory sha1: 191c819cc7943e5e4140744cc04a7fe088897f35
+# parent ids:
+#   [e-mail]-20070312001321-qbz0l8mrp0csql1e
+# base id: [e-mail]-20070312001321-qbz0l8mrp0csql1e
+# properties:
+#   branch-nick: example
+
+
+"""
+sample_bundle = ''.join(sample_merge_directive.splitlines(True)[22:])
+
 
 class QueueSetup(object):
     """Setup a queue with mock messages in it."""
@@ -198,6 +252,14 @@
         return EmailScript(self.scriptname, logging, False, 54, handler,
             configp, self.queue.manager)
 
+
+class TestQueueDirectory(TestWithQueueDirectory):
+
+    def testName(self):
+        patch = pqm.Script('foo.script', logging, False, 0, None, None)
+        self.assertEqual(patch.filename, 'foo.script')
+        self.scriptname = 'fpp'
+
     def testFields(self):
         script = self.getScript(sample_message)
         self.assertEqual(script.getSender(), "[e-mail]")
@@ -216,6 +278,26 @@
                                        self.queue.manager)],
                          script.getCommands())
 
+    def testMergeDirectiveFields(self):
+        script = self.getScript(sample_merge_directive)
+        self.assertEqual(script.getSender(),
+            "John Citizen <[e-mail]>")
+        self.assertEqual(script.getSubject(),
+            "This is my second commit message")
+        commands = script.getCommands()
+        self.assertEqual([ExtendedMergeCommand(
+            None,
+            None,
+            None,
+            '[e-mail]-20070312001559-9jdb99jgb8dn1k5b',
+            '5cd628553ec98c056bd7eff4b8b72fce9961c53b',
+            'Please merge this commit',
+            'http://example.com/target',
+            'http://example.com/source',
+            sample_bundle,
+            )],
+            script.getCommands())
+
     def testGPGFields(self):
         script = self.getScript(sample_signed_message)
         self.assertEqual(script.getSender(), "[e-mail] (Matthew Thomas)")
@@ -273,7 +355,6 @@
         self.assertEqual('bar\nfoo\n', content)
 
 
-
 # NOTDONEYET: move command recognition from CommandRunner to Script
 # and commands should follow the command pattern rather than being strings.
 #
@@ -427,9 +508,10 @@
         self.assertTrue(script.debug)
 
 
-class FunctionalTestCommandRunner(unittest.TestCase):
+class FunctionalTestCommandRunner(TestCaseWithTransport):
 
     def setUp(self):
+        super(FunctionalTestCommandRunner, self).setUp()
         from bzrlib.bzrdir import BzrDir
         from bzrlib.plugin import load_plugins
         load_plugins()
@@ -491,14 +573,18 @@
         load_plugins()
         tree = self.make_branch_and_tree("bzrbranch")
         tree.smart_add(["bzrbranch"])
-        tree.commit("start branch.", verbose=False)
+        tree.commit("start branch.", verbose=False, rev_id='revision-0')
         tree.branch.bzrdir.sprout("bzrbranch-parent")
         tree.branch.bzrdir.sprout("bzrbranch-public")
         tree.branch.bzrdir.sprout("branch-contributor")
         contrib_tree = BzrDir.open("branch-contributor").open_workingtree()
+        self.build_tree_contents([("branch-contributor/NEWS",
+                                   "This is brand-new\n")])
+        contrib_tree.add(["NEWS"])
+        contrib_tree.commit("add NEWS", rev_id='revision-1')
         self.build_tree_contents([("branch-contributor/README", "Boo!\n")])
         contrib_tree.add(["README"])
-        contrib_tree.commit("add README")
+        contrib_tree.commit("add README", rev_id='revision-2')
 
     def tearDown(self):
         shutil.rmtree("bzrbranch")
@@ -507,6 +593,9 @@
         shutil.rmtree("bzrbranch-public")
         super(BzrHandlerTestCase, self).tearDown()
 
+
+class TestBzrHandler(BzrHandlerTestCase):
+
     def test_commit(self):
         from bzrlib.branch import Branch
         branch = Branch.open("bzrbranch")
@@ -569,6 +658,66 @@
                             contrib_branch.last_revision()).message,
                          'add README')
         self.failUnless(os.path.exists("bzrbranch/README"))
+        
+    def test_merge_revision(self):
+        from bzrlib.branch import Branch
+        from bzrlib.testament import StrictTestament3
+        branch = Branch.open("bzrbranch")
+        self.assertEqual(
+            branch.repository.get_revision(branch.last_revision()).message,
+            'start branch.')
+        contrib_branch = Branch.open("branch-contributor")
+        self.assertEqual(contrib_branch.repository.get_revision(
+                            contrib_branch.last_revision()).message,
+                         'add README')
+        self.failIf(os.path.exists("bzrbranch/README"))
+        self.failIf(os.path.exists("bzrbranch/NEWS"))
+        handler = pqm.Bazaar2Handler()
+        t = StrictTestament3.from_revision(contrib_branch.repository,
+                                           'revision-2')
+        self.assertRaises(pqm.PQMTlaFailure, handler.do_bzr_merge, "me",
+                          'revision-1', t.as_sha1(),  "bzrbranch",
+                          "branch-contributor",)
+        t = StrictTestament3.from_revision(contrib_branch.repository,
+                                           'revision-1')
+        self.assertRaises(pqm.PQMTlaFailure, handler.do_bzr_merge, "me",
+                          'revision-1', t.as_sha1(),  "bzrbranch")
+        result = handler.do_bzr_merge("me", 'revision-1', t.as_sha1(),
+                                      "bzrbranch", 'branch-contributor')
+        self.assertEqual(result, ["merge successful"])
+        branch = Branch.open("bzrbranch")
+        self.assertEqual(
+            branch.repository.get_revision(branch.last_revision()).message,
+            'start branch.')
+        contrib_branch = Branch.open("branch-contributor")
+        self.assertEqual(contrib_branch.repository.get_revision(
+                         contrib_branch.last_revision()).message,
+                         'add README')
+        self.failIf(os.path.exists("bzrbranch/README"))
+        self.failUnless(os.path.exists("bzrbranch/NEWS"))
+
+    def test_merge_bundle(self):
+        from bzrlib.branch import Branch
+        from bzrlib.bundle.serializer import write_bundle
+        from bzrlib.testament import StrictTestament3
+        branch = Branch.open("bzrbranch")
+        self.assertEqual(
+            branch.repository.get_revision(branch.last_revision()).message,
+            'start branch.')
+        contrib_branch = Branch.open("branch-contributor")
+        self.assertEqual(contrib_branch.repository.get_revision(
+                            contrib_branch.last_revision()).message,
+                         'add README')
+        self.failIf(os.path.exists("bzrbranch/README"))
+        self.failIf(os.path.exists("bzrbranch/NEWS"))
+        t = StrictTestament3.from_revision(contrib_branch.repository,
+                                           'revision-1')
+        bundle = StringIO()
+        write_bundle(contrib_branch.repository, 'revision-2', 'revision-0',
+                     bundle)
+        handler = pqm.Bazaar2Handler()
+        result = handler.do_bzr_merge("me", 'revision-1', t.as_sha1(),
+                                      "bzrbranch", bundle=bundle.getvalue())
 
     def test_merge_conflicts(self):
         from bzrlib.workingtree import WorkingTree
@@ -608,10 +757,17 @@
         try:
             handler.do_star_merge("me", "unrelated", "bzrbranch")
         except pqm.PQMTlaFailure, e:
+<<<<<<< TREE
             self.assertEqual(
                 ["Branches have no common ancestor, and no merge base"
                  " revision was specified."],
                  e.output)
+=======
+            self.assertEqual(["Conflicts during merge: 1",
+                              "Text conflict in README",
+                              ],
+                             e.output)
+>>>>>>> MERGE-SOURCE
             return
         self.fail("Merge base error not raised.")
 
@@ -622,6 +778,47 @@
         self.assertEqual('start branch.', message)
 
 
+class TestBlackbox(BzrHandlerTestCase, TestWithQueueDirectory):
+
+    def setUp(self):
+        BzrHandlerTestCase.setUp(self)
+        TestWithQueueDirectory.setUp(self)
+
+    def test_blackbox(self):
+        from bzrlib.branch import Branch
+        from bzrlib.bundle.serializer import write_bundle
+        from bzrlib.merge_directive import MergeDirective
+        from bzrlib.testament import StrictTestament3
+        branch = Branch.open("bzrbranch")
+        self.assertEqual(
+            branch.repository.get_revision(branch.last_revision()).message,
+            'start branch.')
+        contrib_branch = Branch.open("branch-contributor")
+        self.assertEqual(contrib_branch.repository.get_revision(
+                            contrib_branch.last_revision()).message,
+                         'add README')
+        repo = contrib_branch.repository
+        repo.lock_write()
+        try:
+            directive = MergeDirective.from_objects(repo,
+                contrib_branch.last_revision(), 0, 0,
+                branch.bzrdir.root_transport.base)
+            script = self.getScript(''.join(directive.to_lines()))
+            self.failIf(os.path.exists("bzrbranch/README"))
+            self.failIf(os.path.exists("bzrbranch/NEWS"))
+            t = StrictTestament3.from_revision(contrib_branch.repository,
+                                           'revision-1')
+            bundle = StringIO()
+            write_bundle(contrib_branch.repository, 'revision-2',
+                         'revision-0', bundle)
+            handler = pqm.Bazaar2Handler()
+            result = handler.do_bzr_merge("me", 'revision-1', t.as_sha1(),
+                                          "bzrbranch",
+                                          bundle=bundle.getvalue())
+        finally:
+            repo.unlock()
+
+
 class TestConfig(unittest.TestCase):
 
     def test_location_overrides(self):

=== modified file 'tests/Makefile.am'
--- tests/Makefile.am	2005-12-19 08:02:19 +0000
+++ tests/Makefile.am	2010-05-04 16:39:23 +0000
@@ -13,7 +13,8 @@
 	$(srcdir)/simple-merge-2.sh \
 	$(srcdir)/simple-merge-3.sh \
 	$(srcdir)/simple-merge-4.sh \
-	$(srcdir)/bzr-merge.sh
+	$(srcdir)/bzr-merge.sh \
+	$(srcdir)/bzr-merge-2.sh
 
 EXTRA_DIST = test-framework pqm-tests.conf pqm-tests-2.conf \
              pqm-tests-3.conf pqm-tests-4.conf \

=== added file 'tests/bzr-merge-2.sh'
--- tests/bzr-merge-2.sh	1970-01-01 00:00:00 +0000
+++ tests/bzr-merge-2.sh	2010-05-04 16:39:23 +0000
@@ -0,0 +1,20 @@
+#!/bin/sh
+# -*- mode: sh; coding: utf-8 -*-
+# Copyright © 2005 Canonical Limited
+#   Authors: Robert Collins <[e-mail]>
+#
+# See the file "COPYING" for further information about
+# the copyright and warranty status of this work.
+
+set -e
+
+srcdir=$(cd ${srcdir} && pwd)
+
+. ${srcdir}/test-framework
+
+PQM_CONFIG_FILE="${srcdir}/pqm-tests-2.conf"
+initial_bzr_setup_with_plain_merge_directive
+run_queue
+bzr_archive_has_revision_with_summary "hello-world/mainline/1.0" 2 'minor rename'
+
+clean_workdir

=== modified file 'tests/test-framework'
--- tests/test-framework	2010-04-13 07:40:54 +0000
+++ tests/test-framework	2010-05-04 16:39:23 +0000
@@ -268,13 +268,13 @@
       (echo "From: ${USERID}"; echo "Subject: ${subj}"; echo) | pqm --no-verify --read "$@"
   else
       if test ${type} = "verify"; then
-	  tmpf="${WORKDIR}/sig.$$"
-	  HOME=${srcdir} gpg --batch --clearsign --passphrase-fd 2 2</dev/null > "${tmpf}"
-	  (echo "From: ${USERID}"; echo "Subject: ${subj}"; echo; cat < "${tmpf}") | pqm --read "$@"
-	  rm -f "${tmpf}"
+          tmpf="${WORKDIR}/sig.$$"
+          HOME=${srcdir} gpg --batch --clearsign --passphrase-fd 2 2</dev/null > "${tmpf}"
+          (echo "From: ${USERID}"; echo "Subject: ${subj}"; echo; cat < "${tmpf}") | pqm --read "$@"
+          rm -f "${tmpf}"
       else
-	  echo "Unknown verification type ${type}!" 1>&2
-	  exit 1
+          echo "Unknown verification type ${type}!" 1>&2
+          exit 1
       fi
   fi
   endverbose
@@ -486,6 +486,20 @@
   endverbose
 }
 
+
+initial_bzr_setup_with_plain_merge_directive ()
+{
+  initial_bzr_setup
+  identity_user1
+  verbose 'doing simple submission'
+  cd ${WORKDIR}/hello-world
+  pqm_bzr rename hello-world.c hello_world.c
+  pqm_bzr commit -m 'rename hello-world => hello_world.c'
+  pqm_bzr merge-directive --plain ${PQM_ARCHIVE_DIR}/hello-world/mainline/1.0 `pwd` | submit_merge 'minor rename' "verify"
+  endverbose
+}
+
+
 import_bzr_hello_world () {
   branch=$1
   shift
@@ -506,7 +520,7 @@
   archive=$1
   revision=$2
   summary=$3
-  verbose "checking for revision \"$1\" in archive \"$2\""
+  verbose "checking for revision \"$2\" in archive \"$1\""
   output=$(pqm_bzr log --message "$summary" ${PQM_ARCHIVE_DIR}/${archive} | grep "revno")
   test "$output" = "revno: $revision [merge]"
   endverbose