← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_bundle.py

  • Committer: Martin Pool
  • Date: 2010-06-02 05:03:31 UTC
  • mto: This revision was merged to the branch mainline in revision 5279.
  • Revision ID: mbp@canonical.com-20100602050331-n2p1qt8hfsahspnv
Correct more sloppy use of the term 'Linux'

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bundle.py
1
 
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
from cStringIO import StringIO
18
18
import os
 
19
import socket
19
20
import sys
20
 
import tempfile
 
21
import threading
21
22
 
22
23
from bzrlib import (
23
24
    bzrdir,
 
25
    diff,
24
26
    errors,
25
27
    inventory,
 
28
    merge,
 
29
    osutils,
26
30
    repository,
27
31
    revision as _mod_revision,
 
32
    tests,
28
33
    treebuilder,
29
34
    )
30
 
from bzrlib.bzrdir import BzrDir
 
35
from bzrlib.bundle import read_mergeable_from_url
31
36
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
32
37
from bzrlib.bundle.bundle_data import BundleTree
 
38
from bzrlib.bzrdir import BzrDir
 
39
from bzrlib.directory_service import directories
33
40
from bzrlib.bundle.serializer import write_bundle, read_bundle, v09, v4
34
41
from bzrlib.bundle.serializer.v08 import BundleSerializerV08
35
42
from bzrlib.bundle.serializer.v09 import BundleSerializerV09
36
43
from bzrlib.bundle.serializer.v4 import BundleSerializerV4
37
44
from bzrlib.branch import Branch
38
 
from bzrlib.diff import internal_diff
39
 
from bzrlib.errors import (BzrError, TestamentMismatch, NotABundle, BadBundle, 
40
 
                           NoSuchFile,)
41
 
from bzrlib.merge import Merge3Merger
42
45
from bzrlib.repofmt import knitrepo
43
 
from bzrlib.osutils import has_symlinks, sha_file
44
 
from bzrlib.tests import (TestCaseInTempDir, TestCaseWithTransport,
45
 
                          TestCase, TestSkipped, test_commit)
 
46
from bzrlib.tests import (
 
47
    test_read_bundle,
 
48
    test_commit,
 
49
    )
46
50
from bzrlib.transform import TreeTransform
47
 
from bzrlib.workingtree import WorkingTree
 
51
 
 
52
 
 
53
def get_text(vf, key):
 
54
    """Get the fulltext for a given revision id that is present in the vf"""
 
55
    stream = vf.get_record_stream([key], 'unordered', True)
 
56
    record = stream.next()
 
57
    return record.get_bytes_as('fulltext')
 
58
 
 
59
 
 
60
def get_inventory_text(repo, revision_id):
 
61
    """Get the fulltext for the inventory at revision id"""
 
62
    repo.lock_read()
 
63
    try:
 
64
        return get_text(repo.inventories, (revision_id,))
 
65
    finally:
 
66
        repo.unlock()
48
67
 
49
68
 
50
69
class MockTree(object):
98
117
        elif kind == 'symlink':
99
118
            ie = InventoryLink(file_id, name, parent_id)
100
119
        else:
101
 
            raise BzrError('unknown kind %r' % kind)
 
120
            raise errors.BzrError('unknown kind %r' % kind)
102
121
        ie.text_sha1 = text_sha_1
103
122
        ie.text_size = text_size
104
123
        return ie
106
125
    def add_dir(self, file_id, path):
107
126
        self.paths[file_id] = path
108
127
        self.ids[path] = file_id
109
 
    
 
128
 
110
129
    def add_file(self, file_id, path, contents):
111
130
        self.add_dir(file_id, path)
112
131
        self.contents[file_id] = contents
129
148
    def contents_stats(self, file_id):
130
149
        if file_id not in self.contents:
131
150
            return None, None
132
 
        text_sha1 = sha_file(self.get_file(file_id))
 
151
        text_sha1 = osutils.sha_file(self.get_file(file_id))
133
152
        return text_sha1, len(self.contents[file_id])
134
153
 
135
154
 
136
 
class BTreeTester(TestCase):
 
155
class BTreeTester(tests.TestCase):
137
156
    """A simple unittest tester for the BundleTree class."""
138
157
 
139
158
    def make_tree_1(self):
143
162
        mtree.add_file("c", "grandparent/parent/file", "Hello\n")
144
163
        mtree.add_dir("d", "grandparent/alt_parent")
145
164
        return BundleTree(mtree, ''), mtree
146
 
        
 
165
 
147
166
    def test_renames(self):
148
167
        """Ensure that file renames have the proper effect on children"""
149
168
        btree = self.make_tree_1()[0]
150
169
        self.assertEqual(btree.old_path("grandparent"), "grandparent")
