/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

(jelmer) Allow CommitBuilder implementations to not provide a
 record_entry_contents implementation. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/per_repository/test_commit_builder.py
60
60
        tree.lock_write()
61
61
        try:
62
62
            builder = tree.branch.get_commit_builder([])
 
63
            if not builder.supports_record_entry_contents:
 
64
                raise tests.TestNotApplicable("CommitBuilder doesn't support "
 
65
                    "record_entry_contents")
63
66
            repo = tree.branch.repository
64
67
            self.record_root(builder, tree)
65
68
            builder.finish_inventory()
84
87
        finally:
85
88
            tree.unlock()
86
89
 
87
 
    def test_abort(self):
 
90
    def test_abort_record_entry_contents(self):
88
91
        tree = self.make_branch_and_tree(".")
89
92
        tree.lock_write()
90
93
        try:
91
94
            builder = tree.branch.get_commit_builder([])
 
95
            if not builder.supports_record_entry_contents:
 
96
                raise tests.TestNotApplicable("CommitBuilder doesn't support "
 
97
                    "record_entry_contents")
92
98
            self.record_root(builder, tree)
93
99
            builder.finish_inventory()
94
100
            builder.abort()
116
122
        tree.lock_write()
117
123
        try:
118
124
            builder = tree.branch.get_commit_builder([])
119
 
            self.record_root(builder, tree)
 
125
            list(builder.record_iter_changes(tree, tree.last_revision(),
 
126
                tree.iter_changes(tree.basis_tree())))
120
127
            builder.finish_inventory()
121
128
            rev_id = builder.commit('foo bar blah')
122
129
        finally:
124
131
        rev = tree.branch.repository.get_revision(rev_id)
125
132
        self.assertEqual('foo bar blah', rev.message)
126
133
 
127
 
    def test_commit_with_revision_id(self):
 
134
    def test_commit_with_revision_id_record_entry_contents(self):
128
135
        tree = self.make_branch_and_tree(".")
129
136
        tree.lock_write()
130
137
        try:
142
149
            except errors.CannotSetRevisionId:
143
150
                # This format doesn't support supplied revision ids
144
151
                return
 
152
            if not builder.supports_record_entry_contents:
 
153
                raise tests.TestNotApplicable("CommitBuilder doesn't support "
 
154
                    "record_entry_contents")
145
155
            self.assertFalse(builder.random_revid)
146
156
            self.record_root(builder, tree)
147
157
            builder.finish_inventory()
218
228
            tree.add('foo', 'foo-id')
219
229
            entry = tree.inventory['foo-id']
220
230
            builder = tree.branch.get_commit_builder([])
 
231
            if not builder.supports_record_entry_contents:
 
232
                raise tests.TestNotApplicable("CommitBuilder doesn't support "
 
233
                    "record_entry_contents")
221
234
            self.assertRaises(errors.RootMissing,
222
235
                builder.record_entry_contents, entry, [], 'foo', tree,
223
236
                    tree.path_content_summary('foo'))
225
238
        finally:
226
239
            tree.unlock()
227
240
 
228
 
    def test_commit_unchanged_root(self):
 
241
    def test_commit_unchanged_root_record_entry_contents(self):
229
242
        tree = self.make_branch_and_tree(".")
230
243
        old_revision_id = tree.commit('')
231
244
        tree.lock_write()
234
247
        self.addCleanup(parent_tree.unlock)
235
248
        builder = tree.branch.get_commit_builder([old_revision_id])
236
249
        try:
 
250
            if not builder.supports_record_entry_contents:
 
251
                raise tests.TestNotApplicable("CommitBuilder doesn't support "
 
252
                    "record_entry_contents")
237
253
            ie = inventory.make_entry('directory', '', None,
238
254
                    tree.get_root_id())
239
255
            delta, version_recorded, fs_hash = builder.record_entry_contents(
285
301
            builder.abort()
286
302
            tree.unlock()
287
303
 
288
 
    def test_commit(self):
 
304
    def test_commit_record_entry_contents(self):
289
305
        tree = self.make_branch_and_tree(".")
290
306
        tree.lock_write()
291
307
        try:
292
308
            builder = tree.branch.get_commit_builder([])
 
309
            if not builder.supports_record_entry_contents:
 
310
                raise tests.TestNotApplicable("CommitBuilder doesn't "
 
311
                    "support record_entry_contents")
293
312
            self.record_root(builder, tree)
294
313
            builder.finish_inventory()
295
314
            rev_id = builder.commit('foo bar')
317
336
            builder = tree.branch.get_commit_builder([old_revision_id])
318
337
            total_delta = []
319
338
            try:
 
339
                if not builder.supports_record_entry_contents:
 
340
                    raise tests.TestNotApplicable("CommitBuilder doesn't "
 
341
                        "support record_entry_contents")
320
342
                parent_invs = [basis.inventory]
321
343
                builder.will_record_deletes()
322
344
                if builder.record_root_entry:
372
394
            basis = tree.branch.repository.revision_tree(rev_id)
373
395
            builder = tree.branch.get_commit_builder([rev_id])
374
396
            try:
 
397
                if not builder.supports_record_entry_contents:
 
398
                    raise tests.TestNotApplicable("CommitBuilder doesn't "
 
399
                        "support record_entry_contents")
375
400
                builder.will_record_deletes()
376
401
                if builder.record_root_entry is True:
377
402
                    parent_invs = [basis.inventory]
432
457
        try:
433
458
            builder = tree.branch.get_commit_builder([rev_id])
434
459
            try:
 
460
                if not builder.supports_record_entry_contents:
 
461
                    raise tests.TestNotApplicable("CommitBuilder doesn't "
 
462
                        "support record_entry_contents")
435
463
                self.record_root(builder, tree)
436
464
                self.assertRaises(AssertionError,
437
465
                    builder.record_delete, "foo", "foo-id")
440
468
        finally:
441
469
            tree.unlock()
442
470
 
443
 
    def test_revision_tree(self):
 
471
    def test_revision_tree_record_entry_contents(self):
444
472
        tree = self.make_branch_and_tree(".")
445
473
        tree.lock_write()
446
474
        try:
447
475
            builder = tree.branch.get_commit_builder([])
 
476
            if not builder.supports_record_entry_contents:
 
477
                raise tests.TestNotApplicable("CommitBuilder doesn't "
 
478
                    "support record_entry_contents")
448
479
            self.record_root(builder, tree)
449
480
            builder.finish_inventory()
450
481
            rev_id = builder.commit('foo bar')
794
825
            parent_ids = tree.get_parent_ids()
795
826
            builder = tree.branch.get_commit_builder(parent_ids)
796
827
            try:
 
828
                if not builder.supports_record_entry_contents:
 
829
                    raise tests.TestNotApplicable("CommitBuilder doesn't "
 
830
                        "support record_entry_contents")
797
831
                parent_tree = tree.basis_tree()
798
832
                parent_tree.lock_read()
799
833
                self.addCleanup(parent_tree.unlock)
914
948
                self.assertFalse(version_recorded)
915
949
            self.assertIs(None, builder.new_inventory)
916
950
            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)
 
951
            if tree.branch.repository._format.supports_full_versioned_files:
 
952
                inv_key = (builder._new_revision_id,)
 
953
                inv_sha1 = tree.branch.repository.inventories.get_sha1s(
 
954
                                [inv_key])[inv_key]
 
955
                self.assertEqual(inv_sha1, builder.inv_sha1)
921
956
            self.assertIs(None, builder.new_inventory)
922
957
            new_inventory = builder.revision_tree().inventory
923
958
            new_entry = new_inventory[file_id]