91
88
def test_attribute_format_pack_compresses(self):
92
89
self.assertFormatAttribute('pack_compresses', (True, False))
94
def test_attribute_inventories_store(self):
95
"""Test the existence of the inventories attribute."""
96
tree = self.make_branch_and_tree('tree')
97
repo = tree.branch.repository
98
self.assertIsInstance(repo.inventories, versionedfile.VersionedFiles)
100
def test_attribute_inventories_basics(self):
101
"""Test basic aspects of the inventories attribute."""
102
tree = self.make_branch_and_tree('tree')
103
repo = tree.branch.repository
104
rev_id = (tree.commit('a'),)
106
self.addCleanup(tree.unlock)
107
self.assertEqual(set([rev_id]), set(repo.inventories.keys()))
109
def test_attribute_revision_store(self):
110
"""Test the existence of the revisions attribute."""
111
tree = self.make_branch_and_tree('tree')
112
repo = tree.branch.repository
113
self.assertIsInstance(repo.revisions,
114
versionedfile.VersionedFiles)
116
def test_attribute_revision_store_basics(self):
117
"""Test the basic behaviour of the revisions attribute."""
118
tree = self.make_branch_and_tree('tree')
119
repo = tree.branch.repository
122
self.assertEqual(set(), set(repo.revisions.keys()))
123
revid = (tree.commit("foo"),)
124
self.assertEqual(set([revid]), set(repo.revisions.keys()))
125
self.assertEqual({revid:()},
126
repo.revisions.get_parent_map([revid]))
129
tree2 = self.make_branch_and_tree('tree2')
130
tree2.pull(tree.branch)
131
left_id = (tree2.commit('left'),)
132
right_id = (tree.commit('right'),)
133
tree.merge_from_branch(tree2.branch)
134
merge_id = (tree.commit('merged'),)
136
self.addCleanup(repo.unlock)
137
self.assertEqual(set([revid, left_id, right_id, merge_id]),
138
set(repo.revisions.keys()))
139
self.assertEqual({revid:(), left_id:(revid,), right_id:(revid,),
140
merge_id:(right_id, left_id)},
141
repo.revisions.get_parent_map(repo.revisions.keys()))
143
def test_attribute_signature_store(self):
144
"""Test the existence of the signatures attribute."""
145
tree = self.make_branch_and_tree('tree')
146
repo = tree.branch.repository
147
self.assertIsInstance(repo.signatures,
148
versionedfile.VersionedFiles)
150
def test_attribute_text_store_basics(self):
151
"""Test the basic behaviour of the text store."""
152
tree = self.make_branch_and_tree('tree')
153
repo = tree.branch.repository
155
file_key = (file_id,)
158
self.assertEqual(set(), set(repo.texts.keys()))
159
tree.add(['foo'], [file_id], ['file'])
160
tree.put_file_bytes_non_atomic(file_id, 'content\n')
162
rev_key = (tree.commit("foo"),)
163
except errors.IllegalPath:
164
raise tests.TestNotApplicable(
165
'file_id %r cannot be stored on this'
166
' platform for this repo format' % (file_id,))
167
if repo._format.rich_root_data:
168
root_commit = (tree.get_root_id(),) + rev_key
169
keys = set([root_commit])
170
parents = {root_commit:()}
174
keys.add(file_key + rev_key)
175
parents[file_key + rev_key] = ()
176
self.assertEqual(keys, set(repo.texts.keys()))
177
self.assertEqual(parents,
178
repo.texts.get_parent_map(repo.texts.keys()))
181
tree2 = self.make_branch_and_tree('tree2')
182
tree2.pull(tree.branch)
183
tree2.put_file_bytes_non_atomic('Foo:Bar', 'right\n')
184
right_key = (tree2.commit('right'),)
185
keys.add(file_key + right_key)
186
parents[file_key + right_key] = (file_key + rev_key,)
187
tree.put_file_bytes_non_atomic('Foo:Bar', 'left\n')
188
left_key = (tree.commit('left'),)
189
keys.add(file_key + left_key)
190
parents[file_key + left_key] = (file_key + rev_key,)
191
tree.merge_from_branch(tree2.branch)
192
tree.put_file_bytes_non_atomic('Foo:Bar', 'merged\n')
195
except errors.UnsupportedOperation:
197
merge_key = (tree.commit('merged'),)
198
keys.add(file_key + merge_key)
199
parents[file_key + merge_key] = (file_key + left_key,
200
file_key + right_key)
202
self.addCleanup(repo.unlock)
203
self.assertEqual(keys, set(repo.texts.keys()))
204
self.assertEqual(parents, repo.texts.get_parent_map(repo.texts.keys()))
206
def test_attribute_text_store(self):
207
"""Test the existence of the texts attribute."""
208
tree = self.make_branch_and_tree('tree')
209
repo = tree.branch.repository
210
self.assertIsInstance(repo.texts,
211
versionedfile.VersionedFiles)
213
def test_exposed_versioned_files_are_marked_dirty(self):
214
repo = self.make_repository('.')
216
signatures = repo.signatures
217
revisions = repo.revisions
218
inventories = repo.inventories
220
self.assertRaises(errors.ObjectNotLocked,
222
self.assertRaises(errors.ObjectNotLocked,
224
self.assertRaises(errors.ObjectNotLocked,
226
self.assertRaises(errors.ObjectNotLocked,
227
signatures.add_lines, ('foo',), [], [])
228
self.assertRaises(errors.ObjectNotLocked,
229
revisions.add_lines, ('foo',), [], [])
230
self.assertRaises(errors.ObjectNotLocked,
231
inventories.add_lines, ('foo',), [], [])
91
def test_attribute_format_supports_full_versioned_files(self):
92
self.assertFormatAttribute('supports_full_versioned_files',
95
def test_attribute_format_supports_funky_characters(self):
96
self.assertFormatAttribute('supports_funky_characters',
99
def test_attribute_format_supports_leaving_lock(self):
100
self.assertFormatAttribute('supports_leaving_lock',
103
def test_attribute_format_versioned_directories(self):
104
self.assertFormatAttribute('supports_versioned_directories', (True, False))
106
def test_attribute_format_revision_graph_can_have_wrong_parents(self):
107
self.assertFormatAttribute('revision_graph_can_have_wrong_parents',
110
def test_format_is_deprecated(self):
111
repo = self.make_repository('repo')
112
self.assertSubset([repo._format.is_deprecated()], (True, False))
114
def test_format_is_supported(self):
115
repo = self.make_repository('repo')
116
self.assertSubset([repo._format.is_supported()], (True, False))
233
118
def test_clone_to_default_format(self):
234
119
#TODO: Test that cloning a repository preserves all the information
414
287
self.assertIsInstance(delta, _mod_delta.TreeDelta)
415
288
self.assertEqual([('vla', 'file2', 'file')], delta.added)
417
def test_get_revision_delta_filtered(self):
418
tree_a = self.make_branch_and_tree('a')
419
self.build_tree(['a/foo', 'a/bar/', 'a/bar/b1', 'a/bar/b2', 'a/baz'])
420
tree_a.add(['foo', 'bar', 'bar/b1', 'bar/b2', 'baz'],
421
['foo-id', 'bar-id', 'b1-id', 'b2-id', 'baz-id'])
422
tree_a.commit('rev1', rev_id='rev1')
423
self.build_tree(['a/bar/b3'])
424
tree_a.add('bar/b3', 'b3-id')
425
tree_a.commit('rev2', rev_id='rev2')
427
# Test multiple files
428
delta = tree_a.branch.repository.get_revision_delta('rev1',
429
specific_fileids=['foo-id', 'baz-id'])
430
self.assertIsInstance(delta, _mod_delta.TreeDelta)
432
('baz', 'baz-id', 'file'),
433
('foo', 'foo-id', 'file'),
436
delta = tree_a.branch.repository.get_revision_delta('rev1',
437
specific_fileids=['bar-id'])
438
self.assertIsInstance(delta, _mod_delta.TreeDelta)
440
('bar', 'bar-id', 'directory'),
441
('bar/b1', 'b1-id', 'file'),
442
('bar/b2', 'b2-id', 'file'),
444
# Test a file in a directory
445
delta = tree_a.branch.repository.get_revision_delta('rev1',
446
specific_fileids=['b2-id'])
447
self.assertIsInstance(delta, _mod_delta.TreeDelta)
449
('bar', 'bar-id', 'directory'),
450
('bar/b2', 'b2-id', 'file'),
452
# Try another revision
453
delta = tree_a.branch.repository.get_revision_delta('rev2',
454
specific_fileids=['b3-id'])
455
self.assertIsInstance(delta, _mod_delta.TreeDelta)
457
('bar', 'bar-id', 'directory'),
458
('bar/b3', 'b3-id', 'file'),
460
delta = tree_a.branch.repository.get_revision_delta('rev2',
461
specific_fileids=['foo-id'])
462
self.assertIsInstance(delta, _mod_delta.TreeDelta)
463
self.assertEqual([], delta.added)
465
290
def test_clone_bzrdir_repository_revision(self):
466
291
# make a repository with some revisions,
467
292
# and clone it, this should not have unreferenced revisions.
662
475
repository.iter_files_bytes(
663
476
[('file3-id', 'rev3', 'file1-notpresent')]))
665
def test_item_keys_introduced_by(self):
666
# Make a repo with one revision and one versioned file.
667
tree = self.make_branch_and_tree('t')
668
self.build_tree(['t/foo'])
669
tree.add('foo', 'file1')
670
tree.commit('message', rev_id='rev_id')
671
repo = tree.branch.repository
673
repo.start_write_group()
674
repo.sign_revision('rev_id', gpg.LoopbackGPGStrategy(None))
675
repo.commit_write_group()
678
self.addCleanup(repo.unlock)
680
# Item keys will be in this order, for maximum convenience for
681
# generating data to insert into knit repository:
686
expected_item_keys = [
687
('file', 'file1', ['rev_id']),
688
('inventory', None, ['rev_id']),
689
('signatures', None, ['rev_id']),
690
('revisions', None, ['rev_id'])]
691
item_keys = list(repo.item_keys_introduced_by(['rev_id']))
693
(kind, file_id, list(versions))
694
for (kind, file_id, versions) in item_keys]
696
if repo.supports_rich_root():
697
# Check for the root versioned file in the item_keys, then remove
698
# it from streamed_names so we can compare that with
699
# expected_record_names.
700
# Note that the file keys can be in any order, so this test is
701
# written to allow that.
702
inv = repo.get_inventory('rev_id')
703
root_item_key = ('file', inv.root.file_id, ['rev_id'])
704
self.assertTrue(root_item_key in item_keys)
705
item_keys.remove(root_item_key)
707
self.assertEqual(expected_item_keys, item_keys)
709
478
def test_get_graph(self):
710
479
"""Bare-bones smoketest that all repositories implement get_graph."""
711
480
repo = self.make_repository('repo')
775
544
repo._check_for_inconsistent_revision_parents()
777
546
def test_add_signature_text(self):
778
repo = self.make_repository('repo')
780
self.addCleanup(repo.unlock)
781
repo.start_write_group()
782
self.addCleanup(repo.abort_write_group)
783
inv = inventory.Inventory(revision_id='A')
784
inv.root.revision = 'A'
785
repo.add_inventory('A', inv, [])
786
repo.add_revision('A', _mod_revision.Revision(
787
'A', committer='A', timestamp=0,
788
inventory_sha1='', timezone=0, message='A'))
789
repo.add_signature_text('A', 'This might be a signature')
790
self.assertEqual('This might be a signature',
791
repo.get_signature_text('A'))
793
def test_add_revision_inventory_sha1(self):
794
inv = inventory.Inventory(revision_id='A')
795
inv.root.revision = 'A'
796
inv.root.file_id = 'fixed-root'
797
# Insert the inventory on its own to an identical repository, to get
799
reference_repo = self.make_repository('reference_repo')
800
reference_repo.lock_write()
801
reference_repo.start_write_group()
802
inv_sha1 = reference_repo.add_inventory('A', inv, [])
803
reference_repo.abort_write_group()
804
reference_repo.unlock()
805
# Now insert a revision with this inventory, and it should get the same
807
repo = self.make_repository('repo')
809
repo.start_write_group()
810
root_id = inv.root.file_id
811
repo.texts.add_lines(('fixed-root', 'A'), [], [])
812
repo.add_revision('A', _mod_revision.Revision(
813
'A', committer='B', timestamp=0,
814
timezone=0, message='C'), inv=inv)
815
repo.commit_write_group()
818
self.assertEquals(inv_sha1, repo.get_revision('A').inventory_sha1)
821
def test_install_revisions(self):
822
wt = self.make_branch_and_tree('source')
823
wt.commit('A', allow_pointless=True, rev_id='A')
824
repo = wt.branch.repository
826
repo.start_write_group()
827
repo.sign_revision('A', gpg.LoopbackGPGStrategy(None))
828
repo.commit_write_group()
831
self.addCleanup(repo.unlock)
832
repo2 = self.make_repository('repo2')
833
revision = repo.get_revision('A')
834
tree = repo.revision_tree('A')
835
signature = repo.get_signature_text('A')
837
self.addCleanup(repo2.unlock)
838
repository.install_revisions(repo2, [(revision, tree, signature)])
839
self.assertEqual(revision, repo2.get_revision('A'))
840
self.assertEqual(signature, repo2.get_signature_text('A'))
547
builder = self.make_branch_builder('.')
548
builder.start_series()
549
builder.build_snapshot('A', None, [
550
('add', ('', 'root-id', 'directory', None))])
551
builder.finish_series()
552
b = builder.get_branch()
554
self.addCleanup(b.unlock)
555
if b.repository._format.supports_revision_signatures:
556
b.repository.start_write_group()
557
b.repository.add_signature_text('A', 'This might be a signature')
558
b.repository.commit_write_group()
559
self.assertEqual('This might be a signature',
560
b.repository.get_signature_text('A'))
562
b.repository.start_write_group()
563
self.addCleanup(b.repository.abort_write_group)
564
self.assertRaises(errors.UnsupportedOperation,
565
b.repository.add_signature_text, 'A',
566
'This might be a signature')
842
568
# XXX: this helper duplicated from tests.test_repository
843
def make_remote_repository(self, path, shared=False):
569
def make_remote_repository(self, path, shared=None):
844
570
"""Make a RemoteRepository object backed by a real repository that will
845
571
be created at the given path."""
846
572
repo = self.make_repository(path, shared=shared)
847
573
smart_server = test_server.SmartTCPServer_for_testing()
848
574
self.start_server(smart_server, self.get_server())
849
remote_transport = transport.get_transport(
575
remote_transport = transport.get_transport_from_url(
850
576
smart_server.get_url()).clone(path)
851
remote_bzrdir = bzrdir.BzrDir.open_from_transport(remote_transport)
577
if not repo.bzrdir._format.supports_transport(remote_transport):
578
raise tests.TestNotApplicable(
579
"format does not support transport")
580
remote_bzrdir = controldir.ControlDir.open_from_transport(
852
582
remote_repo = remote_bzrdir.open_repository()
853
583
return remote_repo
855
585
def test_sprout_from_hpss_preserves_format(self):
856
586
"""repo.sprout from a smart server preserves the repository format."""
857
if self.repository_format == weaverepo.RepositoryFormat7():
858
raise tests.TestNotApplicable(
859
"Cannot fetch weaves over smart protocol.")
860
587
remote_repo = self.make_remote_repository('remote')
861
588
local_bzrdir = self.make_bzrdir('local')
1151
876
self.assertThat(repo.lock_write, ReturnsUnlockable(repo))
1154
class TestCaseWithComplexRepository(per_repository.TestCaseWithRepository):
1157
super(TestCaseWithComplexRepository, self).setUp()
1158
tree_a = self.make_branch_and_tree('a')
1159
self.bzrdir = tree_a.branch.bzrdir
1160
# add a corrupt inventory 'orphan'
1161
# this may need some generalising for knits.
1164
tree_a.branch.repository.start_write_group()
1166
inv_file = tree_a.branch.repository.inventories
1167
inv_file.add_lines(('orphan',), [], [])
1169
tree_a.branch.repository.commit_write_group()
1172
tree_a.branch.repository.abort_write_group()
1175
# add a real revision 'rev1'
1176
tree_a.commit('rev1', rev_id='rev1', allow_pointless=True)
1177
# add a real revision 'rev2' based on rev1
1178
tree_a.commit('rev2', rev_id='rev2', allow_pointless=True)
1179
# add a reference to a ghost
1180
tree_a.add_parent_tree_id('ghost1')
1182
tree_a.commit('rev3', rev_id='rev3', allow_pointless=True)
1183
except errors.RevisionNotPresent:
1184
raise tests.TestNotApplicable(
1185
"Cannot test with ghosts for this format.")
1186
# add another reference to a ghost, and a second ghost.
1187
tree_a.add_parent_tree_id('ghost1')
1188
tree_a.add_parent_tree_id('ghost2')
1189
tree_a.commit('rev4', rev_id='rev4', allow_pointless=True)
1191
def test_revision_trees(self):
1192
revision_ids = ['rev1', 'rev2', 'rev3', 'rev4']
1193
repository = self.bzrdir.open_repository()
1194
repository.lock_read()
1195
self.addCleanup(repository.unlock)
1196
trees1 = list(repository.revision_trees(revision_ids))
1197
trees2 = [repository.revision_tree(t) for t in revision_ids]
1198
self.assertEqual(len(trees1), len(trees2))
1199
for tree1, tree2 in zip(trees1, trees2):
1200
self.assertFalse(tree2.changes_from(tree1).has_changed())
1202
def test_get_deltas_for_revisions(self):
1203
repository = self.bzrdir.open_repository()
1204
repository.lock_read()
1205
self.addCleanup(repository.unlock)
1206
revisions = [repository.get_revision(r) for r in
1207
['rev1', 'rev2', 'rev3', 'rev4']]
1208
deltas1 = list(repository.get_deltas_for_revisions(revisions))
1209
deltas2 = [repository.get_revision_delta(r.revision_id) for r in
1211
self.assertEqual(deltas1, deltas2)
1213
def test_all_revision_ids(self):
1214
# all_revision_ids -> all revisions
1215
self.assertEqual(set(['rev1', 'rev2', 'rev3', 'rev4']),
1216
set(self.bzrdir.open_repository().all_revision_ids()))
1218
def test_get_ancestry_missing_revision(self):
1219
# get_ancestry(revision that is in some data but not fully installed
1221
self.assertRaises(errors.NoSuchRevision,
1222
self.bzrdir.open_repository().get_ancestry, 'orphan')
1224
def test_get_unordered_ancestry(self):
1225
repo = self.bzrdir.open_repository()
1226
self.assertEqual(set(repo.get_ancestry('rev3')),
1227
set(repo.get_ancestry('rev3', topo_sorted=False)))
1229
def test_reserved_id(self):
1230
repo = self.make_repository('repository')
1232
repo.start_write_group()
1234
self.assertRaises(errors.ReservedId, repo.add_inventory, 'reserved:',
1236
self.assertRaises(errors.ReservedId, repo.add_inventory_by_delta,
1237
"foo", [], 'reserved:', None)
1238
self.assertRaises(errors.ReservedId, repo.add_revision, 'reserved:',
1241
repo.abort_write_group()
1245
class TestCaseWithCorruptRepository(per_repository.TestCaseWithRepository):
1248
super(TestCaseWithCorruptRepository, self).setUp()
1249
# a inventory with no parents and the revision has parents..
1251
repo = self.make_repository('inventory_with_unnecessary_ghost')
1253
repo.start_write_group()
1254
inv = inventory.Inventory(revision_id = 'ghost')
1255
inv.root.revision = 'ghost'
1256
if repo.supports_rich_root():
1257
root_id = inv.root.file_id
1258
repo.texts.add_lines((root_id, 'ghost'), [], [])
1259
sha1 = repo.add_inventory('ghost', inv, [])
1260
rev = _mod_revision.Revision(
1261
timestamp=0, timezone=None, committer="Foo Bar <foo@example.com>",
1262
message="Message", inventory_sha1=sha1, revision_id='ghost')
1263
rev.parent_ids = ['the_ghost']
1265
repo.add_revision('ghost', rev)
1266
except (errors.NoSuchRevision, errors.RevisionNotPresent):
1267
raise tests.TestNotApplicable(
1268
"Cannot test with ghosts for this format.")
1270
inv = inventory.Inventory(revision_id = 'the_ghost')
1271
inv.root.revision = 'the_ghost'
1272
if repo.supports_rich_root():
1273
root_id = inv.root.file_id
1274
repo.texts.add_lines((root_id, 'the_ghost'), [], [])
1275
sha1 = repo.add_inventory('the_ghost', inv, [])
1276
rev = _mod_revision.Revision(
1277
timestamp=0, timezone=None, committer="Foo Bar <foo@example.com>",
1278
message="Message", inventory_sha1=sha1, revision_id='the_ghost')
1280
repo.add_revision('the_ghost', rev)
1281
# check its setup usefully
1282
inv_weave = repo.inventories
1283
possible_parents = (None, (('ghost',),))
1284
self.assertSubset(inv_weave.get_parent_map([('ghost',)])[('ghost',)],
1286
repo.commit_write_group()
1289
def test_corrupt_revision_access_asserts_if_reported_wrong(self):
1290
repo_url = self.get_url('inventory_with_unnecessary_ghost')
1291
repo = repository.Repository.open(repo_url)
1292
reported_wrong = False
1294
if repo.get_ancestry('ghost') != [None, 'the_ghost', 'ghost']:
1295
reported_wrong = True
1296
except errors.CorruptRepository:
1297
# caught the bad data:
1299
if not reported_wrong:
1301
self.assertRaises(errors.CorruptRepository, repo.get_revision, 'ghost')
1303
def test_corrupt_revision_get_revision_reconcile(self):
1304
repo_url = self.get_url('inventory_with_unnecessary_ghost')
1305
repo = repository.Repository.open(repo_url)
1306
repo.get_revision_reconcile('ghost')
1309
879
# FIXME: document why this is a TestCaseWithTransport rather than a
1310
880
# TestCaseWithRepository
1311
881
class TestEscaping(tests.TestCaseWithTransport):
1353
923
'rev1', _mod_revision.NULL_REVISION, fileobj)
1358
926
class TestRepositoryControlComponent(per_repository.TestCaseWithRepository):
1359
927
"""Repository implementations adequately implement ControlComponent."""
1361
929
def test_urls(self):
1362
930
repo = self.make_repository('repo')
1363
931
self.assertIsInstance(repo.user_url, str)
1364
932
self.assertEqual(repo.user_url, repo.user_transport.base)
1365
# for all current bzrdir implementations the user dir must be
933
# for all current bzrdir implementations the user dir must be
1366
934
# above the control dir but we might need to relax that?
1367
935
self.assertEqual(repo.control_url.find(repo.user_url), 0)
1368
936
self.assertEqual(repo.control_url, repo.control_transport.base)
939
class TestDeltaRevisionFiltered(per_repository.TestCaseWithRepository):
942
super(TestDeltaRevisionFiltered, self).setUp()
943
tree_a = self.make_branch_and_tree('a')
944
self.build_tree(['a/foo', 'a/bar/', 'a/bar/b1', 'a/bar/b2', 'a/baz'])
945
tree_a.add(['foo', 'bar', 'bar/b1', 'bar/b2', 'baz'],
946
['foo-id', 'bar-id', 'b1-id', 'b2-id', 'baz-id'])
947
tree_a.commit('rev1', rev_id='rev1')
948
self.build_tree(['a/bar/b3'])
949
tree_a.add('bar/b3', 'b3-id')
950
tree_a.commit('rev2', rev_id='rev2')
951
self.repository = tree_a.branch.repository
953
def test_multiple_files(self):
954
# Test multiple files
955
delta = self.repository.get_revision_delta('rev1',
956
specific_fileids=['foo-id', 'baz-id'])
957
self.assertIsInstance(delta, _mod_delta.TreeDelta)
959
('baz', 'baz-id', 'file'),
960
('foo', 'foo-id', 'file'),
963
def test_directory(self):
965
delta = self.repository.get_revision_delta('rev1',
966
specific_fileids=['bar-id'])
967
self.assertIsInstance(delta, _mod_delta.TreeDelta)
969
('bar', 'bar-id', 'directory'),
970
('bar/b1', 'b1-id', 'file'),
971
('bar/b2', 'b2-id', 'file'),
974
def test_unrelated(self):
975
# Try another revision
976
delta = self.repository.get_revision_delta('rev2',
977
specific_fileids=['foo-id'])
978
self.assertIsInstance(delta, _mod_delta.TreeDelta)
979
self.assertEqual([], delta.added)
981
def test_file_in_directory(self):
982
# Test a file in a directory, both of which were added
983
delta = self.repository.get_revision_delta('rev1',
984
specific_fileids=['b2-id'])
985
self.assertIsInstance(delta, _mod_delta.TreeDelta)
987
('bar', 'bar-id', 'directory'),
988
('bar/b2', 'b2-id', 'file'),
991
def test_file_in_unchanged_directory(self):
992
delta = self.repository.get_revision_delta('rev2',
993
specific_fileids=['b3-id'])
994
self.assertIsInstance(delta, _mod_delta.TreeDelta)
996
('bar', 'bar-id', 'directory'),
997
('bar/b3', 'b3-id', 'file')]:
998
self.knownFailure("bzr incorrectly reports 'bar' as added - "
1001
('bar/b3', 'b3-id', 'file'),