← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/per_repository/test_commit_builder.py

  • Committer: Jelmer Vernooij
  • Date: 2011-05-10 07:46:15 UTC
  • mfrom: (5844 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5845.
  • Revision ID: jelmer@samba.org-20110510074615-eptod049ndjxc4i7
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/per_repository/test_commit_builder.py
19
19
import os
20
20
 
21
21
from bzrlib import (
 
22
    config,
22
23
    errors,
23
24
    graph,
24
25
    inventory,
60
61
        tree.lock_write()
61
62
        try:
62
63
            builder = tree.branch.get_commit_builder([])
 
64
            if not builder.supports_record_entry_contents:
 
65
                raise tests.TestNotApplicable("CommitBuilder doesn't support "
 
66
                    "record_entry_contents")
63
67
            repo = tree.branch.repository
64
68
            self.record_root(builder, tree)
65
69
            builder.finish_inventory()
84
88
        finally:
85
89
            tree.unlock()
86
90
 
87
 
    def test_abort(self):
 
91
    def test_abort_record_entry_contents(self):
88
92
        tree = self.make_branch_and_tree(".")
89
93
        tree.lock_write()
90
94
        try:
91
95
            builder = tree.branch.get_commit_builder([])
 
96
            if not builder.supports_record_entry_contents:
 
97
                raise tests.TestNotApplicable("CommitBuilder doesn't support "
 
98
                    "record_entry_contents")
92
99
            self.record_root(builder, tree)
93
100
            builder.finish_inventory()
94
101
            builder.abort()
111
118
        finally:
112
119
            tree.unlock()
113
120
 
 
121
    def test_commit_lossy(self):
 
122
        tree = self.make_branch_and_tree(".")
 
123
        tree.lock_write()
 
124
        try:
 
125
            builder = tree.branch.get_commit_builder([], lossy=True)
 
126
            list(builder.record_iter_changes(tree, tree.last_revision(),
 
127
                tree.iter_changes(tree.basis_tree())))
 
128
            builder.finish_inventory()
 
129
            rev_id = builder.commit('foo bar blah')
 
130
        finally:
 
131
            tree.unlock()
 
132
        rev = tree.branch.repository.get_revision(rev_id)
 
133
        self.assertEqual('foo bar blah', rev.message)
 
134
 
114
135
    def test_commit_message(self):
115
136
        tree = self.make_branch_and_tree(".")
116
137
        tree.lock_write()
117
138
        try:
118
139
            builder = tree.branch.get_commit_builder([])
119
 
            self.record_root(builder, tree)
 
140
            list(builder.record_iter_changes(tree, tree.last_revision(),
 
141
                tree.iter_changes(tree.basis_tree())))
120
142
            builder.finish_inventory()
121
143
            rev_id = builder.commit('foo bar blah')
122
144
        finally:
124
146
        rev = tree.branch.repository.get_revision(rev_id)
125
147
        self.assertEqual('foo bar blah', rev.message)
126
148
 
127
 
    def test_commit_with_revision_id(self):
 
149
    def test_commit_with_revision_id_record_entry_contents(self):
128
150
        tree = self.make_branch_and_tree(".")
129
151
        tree.lock_write()
130
152
        try:
142
164
            except errors.CannotSetRevisionId:
143
165
                # This format doesn't support supplied revision ids
144
166
                return
 
167
            if not builder.supports_record_entry_contents:
 
168
                raise tests.TestNotApplicable("CommitBuilder doesn't support "
 
169
                    "record_entry_contents")
145
170
            self.assertFalse(builder.random_revid)
146
171
            self.record_root(builder, tree)
147
172
            builder.finish_inventory()
218
243
            tree.add('foo', 'foo-id')
219
244
            entry = tree.inventory['foo-id']
220
245
            builder = tree.branch.get_commit_builder([])
 
246
            if not builder.supports_record_entry_contents:
 
247
                raise tests.TestNotApplicable("CommitBuilder doesn't support "
 
248
                    "record_entry_contents")
221
249
            self.assertRaises(errors.RootMissing,
222
250
                builder.record_entry_contents, entry, [], 'foo', tree,
223
251
                    tree.path_content_summary('foo'))
225
253
        finally:
226
254
            tree.unlock()
227
255
 
228
 
    def test_commit_unchanged_root(self):
 
256
    def test_commit_unchanged_root_record_entry_contents(self):
229
257
        tree = self.make_branch_and_tree(".")
230
258
        old_revision_id = tree.commit('')
231
259
        tree.lock_write()
234
262
        self.addCleanup(parent_tree.unlock)
235
263
        builder = tree.branch.get_commit_builder([old_revision_id])
236
264
        try:
 
265
            if not builder.supports_record_entry_contents:
 
266
                raise tests.TestNotApplicable("CommitBuilder doesn't support "
 
267
                    "record_entry_contents")
237
268
            ie = inventory.make_entry('directory', '', None,
238
269
                    tree.get_root_id())
239
270
            delta, version_recorded, fs_hash = builder.record_entry_contents(
285
316
            builder.abort()
286
317
            tree.unlock()
287
318
 
288
 
    def test_commit(self):
 
319
    def test_commit_record_entry_contents(self):
289
320
        tree = self.make_branch_and_tree(".")
290
321
        tree.lock_write()
291
322
        try:
292
323
            builder = tree.branch.get_commit_builder([])
 
324
            if not builder.supports_record_entry_contents:
 
325
                raise tests.TestNotApplicable("CommitBuilder doesn't "
 
326
                    "support record_entry_contents")
293
327
            self.record_root(builder, tree)
294
328
            builder.finish_inventory()
295
329
            rev_id = builder.commit('foo bar')
317
351
            builder = tree.branch.get_commit_builder([old_revision_id])
318
352
            total_delta = []
319
353
            try:
 
354
                if not builder.supports_record_entry_contents:
 
355
                    raise tests.TestNotApplicable("CommitBuilder doesn't "
 
356
                        "support record_entry_contents")
320
357
                parent_invs = [basis.inventory]
321
358
                builder.will_record_deletes()
322
359
                if builder.record_root_entry:
372
409
            basis = tree.branch.repository.revision_tree(rev_id)
373
410
            builder = tree.branch.get_commit_builder([rev_id])
374
411
            try:
 
412
                if not builder.supports_record_entry_contents:
 
413
                    raise tests.TestNotApplicable("CommitBuilder doesn't "
 
414
                        "support record_entry_contents")
375
415
                builder.will_record_deletes()
376
416
                if builder.record_root_entry is True:
377
417
                    parent_invs = [basis.inventory]
432
472
        try:
433
473
            builder = tree.branch.get_commit_builder([rev_id])
434
474
            try:
 
475
                if not builder.supports_record_entry_contents:
 
476
                    raise tests.TestNotApplicable("CommitBuilder doesn't "
 
477
                        "support record_entry_contents")
435
478
                self.record_root(builder, tree)
436
479
                self.assertRaises(AssertionError,
437
480
                    builder.record_delete, "foo", "foo-id")
440
483
        finally:
441
484
            tree.unlock()
442
485
 
443
 
    def test_revision_tree(self):
 
486
    def test_revision_tree_record_entry_contents(self):
444
487
        tree = self.make_branch_and_tree(".")
445
488
        tree.lock_write()
446
489
        try:
447
490
            builder = tree.branch.get_commit_builder([])
 
491
            if not builder.supports_record_entry_contents:
 
492
                raise tests.TestNotApplicable("CommitBuilder doesn't "
 
493
                    "support record_entry_contents")
448
494
            self.record_root(builder, tree)
449
495
            builder.finish_inventory()
450
496
            rev_id = builder.commit('foo bar')
489
535
        basis_tree = tree.basis_tree()
490
536
        basis_tree.lock_read()
491
537
        self.addCleanup(basis_tree.unlock)
492
 
        self.assertEqual(rev_id, basis_tree.inventory.root.revision)
 
538
        self.assertEqual(rev_id,
 
539
            basis_tree.get_file_revision(basis_tree.get_root_id()))
493
540
 
494
541
    def _get_revtrees(self, tree, revision_ids):
495
542
        tree.lock_read()
509
556
        rev1 = tree.commit('')
510
557
        rev2 = tree.commit('')
511
558
        tree1, tree2 = self._get_revtrees(tree, [rev1, rev2])
512
 
        self.assertEqual(rev1, tree1.inventory.root.revision)
 
559
        self.assertEqual(rev1, tree1.get_file_revision(tree1.get_root_id()))
513
560
        if tree.branch.repository.supports_rich_root():
514
 
            self.assertEqual(rev1, tree2.inventory.root.revision)
 
561
            self.assertEqual(rev1,
 
562
                tree2.get_file_revision(tree2.get_root_id()))
515
563
        else:
516
 
            self.assertEqual(rev2, tree2.inventory.root.revision)
 
564
            self.assertEqual(rev2,
 
565
                tree2.get_file_revision(tree2.get_root_id()))
517
566
 
518
567
    def _add_commit_check_unchanged(self, tree, name, mini_commit=None):
519
568
        tree.add([name], [name + 'id'])
526
575
            mini_commit = self.mini_commit
527
576
        rev2 = mini_commit(tree, name, name, False, False)
528
577
        tree1, tree2 = self._get_revtrees(tree, [rev1, rev2])
529
 
        self.assertEqual(rev1, tree1.inventory[file_id].revision)
530
 
        self.assertEqual(rev1, tree2.inventory[file_id].revision)
 
578
        self.assertEqual(rev1, tree1.get_file_revision(file_id))
 
579
        self.assertEqual(rev1, tree2.get_file_revision(file_id))
531
580
        expected_graph = {}
532
581
        expected_graph[(file_id, rev1)] = ()
533
582
        self.assertFileGraph(expected_graph, tree, (file_id, rev1))
556
605
        tree.add(['dir/content'], ['contentid'])
557
606
        rev2 = tree.commit('')
558
607
        tree1, tree2 = self._get_revtrees(tree, [rev1, rev2])
559
 
        self.assertEqual(rev1, tree1.inventory['dirid'].revision)
560
 
        self.assertEqual(rev1, tree2.inventory['dirid'].revision)
 
608
        self.assertEqual(rev1, tree1.get_file_revision('dirid'))
 
609
        self.assertEqual(rev1, tree2.get_file_revision('dirid'))
561
610
        file_id = 'dirid'
562
611
        expected_graph = {}
563
612
        expected_graph[(file_id, rev1)] = ()
766
815
        rev2 = mini_commit(tree, name, tree.id2path(file_id),
767
816
            expect_fs_hash=expect_fs_hash)
768
817
        tree1, tree2 = self._get_revtrees(tree, [rev1, rev2])
769
 
        self.assertEqual(rev1, tree1.inventory[file_id].revision)
770
 
        self.assertEqual(rev2, tree2.inventory[file_id].revision)
 
818
        self.assertEqual(rev1, tree1.get_file_revision(file_id))
 
819
        self.assertEqual(rev2, tree2.get_file_revision(file_id))
771
820
        expected_graph = {}
772
821
        expected_graph[(file_id, rev1)] = ()
773
822
        expected_graph[(file_id, rev2)] = ((file_id, rev1),)
794
843
            parent_ids = tree.get_parent_ids()
795
844
            builder = tree.branch.get_commit_builder(parent_ids)
796
845
            try:
 
846
                if not builder.supports_record_entry_contents:
 
847
                    raise tests.TestNotApplicable("CommitBuilder doesn't "
 
848
                        "support record_entry_contents")
797
849
                parent_tree = tree.basis_tree()
798
850
                parent_tree.lock_read()
799
851
                self.addCleanup(parent_tree.unlock)
914
966
                self.assertFalse(version_recorded)
915
967
            self.assertIs(None, builder.new_inventory)
916
968
            builder.finish_inventory()
917
 
            inv_key = (builder._new_revision_id,)
918
 
            inv_sha1 = tree.branch.repository.inventories.get_sha1s(
919
 
                            [inv_key])[inv_key]
920
 
            self.assertEqual(inv_sha1, builder.inv_sha1)
 
969
            if tree.branch.repository._format.supports_full_versioned_files:
 
970
                inv_key = (builder._new_revision_id,)
 
971
                inv_sha1 = tree.branch.repository.inventories.get_sha1s(
 
972
                                [inv_key])[inv_key]
 
973
                self.assertEqual(inv_sha1, builder.inv_sha1)
921
974
            self.assertIs(None, builder.new_inventory)
922
975
            new_inventory = builder.revision_tree().inventory
923
976
            new_entry = new_inventory[file_id]
1023
1076
        rev4 = mini_commit(tree1, 'new_' + name, 'new_' + name,
1024
1077
            expect_fs_hash=expect_fs_hash)
1025
1078
        tree3, = self._get_revtrees(tree1, [rev4])
1026
 
        self.assertEqual(rev4, tree3.inventory[name + 'id'].revision)
 
1079
        self.assertEqual(rev4, tree3.get_file_revision(name + 'id'))
1027
1080
        file_id = name + 'id'
1028
1081
        expected_graph = {}
1029
1082
        expected_graph[(file_id, rev1)] = ()
1089
1142
            rev3 = mini_commit(in_tree, name, 'new_' + name, False,
1090
1143
                delta_against_basis=changed_in_tree)
1091
1144
            tree3, = self._get_revtrees(in_tree, [rev2])
1092
 
            self.assertEqual(rev2, tree3.inventory[name + 'id'].revision)
 
1145
            self.assertEqual(rev2, tree3.get_file_revision(name + 'id'))
1093
1146
            file_id = name + 'id'
1094
1147
            expected_graph = {}
1095
1148
            expected_graph[(file_id, rev1)] = ()
1121
1174
        rev3 = mini_commit(tree1, None, 'name', False)
1122
1175
        tree3, = self._get_revtrees(tree1, [rev2])
1123
1176
        # in rev2, name should be only changed in rev2
1124
 
        self.assertEqual(rev2, tree3.inventory[file_id].revision)
 
1177
        self.assertEqual(rev2, tree3.get_file_revision(file_id))
1125
1178
        expected_graph = {}
1126
1179
        expected_graph[(file_id, rev2)] = ()
1127
1180
        self.assertFileGraph(expected_graph, tree1, (file_id, rev2))
1326
1379
        # Ensure that when no username is available but a committer is
1327
1380
        # supplied, commit works.
1328
1381
        self.overrideEnv('EMAIL', None)
 
1382
        self.overrideEnv('BZR_EMAIL', None)
 
1383
        # Also, make sure that it's not inferred from mailname.
 
1384
        self.overrideAttr(config, '_auto_user_id',
 
1385
            lambda: (None, None))
1329
1386
        tree = self.make_branch_and_tree(".")
1330
1387
        tree.lock_write()
1331
1388
        try: