141
142
self.assertEqual(imaginary_id, imaginary_id2)
142
143
self.assertEqual(root, transform.get_tree_parent(imaginary_id))
143
144
self.assertEqual('directory', transform.final_kind(root))
144
self.assertEqual(self.wt.get_root_id(), transform.final_file_id(root))
145
self.assertEqual(self.wt.path2id(''), transform.final_file_id(root))
145
146
trans_id = transform.create_path('name', root)
146
147
self.assertIs(transform.final_file_id(trans_id), None)
147
148
self.assertIs(None, transform.final_kind(trans_id))
148
transform.create_file('contents', trans_id)
149
transform.create_file([b'contents'], trans_id)
149
150
transform.set_executability(True, trans_id)
150
transform.version_file('my_pretties', trans_id)
151
transform.version_file(b'my_pretties', trans_id)
151
152
self.assertRaises(DuplicateKey, transform.version_file,
152
'my_pretties', trans_id)
153
self.assertEqual(transform.final_file_id(trans_id), 'my_pretties')
153
b'my_pretties', trans_id)
154
self.assertEqual(transform.final_file_id(trans_id), b'my_pretties')
154
155
self.assertEqual(transform.final_parent(trans_id), root)
155
156
self.assertIs(transform.final_parent(root), ROOT_PARENT)
156
157
self.assertIs(transform.get_tree_parent(root), ROOT_PARENT)
157
158
oz_id = transform.create_path('oz', root)
158
159
transform.create_directory(oz_id)
159
transform.version_file('ozzie', oz_id)
160
transform.version_file(b'ozzie', oz_id)
160
161
trans_id2 = transform.create_path('name2', root)
161
transform.create_file('contents', trans_id2)
162
transform.create_file([b'contents'], trans_id2)
162
163
transform.set_executability(False, trans_id2)
163
transform.version_file('my_pretties2', trans_id2)
164
transform.version_file(b'my_pretties2', trans_id2)
164
165
modified_paths = transform.apply().modified_paths
165
self.assertEqual('contents', self.wt.get_file('name').read())
166
self.assertEqual(self.wt.path2id('name'), 'my_pretties')
166
with self.wt.get_file('name') as f:
167
self.assertEqual(b'contents', f.read())
168
self.assertEqual(self.wt.path2id('name'), b'my_pretties')
167
169
self.assertIs(self.wt.is_executable('name'), True)
168
170
self.assertIs(self.wt.is_executable('name2'), False)
169
171
self.assertEqual('directory', file_kind(self.wt.abspath('oz')))
170
172
self.assertEqual(len(modified_paths), 3)
171
tree_mod_paths = [self.wt.id2abspath(f) for f in
172
('ozzie', 'my_pretties', 'my_pretties2')]
173
tree_mod_paths = [self.wt.abspath(self.wt.id2path(f)) for f in
174
(b'ozzie', b'my_pretties', b'my_pretties2')]
173
175
self.assertSubset(tree_mod_paths, modified_paths)
174
176
# is it safe to finalize repeatedly?
175
177
transform.finalize()
254
257
fo, st2 = self.wt.get_file_with_stat('two', filtered=False)
256
259
# We only guarantee 2s resolution
257
self.assertTrue(abs(creation_mtime - st1.st_mtime) < 2.0,
261
abs(creation_mtime - st1.st_mtime) < 2.0,
258
262
"%s != %s within 2 seconds" % (creation_mtime, st1.st_mtime))
259
263
# But if we have more than that, all files should get the same result
260
264
self.assertEqual(st1.st_mtime, st2.st_mtime)
262
266
def test_change_root_id(self):
263
267
transform, root = self.get_transform()
264
self.assertNotEqual('new-root-id', self.wt.get_root_id())
265
transform.new_directory('', ROOT_PARENT, 'new-root-id')
268
self.assertNotEqual(b'new-root-id', self.wt.path2id(''))
269
transform.new_directory('', ROOT_PARENT, b'new-root-id')
266
270
transform.delete_contents(root)
267
271
transform.unversion_file(root)
268
272
transform.fixup_new_roots()
269
273
transform.apply()
270
self.assertEqual('new-root-id', self.wt.get_root_id())
274
self.assertEqual(b'new-root-id', self.wt.path2id(''))
272
276
def test_change_root_id_add_files(self):
273
277
transform, root = self.get_transform()
274
self.assertNotEqual('new-root-id', self.wt.get_root_id())
275
new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
276
transform.new_file('file', new_trans_id, ['new-contents\n'],
278
self.assertNotEqual(b'new-root-id', self.wt.path2id(''))
279
new_trans_id = transform.new_directory('', ROOT_PARENT, b'new-root-id')
280
transform.new_file('file', new_trans_id, [b'new-contents\n'],
278
282
transform.delete_contents(root)
279
283
transform.unversion_file(root)
280
284
transform.fixup_new_roots()
281
285
transform.apply()
282
self.assertEqual('new-root-id', self.wt.get_root_id())
283
self.assertEqual('new-file-id', self.wt.path2id('file'))
284
self.assertFileEqual('new-contents\n', self.wt.abspath('file'))
286
self.assertEqual(b'new-root-id', self.wt.path2id(''))
287
self.assertEqual(b'new-file-id', self.wt.path2id('file'))
288
self.assertFileEqual(b'new-contents\n', self.wt.abspath('file'))
286
290
def test_add_two_roots(self):
287
291
transform, root = self.get_transform()
288
new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
289
new_trans_id = transform.new_directory('', ROOT_PARENT, 'alt-root-id')
292
transform.new_directory('', ROOT_PARENT, b'new-root-id')
293
transform.new_directory('', ROOT_PARENT, b'alt-root-id')
290
294
self.assertRaises(ValueError, transform.fixup_new_roots)
292
296
def test_retain_existing_root(self):
293
297
tt, root = self.get_transform()
295
tt.new_directory('', ROOT_PARENT, 'new-root-id')
299
tt.new_directory('', ROOT_PARENT, b'new-root-id')
296
300
tt.fixup_new_roots()
297
self.assertNotEqual('new-root-id', tt.final_file_id(tt.root))
301
self.assertNotEqual(b'new-root-id', tt.final_file_id(tt.root))
299
303
def test_retain_existing_root_added_file(self):
300
304
tt, root = self.get_transform()
301
new_trans_id = tt.new_directory('', ROOT_PARENT, 'new-root-id')
302
child = tt.new_directory('child', new_trans_id, 'child-id')
305
new_trans_id = tt.new_directory('', ROOT_PARENT, b'new-root-id')
306
child = tt.new_directory('child', new_trans_id, b'child-id')
303
307
tt.fixup_new_roots()
304
308
self.assertEqual(tt.root, tt.final_parent(child))
306
310
def test_add_unversioned_root(self):
307
311
transform, root = self.get_transform()
308
new_trans_id = transform.new_directory('', ROOT_PARENT, None)
312
transform.new_directory('', ROOT_PARENT, None)
309
313
transform.delete_contents(transform.root)
310
314
transform.fixup_new_roots()
311
315
self.assertNotIn(transform.root, transform._new_id)
313
317
def test_remove_root_fixup(self):
314
318
transform, root = self.get_transform()
315
old_root_id = self.wt.get_root_id()
316
self.assertNotEqual('new-root-id', old_root_id)
319
old_root_id = self.wt.path2id('')
320
self.assertNotEqual(b'new-root-id', old_root_id)
317
321
transform.delete_contents(root)
318
322
transform.unversion_file(root)
319
323
transform.fixup_new_roots()
320
324
transform.apply()
321
self.assertEqual(old_root_id, self.wt.get_root_id())
325
self.assertEqual(old_root_id, self.wt.path2id(''))
323
327
transform, root = self.get_transform()
324
new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
325
new_trans_id = transform.new_directory('', ROOT_PARENT, 'alt-root-id')
328
transform.new_directory('', ROOT_PARENT, b'new-root-id')
329
transform.new_directory('', ROOT_PARENT, b'alt-root-id')
326
330
self.assertRaises(ValueError, transform.fixup_new_roots)
328
332
def test_fixup_new_roots_permits_empty_tree(self):
370
374
transform, root = self.get_transform()
371
375
self.wt.lock_tree_write()
372
376
self.addCleanup(self.wt.unlock)
373
trans_id = transform.new_file('name', root, 'contents',
375
oz = transform.new_directory('oz', root, 'oz-id')
376
dorothy = transform.new_directory('dorothy', oz, 'dorothy-id')
377
toto = transform.new_file('toto', dorothy, 'toto-contents',
377
transform.new_file('name', root, [b'contents'], b'my_pretties', True)
378
oz = transform.new_directory('oz', root, b'oz-id')
379
dorothy = transform.new_directory('dorothy', oz, b'dorothy-id')
380
transform.new_file('toto', dorothy, [b'toto-contents'], b'toto-id',
380
383
self.assertEqual(len(transform.find_conflicts()), 0)
381
384
transform.apply()
382
385
self.assertRaises(ReusingTransform, transform.find_conflicts)
383
self.assertEqual('contents', file(self.wt.abspath('name')).read())
384
self.assertEqual(self.wt.path2id('name'), 'my_pretties')
386
with open(self.wt.abspath('name'), 'r') as f:
387
self.assertEqual('contents', f.read())
388
self.assertEqual(self.wt.path2id('name'), b'my_pretties')
385
389
self.assertIs(self.wt.is_executable('name'), True)
386
self.assertEqual(self.wt.path2id('oz'), 'oz-id')
387
self.assertEqual(self.wt.path2id('oz/dorothy'), 'dorothy-id')
388
self.assertEqual(self.wt.path2id('oz/dorothy/toto'), 'toto-id')
390
self.assertEqual(self.wt.path2id('oz'), b'oz-id')
391
self.assertEqual(self.wt.path2id('oz/dorothy'), b'dorothy-id')
392
self.assertEqual(self.wt.path2id('oz/dorothy/toto'), b'toto-id')
390
self.assertEqual('toto-contents',
394
self.assertEqual(b'toto-contents',
391
395
self.wt.get_file('oz/dorothy/toto').read())
392
396
self.assertIs(self.wt.is_executable('oz/dorothy/toto'), False)
394
398
def test_tree_reference(self):
395
399
transform, root = self.get_transform()
396
400
tree = transform._tree
397
trans_id = transform.new_directory('reference', root, 'subtree-id')
398
transform.set_tree_reference('subtree-revision', trans_id)
401
trans_id = transform.new_directory('reference', root, b'subtree-id')
402
transform.set_tree_reference(b'subtree-revision', trans_id)
399
403
transform.apply()
401
405
self.addCleanup(tree.unlock)
402
self.assertEqual('subtree-revision',
403
tree.root_inventory['subtree-id'].reference_revision)
408
tree.root_inventory.get_entry(b'subtree-id').reference_revision)
405
410
def test_conflicts(self):
406
411
transform, root = self.get_transform()
407
trans_id = transform.new_file('name', root, 'contents',
412
trans_id = transform.new_file('name', root, [b'contents'],
409
414
self.assertEqual(len(transform.find_conflicts()), 0)
410
trans_id2 = transform.new_file('name', root, 'Crontents', 'toto')
415
trans_id2 = transform.new_file('name', root, [b'Crontents'], b'toto')
411
416
self.assertEqual(transform.find_conflicts(),
412
417
[('duplicate', trans_id, trans_id2, 'name')])
413
418
self.assertRaises(MalformedTransform, transform.apply)
624
630
create_tree, root = self.get_transform()
626
632
root = create_tree.root
627
create_tree.new_file('name1', root, 'hello1', 'name1')
628
create_tree.new_file('name2', root, 'hello2', 'name2')
629
ddir = create_tree.new_directory('dying_directory', root, 'ddir')
630
create_tree.new_file('dying_file', ddir, 'goodbye1', 'dfile')
631
create_tree.new_file('moving_file', ddir, 'later1', 'mfile')
632
create_tree.new_file('moving_file2', root, 'later2', 'mfile2')
633
create_tree.new_file('name1', root, [b'hello1'], b'name1')
634
create_tree.new_file('name2', root, [b'hello2'], b'name2')
635
ddir = create_tree.new_directory('dying_directory', root, b'ddir')
636
create_tree.new_file('dying_file', ddir, [b'goodbye1'], b'dfile')
637
create_tree.new_file('moving_file', ddir, [b'later1'], b'mfile')
638
create_tree.new_file('moving_file2', root, [b'later2'], b'mfile2')
633
639
create_tree.apply()
635
641
mangle_tree, root = self.get_transform()
636
642
root = mangle_tree.root
638
name1 = mangle_tree.trans_id_tree_file_id('name1')
639
name2 = mangle_tree.trans_id_tree_file_id('name2')
644
name1 = mangle_tree.trans_id_tree_path('name1')
645
name2 = mangle_tree.trans_id_tree_path('name2')
640
646
mangle_tree.adjust_path('name2', root, name1)
641
647
mangle_tree.adjust_path('name1', root, name2)
643
#tests for deleting parent directories
644
ddir = mangle_tree.trans_id_tree_file_id('ddir')
649
# tests for deleting parent directories
650
ddir = mangle_tree.trans_id_tree_path('dying_directory')
645
651
mangle_tree.delete_contents(ddir)
646
dfile = mangle_tree.trans_id_tree_file_id('dfile')
652
dfile = mangle_tree.trans_id_tree_path('dying_directory/dying_file')
647
653
mangle_tree.delete_versioned(dfile)
648
654
mangle_tree.unversion_file(dfile)
649
mfile = mangle_tree.trans_id_tree_file_id('mfile')
655
mfile = mangle_tree.trans_id_tree_path('dying_directory/moving_file')
650
656
mangle_tree.adjust_path('mfile', root, mfile)
652
#tests for adding parent directories
653
newdir = mangle_tree.new_directory('new_directory', root, 'newdir')
654
mfile2 = mangle_tree.trans_id_tree_file_id('mfile2')
658
# tests for adding parent directories
659
newdir = mangle_tree.new_directory('new_directory', root, b'newdir')
660
mfile2 = mangle_tree.trans_id_tree_path('moving_file2')
655
661
mangle_tree.adjust_path('mfile2', newdir, mfile2)
656
mangle_tree.new_file('newfile', newdir, 'hello3', 'dfile')
657
self.assertEqual(mangle_tree.final_file_id(mfile2), 'mfile2')
662
mangle_tree.new_file('newfile', newdir, [b'hello3'], b'dfile')
663
self.assertEqual(mangle_tree.final_file_id(mfile2), b'mfile2')
658
664
self.assertEqual(mangle_tree.final_parent(mfile2), newdir)
659
self.assertEqual(mangle_tree.final_file_id(mfile2), 'mfile2')
665
self.assertEqual(mangle_tree.final_file_id(mfile2), b'mfile2')
660
666
mangle_tree.apply()
661
self.assertEqual(file(self.wt.abspath('name1')).read(), 'hello2')
662
self.assertEqual(file(self.wt.abspath('name2')).read(), 'hello1')
667
with open(self.wt.abspath('name1'), 'r') as f:
668
self.assertEqual(f.read(), 'hello2')
669
with open(self.wt.abspath('name2'), 'r') as f:
670
self.assertEqual(f.read(), 'hello1')
663
671
mfile2_path = self.wt.abspath(pathjoin('new_directory', 'mfile2'))
664
672
self.assertEqual(mangle_tree.final_parent(mfile2), newdir)
665
self.assertEqual(file(mfile2_path).read(), 'later2')
666
self.assertEqual(self.wt.id2path('mfile2'), 'new_directory/mfile2')
667
self.assertEqual(self.wt.path2id('new_directory/mfile2'), 'mfile2')
673
with open(mfile2_path, 'r') as f:
674
self.assertEqual(f.read(), 'later2')
675
self.assertEqual(self.wt.id2path(b'mfile2'), 'new_directory/mfile2')
676
self.assertEqual(self.wt.path2id('new_directory/mfile2'), b'mfile2')
668
677
newfile_path = self.wt.abspath(pathjoin('new_directory', 'newfile'))
669
self.assertEqual(file(newfile_path).read(), 'hello3')
670
self.assertEqual(self.wt.path2id('dying_directory'), 'ddir')
678
with open(newfile_path, 'r') as f:
679
self.assertEqual(f.read(), 'hello3')
680
self.assertEqual(self.wt.path2id('dying_directory'), b'ddir')
671
681
self.assertIs(self.wt.path2id('dying_directory/dying_file'), None)
672
682
mfile2_path = self.wt.abspath(pathjoin('new_directory', 'mfile2'))
674
684
def test_both_rename(self):
675
685
create_tree, root = self.get_transform()
676
newdir = create_tree.new_directory('selftest', root, 'selftest-id')
677
create_tree.new_file('blackbox.py', newdir, 'hello1', 'blackbox-id')
686
newdir = create_tree.new_directory('selftest', root, b'selftest-id')
687
create_tree.new_file('blackbox.py', newdir, [
688
b'hello1'], b'blackbox-id')
678
689
create_tree.apply()
679
690
mangle_tree, root = self.get_transform()
680
selftest = mangle_tree.trans_id_tree_file_id('selftest-id')
681
blackbox = mangle_tree.trans_id_tree_file_id('blackbox-id')
691
selftest = mangle_tree.trans_id_tree_path('selftest')
692
blackbox = mangle_tree.trans_id_tree_path('selftest/blackbox.py')
682
693
mangle_tree.adjust_path('test', root, selftest)
683
694
mangle_tree.adjust_path('test_too_much', root, selftest)
684
695
mangle_tree.set_executability(True, blackbox)
1117
1130
self.assertEqual([bar1_abspath], stat_paths)
1119
1132
def test_iter_changes(self):
1120
self.wt.set_root_id('eert_toor')
1133
self.wt.set_root_id(b'eert_toor')
1121
1134
transform, root = self.get_transform()
1122
transform.new_file('old', root, 'blah', 'id-1', True)
1135
transform.new_file('old', root, [b'blah'], b'id-1', True)
1123
1136
transform.apply()
1124
1137
transform, root = self.get_transform()
1126
1139
self.assertEqual([], list(transform.iter_changes()))
1127
old = transform.trans_id_tree_file_id('id-1')
1140
old = transform.trans_id_tree_path('old')
1128
1141
transform.unversion_file(old)
1129
self.assertEqual([('id-1', ('old', None), False, (True, False),
1130
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1131
(True, True))], list(transform.iter_changes()))
1132
transform.new_directory('new', root, 'id-1')
1133
self.assertEqual([('id-1', ('old', 'new'), True, (True, True),
1134
('eert_toor', 'eert_toor'), ('old', 'new'),
1135
('file', 'directory'),
1136
(True, False))], list(transform.iter_changes()))
1142
self.assertEqual([(b'id-1', ('old', None), False, (True, False),
1143
(b'eert_toor', b'eert_toor'),
1144
('old', 'old'), ('file', 'file'),
1145
(True, True), False)],
1146
list(transform.iter_changes()))
1147
transform.new_directory('new', root, b'id-1')
1148
self.assertEqual([(b'id-1', ('old', 'new'), True, (True, True),
1149
(b'eert_toor', b'eert_toor'), ('old', 'new'),
1150
('file', 'directory'),
1151
(True, False), False)],
1152
list(transform.iter_changes()))
1138
1154
transform.finalize()
1140
1156
def test_iter_changes_new(self):
1141
self.wt.set_root_id('eert_toor')
1157
self.wt.set_root_id(b'eert_toor')
1142
1158
transform, root = self.get_transform()
1143
transform.new_file('old', root, 'blah')
1159
transform.new_file('old', root, [b'blah'])
1144
1160
transform.apply()
1145
1161
transform, root = self.get_transform()
1147
1163
old = transform.trans_id_tree_path('old')
1148
transform.version_file('id-1', old)
1149
self.assertEqual([('id-1', (None, 'old'), False, (False, True),
1150
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1151
(False, False))], list(transform.iter_changes()))
1164
transform.version_file(b'id-1', old)
1165
self.assertEqual([(b'id-1', (None, 'old'), False, (False, True),
1166
(b'eert_toor', b'eert_toor'),
1167
('old', 'old'), ('file', 'file'),
1168
(False, False), False)],
1169
list(transform.iter_changes()))
1153
1171
transform.finalize()
1155
1173
def test_iter_changes_modifications(self):
1156
self.wt.set_root_id('eert_toor')
1174
self.wt.set_root_id(b'eert_toor')
1157
1175
transform, root = self.get_transform()
1158
transform.new_file('old', root, 'blah', 'id-1')
1159
transform.new_file('new', root, 'blah')
1160
transform.new_directory('subdir', root, 'subdir-id')
1176
transform.new_file('old', root, [b'blah'], b'id-1')
1177
transform.new_file('new', root, [b'blah'])
1178
transform.new_directory('subdir', root, b'subdir-id')
1161
1179
transform.apply()
1162
1180
transform, root = self.get_transform()
1164
1182
old = transform.trans_id_tree_path('old')
1165
subdir = transform.trans_id_tree_file_id('subdir-id')
1183
subdir = transform.trans_id_tree_path('subdir')
1166
1184
new = transform.trans_id_tree_path('new')
1167
1185
self.assertEqual([], list(transform.iter_changes()))
1170
1188
transform.delete_contents(old)
1171
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1172
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', None),
1173
(False, False))], list(transform.iter_changes()))
1189
self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1190
(b'eert_toor', b'eert_toor'),
1191
('old', 'old'), ('file', None),
1192
(False, False), False)],
1193
list(transform.iter_changes()))
1176
transform.create_file('blah', old)
1177
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1178
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1179
(False, False))], list(transform.iter_changes()))
1196
transform.create_file([b'blah'], old)
1197
self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1198
(b'eert_toor', b'eert_toor'),
1199
('old', 'old'), ('file', 'file'),
1200
(False, False), False)],
1201
list(transform.iter_changes()))
1180
1202
transform.cancel_deletion(old)
1181
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1182
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1183
(False, False))], list(transform.iter_changes()))
1203
self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1204
(b'eert_toor', b'eert_toor'),
1205
('old', 'old'), ('file', 'file'),
1206
(False, False), False)],
1207
list(transform.iter_changes()))
1184
1208
transform.cancel_creation(old)
1186
1210
# move file_id to a different file
1187
1211
self.assertEqual([], list(transform.iter_changes()))
1188
1212
transform.unversion_file(old)
1189
transform.version_file('id-1', new)
1213
transform.version_file(b'id-1', new)
1190
1214
transform.adjust_path('old', root, new)
1191
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1192
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1193
(False, False))], list(transform.iter_changes()))
1215
self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1216
(b'eert_toor', b'eert_toor'),
1217
('old', 'old'), ('file', 'file'),
1218
(False, False), False)],
1219
list(transform.iter_changes()))
1194
1220
transform.cancel_versioning(new)
1195
1221
transform._removed_id = set()
1198
1224
self.assertEqual([], list(transform.iter_changes()))
1199
1225
transform.set_executability(True, old)
1200
self.assertEqual([('id-1', ('old', 'old'), False, (True, True),
1201
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1202
(False, True))], list(transform.iter_changes()))
1226
self.assertEqual([(b'id-1', ('old', 'old'), False, (True, True),
1227
(b'eert_toor', b'eert_toor'),
1228
('old', 'old'), ('file', 'file'),
1229
(False, True), False)],
1230
list(transform.iter_changes()))
1203
1231
transform.set_executability(None, old)
1206
1234
self.assertEqual([], list(transform.iter_changes()))
1207
1235
transform.adjust_path('new', root, old)
1208
1236
transform._new_parent = {}
1209
self.assertEqual([('id-1', ('old', 'new'), False, (True, True),
1210
('eert_toor', 'eert_toor'), ('old', 'new'), ('file', 'file'),
1211
(False, False))], list(transform.iter_changes()))
1237
self.assertEqual([(b'id-1', ('old', 'new'), False, (True, True),
1238
(b'eert_toor', b'eert_toor'),
1239
('old', 'new'), ('file', 'file'),
1240
(False, False), False)],
1241
list(transform.iter_changes()))
1212
1242
transform._new_name = {}
1214
1244
# parent directory
1215
1245
self.assertEqual([], list(transform.iter_changes()))
1216
1246
transform.adjust_path('new', subdir, old)
1217
1247
transform._new_name = {}
1218
self.assertEqual([('id-1', ('old', 'subdir/old'), False,
1219
(True, True), ('eert_toor', 'subdir-id'), ('old', 'old'),
1220
('file', 'file'), (False, False))],
1221
list(transform.iter_changes()))
1248
self.assertEqual([(b'id-1', ('old', 'subdir/old'), False,
1249
(True, True), (b'eert_toor',
1250
b'subdir-id'), ('old', 'old'),
1251
('file', 'file'), (False, False), False)],
1252
list(transform.iter_changes()))
1222
1253
transform._new_path = {}
1225
1256
transform.finalize()
1227
1258
def test_iter_changes_modified_bleed(self):
1228
self.wt.set_root_id('eert_toor')
1259
self.wt.set_root_id(b'eert_toor')
1229
1260
"""Modified flag should not bleed from one change to another"""
1230
1261
# unfortunately, we have no guarantee that file1 (which is modified)
1231
1262
# will be applied before file2. And if it's applied after file2, it
1232
1263
# obviously can't bleed into file2's change output. But for now, it
1234
1265
transform, root = self.get_transform()
1235
transform.new_file('file1', root, 'blah', 'id-1')
1236
transform.new_file('file2', root, 'blah', 'id-2')
1266
transform.new_file('file1', root, [b'blah'], b'id-1')
1267
transform.new_file('file2', root, [b'blah'], b'id-2')
1237
1268
transform.apply()
1238
1269
transform, root = self.get_transform()
1240
transform.delete_contents(transform.trans_id_file_id('id-1'))
1271
transform.delete_contents(transform.trans_id_file_id(b'id-1'))
1241
1272
transform.set_executability(True,
1242
transform.trans_id_file_id('id-2'))
1243
self.assertEqual([('id-1', (u'file1', u'file1'), True, (True, True),
1244
('eert_toor', 'eert_toor'), ('file1', u'file1'),
1245
('file', None), (False, False)),
1246
('id-2', (u'file2', u'file2'), False, (True, True),
1247
('eert_toor', 'eert_toor'), ('file2', u'file2'),
1248
('file', 'file'), (False, True))],
1273
transform.trans_id_file_id(b'id-2'))
1275
[(b'id-1', (u'file1', u'file1'), True, (True, True),
1276
(b'eert_toor', b'eert_toor'), ('file1', u'file1'),
1277
('file', None), (False, False), False),
1278
(b'id-2', (u'file2', u'file2'), False, (True, True),
1279
(b'eert_toor', b'eert_toor'), ('file2', u'file2'),
1280
('file', 'file'), (False, True), False)],
1249
1281
list(transform.iter_changes()))
1251
1283
transform.finalize()
1253
1285
def test_iter_changes_move_missing(self):
1254
1286
"""Test moving ids with no files around"""
1255
self.wt.set_root_id('toor_eert')
1287
self.wt.set_root_id(b'toor_eert')
1256
1288
# Need two steps because versioning a non-existant file is a conflict.
1257
1289
transform, root = self.get_transform()
1258
transform.new_directory('floater', root, 'floater-id')
1290
transform.new_directory('floater', root, b'floater-id')
1259
1291
transform.apply()
1260
1292
transform, root = self.get_transform()
1261
1293
transform.delete_contents(transform.trans_id_tree_path('floater'))
1599
1652
def test_no_final_path(self):
1600
1653
transform, root = self.get_transform()
1601
trans_id = transform.trans_id_file_id('foo')
1602
transform.create_file('bar', trans_id)
1654
trans_id = transform.trans_id_file_id(b'foo')
1655
transform.create_file([b'bar'], trans_id)
1603
1656
transform.cancel_creation(trans_id)
1604
1657
transform.apply()
1606
1659
def test_create_from_tree(self):
1607
1660
tree1 = self.make_branch_and_tree('tree1')
1608
self.build_tree_contents([('tree1/foo/',), ('tree1/bar', 'baz')])
1609
tree1.add(['foo', 'bar'], ['foo-id', 'bar-id'])
1661
self.build_tree_contents([('tree1/foo/',), ('tree1/bar', b'baz')])
1662
tree1.add(['foo', 'bar'], [b'foo-id', b'bar-id'])
1610
1663
tree2 = self.make_branch_and_tree('tree2')
1611
1664
tt = TreeTransform(tree2)
1612
1665
foo_trans_id = tt.create_path('foo', tt.root)
1613
create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id='foo-id')
1666
create_from_tree(tt, foo_trans_id, tree1, 'foo')
1614
1667
bar_trans_id = tt.create_path('bar', tt.root)
1615
create_from_tree(tt, bar_trans_id, tree1, 'bar', file_id='bar-id')
1668
create_from_tree(tt, bar_trans_id, tree1, 'bar')
1617
1670
self.assertEqual('directory', osutils.file_kind('tree2/foo'))
1618
self.assertFileEqual('baz', 'tree2/bar')
1671
self.assertFileEqual(b'baz', 'tree2/bar')
1620
1673
def test_create_from_tree_bytes(self):
1621
1674
"""Provided lines are used instead of tree content."""
1622
1675
tree1 = self.make_branch_and_tree('tree1')
1623
self.build_tree_contents([('tree1/foo', 'bar'),])
1624
tree1.add('foo', 'foo-id')
1676
self.build_tree_contents([('tree1/foo', b'bar'), ])
1677
tree1.add('foo', b'foo-id')
1625
1678
tree2 = self.make_branch_and_tree('tree2')
1626
1679
tt = TreeTransform(tree2)
1627
1680
foo_trans_id = tt.create_path('foo', tt.root)
1628
create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id='foo-id',
1681
create_from_tree(tt, foo_trans_id, tree1, 'foo', chunks=[b'qux'])
1631
self.assertFileEqual('qux', 'tree2/foo')
1683
self.assertFileEqual(b'qux', 'tree2/foo')
1633
1685
def test_create_from_tree_symlink(self):
1634
1686
self.requireFeature(SymlinkFeature)
1635
1687
tree1 = self.make_branch_and_tree('tree1')
1636
1688
os.symlink('bar', 'tree1/foo')
1637
tree1.add('foo', 'foo-id')
1689
tree1.add('foo', b'foo-id')
1638
1690
tt = TreeTransform(self.make_branch_and_tree('tree2'))
1639
1691
foo_trans_id = tt.create_path('foo', tt.root)
1640
create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id='foo-id')
1692
create_from_tree(tt, foo_trans_id, tree1, 'foo')
1642
1694
self.assertEqual('bar', os.readlink('tree2/foo'))
1696
1748
def test_text_merge(self):
1697
1749
root_id = generate_ids.gen_root_id()
1698
1750
base = TransformGroup("base", root_id)
1699
base.tt.new_file('a', base.root, 'a\nb\nc\nd\be\n', 'a')
1700
base.tt.new_file('b', base.root, 'b1', 'b')
1701
base.tt.new_file('c', base.root, 'c', 'c')
1702
base.tt.new_file('d', base.root, 'd', 'd')
1703
base.tt.new_file('e', base.root, 'e', 'e')
1704
base.tt.new_file('f', base.root, 'f', 'f')
1705
base.tt.new_directory('g', base.root, 'g')
1706
base.tt.new_directory('h', base.root, 'h')
1751
base.tt.new_file('a', base.root, [b'a\nb\nc\nd\be\n'], b'a')
1752
base.tt.new_file('b', base.root, [b'b1'], b'b')
1753
base.tt.new_file('c', base.root, [b'c'], b'c')
1754
base.tt.new_file('d', base.root, [b'd'], b'd')
1755
base.tt.new_file('e', base.root, [b'e'], b'e')
1756
base.tt.new_file('f', base.root, [b'f'], b'f')
1757
base.tt.new_directory('g', base.root, b'g')
1758
base.tt.new_directory('h', base.root, b'h')
1707
1759
base.tt.apply()
1708
1760
other = TransformGroup("other", root_id)
1709
other.tt.new_file('a', other.root, 'y\nb\nc\nd\be\n', 'a')
1710
other.tt.new_file('b', other.root, 'b2', 'b')
1711
other.tt.new_file('c', other.root, 'c2', 'c')
1712
other.tt.new_file('d', other.root, 'd', 'd')
1713
other.tt.new_file('e', other.root, 'e2', 'e')
1714
other.tt.new_file('f', other.root, 'f', 'f')
1715
other.tt.new_file('g', other.root, 'g', 'g')
1716
other.tt.new_file('h', other.root, 'h\ni\nj\nk\n', 'h')
1717
other.tt.new_file('i', other.root, 'h\ni\nj\nk\n', 'i')
1761
other.tt.new_file('a', other.root, [b'y\nb\nc\nd\be\n'], b'a')
1762
other.tt.new_file('b', other.root, [b'b2'], b'b')
1763
other.tt.new_file('c', other.root, [b'c2'], b'c')
1764
other.tt.new_file('d', other.root, [b'd'], b'd')
1765
other.tt.new_file('e', other.root, [b'e2'], b'e')
1766
other.tt.new_file('f', other.root, [b'f'], b'f')
1767
other.tt.new_file('g', other.root, [b'g'], b'g')
1768
other.tt.new_file('h', other.root, [b'h\ni\nj\nk\n'], b'h')
1769
other.tt.new_file('i', other.root, [b'h\ni\nj\nk\n'], b'i')
1718
1770
other.tt.apply()
1719
1771
this = TransformGroup("this", root_id)
1720
this.tt.new_file('a', this.root, 'a\nb\nc\nd\bz\n', 'a')
1721
this.tt.new_file('b', this.root, 'b', 'b')
1722
this.tt.new_file('c', this.root, 'c', 'c')
1723
this.tt.new_file('d', this.root, 'd2', 'd')
1724
this.tt.new_file('e', this.root, 'e2', 'e')
1725
this.tt.new_file('f', this.root, 'f', 'f')
1726
this.tt.new_file('g', this.root, 'g', 'g')
1727
this.tt.new_file('h', this.root, '1\n2\n3\n4\n', 'h')
1728
this.tt.new_file('i', this.root, '1\n2\n3\n4\n', 'i')
1772
this.tt.new_file('a', this.root, [b'a\nb\nc\nd\bz\n'], b'a')
1773
this.tt.new_file('b', this.root, [b'b'], b'b')
1774
this.tt.new_file('c', this.root, [b'c'], b'c')
1775
this.tt.new_file('d', this.root, [b'd2'], b'd')
1776
this.tt.new_file('e', this.root, [b'e2'], b'e')
1777
this.tt.new_file('f', this.root, [b'f'], b'f')
1778
this.tt.new_file('g', this.root, [b'g'], b'g')
1779
this.tt.new_file('h', this.root, [b'1\n2\n3\n4\n'], b'h')
1780
this.tt.new_file('i', this.root, [b'1\n2\n3\n4\n'], b'i')
1729
1781
this.tt.apply()
1730
1782
Merge3Merger(this.wt, this.wt, base.wt, other.wt)
1732
1784
# textual merge
1733
self.assertEqual(this.wt.get_file(this.wt.id2path('a')).read(), 'y\nb\nc\nd\bz\n')
1785
with this.wt.get_file(this.wt.id2path(b'a')) as f:
1786
self.assertEqual(f.read(), b'y\nb\nc\nd\bz\n')
1734
1787
# three-way text conflict
1735
self.assertEqual(this.wt.get_file(this.wt.id2path('b')).read(),
1736
conflict_text('b', 'b2'))
1788
with this.wt.get_file(this.wt.id2path(b'b')) as f:
1789
self.assertEqual(f.read(), conflict_text(b'b', b'b2'))
1738
self.assertEqual(this.wt.get_file(this.wt.id2path('c')).read(), 'c2')
1791
self.assertEqual(this.wt.get_file(this.wt.id2path(b'c')).read(), b'c2')
1740
self.assertEqual(this.wt.get_file(this.wt.id2path('d')).read(), 'd2')
1793
self.assertEqual(this.wt.get_file(this.wt.id2path(b'd')).read(), b'd2')
1741
1794
# Ambigious clean merge
1742
self.assertEqual(this.wt.get_file(this.wt.id2path('e')).read(), 'e2')
1795
self.assertEqual(this.wt.get_file(this.wt.id2path(b'e')).read(), b'e2')
1744
self.assertEqual(this.wt.get_file(this.wt.id2path('f')).read(), 'f')
1797
self.assertEqual(this.wt.get_file(this.wt.id2path(b'f')).read(), b'f')
1745
1798
# Correct correct results when THIS == OTHER
1746
self.assertEqual(this.wt.get_file(this.wt.id2path('g')).read(), 'g')
1799
self.assertEqual(this.wt.get_file(this.wt.id2path(b'g')).read(), b'g')
1747
1800
# Text conflict when THIS & OTHER are text and BASE is dir
1748
self.assertEqual(this.wt.get_file(this.wt.id2path('h')).read(),
1749
conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))
1801
self.assertEqual(this.wt.get_file(this.wt.id2path(b'h')).read(),
1802
conflict_text(b'1\n2\n3\n4\n', b'h\ni\nj\nk\n'))
1750
1803
self.assertEqual(this.wt.get_file('h.THIS').read(),
1752
1805
self.assertEqual(this.wt.get_file('h.OTHER').read(),
1754
1807
self.assertEqual(file_kind(this.wt.abspath('h.BASE')), 'directory')
1755
self.assertEqual(this.wt.get_file(this.wt.id2path('i')).read(),
1756
conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))
1808
self.assertEqual(this.wt.get_file(this.wt.id2path(b'i')).read(),
1809
conflict_text(b'1\n2\n3\n4\n', b'h\ni\nj\nk\n'))
1757
1810
self.assertEqual(this.wt.get_file('i.THIS').read(),
1759
1812
self.assertEqual(this.wt.get_file('i.OTHER').read(),
1761
1814
self.assertEqual(os.path.exists(this.wt.abspath('i.BASE')), False)
1762
1815
modified = ['a', 'b', 'c', 'h', 'i']
1763
1816
merge_modified = this.wt.merge_modified()
1764
1817
self.assertSubset(merge_modified, modified)
1765
1818
self.assertEqual(len(merge_modified), len(modified))
1766
with file(this.wt.id2abspath('a'), 'wb') as f: f.write('booga')
1819
with open(this.wt.abspath(this.wt.id2path(b'a')), 'wb') as f:
1767
1821
modified.pop(0)
1768
1822
merge_modified = this.wt.merge_modified()
1769
1823
self.assertSubset(merge_modified, modified)
1818
1874
base = TransformGroup("BASE", root_id)
1819
1875
this = TransformGroup("THIS", root_id)
1820
1876
other = TransformGroup("OTHER", root_id)
1821
base_a, this_a, other_a = [t.tt.new_directory('a', t.root, 'a')
1822
for t in [base, this, other]]
1823
base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b')
1824
for t in [base, this, other]]
1825
base.tt.new_directory('c', base_a, 'c')
1826
this.tt.new_directory('c1', this_a, 'c')
1827
other.tt.new_directory('c', other_b, 'c')
1829
base.tt.new_directory('d', base_a, 'd')
1830
this.tt.new_directory('d1', this_b, 'd')
1831
other.tt.new_directory('d', other_a, 'd')
1833
base.tt.new_directory('e', base_a, 'e')
1834
this.tt.new_directory('e', this_a, 'e')
1835
other.tt.new_directory('e1', other_b, 'e')
1837
base.tt.new_directory('f', base_a, 'f')
1838
this.tt.new_directory('f1', this_b, 'f')
1839
other.tt.new_directory('f1', other_b, 'f')
1877
base_a, this_a, other_a = [t.tt.new_directory('a', t.root, b'a')
1878
for t in [base, this, other]]
1879
base_b, this_b, other_b = [t.tt.new_directory('b', t.root, b'b')
1880
for t in [base, this, other]]
1881
base.tt.new_directory('c', base_a, b'c')
1882
this.tt.new_directory('c1', this_a, b'c')
1883
other.tt.new_directory('c', other_b, b'c')
1885
base.tt.new_directory('d', base_a, b'd')
1886
this.tt.new_directory('d1', this_b, b'd')
1887
other.tt.new_directory('d', other_a, b'd')
1889
base.tt.new_directory('e', base_a, b'e')
1890
this.tt.new_directory('e', this_a, b'e')
1891
other.tt.new_directory('e1', other_b, b'e')
1893
base.tt.new_directory('f', base_a, b'f')
1894
this.tt.new_directory('f1', this_b, b'f')
1895
other.tt.new_directory('f1', other_b, b'f')
1841
1897
for tg in [this, base, other]:
1843
1899
Merge3Merger(this.wt, this.wt, base.wt, other.wt)
1844
self.assertEqual(this.wt.id2path('c'), pathjoin('b/c1'))
1845
self.assertEqual(this.wt.id2path('d'), pathjoin('b/d1'))
1846
self.assertEqual(this.wt.id2path('e'), pathjoin('b/e1'))
1847
self.assertEqual(this.wt.id2path('f'), pathjoin('b/f1'))
1900
self.assertEqual(this.wt.id2path(b'c'), pathjoin('b/c1'))
1901
self.assertEqual(this.wt.id2path(b'd'), pathjoin('b/d1'))
1902
self.assertEqual(this.wt.id2path(b'e'), pathjoin('b/e1'))
1903
self.assertEqual(this.wt.id2path(b'f'), pathjoin('b/f1'))
1849
1905
def test_filename_merge_conflicts(self):
1850
1906
root_id = generate_ids.gen_root_id()
1851
1907
base = TransformGroup("BASE", root_id)
1852
1908
this = TransformGroup("THIS", root_id)
1853
1909
other = TransformGroup("OTHER", root_id)
1854
base_a, this_a, other_a = [t.tt.new_directory('a', t.root, 'a')
1855
for t in [base, this, other]]
1856
base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b')
1857
for t in [base, this, other]]
1859
base.tt.new_file('g', base_a, 'g', 'g')
1860
other.tt.new_file('g1', other_b, 'g1', 'g')
1862
base.tt.new_file('h', base_a, 'h', 'h')
1863
this.tt.new_file('h1', this_b, 'h1', 'h')
1865
base.tt.new_file('i', base.root, 'i', 'i')
1866
other.tt.new_directory('i1', this_b, 'i')
1910
base_a, this_a, other_a = [t.tt.new_directory('a', t.root, b'a')
1911
for t in [base, this, other]]
1912
base_b, this_b, other_b = [t.tt.new_directory('b', t.root, b'b')
1913
for t in [base, this, other]]
1915
base.tt.new_file('g', base_a, [b'g'], b'g')
1916
other.tt.new_file('g1', other_b, [b'g1'], b'g')
1918
base.tt.new_file('h', base_a, [b'h'], b'h')
1919
this.tt.new_file('h1', this_b, [b'h1'], b'h')
1921
base.tt.new_file('i', base.root, [b'i'], b'i')
1922
other.tt.new_directory('i1', this_b, b'i')
1868
1924
for tg in [this, base, other]:
1870
1926
Merge3Merger(this.wt, this.wt, base.wt, other.wt)
1872
self.assertEqual(this.wt.id2path('g'), pathjoin('b/g1.OTHER'))
1928
self.assertEqual(this.wt.id2path(b'g'), pathjoin('b/g1.OTHER'))
1873
1929
self.assertIs(os.path.lexists(this.wt.abspath('b/g1.BASE')), True)
1874
1930
self.assertIs(os.path.lexists(this.wt.abspath('b/g1.THIS')), False)
1875
self.assertEqual(this.wt.id2path('h'), pathjoin('b/h1.THIS'))
1931
self.assertEqual(this.wt.id2path(b'h'), pathjoin('b/h1.THIS'))
1876
1932
self.assertIs(os.path.lexists(this.wt.abspath('b/h1.BASE')), True)
1877
1933
self.assertIs(os.path.lexists(this.wt.abspath('b/h1.OTHER')), False)
1878
self.assertEqual(this.wt.id2path('i'), pathjoin('b/i1.OTHER'))
1934
self.assertEqual(this.wt.id2path(b'i'), pathjoin('b/i1.OTHER'))
1881
1937
class TestBuildTree(tests.TestCaseWithTransport):
2332
2395
tt = TransformPreview(branch.basis_tree())
2333
2396
self.addCleanup(tt.finalize)
2334
2397
e = self.assertRaises(ValueError, tt.commit, branch,
2335
'my message', ['rev1b-id'])
2398
'my message', [b'rev1b-id'])
2336
2399
self.assertEqual('Cannot supply merge parents for first commit.',
2338
2401
self.assertEqual(_mod_revision.NULL_REVISION, branch.last_revision())
2340
2403
def test_add_files(self):
2341
2404
branch, tt = self.get_branch_and_transform()
2342
tt.new_file('file', tt.root, 'contents', 'file-id')
2343
trans_id = tt.new_directory('dir', tt.root, 'dir-id')
2405
tt.new_file('file', tt.root, [b'contents'], b'file-id')
2406
trans_id = tt.new_directory('dir', tt.root, b'dir-id')
2344
2407
if SymlinkFeature.available():
2345
tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')
2346
rev = tt.commit(branch, 'message')
2408
tt.new_symlink('symlink', trans_id, 'target', b'symlink-id')
2409
tt.commit(branch, 'message')
2347
2410
tree = branch.basis_tree()
2348
self.assertEqual('file', tree.id2path('file-id'))
2349
self.assertEqual('contents', tree.get_file_text('file', 'file-id'))
2350
self.assertEqual('dir', tree.id2path('dir-id'))
2411
self.assertEqual('file', tree.id2path(b'file-id'))
2412
self.assertEqual(b'contents', tree.get_file_text('file'))
2413
self.assertEqual('dir', tree.id2path(b'dir-id'))
2351
2414
if SymlinkFeature.available():
2352
self.assertEqual('dir/symlink', tree.id2path('symlink-id'))
2415
self.assertEqual('dir/symlink', tree.id2path(b'symlink-id'))
2353
2416
self.assertEqual('target', tree.get_symlink_target('dir/symlink'))
2355
2418
def test_add_unversioned(self):
2356
2419
branch, tt = self.get_branch_and_transform()
2357
tt.new_file('file', tt.root, 'contents')
2420
tt.new_file('file', tt.root, [b'contents'])
2358
2421
self.assertRaises(errors.StrictCommitFailed, tt.commit, branch,
2359
2422
'message', strict=True)
2361
2424
def test_modify_strict(self):
2362
2425
branch, tt = self.get_branch_and_transform()
2363
tt.new_file('file', tt.root, 'contents', 'file-id')
2426
tt.new_file('file', tt.root, [b'contents'], b'file-id')
2364
2427
tt.commit(branch, 'message', strict=True)
2365
2428
tt = TransformPreview(branch.basis_tree())
2366
2429
self.addCleanup(tt.finalize)
2367
trans_id = tt.trans_id_file_id('file-id')
2430
trans_id = tt.trans_id_file_id(b'file-id')
2368
2431
tt.delete_contents(trans_id)
2369
tt.create_file('contents', trans_id)
2432
tt.create_file([b'contents'], trans_id)
2370
2433
tt.commit(branch, 'message', strict=True)
2372
2435
def test_commit_malformed(self):
2730
2797
revision_tree = self.create_tree()
2731
2798
preview = TransformPreview(revision_tree)
2732
2799
self.addCleanup(preview.finalize)
2733
preview.new_file('file2', preview.root, 'content B\n', 'file2-id')
2800
preview.new_file('file2', preview.root, [b'content B\n'], b'file2-id')
2734
2801
preview_tree = preview.get_preview_tree()
2735
2802
self.assertEqual(preview_tree.kind('file2'), 'file')
2737
preview_tree.get_file('file2', 'file2-id').read(), 'content B\n')
2803
with preview_tree.get_file('file2') as f:
2804
self.assertEqual(f.read(), b'content B\n')
2739
2806
def test_diff_preview_tree(self):
2740
2807
revision_tree = self.create_tree()
2741
2808
preview = TransformPreview(revision_tree)
2742
2809
self.addCleanup(preview.finalize)
2743
preview.new_file('file2', preview.root, 'content B\n', 'file2-id')
2810
preview.new_file('file2', preview.root, [b'content B\n'], b'file2-id')
2744
2811
preview_tree = preview.get_preview_tree()
2745
2812
out = BytesIO()
2746
2813
show_diff_trees(revision_tree, preview_tree, out)
2747
2814
lines = out.getvalue().splitlines()
2748
self.assertEqual(lines[0], "=== added file 'file2'")
2815
self.assertEqual(lines[0], b"=== added file 'file2'")
2749
2816
# 3 lines of diff administrivia
2750
self.assertEqual(lines[4], "+content B")
2817
self.assertEqual(lines[4], b"+content B")
2819
def test_unsupported_symlink_diff(self):
2820
self.requireFeature(SymlinkFeature)
2821
tree = self.make_branch_and_tree('.')
2822
self.build_tree_contents([('a', 'content 1')])
2823
tree.set_root_id(b'TREE_ROOT')
2824
tree.add('a', b'a-id')
2825
os.symlink('a', 'foo')
2826
tree.add('foo', b'foo-id')
2827
tree.commit('rev1', rev_id=b'rev1')
2828
revision_tree = tree.branch.repository.revision_tree(b'rev1')
2829
preview = TransformPreview(revision_tree)
2830
self.addCleanup(preview.finalize)
2831
preview.delete_versioned(preview.trans_id_tree_path('foo'))
2832
preview_tree = preview.get_preview_tree()
2835
trace.push_log_file(log)
2836
os_symlink = getattr(os, 'symlink', None)
2839
show_diff_trees(revision_tree, preview_tree, out)
2840
lines = out.getvalue().splitlines()
2842
os.symlink = os_symlink
2843
self.assertContainsRe(
2845
b'Ignoring "foo" as symlinks are not supported on this filesystem')
2752
2847
def test_transform_conflicts(self):
2753
2848
revision_tree = self.create_tree()
2754
2849
preview = TransformPreview(revision_tree)
2755
2850
self.addCleanup(preview.finalize)
2756
preview.new_file('a', preview.root, 'content 2')
2851
preview.new_file('a', preview.root, [b'content 2'])
2757
2852
resolve_conflicts(preview)
2758
trans_id = preview.trans_id_file_id('a-id')
2853
trans_id = preview.trans_id_file_id(b'a-id')
2759
2854
self.assertEqual('a.moved', preview.final_name(trans_id))
2761
2856
def get_tree_and_preview_tree(self):
2762
2857
revision_tree = self.create_tree()
2763
2858
preview = TransformPreview(revision_tree)
2764
2859
self.addCleanup(preview.finalize)
2765
a_trans_id = preview.trans_id_file_id('a-id')
2860
a_trans_id = preview.trans_id_file_id(b'a-id')
2766
2861
preview.delete_contents(a_trans_id)
2767
preview.create_file('b content', a_trans_id)
2862
preview.create_file([b'b content'], a_trans_id)
2768
2863
preview_tree = preview.get_preview_tree()
2769
2864
return revision_tree, preview_tree
2771
2866
def test_iter_changes(self):
2772
2867
revision_tree, preview_tree = self.get_tree_and_preview_tree()
2773
root = revision_tree.get_root_id()
2774
self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
2775
(root, root), ('a', 'a'), ('file', 'file'),
2777
list(preview_tree.iter_changes(revision_tree)))
2868
root = revision_tree.path2id('')
2869
self.assertEqual([(b'a-id', ('a', 'a'), True, (True, True),
2870
(root, root), ('a', 'a'), ('file', 'file'),
2871
(False, False), False)],
2872
list(preview_tree.iter_changes(revision_tree)))
2779
2874
def test_include_unchanged_succeeds(self):
2780
2875
revision_tree, preview_tree = self.get_tree_and_preview_tree()
2781
2876
changes = preview_tree.iter_changes(revision_tree,
2782
2877
include_unchanged=True)
2783
root = revision_tree.get_root_id()
2785
2878
self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
2787
2880
def test_specific_files(self):
2816
2909
revision_tree = self.create_tree()
2817
2910
preview = TransformPreview(revision_tree)
2818
2911
self.addCleanup(preview.finalize)
2819
preview.new_file('file', preview.root, 'contents', 'file-id')
2820
preview.new_directory('directory', preview.root, 'dir-id')
2912
preview.new_file('file', preview.root, [b'contents'], b'file-id')
2913
preview.new_directory('directory', preview.root, b'dir-id')
2821
2914
preview_tree = preview.get_preview_tree()
2822
2915
self.assertEqual('file', preview_tree.kind('file'))
2823
2916
self.assertEqual('directory', preview_tree.kind('directory'))
2825
2918
def test_get_file_mtime(self):
2826
2919
preview = self.get_empty_preview()
2827
file_trans_id = preview.new_file('file', preview.root, 'contents',
2920
file_trans_id = preview.new_file('file', preview.root, [b'contents'],
2829
2922
limbo_path = preview._limbo_name(file_trans_id)
2830
2923
preview_tree = preview.get_preview_tree()
2831
2924
self.assertEqual(os.stat(limbo_path).st_mtime,
2832
preview_tree.get_file_mtime('file', 'file-id'))
2925
preview_tree.get_file_mtime('file'))
2834
2927
def test_get_file_mtime_renamed(self):
2835
2928
work_tree = self.make_branch_and_tree('tree')
2836
2929
self.build_tree(['tree/file'])
2837
work_tree.add('file', 'file-id')
2930
work_tree.add('file', b'file-id')
2838
2931
preview = TransformPreview(work_tree)
2839
2932
self.addCleanup(preview.finalize)
2840
file_trans_id = preview.trans_id_tree_file_id('file-id')
2933
file_trans_id = preview.trans_id_tree_path('file')
2841
2934
preview.adjust_path('renamed', preview.root, file_trans_id)
2842
2935
preview_tree = preview.get_preview_tree()
2843
preview_mtime = preview_tree.get_file_mtime('renamed', 'file-id')
2844
work_mtime = work_tree.get_file_mtime('file', 'file-id')
2936
preview_mtime = preview_tree.get_file_mtime('renamed')
2937
work_mtime = work_tree.get_file_mtime('file')
2846
2939
def test_get_file_size(self):
2847
2940
work_tree = self.make_branch_and_tree('tree')
2848
self.build_tree_contents([('tree/old', 'old')])
2849
work_tree.add('old', 'old-id')
2941
self.build_tree_contents([('tree/old', b'old')])
2942
work_tree.add('old', b'old-id')
2850
2943
preview = TransformPreview(work_tree)
2851
2944
self.addCleanup(preview.finalize)
2852
new_id = preview.new_file('name', preview.root, 'contents', 'new-id',
2945
preview.new_file('name', preview.root, [b'contents'], b'new-id',
2854
2947
tree = preview.get_preview_tree()
2855
2948
self.assertEqual(len('old'), tree.get_file_size('old'))
2856
2949
self.assertEqual(len('contents'), tree.get_file_size('name'))
2858
2951
def test_get_file(self):
2859
2952
preview = self.get_empty_preview()
2860
preview.new_file('file', preview.root, 'contents', 'file-id')
2953
preview.new_file('file', preview.root, [b'contents'], b'file-id')
2861
2954
preview_tree = preview.get_preview_tree()
2862
tree_file = preview_tree.get_file('file')
2864
self.assertEqual('contents', tree_file.read())
2955
with preview_tree.get_file('file') as tree_file:
2956
self.assertEqual(b'contents', tree_file.read())
2868
2958
def test_get_symlink_target(self):
2869
2959
self.requireFeature(SymlinkFeature)
2870
2960
preview = self.get_empty_preview()
2871
preview.new_symlink('symlink', preview.root, 'target', 'symlink-id')
2961
preview.new_symlink('symlink', preview.root, 'target', b'symlink-id')
2872
2962
preview_tree = preview.get_preview_tree()
2873
2963
self.assertEqual('target',
2874
2964
preview_tree.get_symlink_target('symlink'))
2876
2966
def test_all_file_ids(self):
2877
2967
tree = self.make_branch_and_tree('tree')
2878
2968
self.build_tree(['tree/a', 'tree/b', 'tree/c'])
2879
tree.add(['a', 'b', 'c'], ['a-id', 'b-id', 'c-id'])
2969
tree.add(['a', 'b', 'c'], [b'a-id', b'b-id', b'c-id'])
2880
2970
preview = TransformPreview(tree)
2881
2971
self.addCleanup(preview.finalize)
2882
preview.unversion_file(preview.trans_id_file_id('b-id'))
2883
c_trans_id = preview.trans_id_file_id('c-id')
2972
preview.unversion_file(preview.trans_id_file_id(b'b-id'))
2973
c_trans_id = preview.trans_id_file_id(b'c-id')
2884
2974
preview.unversion_file(c_trans_id)
2885
preview.version_file('c-id', c_trans_id)
2975
preview.version_file(b'c-id', c_trans_id)
2886
2976
preview_tree = preview.get_preview_tree()
2887
self.assertEqual({'a-id', 'c-id', tree.get_root_id()},
2977
self.assertEqual({b'a-id', b'c-id', tree.path2id('')},
2888
2978
preview_tree.all_file_ids())
2890
2980
def test_path2id_deleted_unchanged(self):
2891
2981
tree = self.make_branch_and_tree('tree')
2892
2982
self.build_tree(['tree/unchanged', 'tree/deleted'])
2893
tree.add(['unchanged', 'deleted'], ['unchanged-id', 'deleted-id'])
2983
tree.add(['unchanged', 'deleted'], [b'unchanged-id', b'deleted-id'])
2894
2984
preview = TransformPreview(tree)
2895
2985
self.addCleanup(preview.finalize)
2896
preview.unversion_file(preview.trans_id_file_id('deleted-id'))
2986
preview.unversion_file(preview.trans_id_file_id(b'deleted-id'))
2897
2987
preview_tree = preview.get_preview_tree()
2898
self.assertEqual('unchanged-id', preview_tree.path2id('unchanged'))
2988
self.assertEqual(b'unchanged-id', preview_tree.path2id('unchanged'))
2899
2989
self.assertFalse(preview_tree.is_versioned('deleted'))
2901
2991
def test_path2id_created(self):
2902
2992
tree = self.make_branch_and_tree('tree')
2903
2993
self.build_tree(['tree/unchanged'])
2904
tree.add(['unchanged'], ['unchanged-id'])
2994
tree.add(['unchanged'], [b'unchanged-id'])
2905
2995
preview = TransformPreview(tree)
2906
2996
self.addCleanup(preview.finalize)
2907
preview.new_file('new', preview.trans_id_file_id('unchanged-id'),
2908
'contents', 'new-id')
2997
preview.new_file('new', preview.trans_id_file_id(b'unchanged-id'),
2998
[b'contents'], b'new-id')
2909
2999
preview_tree = preview.get_preview_tree()
2910
self.assertEqual('new-id', preview_tree.path2id('unchanged/new'))
3000
self.assertEqual(b'new-id', preview_tree.path2id('unchanged/new'))
2912
3002
def test_path2id_moved(self):
2913
3003
tree = self.make_branch_and_tree('tree')
2914
3004
self.build_tree(['tree/old_parent/', 'tree/old_parent/child'])
2915
3005
tree.add(['old_parent', 'old_parent/child'],
2916
['old_parent-id', 'child-id'])
3006
[b'old_parent-id', b'child-id'])
2917
3007
preview = TransformPreview(tree)
2918
3008
self.addCleanup(preview.finalize)
2919
3009
new_parent = preview.new_directory('new_parent', preview.root,
2921
3011
preview.adjust_path('child', new_parent,
2922
preview.trans_id_file_id('child-id'))
3012
preview.trans_id_file_id(b'child-id'))
2923
3013
preview_tree = preview.get_preview_tree()
2924
3014
self.assertFalse(preview_tree.is_versioned('old_parent/child'))
2925
self.assertEqual('child-id', preview_tree.path2id('new_parent/child'))
3015
self.assertEqual(b'child-id', preview_tree.path2id('new_parent/child'))
2927
3017
def test_path2id_renamed_parent(self):
2928
3018
tree = self.make_branch_and_tree('tree')
2929
3019
self.build_tree(['tree/old_name/', 'tree/old_name/child'])
2930
3020
tree.add(['old_name', 'old_name/child'],
2931
['parent-id', 'child-id'])
3021
[b'parent-id', b'child-id'])
2932
3022
preview = TransformPreview(tree)
2933
3023
self.addCleanup(preview.finalize)
2934
3024
preview.adjust_path('new_name', preview.root,
2935
preview.trans_id_file_id('parent-id'))
3025
preview.trans_id_file_id(b'parent-id'))
2936
3026
preview_tree = preview.get_preview_tree()
2937
3027
self.assertFalse(preview_tree.is_versioned('old_name/child'))
2938
self.assertEqual('child-id', preview_tree.path2id('new_name/child'))
3028
self.assertEqual(b'child-id', preview_tree.path2id('new_name/child'))
2940
def assertMatchingIterEntries(self, tt, specific_file_ids=None):
3030
def assertMatchingIterEntries(self, tt, specific_files=None):
2941
3031
preview_tree = tt.get_preview_tree()
2942
3032
preview_result = list(preview_tree.iter_entries_by_dir(
3033
specific_files=specific_files))
2944
3034
tree = tt._tree
2946
actual_result = list(tree.iter_entries_by_dir(specific_file_ids))
3036
actual_result = list(tree.iter_entries_by_dir(
3037
specific_files=specific_files))
2947
3038
self.assertEqual(actual_result, preview_result)
2949
3040
def test_iter_entries_by_dir_new(self):
2950
3041
tree = self.make_branch_and_tree('tree')
2951
3042
tt = TreeTransform(tree)
2952
tt.new_file('new', tt.root, 'contents', 'new-id')
3043
tt.new_file('new', tt.root, [b'contents'], b'new-id')
2953
3044
self.assertMatchingIterEntries(tt)
2955
3046
def test_iter_entries_by_dir_deleted(self):
2956
3047
tree = self.make_branch_and_tree('tree')
2957
3048
self.build_tree(['tree/deleted'])
2958
tree.add('deleted', 'deleted-id')
3049
tree.add('deleted', b'deleted-id')
2959
3050
tt = TreeTransform(tree)
2960
tt.delete_contents(tt.trans_id_file_id('deleted-id'))
3051
tt.delete_contents(tt.trans_id_file_id(b'deleted-id'))
2961
3052
self.assertMatchingIterEntries(tt)
2963
3054
def test_iter_entries_by_dir_unversioned(self):
2964
3055
tree = self.make_branch_and_tree('tree')
2965
3056
self.build_tree(['tree/removed'])
2966
tree.add('removed', 'removed-id')
3057
tree.add('removed', b'removed-id')
2967
3058
tt = TreeTransform(tree)
2968
tt.unversion_file(tt.trans_id_file_id('removed-id'))
3059
tt.unversion_file(tt.trans_id_file_id(b'removed-id'))
2969
3060
self.assertMatchingIterEntries(tt)
2971
3062
def test_iter_entries_by_dir_moved(self):
2972
3063
tree = self.make_branch_and_tree('tree')
2973
3064
self.build_tree(['tree/moved', 'tree/new_parent/'])
2974
tree.add(['moved', 'new_parent'], ['moved-id', 'new_parent-id'])
3065
tree.add(['moved', 'new_parent'], [b'moved-id', b'new_parent-id'])
2975
3066
tt = TreeTransform(tree)
2976
tt.adjust_path('moved', tt.trans_id_file_id('new_parent-id'),
2977
tt.trans_id_file_id('moved-id'))
3067
tt.adjust_path('moved', tt.trans_id_file_id(b'new_parent-id'),
3068
tt.trans_id_file_id(b'moved-id'))
2978
3069
self.assertMatchingIterEntries(tt)
2980
def test_iter_entries_by_dir_specific_file_ids(self):
3071
def test_iter_entries_by_dir_specific_files(self):
2981
3072
tree = self.make_branch_and_tree('tree')
2982
tree.set_root_id('tree-root-id')
3073
tree.set_root_id(b'tree-root-id')
2983
3074
self.build_tree(['tree/parent/', 'tree/parent/child'])
2984
tree.add(['parent', 'parent/child'], ['parent-id', 'child-id'])
3075
tree.add(['parent', 'parent/child'], [b'parent-id', b'child-id'])
2985
3076
tt = TreeTransform(tree)
2986
self.assertMatchingIterEntries(tt, ['tree-root-id', 'child-id'])
3077
self.assertMatchingIterEntries(tt, ['', 'parent/child'])
2988
3079
def test_symlink_content_summary(self):
2989
3080
self.requireFeature(SymlinkFeature)
2990
3081
preview = self.get_empty_preview()
2991
preview.new_symlink('path', preview.root, 'target', 'path-id')
3082
preview.new_symlink('path', preview.root, 'target', b'path-id')
2992
3083
summary = preview.get_preview_tree().path_content_summary('path')
2993
3084
self.assertEqual(('symlink', None, None, 'target'), summary)
3048
3140
def test_dir_content_summary(self):
3049
3141
preview = self.get_empty_preview()
3050
preview.new_directory('path', preview.root, 'path-id')
3142
preview.new_directory('path', preview.root, b'path-id')
3051
3143
summary = preview.get_preview_tree().path_content_summary('path')
3052
3144
self.assertEqual(('directory', None, None, None), summary)
3054
3146
def test_tree_content_summary(self):
3055
3147
preview = self.get_empty_preview()
3056
path = preview.new_directory('path', preview.root, 'path-id')
3057
preview.set_tree_reference('rev-1', path)
3148
path = preview.new_directory('path', preview.root, b'path-id')
3149
preview.set_tree_reference(b'rev-1', path)
3058
3150
summary = preview.get_preview_tree().path_content_summary('path')
3059
3151
self.assertEqual(4, len(summary))
3060
3152
self.assertEqual('tree-reference', summary[0])
3062
3154
def test_annotate(self):
3063
3155
tree = self.make_branch_and_tree('tree')
3064
self.build_tree_contents([('tree/file', 'a\n')])
3065
tree.add('file', 'file-id')
3066
tree.commit('a', rev_id='one')
3067
self.build_tree_contents([('tree/file', 'a\nb\n')])
3156
self.build_tree_contents([('tree/file', b'a\n')])
3157
tree.add('file', b'file-id')
3158
tree.commit('a', rev_id=b'one')
3159
self.build_tree_contents([('tree/file', b'a\nb\n')])
3068
3160
preview = TransformPreview(tree)
3069
3161
self.addCleanup(preview.finalize)
3070
file_trans_id = preview.trans_id_file_id('file-id')
3162
file_trans_id = preview.trans_id_file_id(b'file-id')
3071
3163
preview.delete_contents(file_trans_id)
3072
preview.create_file('a\nb\nc\n', file_trans_id)
3164
preview.create_file([b'a\nb\nc\n'], file_trans_id)
3073
3165
preview_tree = preview.get_preview_tree()
3079
annotation = preview_tree.annotate_iter('file', default_revision='me:')
3171
annotation = preview_tree.annotate_iter(
3172
'file', default_revision=b'me:')
3080
3173
self.assertEqual(expected, annotation)
3082
3175
def test_annotate_missing(self):
3083
3176
preview = self.get_empty_preview()
3084
preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')
3177
preview.new_file('file', preview.root, [b'a\nb\nc\n'], b'file-id')
3085
3178
preview_tree = preview.get_preview_tree()
3091
annotation = preview_tree.annotate_iter('file', default_revision='me:')
3184
annotation = preview_tree.annotate_iter(
3185
'file', default_revision=b'me:')
3092
3186
self.assertEqual(expected, annotation)
3094
3188
def test_annotate_rename(self):
3095
3189
tree = self.make_branch_and_tree('tree')
3096
self.build_tree_contents([('tree/file', 'a\n')])
3097
tree.add('file', 'file-id')
3098
tree.commit('a', rev_id='one')
3190
self.build_tree_contents([('tree/file', b'a\n')])
3191
tree.add('file', b'file-id')
3192
tree.commit('a', rev_id=b'one')
3099
3193
preview = TransformPreview(tree)
3100
3194
self.addCleanup(preview.finalize)
3101
file_trans_id = preview.trans_id_file_id('file-id')
3195
file_trans_id = preview.trans_id_file_id(b'file-id')
3102
3196
preview.adjust_path('newname', preview.root, file_trans_id)
3103
3197
preview_tree = preview.get_preview_tree()
3107
annotation = preview_tree.annotate_iter('file', default_revision='me:')
3201
annotation = preview_tree.annotate_iter(
3202
'file', default_revision=b'me:')
3108
3203
self.assertEqual(expected, annotation)
3110
3205
def test_annotate_deleted(self):
3111
3206
tree = self.make_branch_and_tree('tree')
3112
self.build_tree_contents([('tree/file', 'a\n')])
3113
tree.add('file', 'file-id')
3114
tree.commit('a', rev_id='one')
3115
self.build_tree_contents([('tree/file', 'a\nb\n')])
3207
self.build_tree_contents([('tree/file', b'a\n')])
3208
tree.add('file', b'file-id')
3209
tree.commit('a', rev_id=b'one')
3210
self.build_tree_contents([('tree/file', b'a\nb\n')])
3116
3211
preview = TransformPreview(tree)
3117
3212
self.addCleanup(preview.finalize)
3118
file_trans_id = preview.trans_id_file_id('file-id')
3213
file_trans_id = preview.trans_id_file_id(b'file-id')
3119
3214
preview.delete_contents(file_trans_id)
3120
3215
preview_tree = preview.get_preview_tree()
3121
annotation = preview_tree.annotate_iter('file', default_revision='me:')
3216
annotation = preview_tree.annotate_iter(
3217
'file', default_revision=b'me:')
3122
3218
self.assertIs(None, annotation)
3124
3220
def test_stored_kind(self):
3125
3221
preview = self.get_empty_preview()
3126
preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')
3222
preview.new_file('file', preview.root, [b'a\nb\nc\n'], b'file-id')
3127
3223
preview_tree = preview.get_preview_tree()
3128
3224
self.assertEqual('file', preview_tree.stored_kind('file'))
3130
3226
def test_is_executable(self):
3131
3227
preview = self.get_empty_preview()
3132
preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')
3133
preview.set_executability(True, preview.trans_id_file_id('file-id'))
3228
preview.new_file('file', preview.root, [b'a\nb\nc\n'], b'file-id')
3229
preview.set_executability(True, preview.trans_id_file_id(b'file-id'))
3134
3230
preview_tree = preview.get_preview_tree()
3135
3231
self.assertEqual(True, preview_tree.is_executable('file'))
3137
3233
def test_get_set_parent_ids(self):
3138
3234
revision_tree, preview_tree = self.get_tree_and_preview_tree()
3139
3235
self.assertEqual([], preview_tree.get_parent_ids())
3140
preview_tree.set_parent_ids(['rev-1'])
3141
self.assertEqual(['rev-1'], preview_tree.get_parent_ids())
3236
preview_tree.set_parent_ids([b'rev-1'])
3237
self.assertEqual([b'rev-1'], preview_tree.get_parent_ids())
3143
3239
def test_plan_file_merge(self):
3144
3240
work_a = self.make_branch_and_tree('wta')
3145
self.build_tree_contents([('wta/file', 'a\nb\nc\nd\n')])
3146
work_a.add('file', 'file-id')
3241
self.build_tree_contents([('wta/file', b'a\nb\nc\nd\n')])
3242
work_a.add('file', b'file-id')
3147
3243
base_id = work_a.commit('base version')
3148
3244
tree_b = work_a.controldir.sprout('wtb').open_workingtree()
3149
3245
preview = TransformPreview(work_a)
3150
3246
self.addCleanup(preview.finalize)
3151
trans_id = preview.trans_id_file_id('file-id')
3247
trans_id = preview.trans_id_file_id(b'file-id')
3152
3248
preview.delete_contents(trans_id)
3153
preview.create_file('b\nc\nd\ne\n', trans_id)
3154
self.build_tree_contents([('wtb/file', 'a\nc\nd\nf\n')])
3249
preview.create_file([b'b\nc\nd\ne\n'], trans_id)
3250
self.build_tree_contents([('wtb/file', b'a\nc\nd\nf\n')])
3155
3251
tree_a = preview.get_preview_tree()
3156
3252
tree_a.set_parent_ids([base_id])
3157
3253
self.assertEqual([
3158
('killed-a', 'a\n'),
3159
('killed-b', 'b\n'),
3160
('unchanged', 'c\n'),
3161
('unchanged', 'd\n'),
3164
], list(tree_a.plan_file_merge('file-id', tree_b)))
3254
('killed-a', b'a\n'),
3255
('killed-b', b'b\n'),
3256
('unchanged', b'c\n'),
3257
('unchanged', b'd\n'),
3260
], list(tree_a.plan_file_merge('file', tree_b)))
3166
3262
def test_plan_file_merge_revision_tree(self):
3167
3263
work_a = self.make_branch_and_tree('wta')
3168
self.build_tree_contents([('wta/file', 'a\nb\nc\nd\n')])
3169
work_a.add('file', 'file-id')
3264
self.build_tree_contents([('wta/file', b'a\nb\nc\nd\n')])
3265
work_a.add('file', b'file-id')
3170
3266
base_id = work_a.commit('base version')
3171
3267
tree_b = work_a.controldir.sprout('wtb').open_workingtree()
3172
3268
preview = TransformPreview(work_a.basis_tree())
3173
3269
self.addCleanup(preview.finalize)
3174
trans_id = preview.trans_id_file_id('file-id')
3270
trans_id = preview.trans_id_file_id(b'file-id')
3175
3271
preview.delete_contents(trans_id)
3176
preview.create_file('b\nc\nd\ne\n', trans_id)
3177
self.build_tree_contents([('wtb/file', 'a\nc\nd\nf\n')])
3272
preview.create_file([b'b\nc\nd\ne\n'], trans_id)
3273
self.build_tree_contents([('wtb/file', b'a\nc\nd\nf\n')])
3178
3274
tree_a = preview.get_preview_tree()
3179
3275
tree_a.set_parent_ids([base_id])
3180
3276
self.assertEqual([
3181
('killed-a', 'a\n'),
3182
('killed-b', 'b\n'),
3183
('unchanged', 'c\n'),
3184
('unchanged', 'd\n'),
3187
], list(tree_a.plan_file_merge('file-id', tree_b)))
3277
('killed-a', b'a\n'),
3278
('killed-b', b'b\n'),
3279
('unchanged', b'c\n'),
3280
('unchanged', b'd\n'),
3283
], list(tree_a.plan_file_merge('file', tree_b)))
3189
3285
def test_walkdirs(self):
3190
3286
preview = self.get_empty_preview()
3191
root = preview.new_directory('', ROOT_PARENT, 'tree-root')
3287
preview.new_directory('', ROOT_PARENT, b'tree-root')
3192
3288
# FIXME: new_directory should mark root.
3193
3289
preview.fixup_new_roots()
3194
3290
preview_tree = preview.get_preview_tree()
3195
file_trans_id = preview.new_file('a', preview.root, 'contents',
3197
expected = [(('', 'tree-root'),
3198
[('a', 'a', 'file', None, 'a-id', 'file')])]
3291
preview.new_file('a', preview.root, [b'contents'], b'a-id')
3292
expected = [(('', b'tree-root'),
3293
[('a', 'a', 'file', None, b'a-id', 'file')])]
3199
3294
self.assertEqual(expected, list(preview_tree.walkdirs()))
3201
3296
def test_extras(self):
added
removed
breezy/tests/test_transform.py
