73
72
private_default = old_default().repository_format.__class__
74
73
old_format = repository.format_registry.get_default()
75
74
self.assertTrue(isinstance(old_format, private_default))
76
76
def make_sample_bzrdir():
77
77
my_bzrdir = bzrdir.BzrDirMetaFormat1()
78
78
my_bzrdir.repository_format = SampleRepositoryFormat()
137
137
# create a branch with a few known format objects.
138
138
# this is not quite the same as
139
139
self.build_tree(["foo/", "bar/"])
140
141
def check_format(format, url):
141
142
dir = format._matchingcontroldir.initialize(url)
142
143
format.initialize(dir)
143
t = transport.get_transport_from_path(url)
144
found_format = bzrrepository.RepositoryFormatMetaDir.find_format(dir)
144
found_format = bzrrepository.RepositoryFormatMetaDir.find_format(
145
146
self.assertIsInstance(found_format, format.__class__)
146
147
check_format(repository.format_registry.get_default(), "bar")
157
158
b"Sample .bzr repository format."),
158
159
SampleRepositoryFormat)
159
160
self.assertRaises(AssertionError,
160
SampleRepositoryFormat.from_string,
161
b"Different .bzr repository format.")
161
SampleRepositoryFormat.from_string,
162
b"Different .bzr repository format.")
163
164
def test_find_format_unknown_format(self):
164
165
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
170
171
def test_find_format_with_features(self):
171
172
tree = self.make_branch_and_tree('.', format='2a')
172
173
tree.branch.repository.update_feature_flags({b"name": b"necessity"})
173
found_format = bzrrepository.RepositoryFormatMetaDir.find_format(tree.controldir)
174
self.assertIsInstance(found_format, bzrrepository.RepositoryFormatMetaDir)
174
found_format = bzrrepository.RepositoryFormatMetaDir.find_format(
176
self.assertIsInstance(
177
found_format, bzrrepository.RepositoryFormatMetaDir)
175
178
self.assertEqual(found_format.features.get(b"name"), b"necessity")
176
self.assertRaises(bzrdir.MissingFeature, found_format.check_support_status,
178
self.addCleanup(bzrrepository.RepositoryFormatMetaDir.unregister_feature,
180
bzrdir.MissingFeature, found_format.check_support_status, True)
182
bzrrepository.RepositoryFormatMetaDir.unregister_feature, b"name")
180
183
bzrrepository.RepositoryFormatMetaDir.register_feature(b"name")
181
184
found_format.check_support_status(True)
190
193
def test_register_unregister_format(self):
191
194
format = SampleRepositoryFormat()
192
195
self.registry.register(format)
193
self.assertEqual(format, self.registry.get(b"Sample .bzr repository format."))
196
self.assertEqual(format, self.registry.get(
197
b"Sample .bzr repository format."))
194
198
self.registry.remove(format)
195
self.assertRaises(KeyError, self.registry.get, b"Sample .bzr repository format.")
199
self.assertRaises(KeyError, self.registry.get,
200
b"Sample .bzr repository format.")
197
202
def test_get_all(self):
198
203
format = SampleRepositoryFormat()
209
214
def test_register_extra_lazy(self):
210
215
self.assertEqual([], self.registry._get_all())
211
216
self.registry.register_extra_lazy("breezy.tests.test_repository",
212
"SampleExtraRepositoryFormat")
217
"SampleExtraRepositoryFormat")
213
218
formats = self.registry._get_all()
214
219
self.assertEqual(1, len(formats))
215
220
self.assertIsInstance(formats[0], SampleExtraRepositoryFormat)
220
225
def test_attribute__fetch_order(self):
221
226
"""Knits need topological data insertion."""
222
repo = self.make_repository('.',
223
format=controldir.format_registry.get('knit')())
227
repo = self.make_repository(
228
'.', format=controldir.format_registry.get('knit')())
224
229
self.assertEqual('topological', repo._format._fetch_order)
226
231
def test_attribute__fetch_uses_deltas(self):
227
232
"""Knits reuse deltas."""
228
repo = self.make_repository('.',
229
format=controldir.format_registry.get('knit')())
233
repo = self.make_repository(
234
'.', format=controldir.format_registry.get('knit')())
230
235
self.assertEqual(True, repo._format._fetch_uses_deltas)
232
237
def test_disk_layout(self):
250
255
self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
251
256
self.check_knits(t)
252
257
# Check per-file knits.
253
branch = control.create_branch()
258
control.create_branch()
254
259
tree = control.create_workingtree()
255
260
tree.add(['foo'], [b'Nasty-IdC:'], ['file'])
256
261
tree.put_file_bytes_non_atomic('foo', b'')
257
262
tree.commit('1st post', rev_id=b'foo')
258
263
self.assertHasKnit(t, 'knits/e8/%254easty-%2549d%2543%253a',
259
b'\nfoo fulltext 0 81 :')
264
b'\nfoo fulltext 0 81 :')
261
266
def assertHasKnit(self, t, knit_name, extra_content=b''):
262
267
"""Assert that knit_name exists on t."""
272
277
def test_shared_disk_layout(self):
273
278
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
274
repo = knitrepo.RepositoryFormatKnit1().initialize(control, shared=True)
279
knitrepo.RepositoryFormatKnit1().initialize(control, shared=True)
276
281
# format 'Bazaar-NG Knit Repository Format 1'
277
282
# lock: is a directory
292
297
def test_shared_no_tree_disk_layout(self):
293
298
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
294
repo = knitrepo.RepositoryFormatKnit1().initialize(control, shared=True)
299
repo = knitrepo.RepositoryFormatKnit1().initialize(
300
control, shared=True)
295
301
repo.set_make_working_trees(False)
297
303
# format 'Bazaar-NG Knit Repository Format 1'
320
326
the whole inventory. So we grab the one from the expected text. Which
321
327
is valid when the api is not being abused.
323
repo = self.make_repository('.',
324
format=controldir.format_registry.get('knit')())
329
repo = self.make_repository(
330
'.', format=controldir.format_registry.get('knit')())
325
331
inv_xml = b'<inventory format="5">\n</inventory>\n'
326
332
inv = repo._deserialise_inventory(b'test-rev-id', inv_xml)
327
333
self.assertEqual(b'test-rev-id', inv.root.revision)
329
335
def test_deserialise_uses_global_revision_id(self):
330
336
"""If it is set, then we re-use the global revision id"""
331
repo = self.make_repository('.',
332
format=controldir.format_registry.get('knit')())
337
repo = self.make_repository(
338
'.', format=controldir.format_registry.get('knit')())
333
339
inv_xml = (b'<inventory format="5" revision_id="other-rev-id">\n'
334
340
b'</inventory>\n')
335
341
# Arguably, the deserialise_inventory should detect a mismatch, and
336
342
# raise an error, rather than silently using one revision_id over the
338
344
self.assertRaises(AssertionError, repo._deserialise_inventory,
339
b'test-rev-id', inv_xml)
345
b'test-rev-id', inv_xml)
340
346
inv = repo._deserialise_inventory(b'other-rev-id', inv_xml)
341
347
self.assertEqual(b'other-rev-id', inv.root.revision)
343
349
def test_supports_external_lookups(self):
344
repo = self.make_repository('.',
345
format=controldir.format_registry.get('knit')())
350
repo = self.make_repository(
351
'.', format=controldir.format_registry.get('knit')())
346
352
self.assertFalse(repo._format.supports_external_lookups)
376
382
def is_compatible(repo_source, repo_target):
377
383
"""InterDummy is compatible with DummyRepository."""
378
384
return (isinstance(repo_source, DummyRepository) and
379
isinstance(repo_target, DummyRepository))
385
isinstance(repo_target, DummyRepository))
382
388
class TestInterRepository(TestCaseWithTransport):
421
427
repo = self.make_repository('.')
422
428
# hack dummies to look like repo somewhat.
423
429
dummy_a._serializer = repo._serializer
424
dummy_a._format.supports_tree_reference = repo._format.supports_tree_reference
430
dummy_a._format.supports_tree_reference = (
431
repo._format.supports_tree_reference)
425
432
dummy_a._format.rich_root_data = repo._format.rich_root_data
426
dummy_a._format.supports_full_versioned_files = repo._format.supports_full_versioned_files
433
dummy_a._format.supports_full_versioned_files = (
434
repo._format.supports_full_versioned_files)
427
435
dummy_b._serializer = repo._serializer
428
dummy_b._format.supports_tree_reference = repo._format.supports_tree_reference
436
dummy_b._format.supports_tree_reference = (
437
repo._format.supports_tree_reference)
429
438
dummy_b._format.rich_root_data = repo._format.rich_root_data
430
dummy_b._format.supports_full_versioned_files = repo._format.supports_full_versioned_files
439
dummy_b._format.supports_full_versioned_files = (
440
repo._format.supports_full_versioned_files)
431
441
repository.InterRepository.register_optimiser(InterDummy)
433
443
# we should get the default for something InterDummy returns False
467
477
target_format = TestRepositoryFormat2()
468
478
repository.format_registry.register(source_format)
469
479
self.addCleanup(repository.format_registry.remove,
471
481
repository.format_registry.register(target_format)
472
482
self.addCleanup(repository.format_registry.remove,
474
484
t = self.get_transport()
475
485
t.mkdir('repository')
476
486
repo_dir = bzrdir.BzrDirMetaFormat1().initialize('repository')
634
644
inv.parent_id_basename_to_file_id._ensure_root()
635
645
inv.id_to_entry._ensure_root()
636
646
self.assertEqual(65536, inv.id_to_entry._root_node.maximum_size)
637
self.assertEqual(65536,
638
inv.parent_id_basename_to_file_id._root_node.maximum_size)
648
65536, inv.parent_id_basename_to_file_id._root_node.maximum_size)
640
650
def test_autopack_unchanged_chk_nodes(self):
641
651
# at 20 unchanged commits, chk pages are packed that are split into
687
697
def test_get_stream_for_missing_keys_includes_all_chk_refs(self):
688
698
source_builder = self.make_branch_builder('source',
690
700
# We have to build a fairly large tree, so that we are sure the chk
691
701
# pages will have split into multiple pages.
692
702
entries = [('add', ('', b'a-root-id', 'directory', None))]
716
726
# On a regular pass, getting the inventories and chk pages for rev-2
717
727
# would only get the newly created chk pages
718
728
search = vf_search.SearchResult({b'rev-2'}, {b'rev-1'}, 1,
720
730
simple_chk_records = set()
721
731
for vf_name, substream in source.get_stream(search):
722
732
if vf_name == 'chk_bytes':
764
774
source = self.make_repository('source', format='pack-0.92')
765
775
target = self.make_repository('target', format='pack-0.92')
766
776
stream_source = source._get_source(target._format)
767
self.assertIsInstance(stream_source, knitpack_repo.KnitPackStreamSource)
777
self.assertIsInstance(
778
stream_source, knitpack_repo.KnitPackStreamSource)
769
780
def test_source_to_exact_pack_rich_root_pack(self):
770
781
source = self.make_repository('source', format='rich-root-pack')
771
782
target = self.make_repository('target', format='rich-root-pack')
772
783
stream_source = source._get_source(target._format)
773
self.assertIsInstance(stream_source, knitpack_repo.KnitPackStreamSource)
784
self.assertIsInstance(
785
stream_source, knitpack_repo.KnitPackStreamSource)
775
787
def test_source_to_exact_pack_19(self):
776
788
source = self.make_repository('source', format='1.9')
777
789
target = self.make_repository('target', format='1.9')
778
790
stream_source = source._get_source(target._format)
779
self.assertIsInstance(stream_source, knitpack_repo.KnitPackStreamSource)
791
self.assertIsInstance(
792
stream_source, knitpack_repo.KnitPackStreamSource)
781
794
def test_source_to_exact_pack_19_rich_root(self):
782
795
source = self.make_repository('source', format='1.9-rich-root')
783
796
target = self.make_repository('target', format='1.9-rich-root')
784
797
stream_source = source._get_source(target._format)
785
self.assertIsInstance(stream_source, knitpack_repo.KnitPackStreamSource)
798
self.assertIsInstance(
799
stream_source, knitpack_repo.KnitPackStreamSource)
787
801
def test_source_to_remote_exact_pack_19(self):
788
802
trans = self.make_smart_server('target')
791
805
target = self.make_repository('target', format='1.9')
792
806
target = repository.Repository.open(trans.base)
793
807
stream_source = source._get_source(target._format)
794
self.assertIsInstance(stream_source, knitpack_repo.KnitPackStreamSource)
808
self.assertIsInstance(
809
stream_source, knitpack_repo.KnitPackStreamSource)
796
811
def test_stream_source_to_non_exact(self):
797
812
source = self.make_repository('source', format='pack-0.92')
828
843
super(TestDevelopment6FindParentIdsOfRevisions, self).setUp()
829
844
self.builder = self.make_branch_builder('source')
830
845
self.builder.start_series()
831
self.builder.build_snapshot(None,
846
self.builder.build_snapshot(
832
848
[('add', ('', b'tree-root', 'directory', None))],
833
849
revision_id=b'initial')
834
850
self.repo = self.builder.get_branch().repository
835
851
self.addCleanup(self.builder.finish_series)
837
853
def assertParentIds(self, expected_result, rev_set):
838
self.assertEqual(sorted(expected_result),
855
sorted(expected_result),
839
856
sorted(self.repo._find_parent_ids_of_revisions(rev_set)))
841
858
def test_simple(self):
868
885
def test_ghost_parent(self):
869
886
self.builder.build_snapshot(None, [], revision_id=b'revid1')
870
self.builder.build_snapshot([b'revid1', b'ghost'], [], revision_id=b'revid2')
887
self.builder.build_snapshot(
888
[b'revid1', b'ghost'], [], revision_id=b'revid2')
871
889
rev_set = [b'revid2', b'revid1']
872
890
self.assertParentIds([b'ghost', b'initial'], rev_set)
901
919
self.add_file(repo, inv, 'file1', b'rev1a', [])
902
920
repo.texts.add_lines((inv.root.file_id, b'rev1a'), [], [])
903
921
repo.add_inventory(b'rev1a', inv, [])
904
revision = _mod_revision.Revision(b'rev1a',
922
revision = _mod_revision.Revision(
905
924
committer='jrandom@example.com', timestamp=0,
906
925
inventory_sha1='', timezone=0, message='foo', parent_ids=[])
907
926
repo.add_revision(b'rev1a', revision, inv)
942
961
inv.root.revision = revision_id
943
962
repo.texts.add_lines((inv.root.file_id, revision_id), [], [])
944
963
repo.add_inventory(revision_id, inv, parent_ids)
945
revision = _mod_revision.Revision(revision_id,
964
revision = _mod_revision.Revision(
946
966
committer='jrandom@example.com', timestamp=0, inventory_sha1='',
947
967
timezone=0, message='foo', parent_ids=parent_ids)
948
968
repo.add_revision(revision_id, revision, inv)
1059
1079
def test_repr(self):
1060
1080
packs = self.get_packs()
1061
1081
self.assertContainsRe(repr(packs),
1062
'RepositoryPackCollection(.*Repository(.*))')
1082
'RepositoryPackCollection(.*Repository(.*))')
1064
1084
def test__obsolete_packs(self):
1065
1085
tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1080
1100
sorted(packs._pack_transport.list_dir('.')))
1081
1101
# names[0] should not be present in the index anymore
1082
1102
self.assertEqual(names[1:],
1083
sorted({osutils.splitext(n)[0] for n in
1084
packs._index_transport.list_dir('.')}))
1103
sorted({osutils.splitext(n)[0] for n in
1104
packs._index_transport.list_dir('.')}))
1086
1106
def test__obsolete_packs_missing_directory(self):
1087
1107
tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1097
1117
sorted(packs._pack_transport.list_dir('.')))
1098
1118
# names[0] should not be present in the index anymore
1099
1119
self.assertEqual(names[1:],
1100
sorted({osutils.splitext(n)[0] for n in
1101
packs._index_transport.list_dir('.')}))
1120
sorted({osutils.splitext(n)[0] for n in
1121
packs._index_transport.list_dir('.')}))
1103
1123
def test_pack_distribution_zero(self):
1104
1124
packs = self.get_packs()
1112
1132
def test_pack_distribution_one_to_nine(self):
1113
1133
packs = self.get_packs()
1114
1134
self.assertEqual([1],
1115
packs.pack_distribution(1))
1135
packs.pack_distribution(1))
1116
1136
self.assertEqual([1, 1],
1117
packs.pack_distribution(2))
1137
packs.pack_distribution(2))
1118
1138
self.assertEqual([1, 1, 1],
1119
packs.pack_distribution(3))
1139
packs.pack_distribution(3))
1120
1140
self.assertEqual([1, 1, 1, 1],
1121
packs.pack_distribution(4))
1141
packs.pack_distribution(4))
1122
1142
self.assertEqual([1, 1, 1, 1, 1],
1123
packs.pack_distribution(5))
1143
packs.pack_distribution(5))
1124
1144
self.assertEqual([1, 1, 1, 1, 1, 1],
1125
packs.pack_distribution(6))
1145
packs.pack_distribution(6))
1126
1146
self.assertEqual([1, 1, 1, 1, 1, 1, 1],
1127
packs.pack_distribution(7))
1147
packs.pack_distribution(7))
1128
1148
self.assertEqual([1, 1, 1, 1, 1, 1, 1, 1],
1129
packs.pack_distribution(8))
1149
packs.pack_distribution(8))
1130
1150
self.assertEqual([1, 1, 1, 1, 1, 1, 1, 1, 1],
1131
packs.pack_distribution(9))
1151
packs.pack_distribution(9))
1133
1153
def test_pack_distribution_stable_at_boundaries(self):
1134
1154
"""When there are multi-rev packs the counts are stable."""
1165
1185
def test_plan_pack_operations_2010_combines_smallest_two(self):
1166
1186
packs = self.get_packs()
1167
1187
existing_packs = [(1999, "big"), (9, "medium"), (1, "single2"),
1169
1189
# rev count - 2010 -> 2x1000 + 1x10 (3)
1170
1190
pack_operations = packs.plan_autopack_combinations(
1171
1191
existing_packs, [1000, 1000, 10])
1238
1258
inv_index = GraphIndex(packs._index_transport, name + '.iix', sizes[1])
1239
1259
txt_index = GraphIndex(packs._index_transport, name + '.tix', sizes[2])
1240
1260
sig_index = GraphIndex(packs._index_transport, name + '.six', sizes[3])
1241
self.assertEqual(pack_repo.ExistingPack(packs._pack_transport,
1242
name, rev_index, inv_index, txt_index, sig_index), pack_1)
1262
pack_repo.ExistingPack(
1263
packs._pack_transport, name, rev_index, inv_index, txt_index,
1243
1265
# and the same instance should be returned on successive calls.
1244
1266
self.assertTrue(pack_1 is packs.get_pack_by_name(name))
1257
1279
self.assertTrue(packs.reload_pack_names())
1258
1280
self.assertEqual(new_names, packs.names())
1259
1281
# And the repository can access the new revision
1260
self.assertEqual({rev4:(revs[-1],)}, r.get_parent_map([rev4]))
1282
self.assertEqual({rev4: (revs[-1],)}, r.get_parent_map([rev4]))
1261
1283
self.assertFalse(packs.reload_pack_names())
1263
1285
def test_reload_pack_names_added_and_removed(self):
1270
1292
self.assertEqual(names, packs.names())
1271
1293
self.assertTrue(packs.reload_pack_names())
1272
1294
self.assertEqual(new_names, packs.names())
1273
self.assertEqual({revs[-1]:(revs[-2],)}, r.get_parent_map([revs[-1]]))
1295
self.assertEqual({revs[-1]: (revs[-2],)}, r.get_parent_map([revs[-1]]))
1274
1296
self.assertFalse(packs.reload_pack_names())
1276
1298
def test_reload_pack_names_preserves_pending(self):
1321
1343
(b'bogus-rev',), (), None, b'bogus-content\n')])
1322
1344
# This should trigger an autopack, which will combine everything into a
1323
1345
# single pack file.
1324
new_names = r.commit_write_group()
1346
r.commit_write_group()
1325
1347
names = packs.names()
1326
1348
self.assertEqual(1, len(names))
1327
1349
self.assertEqual([names[0] + '.pack'],
1333
1355
# full-pack via the other repo which will cause us to re-evaluate and
1334
1356
# decide we don't need to do anything
1335
1357
orig_execute = packs._execute_pack_operations
1336
1359
def _munged_execute_pack_ops(*args, **kwargs):
1337
1360
tree.branch.repository.pack()
1338
1361
return orig_execute(*args, **kwargs)
1451
1474
index_class=BTreeGraphIndex,
1452
1475
use_chk_index=False)
1453
1476
pack = pack_repo.NewPack(collection)
1454
self.addCleanup(pack.abort) # Make sure the write stream gets closed
1477
self.addCleanup(pack.abort) # Make sure the write stream gets closed
1455
1478
self.assertIsInstance(pack.revision_index, BTreeBuilder)
1456
1479
self.assertIsInstance(pack.inventory_index, BTreeBuilder)
1457
1480
self.assertIsInstance(pack._hash, type(osutils.md5()))
1475
1498
('add', ('f', b'f-id', 'file', b'content\n'))],
1476
1499
revision_id=b'A')
1477
1500
builder.build_snapshot([b'A'],
1478
[('modify', ('f', b'new-content\n'))],
1501
[('modify', ('f', b'new-content\n'))],
1480
1503
builder.build_snapshot([b'B'],
1481
[('modify', ('f', b'third-content\n'))],
1504
[('modify', ('f', b'third-content\n'))],
1483
1506
builder.build_snapshot([b'C'],
1484
[('modify', ('f', b'fourth-content\n'))],
1507
[('modify', ('f', b'fourth-content\n'))],
1486
1509
b = builder.get_branch()
1488
1511
builder.finish_series()
1492
1515
# ['D', 'C', 'B', 'A']
1493
1516
packs = b.repository._pack_collection.packs
1494
1517
packer = knitpack_repo.KnitPacker(b.repository._pack_collection,
1496
revision_ids=[b'B', b'C'])
1519
revision_ids=[b'B', b'C'])
1497
1520
# Now, when we are copying the B & C revisions, their pack files should
1498
1521
# be moved to the front of the stack
1499
1522
# The new ordering moves B & C to the front of the .packs attribute,
1500
1523
# and leaves the others in the original order.
1501
1524
new_packs = [packs[1], packs[2], packs[0], packs[3]]
1502
new_pack = packer.pack()
1503
1526
self.assertEqual(new_packs, packer.packs)
1513
1536
def test_open_pack_will_optimise(self):
1514
1537
packer = knitpack_repo.OptimisingKnitPacker(self.get_pack_collection(),
1516
1539
new_pack = packer.open_pack()
1517
self.addCleanup(new_pack.abort) # ensure cleanup
1540
self.addCleanup(new_pack.abort) # ensure cleanup
1518
1541
self.assertIsInstance(new_pack, pack_repo.NewPack)
1519
1542
self.assertTrue(new_pack.revision_index._optimize_for_size)
1520
1543
self.assertTrue(new_pack.inventory_index._optimize_for_size)
1552
1575
pack_name_with_rev_C_content)
1554
1577
b_source = self.make_abc_branch()
1555
b_base = b_source.controldir.sprout('base', revision_id=b'A').open_branch()
1556
b_stacked = b_base.controldir.sprout('stacked', stacked=True).open_branch()
1578
b_base = b_source.controldir.sprout(
1579
'base', revision_id=b'A').open_branch()
1580
b_stacked = b_base.controldir.sprout(
1581
'stacked', stacked=True).open_branch()
1557
1582
b_stacked.lock_write()
1558
1583
self.addCleanup(b_stacked.unlock)
1559
1584
b_stacked.fetch(b_source, b'B')
1604
1629
a_pack = repo._pack_collection.get_pack_by_name(rev_a_pack_name)
1605
1630
c_pack = repo._pack_collection.get_pack_by_name(rev_c_pack_name)
1606
1631
packer = groupcompress_repo.GCCHKPacker(repo._pack_collection,
1607
[a_pack, c_pack], '.test-pack')
1632
[a_pack, c_pack], '.test-pack')
1608
1633
# This would raise ValueError in bug #437003, but should not raise an
1609
1634
# error once fixed.
1617
1642
inv_a_pack = repo._pack_collection.get_pack_by_name(inv_a_pack_name)
1618
1643
repo._pack_collection._remove_pack_from_memory(inv_a_pack)
1619
1644
packer = groupcompress_repo.GCCHKPacker(repo._pack_collection,
1620
repo._pack_collection.all_packs(), '.test-pack')
1645
repo._pack_collection.all_packs(), '.test-pack')
1621
1646
e = self.assertRaises(ValueError, packer.pack)
1622
1647
packer.new_pack.abort()
1623
1648
self.assertContainsRe(str(e),
1624
r"We are missing inventories for revisions: .*'A'")
1649
r"We are missing inventories for revisions: .*'A'")
1627
1652
class TestCrossFormatPacks(TestCaseWithTransport):
1662
1687
source_tree = self.make_branch_and_tree('src', format=src_fmt)
1663
1688
source_tree.lock_write()
1664
1689
self.addCleanup(source_tree.unlock)
1665
tip = source_tree.commit('foo')
1690
source_tree.commit('foo')
1666
1691
target = self.make_repository('target', format=target_fmt)
1667
1692
target.lock_write()
1668
1693
self.addCleanup(target.unlock)
added
removed
breezy/tests/test_repository.py