151
 
        self.assertEqual(btree.old_path("grandparent/parent"), 
 
170
        self.assertEqual(btree.old_path("grandparent/parent"),
152
171
                         "grandparent/parent")
153
172
        self.assertEqual(btree.old_path("grandparent/parent/file"),
154
173
                         "grandparent/parent/file")
161
180
        self.assertEqual(btree.path2id("grandparent/parent"), "b")
162
181
        self.assertEqual(btree.path2id("grandparent/parent/file"), "c")
163
182
 
164
 
        assert btree.path2id("grandparent2") is None
165
 
        assert btree.path2id("grandparent2/parent") is None
166
 
        assert btree.path2id("grandparent2/parent/file") is None
 
183
        self.assertTrue(btree.path2id("grandparent2") is None)
 
184
        self.assertTrue(btree.path2id("grandparent2/parent") is None)
 
185
        self.assertTrue(btree.path2id("grandparent2/parent/file") is None)
167
186
 
168
187
        btree.note_rename("grandparent", "grandparent2")
169
 
        assert btree.old_path("grandparent") is None
170
 
        assert btree.old_path("grandparent/parent") is None
171
 
        assert btree.old_path("grandparent/parent/file") is None
 
188
        self.assertTrue(btree.old_path("grandparent") is None)
 
189
        self.assertTrue(btree.old_path("grandparent/parent") is None)
 
190
        self.assertTrue(btree.old_path("grandparent/parent/file") is None)
172
191
 
173
192
        self.assertEqual(btree.id2path("a"), "grandparent2")
174
193
        self.assertEqual(btree.id2path("b"), "grandparent2/parent")
178
197
        self.assertEqual(btree.path2id("grandparent2/parent"), "b")
179
198
        self.assertEqual(btree.path2id("grandparent2/parent/file"), "c")
180
199
 
181
 
        assert btree.path2id("grandparent") is None
182
 
        assert btree.path2id("grandparent/parent") is None
183
 
        assert btree.path2id("grandparent/parent/file") is None
 
200
        self.assertTrue(btree.path2id("grandparent") is None)
 
201
        self.assertTrue(btree.path2id("grandparent/parent") is None)
 
202
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
184
203
 
185
204
        btree.note_rename("grandparent/parent", "grandparent2/parent2")
186
205
        self.assertEqual(btree.id2path("a"), "grandparent2")
191
210
        self.assertEqual(btree.path2id("grandparent2/parent2"), "b")
192
211
        self.assertEqual(btree.path2id("grandparent2/parent2/file"), "c")
193
212
 
194
 
        assert btree.path2id("grandparent2/parent") is None
195
 
        assert btree.path2id("grandparent2/parent/file") is None
 
213
        self.assertTrue(btree.path2id("grandparent2/parent") is None)
 
214
        self.assertTrue(btree.path2id("grandparent2/parent/file") is None)
196
215
 
197
 
        btree.note_rename("grandparent/parent/file", 
 
216
        btree.note_rename("grandparent/parent/file",
198
217
                          "grandparent2/parent2/file2")
199
218
        self.assertEqual(btree.id2path("a"), "grandparent2")
200
219
        self.assertEqual(btree.id2path("b"), "grandparent2/parent2")
204
223
        self.assertEqual(btree.path2id("grandparent2/parent2"), "b")
205
224
        self.assertEqual(btree.path2id("grandparent2/parent2/file2"), "c")
206
225
 
207
 
        assert btree.path2id("grandparent2/parent2/file") is None
 
226
        self.assertTrue(btree.path2id("grandparent2/parent2/file") is None)
208
227
 
209
228
    def test_moves(self):
210
229
        """Ensure that file moves have the proper effect on children"""
211
230
        btree = self.make_tree_1()[0]
212
 
        btree.note_rename("grandparent/parent/file", 
 
231
        btree.note_rename("grandparent/parent/file",
213
232
                          "grandparent/alt_parent/file")
214
233
        self.assertEqual(btree.id2path("c"), "grandparent/alt_parent/file")
215
234
        self.assertEqual(btree.path2id("grandparent/alt_parent/file"), "c")
216
 
        assert btree.path2id("grandparent/parent/file") is None
 
235
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
217
236
 
218
237
    def unified_diff(self, old, new):
219
238
        out = StringIO()
220
 
        internal_diff("old", old, "new", new, out)
 
239
        diff.internal_diff("old", old, "new", new, out)
221
240
        out.seek(0,0)
222
241
        return out.read()
223
242
 
224
243
    def make_tree_2(self):
225
244
        btree = self.make_tree_1()[0]
226
 
        btree.note_rename("grandparent/parent/file", 
 
245
        btree.note_rename("grandparent/parent/file",
227
246
                          "grandparent/alt_parent/file")
228
 
        assert btree.id2path("e") is None
229
 
        assert btree.path2id("grandparent/parent/file") is None
 
247
        self.assertTrue(btree.id2path("e") is None)
 
248
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
230
249
        btree.note_id("e", "grandparent/parent/file")
231
250
        return btree
232
251
 
258
277
    def make_tree_3(self):
259
278
        btree, mtree = self.make_tree_1()
260
279
        mtree.add_file("e", "grandparent/parent/topping", "Anchovies\n")
261
 
        btree.note_rename("grandparent/parent/file", 
 
280
        btree.note_rename("grandparent/parent/file",
262
281
                          "grandparent/alt_parent/file")
263
 
        btree.note_rename("grandparent/parent/topping", 
 
282
        btree.note_rename("grandparent/parent/topping",
264
283
                          "grandparent/alt_parent/stopping")
265
284
        return btree
266
285
 
290
309
        btree = self.make_tree_1()[0]
291
310
        self.assertEqual(btree.get_file("c").read(), "Hello\n")
292
311
        btree.note_deletion("grandparent/parent/file")
293
 
        assert btree.id2path("c") is None
294
 
        assert btree.path2id("grandparent/parent/file") is None
 
312
        self.assertTrue(btree.id2path("c") is None)
 
313
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
295
314
 
296
315
    def sorted_ids(self, tree):
297
316
        ids = list(tree)
305
324
            [inventory.ROOT_ID, 'a', 'b', 'c', 'd'])
306
325
        btree.note_deletion("grandparent/parent/file")
307
326
        btree.note_id("e", "grandparent/alt_parent/fool", kind="directory")
308
 
        btree.note_last_changed("grandparent/alt_parent/fool", 
 
327
        btree.note_last_changed("grandparent/alt_parent/fool",
309
328
                                "revisionidiguess")
310
329
        self.assertEqual(self.sorted_ids(btree),
311
330
            [inventory.ROOT_ID, 'a', 'b', 'd', 'e'])
312
331
 
313
332
 
314
 
class BundleTester1(TestCaseWithTransport):
 
333
class BundleTester1(tests.TestCaseWithTransport):
315
334
 
316
335
    def test_mismatched_bundle(self):
317
336
        format = bzrdir.BzrDirMetaFormat1()
318
337
        format.repository_format = knitrepo.RepositoryFormatKnit3()
319
338
        serializer = BundleSerializerV08('0.8')
320
339
        b = self.make_branch('.', format=format)
321
 
        self.assertRaises(errors.IncompatibleBundleFormat, serializer.write, 
 
340
        self.assertRaises(errors.IncompatibleBundleFormat, serializer.write,
322
341
                          b.repository, [], {}, StringIO())
323
342
 
324
343
    def test_matched_bundle(self):
344
363
        format = bzrdir.BzrDirMetaFormat1()
345
364
        format.repository_format = knitrepo.RepositoryFormatKnit1()
346
365
        target = self.make_branch('target', format=format)
347
 
        self.assertRaises(errors.IncompatibleRevision, install_bundle, 
 
366
        self.assertRaises(errors.IncompatibleRevision, install_bundle,
348
367
                          target.repository, read_bundle(text))
349
368
 
350
369
 
358
377
    def make_branch_and_tree(self, path, format=None):
359
378
        if format is None:
360
379
            format = self.bzrdir_format()
361
 
        return TestCaseWithTransport.make_branch_and_tree(self, path, format)
 
380
        return tests.TestCaseWithTransport.make_branch_and_tree(
 
381
            self, path, format)
362
382
 
363
383
    def make_branch(self, path, format=None):
364
384
        if format is None:
365
385
            format = self.bzrdir_format()
366
 
        return TestCaseWithTransport.make_branch(self, path, format)
 
386
        return tests.TestCaseWithTransport.make_branch(self, path, format)
367
387
 
368
388
    def create_bundle_text(self, base_rev_id, rev_id):
369
389
        bundle_txt = StringIO()
370
 
        rev_ids = write_bundle(self.b1.repository, rev_id, base_rev_id, 
 
390
        rev_ids = write_bundle(self.b1.repository, rev_id, base_rev_id,
371
391
                               bundle_txt, format=self.format)
372
392
        bundle_txt.seek(0)
373
 
        self.assertEqual(bundle_txt.readline(), 
 
393
        self.assertEqual(bundle_txt.readline(),
374
394
                         '# Bazaar revision bundle v%s\n' % self.format)
375
395
        self.assertEqual(bundle_txt.readline(), '#\n')
376
396
 
384
404
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
385
405
        Make sure that the text generated is valid, and that it
386
406
        can be applied against the base, and generate the same information.
387
 
        
388
 
        :return: The in-memory bundle 
 
407
 
 
408
        :return: The in-memory bundle
389
409
        """
390
410
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
391
411
 
392
 
        # This should also validate the generated bundle 
 
412
        # This should also validate the generated bundle
393
413
        bundle = read_bundle(bundle_txt)
394
414
        repository = self.b1.repository
395
415
        for bundle_rev in bundle.real_revisions:
399
419
            # it
400
420
            branch_rev = repository.get_revision(bundle_rev.revision_id)
401
421
            for a in ('inventory_sha1', 'revision_id', 'parent_ids',
402
 
                      'timestamp', 'timezone', 'message', 'committer', 
 
422
                      'timestamp', 'timezone', 'message', 'committer',
403
423
                      'parent_ids', 'properties'):
404
 
                self.assertEqual(getattr(branch_rev, a), 
 
424
                self.assertEqual(getattr(branch_rev, a),
405
425
                                 getattr(bundle_rev, a))
406
 
            self.assertEqual(len(branch_rev.parent_ids), 
 
426
            self.assertEqual(len(branch_rev.parent_ids),
407
427
                             len(bundle_rev.parent_ids))
408
 
        self.assertEqual(rev_ids, 
 
428
        self.assertEqual(rev_ids,
409
429
                         [r.revision_id for r in bundle.real_revisions])
410
430
        self.valid_apply_bundle(base_rev_id, bundle,
411
431
                                   checkout_dir=checkout_dir)
415
435
    def get_invalid_bundle(self, base_rev_id, rev_id):
416
436
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
417
437
        Munge the text so that it's invalid.
418
 
        
 
438
 
419
439
        :return: The in-memory bundle
420
440
        """
421
441
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
422
 
        new_text = bundle_txt.getvalue().replace('executable:no', 
 
442
        new_text = bundle_txt.getvalue().replace('executable:no',
423
443
                                               'executable:yes')
424
444
        bundle_txt = StringIO(new_text)
425
445
        bundle = read_bundle(bundle_txt)
426
446
        self.valid_apply_bundle(base_rev_id, bundle)
427
 
        return bundle 
 
447
        return bundle
428
448
 
429
449
    def test_non_bundle(self):
430
 
        self.assertRaises(NotABundle, read_bundle, StringIO('#!/bin/sh\n'))
 
450
        self.assertRaises(errors.NotABundle,
 
451
                          read_bundle, StringIO('#!/bin/sh\n'))
431
452
 
432
453
    def test_malformed(self):
433
 
        self.assertRaises(BadBundle, read_bundle, 
 
454
        self.assertRaises(errors.BadBundle, read_bundle,
434
455
                          StringIO('# Bazaar revision bundle v'))
435
456
 
436
457
    def test_crlf_bundle(self):
437
458
        try:
438
459
            read_bundle(StringIO('# Bazaar revision bundle v0.8\r\n'))
439
 
        except BadBundle:
 
460
        except errors.BadBundle:
440
461
            # It is currently permitted for bundles with crlf line endings to
441
462
            # make read_bundle raise a BadBundle, but this should be fixed.
442
463
            # Anything else, especially NotABundle, is an error.
447
468
        """
448
469
 
449
470
        if checkout_dir is None:
450
 
            checkout_dir = tempfile.mkdtemp(prefix='test-branch-', dir='.')
 
471
            checkout_dir = osutils.mkdtemp(prefix='test-branch-', dir='.')
451
472
        else:
452
473
            if not os.path.exists(checkout_dir):
453
474
                os.mkdir(checkout_dir)
456
477
        ancestors = write_bundle(self.b1.repository, rev_id, 'null:', s,
457
478
                                 format=self.format)
458
479
        s.seek(0)
459
 
        assert isinstance(s.getvalue(), str), (
460
 
            "Bundle isn't a bytestring:\n %s..." % repr(s.getvalue())[:40])
 
480
        self.assertIsInstance(s.getvalue(), str)
461
481
        install_bundle(tree.branch.repository, read_bundle(s))
462
482
        for ancestor in ancestors:
463
483
            old = self.b1.repository.revision_tree(ancestor)
464
484
            new = tree.branch.repository.revision_tree(ancestor)
465
 
 
466
 
            # Check that there aren't any inventory level changes
467
 
            delta = new.changes_from(old)
468
 
            self.assertFalse(delta.has_changed(),
469
 
                             'Revision %s not copied correctly.'
470
 
                             % (ancestor,))
471
 
 
472
 
            # Now check that the file contents are all correct
473
 
            for inventory_id in old:
474
 
                try:
475
 
                    old_file = old.get_file(inventory_id)
476
 
                except NoSuchFile:
477
 
                    continue
478
 
                if old_file is None:
479
 
                    continue
480
 
                self.assertEqual(old_file.read(),
481
 
                                 new.get_file(inventory_id).read())
 
485
            old.lock_read()
 
486
            new.lock_read()
 
487
            try:
 
488
                # Check that there aren't any inventory level changes
 
489
                delta = new.changes_from(old)
 
490
                self.assertFalse(delta.has_changed(),
 
491
                                 'Revision %s not copied correctly.'
 
492
                                 % (ancestor,))
 
493
 
 
494
                # Now check that the file contents are all correct
 
495
                for inventory_id in old:
 
496
                    try:
 
497
                        old_file = old.get_file(inventory_id)
 
498
                    except errors.NoSuchFile:
 
499
                        continue
 
500
                    if old_file is None:
 
501
                        continue
 
502
                    self.assertEqual(old_file.read(),
 
503
                                     new.get_file(inventory_id).read())
 
504
            finally:
 
505
                new.unlock()
 
506
                old.unlock()
482
507
        if not _mod_revision.is_null(rev_id):
483
508
            rh = self.b1.revision_history()
484
509
            tree.branch.set_revision_history(rh[:rh.index(rev_id)+1])
493
518
        sure everything matches the builtin branch.
494
519
        """
495
520
        to_tree = self.get_checkout(base_rev_id, checkout_dir=checkout_dir)
 
521
        to_tree.lock_write()
 
522
        try:
 
523
            self._valid_apply_bundle(base_rev_id, info, to_tree)
 
524
        finally:
 
525
            to_tree.unlock()
 
526
 
 
527
    def _valid_apply_bundle(self, base_rev_id, info, to_tree):
496
528
        original_parents = to_tree.get_parent_ids()
497
529
        repository = to_tree.branch.repository
498
530
        original_parents = to_tree.get_parent_ids()
499
531
        self.assertIs(repository.has_revision(base_rev_id), True)
500
532
        for rev in info.real_revisions:
501
533
            self.assert_(not repository.has_revision(rev.revision_id),
502
 
                'Revision {%s} present before applying bundle' 
 
534
                'Revision {%s} present before applying bundle'
503
535
                % rev.revision_id)
504
 
        merge_bundle(info, to_tree, True, Merge3Merger, False, False)
 
536
        merge_bundle(info, to_tree, True, merge.Merge3Merger, False, False)
505
537
 
506
538
        for rev in info.real_revisions:
507
539
            self.assert_(repository.has_revision(rev.revision_id),
508
 
                'Missing revision {%s} after applying bundle' 
 
540
                'Missing revision {%s} after applying bundle'
509
541
                % rev.revision_id)
510
542
 
511
543
        self.assert_(to_tree.branch.repository.has_revision(info.target))
517
549
        rev = info.real_revisions[-1]
518
550
        base_tree = self.b1.repository.revision_tree(rev.revision_id)
519
551
        to_tree = to_tree.branch.repository.revision_tree(rev.revision_id)
520
 
        
 
552
 
521
553
        # TODO: make sure the target tree is identical to base tree
522
554
        #       we might also check the working tree.
523
555
 
542
574
        self.tree1 = self.make_branch_and_tree('b1')
543
575
        self.b1 = self.tree1.branch
544
576
 
545
 
        open('b1/one', 'wb').write('one\n')
546
 
        self.tree1.add('one')
 
577
        self.build_tree_contents([('b1/one', 'one\n')])
 
578
        self.tree1.add('one', 'one-id')
 
579
        self.tree1.set_root_id('root-id')
547
580
        self.tree1.commit('add one', rev_id='a@cset-0-1')
548
581
 
549
582
        bundle = self.get_valid_bundle('null:', 'a@cset-0-1')
560
593
                , 'b1/sub/sub/'
561
594
                , 'b1/sub/sub/nonempty.txt'
562
595
                ])
563
 
        open('b1/sub/sub/emptyfile.txt', 'wb').close()
564
 
        open('b1/dir/nolastnewline.txt', 'wb').write('bloop')
 
596
        self.build_tree_contents([('b1/sub/sub/emptyfile.txt', ''),
 
597
                                  ('b1/dir/nolastnewline.txt', 'bloop')])
565
598
        tt = TreeTransform(self.tree1)
566
599
        tt.new_file('executable', tt.root, '#!/bin/sh\n', 'exe-1', True)
567
600
        tt.apply()
583
616
 
584
617
        bundle = self.get_valid_bundle('a@cset-0-1', 'a@cset-0-2')
585
618
 
586
 
        # Check a rollup bundle 
 
619
        # Check a rollup bundle
587
620
        bundle = self.get_valid_bundle('null:', 'a@cset-0-2')
588
621
 
589
622
        # Now delete entries
597
630
        tt.set_executability(False, trans_id)
598
631
        tt.apply()
599
632
        self.tree1.commit('removed', rev_id='a@cset-0-3')
600
 
        
 
633
 
601
634
        bundle = self.get_valid_bundle('a@cset-0-2', 'a@cset-0-3')
602
 
        self.assertRaises((TestamentMismatch,
603
 
            errors.VersionedFileInvalidChecksum), self.get_invalid_bundle,
 
635
        self.assertRaises((errors.TestamentMismatch,
 
636
            errors.VersionedFileInvalidChecksum,
 
637
            errors.BadBundle), self.get_invalid_bundle,
604
638
            'a@cset-0-2', 'a@cset-0-3')
605
 
        # Check a rollup bundle 
 
639
        # Check a rollup bundle
606
640
        bundle = self.get_valid_bundle('null:', 'a@cset-0-3')
607
641
 
608
642
        # Now move the directory
610
644
        self.tree1.commit('rename dir', rev_id='a@cset-0-4')
611
645
 
612
646
        bundle = self.get_valid_bundle('a@cset-0-3', 'a@cset-0-4')
613
 
        # Check a rollup bundle 
 
647
        # Check a rollup bundle
614
648
        bundle = self.get_valid_bundle('null:', 'a@cset-0-4')
615
649
 
616
650
        # Modified files
618
652
        open('b1/sub/dir/ pre space', 'ab').write(
619
653
             '\r\nAdding some\r\nDOS format lines\r\n')
620
654
        open('b1/sub/dir/nolastnewline.txt', 'ab').write('\n')
621
 
        self.tree1.rename_one('sub/dir/ pre space', 
 
655
        self.tree1.rename_one('sub/dir/ pre space',
622
656
                              'sub/ start space')
623
657
        self.tree1.commit('Modified files', rev_id='a@cset-0-5')
624
658
        bundle = self.get_valid_bundle('a@cset-0-4', 'a@cset-0-5')
630
664
                          verbose=False)
631
665
        bundle = self.get_valid_bundle('a@cset-0-5', 'a@cset-0-6')
632
666
        other = self.get_checkout('a@cset-0-5')
633
 
        tree1_inv = self.tree1.branch.repository.get_inventory_xml(
634
 
            'a@cset-0-5')
635
 
        tree2_inv = other.branch.repository.get_inventory_xml('a@cset-0-5')
 
667
        tree1_inv = get_inventory_text(self.tree1.branch.repository,
 
668
                                       'a@cset-0-5')
 
669
        tree2_inv = get_inventory_text(other.branch.repository,
 
670
                                       'a@cset-0-5')
636
671
        self.assertEqualDiff(tree1_inv, tree2_inv)
637
672
        other.rename_one('sub/dir/nolastnewline.txt', 'sub/nolastnewline.txt')
638
673
        other.commit('rename file', rev_id='a@cset-0-6b')
641
676
                          verbose=False)
642
677
        bundle = self.get_valid_bundle('a@cset-0-6', 'a@cset-0-7')
643
678
 
644
 
    def test_symlink_bundle(self):
645
 
        if not has_symlinks():
646
 
            raise TestSkipped("No symlink support")
 
679
    def _test_symlink_bundle(self, link_name, link_target, new_link_target):
 
680
        link_id = 'link-1'
 
681
 
 
682
        self.requireFeature(tests.SymlinkFeature)
647
683
        self.tree1 = self.make_branch_and_tree('b1')
648
684
        self.b1 = self.tree1.branch
 
685
 
649
686
        tt = TreeTransform(self.tree1)
650
 
        tt.new_symlink('link', tt.root, 'bar/foo', 'link-1')
 
687
        tt.new_symlink(link_name, tt.root, link_target, link_id)
651
688
        tt.apply()
652
689
        self.tree1.commit('add symlink', rev_id='l@cset-0-1')
653
 
        self.get_valid_bundle('null:', 'l@cset-0-1')
 
690
        bundle = self.get_valid_bundle('null:', 'l@cset-0-1')
 
691
        if getattr(bundle ,'revision_tree', None) is not None:
 
692
            # Not all bundle formats supports revision_tree
 
693
            bund_tree = bundle.revision_tree(self.b1.repository, 'l@cset-0-1')
 
694
            self.assertEqual(link_target, bund_tree.get_symlink_target(link_id))
 
695
 
654
696
        tt = TreeTransform(self.tree1)
655
 
        trans_id = tt.trans_id_tree_file_id('link-1')
 
697
        trans_id = tt.trans_id_tree_file_id(link_id)
656
698
        tt.adjust_path('link2', tt.root, trans_id)
657
699
        tt.delete_contents(trans_id)
658
 
        tt.create_symlink('mars', trans_id)
 
700
        tt.create_symlink(new_link_target, trans_id)
659
701
        tt.apply()
660
702
        self.tree1.commit('rename and change symlink', rev_id='l@cset-0-2')
661
 
        self.get_valid_bundle('l@cset-0-1', 'l@cset-0-2')
 
703
        bundle = self.get_valid_bundle('l@cset-0-1', 'l@cset-0-2')
 
704
        if getattr(bundle ,'revision_tree', None) is not None:
 
705
            # Not all bundle formats supports revision_tree
 
706
            bund_tree = bundle.revision_tree(self.b1.repository, 'l@cset-0-2')
 
707
            self.assertEqual(new_link_target,
 
708
                             bund_tree.get_symlink_target(link_id))
 
709
 
662
710
        tt = TreeTransform(self.tree1)
663
 
        trans_id = tt.trans_id_tree_file_id('link-1')
 
711
        trans_id = tt.trans_id_tree_file_id(link_id)
664
712
        tt.delete_contents(trans_id)
665
713
        tt.create_symlink('jupiter', trans_id)
666
714
        tt.apply()
667
715
        self.tree1.commit('just change symlink target', rev_id='l@cset-0-3')
668
 
        self.get_valid_bundle('l@cset-0-2', 'l@cset-0-3')
 
716
        bundle = self.get_valid_bundle('l@cset-0-2', 'l@cset-0-3')
 
717
 
669
718
        tt = TreeTransform(self.tree1)
670
 
        trans_id = tt.trans_id_tree_file_id('link-1')
 
719
        trans_id = tt.trans_id_tree_file_id(link_id)
671
720
        tt.delete_contents(trans_id)
672
721
        tt.apply()
673
722
        self.tree1.commit('Delete symlink', rev_id='l@cset-0-4')
674
 
        self.get_valid_bundle('l@cset-0-3', 'l@cset-0-4')
 
723
        bundle = self.get_valid_bundle('l@cset-0-3', 'l@cset-0-4')
 
724
 
 
725
    def test_symlink_bundle(self):
 
726
        self._test_symlink_bundle('link', 'bar/foo', 'mars')
 
727
 
 
728
    def test_unicode_symlink_bundle(self):
 
729
        self.requireFeature(tests.UnicodeFilenameFeature)
 
730
        self._test_symlink_bundle(u'\N{Euro Sign}link',
 
731
                                  u'bar/\N{Euro Sign}foo',
 
732
                                  u'mars\N{Euro Sign}')
675
733
 
676
734
    def test_binary_bundle(self):
677
735
        self.tree1 = self.make_branch_and_tree('b1')
678
736
        self.b1 = self.tree1.branch
679
737
        tt = TreeTransform(self.tree1)
680
 
        
 
738
 
681
739
        # Add
682
740
        tt.new_file('file', tt.root, '\x00\n\x00\r\x01\n\x02\r\xff', 'binary-1')
683
741
        tt.new_file('file2', tt.root, '\x01\n\x02\r\x03\n\x04\r\xff',
775
833
        return bundle_file.getvalue()
776
834
 
777
835
    def test_unicode_bundle(self):
 
836
        self.requireFeature(tests.UnicodeFilenameFeature)
778
837
        # Handle international characters
779
838
        os.mkdir('b1')
780
 
        try:
781
 
            f = open(u'b1/with Dod\xe9', 'wb')
782
 
        except UnicodeEncodeError:
783
 
            raise TestSkipped("Filesystem doesn't support unicode")
 
839
        f = open(u'b1/with Dod\N{Euro Sign}', 'wb')
784
840
 
785
841
        self.tree1 = self.make_branch_and_tree('b1')
786
842
        self.b1 = self.tree1.branch
790
846
            u'William Dod\xe9\n').encode('utf-8'))
791
847
        f.close()
792
848
 
793
 
        self.tree1.add([u'with Dod\xe9'], ['withdod-id'])
 
849
        self.tree1.add([u'with Dod\N{Euro Sign}'], ['withdod-id'])
794
850
        self.tree1.commit(u'i18n commit from William Dod\xe9',
795
851
                          rev_id='i18n-1', committer=u'William Dod\xe9')
796
852
 
797
 
        if sys.platform == 'darwin':
798
 
            # On Mac the '\xe9' gets changed to 'e\u0301'
799
 
            self.assertEqual([u'.bzr', u'with Dode\u0301'],
800
 
                             sorted(os.listdir(u'b1')))
801
 
            delta = self.tree1.changes_from(self.tree1.basis_tree())
802
 
            self.assertEqual([(u'with Dod\xe9', 'withdod-id', 'file')],
803
 
                             delta.removed)
804
 
            self.knownFailure("Mac OSX doesn't preserve unicode"
805
 
                              " combining characters.")
806
 
 
807
853
        # Add
808
854
        bundle = self.get_valid_bundle('null:', 'i18n-1')
809
855
 
810
856
        # Modified
811
 
        f = open(u'b1/with Dod\xe9', 'wb')
 
857
        f = open(u'b1/with Dod\N{Euro Sign}', 'wb')
812
858
        f.write(u'Modified \xb5\n'.encode('utf8'))
813
859
        f.close()
814
860
        self.tree1.commit(u'modified', rev_id='i18n-2')
815
861
 
816
862
        bundle = self.get_valid_bundle('i18n-1', 'i18n-2')
817
 
        
 
863
 
818
864
        # Renamed
819
 
        self.tree1.rename_one(u'with Dod\xe9', u'B\xe5gfors')
 
865
        self.tree1.rename_one(u'with Dod\N{Euro Sign}', u'B\N{Euro Sign}gfors')
820
866
        self.tree1.commit(u'renamed, the new i18n man', rev_id='i18n-3',
821
867
                          committer=u'Erik B\xe5gfors')
822
868
 
823
869
        bundle = self.get_valid_bundle('i18n-2', 'i18n-3')
824
870
 
825
871
        # Removed
826
 
        self.tree1.remove([u'B\xe5gfors'])
 
872
        self.tree1.remove([u'B\N{Euro Sign}gfors'])
827
873
        self.tree1.commit(u'removed', rev_id='i18n-4')
828
874
 
829
875
        bundle = self.get_valid_bundle('i18n-3', 'i18n-4')
834
880
 
835
881
    def test_whitespace_bundle(self):
836
882
        if sys.platform in ('win32', 'cygwin'):
837
 
            raise TestSkipped('Windows doesn\'t support filenames'
838
 
                              ' with tabs or trailing spaces')
 
883
            raise tests.TestSkipped('Windows doesn\'t support filenames'
 
884
                                    ' with tabs or trailing spaces')
839
885
        self.tree1 = self.make_branch_and_tree('b1')
840
886
        self.b1 = self.tree1.branch
841
887
 
866
912
        self.tree1.commit('removed', rev_id='white-4')
867
913
 
868
914
        bundle = self.get_valid_bundle('white-3', 'white-4')
869
 
        
 
915
 
870
916
        # Now test a complet roll-up
871
917
        bundle = self.get_valid_bundle('null:', 'white-4')
872
918
 
885
931
                          timezone=19800, timestamp=1152544886.0)
886
932
 
887
933
        bundle = self.get_valid_bundle('null:', 'tz-1')
888
 
        
 
934
 
889
935
        rev = bundle.revisions[0]
890
936
        self.assertEqual('Mon 2006-07-10 20:51:26.000000000 +0530', rev.date)
891
937
        self.assertEqual(19800, rev.timezone)
993
1039
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
994
1040
        repo = self.make_repository('repo', format='dirstate-with-subtree')
995
1041
        bundle.install_revisions(repo)
996
 
        inv_text = repo.get_inventory_xml('rev2')
 
1042
        inv_text = repo._get_inventory_xml('rev2')
997
1043
        self.assertNotContainsRe(inv_text, 'format="5"')
998
1044
        self.assertContainsRe(inv_text, 'format="7"')
999
1045
 
 
1046
    def make_repo_with_installed_revisions(self):
 
1047
        tree = self.make_simple_tree('knit')
 
1048
        tree.commit('hello', rev_id='rev1')
 
1049
        tree.commit('hello', rev_id='rev2')
 
1050
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1051
        repo = self.make_repository('repo', format='dirstate-with-subtree')
 
1052
        bundle.install_revisions(repo)
 
1053
        return repo
 
1054
 
1000
1055
    def test_across_models(self):
1001
 
        tree = self.make_simple_tree('knit')
1002
 
        tree.commit('hello', rev_id='rev1')
1003
 
        tree.commit('hello', rev_id='rev2')
1004
 
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
1005
 
        repo = self.make_repository('repo', format='dirstate-with-subtree')
1006
 
        bundle.install_revisions(repo)
 
1056
        repo = self.make_repo_with_installed_revisions()
1007
1057
        inv = repo.get_inventory('rev2')
1008
1058
        self.assertEqual('rev2', inv.root.revision)
1009
 
        root_vf = repo.weave_store.get_weave(inv.root.file_id,
1010
 
                                             repo.get_transaction())
1011
 
        self.assertEqual(root_vf.versions(), ['rev1', 'rev2'])
 
1059
        root_id = inv.root.file_id
 
1060
        repo.lock_read()
 
1061
        self.addCleanup(repo.unlock)
 
1062
        self.assertEqual({(root_id, 'rev1'):(),
 
1063
            (root_id, 'rev2'):((root_id, 'rev1'),)},
 
1064
            repo.texts.get_parent_map([(root_id, 'rev1'), (root_id, 'rev2')]))
 
1065
 
 
1066
    def test_inv_hash_across_serializers(self):
 
1067
        repo = self.make_repo_with_installed_revisions()
 
1068
        recorded_inv_sha1 = repo.get_revision('rev2').inventory_sha1
 
1069
        xml = repo._get_inventory_xml('rev2')
 
1070
        self.assertEqual(osutils.sha_string(xml), recorded_inv_sha1)
1012
1071
 
1013
1072
    def test_across_models_incompatible(self):
1014
1073
        tree = self.make_simple_tree('dirstate-with-subtree')
1017
1076
        try:
1018
1077
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
1019
1078
        except errors.IncompatibleBundleFormat:
1020
 
            raise TestSkipped("Format 0.8 doesn't work with knit3")
 
1079
            raise tests.TestSkipped("Format 0.8 doesn't work with knit3")
1021
1080
        repo = self.make_repository('repo', format='knit')
1022
1081
        bundle.install_revisions(repo)
1023
1082
 
1044
1103
        try:
1045
1104
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
1046
1105
        except errors.IncompatibleBundleFormat:
1047
 
            raise TestSkipped("Format 0.8 doesn't work with knit3")
 
1106
            raise tests.TestSkipped("Format 0.8 doesn't work with knit3")
1048
1107
        if isinstance(bundle, v09.BundleInfo09):
1049
 
            raise TestSkipped("Format 0.9 doesn't work with subtrees")
 
1108
            raise tests.TestSkipped("Format 0.9 doesn't work with subtrees")
1050
1109
        repo = self.make_repository('repo', format='knit')
1051
1110
        self.assertRaises(errors.IncompatibleRevision,
1052
1111
                          bundle.install_revisions, repo)
1059
1118
        try:
1060
1119
            self.tree1.commit('Revision/id/with/slashes', rev_id='rev/id')
1061
1120
        except ValueError:
1062
 
            raise TestSkipped("Repository doesn't support revision ids with"
1063
 
                              " slashes")
 
1121
            raise tests.TestSkipped(
 
1122
                "Repository doesn't support revision ids with slashes")
1064
1123
        bundle = self.get_valid_bundle('null:', 'rev/id')
1065
1124
 
1066
1125
    def test_skip_file(self):
1082
1141
        self.tree1.commit('rev3', rev_id='rev3')
1083
1142
        bundle = self.get_valid_bundle('reva', 'rev3')
1084
1143
        if getattr(bundle, 'get_bundle_reader', None) is None:
1085
 
            raise TestSkipped('Bundle format cannot provide reader')
 
1144
            raise tests.TestSkipped('Bundle format cannot provide reader')
1086
1145
        # be sure that file1 comes before file2
1087
1146
        for b, m, k, r, f in bundle.get_bundle_reader().iter_records():
1088
1147
            if f == 'file3-id':
1091
1150
        bundle.install_revisions(target.branch.repository)
1092
1151
 
1093
1152
 
1094
 
class V08BundleTester(BundleTester, TestCaseWithTransport):
 
1153
class V08BundleTester(BundleTester, tests.TestCaseWithTransport):
1095
1154
 
1096
1155
    format = '0.8'
1097
1156
 
1230
1289
        return format
1231
1290
 
1232
1291
 
1233
 
class V4BundleTester(BundleTester, TestCaseWithTransport):
 
1292
class V4BundleTester(BundleTester, tests.TestCaseWithTransport):
1234
1293
 
1235
1294
    format = '4'
1236
1295
 
1238
1297
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
1239
1298
        Make sure that the text generated is valid, and that it
1240
1299
        can be applied against the base, and generate the same information.
1241
 
        
1242
 
        :return: The in-memory bundle 
 
1300
 
 
1301
        :return: The in-memory bundle
1243
1302
        """
1244
1303
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
1245
1304
 
1246
 
        # This should also validate the generated bundle 
 
1305
        # This should also validate the generated bundle
1247
1306
        bundle = read_bundle(bundle_txt)
1248
1307
        repository = self.b1.repository
1249
1308
        for bundle_rev in bundle.real_revisions:
1253
1312
            # it
1254
1313
            branch_rev = repository.get_revision(bundle_rev.revision_id)
1255
1314
            for a in ('inventory_sha1', 'revision_id', 'parent_ids',
1256
 
                      'timestamp', 'timezone', 'message', 'committer', 
 
1315
                      'timestamp', 'timezone', 'message', 'committer',
1257
1316
                      'parent_ids', 'properties'):
1258
 
                self.assertEqual(getattr(branch_rev, a), 
 
1317
                self.assertEqual(getattr(branch_rev, a),
1259
1318
                                 getattr(bundle_rev, a))
1260
 
            self.assertEqual(len(branch_rev.parent_ids), 
 
1319
            self.assertEqual(len(branch_rev.parent_ids),
1261
1320
                             len(bundle_rev.parent_ids))
1262
1321
        self.assertEqual(set(rev_ids),
1263
1322
                         set([r.revision_id for r in bundle.real_revisions]))
1277
1336
        new_text = self.get_raw(StringIO(''.join(bundle_txt)))
1278
1337
        new_text = new_text.replace('<file file_id="exe-1"',
1279
1338
                                    '<file executable="y" file_id="exe-1"')
1280
 
        new_text = new_text.replace('B222', 'B237')
 
1339
        new_text = new_text.replace('B260', 'B275')
1281
1340
        bundle_txt = StringIO()
1282
1341
        bundle_txt.write(serializer._get_bundle_header('4'))
1283
1342
        bundle_txt.write('\n')
1289
1348
 
1290
1349
    def create_bundle_text(self, base_rev_id, rev_id):
1291
1350
        bundle_txt = StringIO()
1292
 
        rev_ids = write_bundle(self.b1.repository, rev_id, base_rev_id, 
 
1351
        rev_ids = write_bundle(self.b1.repository, rev_id, base_rev_id,
1293
1352
                               bundle_txt, format=self.format)
1294
1353
        bundle_txt.seek(0)
1295
 
        self.assertEqual(bundle_txt.readline(), 
 
1354
        self.assertEqual(bundle_txt.readline(),
1296
1355
                         '# Bazaar revision bundle v%s\n' % self.format)
1297
1356
        self.assertEqual(bundle_txt.readline(), '#\n')
1298
1357
        rev = self.b1.repository.get_revision(rev_id)
1318
1377
        tree2 = self.make_branch_and_tree('target')
1319
1378
        target_repo = tree2.branch.repository
1320
1379
        install_bundle(target_repo, serializer.read(s))
1321
 
        vf = target_repo.weave_store.get_weave('fileid-2',
1322
 
            target_repo.get_transaction())
1323
 
        self.assertEqual('contents1\nstatic\n', vf.get_text('rev1'))
1324
 
        self.assertEqual('contents2\nstatic\n', vf.get_text('rev2'))
 
1380
        target_repo.lock_read()
 
1381
        self.addCleanup(target_repo.unlock)
 
1382
        # Turn the 'iterators_of_bytes' back into simple strings for comparison
 
1383
        repo_texts = dict((i, ''.join(content)) for i, content
 
1384
                          in target_repo.iter_files_bytes(
 
1385
                                [('fileid-2', 'rev1', '1'),
 
1386
                                 ('fileid-2', 'rev2', '2')]))
 
1387
        self.assertEqual({'1':'contents1\nstatic\n',
 
1388
                          '2':'contents2\nstatic\n'},
 
1389
                         repo_texts)
1325
1390
        rtree = target_repo.revision_tree('rev2')
1326
 
        inventory_vf = target_repo.get_inventory_weave()
1327
 
        self.assertEqual(['rev1'], inventory_vf.get_parents('rev2'))
 
1391
        inventory_vf = target_repo.inventories
 
1392
        # If the inventory store has a graph, it must match the revision graph.
 
1393
        self.assertSubset(
 
1394
            [inventory_vf.get_parent_map([('rev2',)])[('rev2',)]],
 
1395
            [None, (('rev1',),)])
1328
1396
        self.assertEqual('changed file',
1329
1397
                         target_repo.get_revision('rev2').message)
1330
1398
 
1380
1448
        return 'metaweave'
1381
1449
 
1382
1450
 
 
1451
class V4_2aBundleTester(V4BundleTester):
 
1452
 
 
1453
    def bzrdir_format(self):
 
1454
        return '2a'
 
1455
 
 
1456
    def get_invalid_bundle(self, base_rev_id, rev_id):
 
1457
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
 
1458
        Munge the text so that it's invalid.
 
1459
 
 
1460
        :return: The in-memory bundle
 
1461
        """
 
1462
        from bzrlib.bundle import serializer
 
1463
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
 
1464
        new_text = self.get_raw(StringIO(''.join(bundle_txt)))
 
1465
        # We are going to be replacing some text to set the executable bit on a
 
1466
        # file. Make sure the text replacement actually works correctly.
 
1467
        self.assertContainsRe(new_text, '(?m)B244\n\ni 1\n<inventory')
 
1468
        new_text = new_text.replace('<file file_id="exe-1"',
 
1469
                                    '<file executable="y" file_id="exe-1"')
 
1470
        new_text = new_text.replace('B244', 'B259')
 
1471
        bundle_txt = StringIO()
 
1472
        bundle_txt.write(serializer._get_bundle_header('4'))
 
1473
        bundle_txt.write('\n')
 
1474
        bundle_txt.write(new_text.encode('bz2'))
 
1475
        bundle_txt.seek(0)
 
1476
        bundle = read_bundle(bundle_txt)
 
1477
        self.valid_apply_bundle(base_rev_id, bundle)
 
1478
        return bundle
 
1479
 
 
1480
    def make_merged_branch(self):
 
1481
        builder = self.make_branch_builder('source')
 
1482
        builder.start_series()
 
1483
        builder.build_snapshot('a@cset-0-1', None, [
 
1484
            ('add', ('', 'root-id', 'directory', None)),
 
1485
            ('add', ('file', 'file-id', 'file', 'original content\n')),
 
1486
            ])
 
1487
        builder.build_snapshot('a@cset-0-2a', ['a@cset-0-1'], [
 
1488
            ('modify', ('file-id', 'new-content\n')),
 
1489
            ])
 
1490
        builder.build_snapshot('a@cset-0-2b', ['a@cset-0-1'], [
 
1491
            ('add', ('other-file', 'file2-id', 'file', 'file2-content\n')),
 
1492
            ])
 
1493
        builder.build_snapshot('a@cset-0-3', ['a@cset-0-2a', 'a@cset-0-2b'], [
 
1494
            ('add', ('other-file', 'file2-id', 'file', 'file2-content\n')),
 
1495
            ])
 
1496
        builder.finish_series()
 
1497
        self.b1 = builder.get_branch()
 
1498
        self.b1.lock_read()
 
1499
        self.addCleanup(self.b1.unlock)
 
1500
 
 
1501
    def make_bundle_just_inventories(self, base_revision_id,
 
1502
                                     target_revision_id,
 
1503
                                     revision_ids):
 
1504
        sio = StringIO()
 
1505
        writer = v4.BundleWriteOperation(base_revision_id, target_revision_id,
 
1506
                                         self.b1.repository, sio)
 
1507
        writer.bundle.begin()
 
1508
        writer._add_inventory_mpdiffs_from_serializer(revision_ids)
 
1509
        writer.bundle.end()
 
1510
        sio.seek(0)
 
1511
        return sio
 
1512
 
 
1513
    def test_single_inventory_multiple_parents_as_xml(self):
 
1514
        self.make_merged_branch()
 
1515
        sio = self.make_bundle_just_inventories('a@cset-0-1', 'a@cset-0-3',
 
1516
                                                ['a@cset-0-3'])
 
1517
        reader = v4.BundleReader(sio, stream_input=False)
 
1518
        records = list(reader.iter_records())
 
1519
        self.assertEqual(1, len(records))
 
1520
        (bytes, metadata, repo_kind, revision_id,
 
1521
         file_id) = records[0]
 
1522
        self.assertIs(None, file_id)
 
1523
        self.assertEqual('a@cset-0-3', revision_id)
 
1524
        self.assertEqual('inventory', repo_kind)
 
1525
        self.assertEqual({'parents': ['a@cset-0-2a', 'a@cset-0-2b'],
 
1526
                          'sha1': '09c53b0c4de0895e11a2aacc34fef60a6e70865c',
 
1527
                          'storage_kind': 'mpdiff',
 
1528
                         }, metadata)
 
1529
        # We should have an mpdiff that takes some lines from both parents.
 
1530
        self.assertEqualDiff(
 
1531
            'i 1\n'
 
1532
            '<inventory format="10" revision_id="a@cset-0-3">\n'
 
1533
            '\n'
 
1534
            'c 0 1 1 2\n'
 
1535
            'c 1 3 3 2\n', bytes)
 
1536
 
 
1537
    def test_single_inv_no_parents_as_xml(self):
 
1538
        self.make_merged_branch()
 
1539
        sio = self.make_bundle_just_inventories('null:', 'a@cset-0-1',
 
1540
                                                ['a@cset-0-1'])
 
1541
        reader = v4.BundleReader(sio, stream_input=False)
 
1542
        records = list(reader.iter_records())
 
1543
        self.assertEqual(1, len(records))
 
1544
        (bytes, metadata, repo_kind, revision_id,
 
1545
         file_id) = records[0]
 
1546
        self.assertIs(None, file_id)
 
1547
        self.assertEqual('a@cset-0-1', revision_id)
 
1548
        self.assertEqual('inventory', repo_kind)
 
1549
        self.assertEqual({'parents': [],
 
1550
                          'sha1': 'a13f42b142d544aac9b085c42595d304150e31a2',
 
1551
                          'storage_kind': 'mpdiff',
 
1552
                         }, metadata)
 
1553
        # We should have an mpdiff that takes some lines from both parents.
 
1554
        self.assertEqualDiff(
 
1555
            'i 4\n'
 
1556
            '<inventory format="10" revision_id="a@cset-0-1">\n'
 
1557
            '<directory file_id="root-id" name=""'
 
1558
                ' revision="a@cset-0-1" />\n'
 
1559
            '<file file_id="file-id" name="file" parent_id="root-id"'
 
1560
                ' revision="a@cset-0-1"'
 
1561
                ' text_sha1="09c2f8647e14e49e922b955c194102070597c2d1"'
 
1562
                ' text_size="17" />\n'
 
1563
            '</inventory>\n'
 
1564
            '\n', bytes)
 
1565
 
 
1566
    def test_multiple_inventories_as_xml(self):
 
1567
        self.make_merged_branch()
 
1568
        sio = self.make_bundle_just_inventories('a@cset-0-1', 'a@cset-0-3',
 
1569
            ['a@cset-0-2a', 'a@cset-0-2b', 'a@cset-0-3'])
 
1570
        reader = v4.BundleReader(sio, stream_input=False)
 
1571
        records = list(reader.iter_records())
 
1572
        self.assertEqual(3, len(records))
 
1573
        revision_ids = [rev_id for b, m, k, rev_id, f in records]
 
1574
        self.assertEqual(['a@cset-0-2a', 'a@cset-0-2b', 'a@cset-0-3'],
 
1575
                         revision_ids)
 
1576
        metadata_2a = records[0][1]
 
1577
        self.assertEqual({'parents': ['a@cset-0-1'],
 
1578
                          'sha1': '1e105886d62d510763e22885eec733b66f5f09bf',
 
1579
                          'storage_kind': 'mpdiff',
 
1580
                         }, metadata_2a)
 
1581
        metadata_2b = records[1][1]
 
1582
        self.assertEqual({'parents': ['a@cset-0-1'],
 
1583
                          'sha1': 'f03f12574bdb5ed2204c28636c98a8547544ccd8',
 
1584
                          'storage_kind': 'mpdiff',
 
1585
                         }, metadata_2b)
 
1586
        metadata_3 = records[2][1]
 
1587
        self.assertEqual({'parents': ['a@cset-0-2a', 'a@cset-0-2b'],
 
1588
                          'sha1': '09c53b0c4de0895e11a2aacc34fef60a6e70865c',
 
1589
                          'storage_kind': 'mpdiff',
 
1590
                         }, metadata_3)
 
1591
        bytes_2a = records[0][0]
 
1592
        self.assertEqualDiff(
 
1593
            'i 1\n'
 
1594
            '<inventory format="10" revision_id="a@cset-0-2a">\n'
 
1595
            '\n'
 
1596
            'c 0 1 1 1\n'
 
1597
            'i 1\n'
 
1598
            '<file file_id="file-id" name="file" parent_id="root-id"'
 
1599
                ' revision="a@cset-0-2a"'
 
1600
                ' text_sha1="50f545ff40e57b6924b1f3174b267ffc4576e9a9"'
 
1601
                ' text_size="12" />\n'
 
1602
            '\n'
 
1603
            'c 0 3 3 1\n', bytes_2a)
 
1604
        bytes_2b = records[1][0]
 
1605
        self.assertEqualDiff(
 
1606
            'i 1\n'
 
1607
            '<inventory format="10" revision_id="a@cset-0-2b">\n'
 
1608
            '\n'
 
1609
            'c 0 1 1 2\n'
 
1610
            'i 1\n'
 
1611
            '<file file_id="file2-id" name="other-file" parent_id="root-id"'
 
1612
                ' revision="a@cset-0-2b"'
 
1613
                ' text_sha1="b46c0c8ea1e5ef8e46fc8894bfd4752a88ec939e"'
 
1614
                ' text_size="14" />\n'
 
1615
            '\n'
 
1616
            'c 0 3 4 1\n', bytes_2b)
 
1617
        bytes_3 = records[2][0]
 
1618
        self.assertEqualDiff(
 
1619
            'i 1\n'
 
1620
            '<inventory format="10" revision_id="a@cset-0-3">\n'
 
1621
            '\n'
 
1622
            'c 0 1 1 2\n'
 
1623
            'c 1 3 3 2\n', bytes_3)
 
1624
 
 
1625
    def test_creating_bundle_preserves_chk_pages(self):
 
1626
        self.make_merged_branch()
 
1627
        target = self.b1.bzrdir.sprout('target',
 
1628
                                       revision_id='a@cset-0-2a').open_branch()
 
1629
        bundle_txt, rev_ids = self.create_bundle_text('a@cset-0-2a',
 
1630
                                                      'a@cset-0-3')
 
1631
        self.assertEqual(['a@cset-0-2b', 'a@cset-0-3'], rev_ids)
 
1632
        bundle = read_bundle(bundle_txt)
 
1633
        target.lock_write()
 
1634
        self.addCleanup(target.unlock)
 
1635
        install_bundle(target.repository, bundle)
 
1636
        inv1 = self.b1.repository.inventories.get_record_stream([
 
1637
            ('a@cset-0-3',)], 'unordered',
 
1638
            True).next().get_bytes_as('fulltext')
 
1639
        inv2 = target.repository.inventories.get_record_stream([
 
1640
            ('a@cset-0-3',)], 'unordered',
 
1641
            True).next().get_bytes_as('fulltext')
 
1642
        self.assertEqualDiff(inv1, inv2)
 
1643
 
 
1644
 
1383
1645
class MungedBundleTester(object):
1384
1646
 
1385
1647
    def build_test_bundle(self):
1432
1694
        self.check_valid(bundle)
1433
1695
 
1434
1696
 
1435
 
class MungedBundleTesterV09(TestCaseWithTransport, MungedBundleTester):
 
1697
class MungedBundleTesterV09(tests.TestCaseWithTransport, MungedBundleTester):
1436
1698
 
1437
1699
    format = '0.9'
1438
1700
 
1470
1732
        self.check_valid(bundle)
1471
1733
 
1472
1734
 
1473
 
class MungedBundleTesterV4(TestCaseWithTransport, MungedBundleTester):
 
1735
class MungedBundleTesterV4(tests.TestCaseWithTransport, MungedBundleTester):
1474
1736
 
1475
1737
    format = '4'
1476
1738
 
1477
1739
 
1478
 
class TestBundleWriterReader(TestCase):
 
1740
class TestBundleWriterReader(tests.TestCase):
1479
1741
 
1480
1742
    def test_roundtrip_record(self):
1481
1743
        fileobj = StringIO()
1543
1805
        record = record_iter.next()
1544
1806
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
1545
1807
            'info', None, None), record)
1546
 
        self.assertRaises(BadBundle, record_iter.next)
 
1808
        self.assertRaises(errors.BadBundle, record_iter.next)
 
1809
 
 
1810
 
 
1811
class TestReadMergeableFromUrl(tests.TestCaseWithTransport):
 
1812
 
 
1813
    def test_read_mergeable_skips_local(self):
 
1814
        """A local bundle named like the URL should not be read.
 
1815
        """
 
1816
        out, wt = test_read_bundle.create_bundle_file(self)
 
1817
        class FooService(object):
 
1818
            """A directory service that always returns source"""
 
1819
 
 
1820
            def look_up(self, name, url):
 
1821
                return 'source'
 
1822
        directories.register('foo:', FooService, 'Testing directory service')
 
1823
        self.addCleanup(directories.remove, 'foo:')
 
1824
        self.build_tree_contents([('./foo:bar', out.getvalue())])
 
1825
        self.assertRaises(errors.NotABundle, read_mergeable_from_url,
 
1826
                          'foo:bar')
 
1827
 
 
1828
    def test_infinite_redirects_are_not_a_bundle(self):
 
1829
        """If a URL causes TooManyRedirections then NotABundle is raised.
 
1830
        """
 
1831
        from bzrlib.tests.blackbox.test_push import RedirectingMemoryServer
 
1832
        server = RedirectingMemoryServer()
 
1833
        self.start_server(server)
 
1834
        url = server.get_url() + 'infinite-loop'
 
1835
        self.assertRaises(errors.NotABundle, read_mergeable_from_url, url)
 
1836
 
 
1837
    def test_smart_server_connection_reset(self):
 
1838
        """If a smart server connection fails during the attempt to read a
 
1839
        bundle, then the ConnectionReset error should be propagated.
 
1840
        """
 
1841
        # Instantiate a server that will provoke a ConnectionReset
 
1842
        sock_server = _DisconnectingTCPServer()
 
1843
        self.start_server(sock_server)
 
1844
        # We don't really care what the url is since the server will close the
 
1845
        # connection without interpreting it
 
1846
        url = sock_server.get_url()
 
1847
        self.assertRaises(errors.ConnectionReset, read_mergeable_from_url, url)
 
1848
 
 
1849
 
 
1850
class _DisconnectingTCPServer(object):
 
1851
    """A TCP server that immediately closes any connection made to it."""
 
1852
 
 
1853
    def start_server(self):
 
1854
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
1855
        self.sock.bind(('127.0.0.1', 0))
 
1856
        self.sock.listen(1)
 
1857
        self.port = self.sock.getsockname()[1]
 
1858
        self.thread = threading.Thread(
 
1859
            name='%s (port %d)' % (self.__class__.__name__, self.port),
 
1860
            target=self.accept_and_close)
 
1861
        self.thread.start()
 
1862
 
 
1863
    def accept_and_close(self):
 
1864
        conn, addr = self.sock.accept()
 
1865
        conn.shutdown(socket.SHUT_RDWR)
 
1866
        conn.close()
 
1867
 
 
1868
    def get_url(self):
 
1869
        return 'bzr://127.0.0.1:%d/' % (self.port,)
 
1870
 
 
1871
    def stop_server(self):
 
1872
        try:
 
1873
            # make sure the thread dies by connecting to the listening socket,
 
1874
            # just in case the test failed to do so.
 
1875
            conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
1876
            conn.connect(self.sock.getsockname())
 
1877
            conn.close()
 
1878
        except socket.error:
 
1879
            pass
 
1880
        self.sock.close()
 
1881
        self.thread.join()