507
1055
transform, root = self.get_transform()
508
1056
wt = transform._tree
1058
self.addCleanup(wt.unlock)
509
1059
transform.new_file('set_on_creation', root, 'Set on creation', 'soc',
511
sac = transform.new_file('set_after_creation', root, 'Set after creation', 'sac')
1061
sac = transform.new_file('set_after_creation', root,
1062
'Set after creation', 'sac')
512
1063
transform.set_executability(True, sac)
513
uws = transform.new_file('unset_without_set', root, 'Unset badly', 'uws')
1064
uws = transform.new_file('unset_without_set', root, 'Unset badly',
514
1066
self.assertRaises(KeyError, transform.set_executability, None, uws)
515
1067
transform.apply()
516
1068
self.assertTrue(wt.is_executable('soc'))
517
1069
self.assertTrue(wt.is_executable('sac'))
1071
def test_preserve_mode(self):
1072
"""File mode is preserved when replacing content"""
1073
if sys.platform == 'win32':
1074
raise TestSkipped('chmod has no effect on win32')
1075
transform, root = self.get_transform()
1076
transform.new_file('file1', root, 'contents', 'file1-id', True)
1078
self.wt.lock_write()
1079
self.addCleanup(self.wt.unlock)
1080
self.assertTrue(self.wt.is_executable('file1-id'))
1081
transform, root = self.get_transform()
1082
file1_id = transform.trans_id_tree_file_id('file1-id')
1083
transform.delete_contents(file1_id)
1084
transform.create_file('contents2', file1_id)
1086
self.assertTrue(self.wt.is_executable('file1-id'))
1088
def test__set_mode_stats_correctly(self):
1089
"""_set_mode stats to determine file mode."""
1090
if sys.platform == 'win32':
1091
raise TestSkipped('chmod has no effect on win32')
1095
def instrumented_stat(path):
1096
stat_paths.append(path)
1097
return real_stat(path)
1099
transform, root = self.get_transform()
1101
bar1_id = transform.new_file('bar', root, 'bar contents 1\n',
1102
file_id='bar-id-1', executable=False)
1105
transform, root = self.get_transform()
1106
bar1_id = transform.trans_id_tree_path('bar')
1107
bar2_id = transform.trans_id_tree_path('bar2')
1109
os.stat = instrumented_stat
1110
transform.create_file('bar2 contents\n', bar2_id, mode_id=bar1_id)
1113
transform.finalize()
1115
bar1_abspath = self.wt.abspath('bar')
1116
self.assertEqual([bar1_abspath], stat_paths)
1118
def test_iter_changes(self):
1119
self.wt.set_root_id('eert_toor')
1120
transform, root = self.get_transform()
1121
transform.new_file('old', root, 'blah', 'id-1', True)
1123
transform, root = self.get_transform()
1125
self.assertEqual([], list(transform.iter_changes()))
1126
old = transform.trans_id_tree_file_id('id-1')
1127
transform.unversion_file(old)
1128
self.assertEqual([('id-1', ('old', None), False, (True, False),
1129
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1130
(True, True))], list(transform.iter_changes()))
1131
transform.new_directory('new', root, 'id-1')
1132
self.assertEqual([('id-1', ('old', 'new'), True, (True, True),
1133
('eert_toor', 'eert_toor'), ('old', 'new'),
1134
('file', 'directory'),
1135
(True, False))], list(transform.iter_changes()))
1137
transform.finalize()
1139
def test_iter_changes_new(self):
1140
self.wt.set_root_id('eert_toor')
1141
transform, root = self.get_transform()
1142
transform.new_file('old', root, 'blah')
1144
transform, root = self.get_transform()
1146
old = transform.trans_id_tree_path('old')
1147
transform.version_file('id-1', old)
1148
self.assertEqual([('id-1', (None, 'old'), False, (False, True),
1149
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1150
(False, False))], list(transform.iter_changes()))
1152
transform.finalize()
1154
def test_iter_changes_modifications(self):
1155
self.wt.set_root_id('eert_toor')
1156
transform, root = self.get_transform()
1157
transform.new_file('old', root, 'blah', 'id-1')
1158
transform.new_file('new', root, 'blah')
1159
transform.new_directory('subdir', root, 'subdir-id')
1161
transform, root = self.get_transform()
1163
old = transform.trans_id_tree_path('old')
1164
subdir = transform.trans_id_tree_file_id('subdir-id')
1165
new = transform.trans_id_tree_path('new')
1166
self.assertEqual([], list(transform.iter_changes()))
1169
transform.delete_contents(old)
1170
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1171
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', None),
1172
(False, False))], list(transform.iter_changes()))
1175
transform.create_file('blah', old)
1176
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1177
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1178
(False, False))], list(transform.iter_changes()))
1179
transform.cancel_deletion(old)
1180
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1181
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1182
(False, False))], list(transform.iter_changes()))
1183
transform.cancel_creation(old)
1185
# move file_id to a different file
1186
self.assertEqual([], list(transform.iter_changes()))
1187
transform.unversion_file(old)
1188
transform.version_file('id-1', new)
1189
transform.adjust_path('old', root, new)
1190
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1191
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1192
(False, False))], list(transform.iter_changes()))
1193
transform.cancel_versioning(new)
1194
transform._removed_id = set()
1197
self.assertEqual([], list(transform.iter_changes()))
1198
transform.set_executability(True, old)
1199
self.assertEqual([('id-1', ('old', 'old'), False, (True, True),
1200
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1201
(False, True))], list(transform.iter_changes()))
1202
transform.set_executability(None, old)
1205
self.assertEqual([], list(transform.iter_changes()))
1206
transform.adjust_path('new', root, old)
1207
transform._new_parent = {}
1208
self.assertEqual([('id-1', ('old', 'new'), False, (True, True),
1209
('eert_toor', 'eert_toor'), ('old', 'new'), ('file', 'file'),
1210
(False, False))], list(transform.iter_changes()))
1211
transform._new_name = {}
1214
self.assertEqual([], list(transform.iter_changes()))
1215
transform.adjust_path('new', subdir, old)
1216
transform._new_name = {}
1217
self.assertEqual([('id-1', ('old', 'subdir/old'), False,
1218
(True, True), ('eert_toor', 'subdir-id'), ('old', 'old'),
1219
('file', 'file'), (False, False))],
1220
list(transform.iter_changes()))
1221
transform._new_path = {}
1224
transform.finalize()
1226
def test_iter_changes_modified_bleed(self):
1227
self.wt.set_root_id('eert_toor')
1228
"""Modified flag should not bleed from one change to another"""
1229
# unfortunately, we have no guarantee that file1 (which is modified)
1230
# will be applied before file2. And if it's applied after file2, it
1231
# obviously can't bleed into file2's change output. But for now, it
1233
transform, root = self.get_transform()
1234
transform.new_file('file1', root, 'blah', 'id-1')
1235
transform.new_file('file2', root, 'blah', 'id-2')
1237
transform, root = self.get_transform()
1239
transform.delete_contents(transform.trans_id_file_id('id-1'))
1240
transform.set_executability(True,
1241
transform.trans_id_file_id('id-2'))
1242
self.assertEqual([('id-1', (u'file1', u'file1'), True, (True, True),
1243
('eert_toor', 'eert_toor'), ('file1', u'file1'),
1244
('file', None), (False, False)),
1245
('id-2', (u'file2', u'file2'), False, (True, True),
1246
('eert_toor', 'eert_toor'), ('file2', u'file2'),
1247
('file', 'file'), (False, True))],
1248
list(transform.iter_changes()))
1250
transform.finalize()
1252
def test_iter_changes_move_missing(self):
1253
"""Test moving ids with no files around"""
1254
self.wt.set_root_id('toor_eert')
1255
# Need two steps because versioning a non-existant file is a conflict.
1256
transform, root = self.get_transform()
1257
transform.new_directory('floater', root, 'floater-id')
1259
transform, root = self.get_transform()
1260
transform.delete_contents(transform.trans_id_tree_path('floater'))
1262
transform, root = self.get_transform()
1263
floater = transform.trans_id_tree_path('floater')
1265
transform.adjust_path('flitter', root, floater)
1266
self.assertEqual([('floater-id', ('floater', 'flitter'), False,
1267
(True, True), ('toor_eert', 'toor_eert'), ('floater', 'flitter'),
1268
(None, None), (False, False))], list(transform.iter_changes()))
1270
transform.finalize()
1272
def test_iter_changes_pointless(self):
1273
"""Ensure that no-ops are not treated as modifications"""
1274
self.wt.set_root_id('eert_toor')
1275
transform, root = self.get_transform()
1276
transform.new_file('old', root, 'blah', 'id-1')
1277
transform.new_directory('subdir', root, 'subdir-id')
1279
transform, root = self.get_transform()
1281
old = transform.trans_id_tree_path('old')
1282
subdir = transform.trans_id_tree_file_id('subdir-id')
1283
self.assertEqual([], list(transform.iter_changes()))
1284
transform.delete_contents(subdir)
1285
transform.create_directory(subdir)
1286
transform.set_executability(False, old)
1287
transform.unversion_file(old)
1288
transform.version_file('id-1', old)
1289
transform.adjust_path('old', root, old)
1290
self.assertEqual([], list(transform.iter_changes()))
1292
transform.finalize()
1294
def test_rename_count(self):
1295
transform, root = self.get_transform()
1296
transform.new_file('name1', root, 'contents')
1297
self.assertEqual(transform.rename_count, 0)
1299
self.assertEqual(transform.rename_count, 1)
1300
transform2, root = self.get_transform()
1301
transform2.adjust_path('name2', root,
1302
transform2.trans_id_tree_path('name1'))
1303
self.assertEqual(transform2.rename_count, 0)
1305
self.assertEqual(transform2.rename_count, 2)
1307
def test_change_parent(self):
1308
"""Ensure that after we change a parent, the results are still right.
1310
Renames and parent changes on pending transforms can happen as part
1311
of conflict resolution, and are explicitly permitted by the
1314
This test ensures they work correctly with the rename-avoidance
1317
transform, root = self.get_transform()
1318
parent1 = transform.new_directory('parent1', root)
1319
child1 = transform.new_file('child1', parent1, 'contents')
1320
parent2 = transform.new_directory('parent2', root)
1321
transform.adjust_path('child1', parent2, child1)
1323
self.assertPathDoesNotExist(self.wt.abspath('parent1/child1'))
1324
self.assertPathExists(self.wt.abspath('parent2/child1'))
1325
# rename limbo/new-1 => parent1, rename limbo/new-3 => parent2
1326
# no rename for child1 (counting only renames during apply)
1327
self.assertEqual(2, transform.rename_count)
1329
def test_cancel_parent(self):
1330
"""Cancelling a parent doesn't cause deletion of a non-empty directory
1332
This is like the test_change_parent, except that we cancel the parent
1333
before adjusting the path. The transform must detect that the
1334
directory is non-empty, and move children to safe locations.
1336
transform, root = self.get_transform()
1337
parent1 = transform.new_directory('parent1', root)
1338
child1 = transform.new_file('child1', parent1, 'contents')
1339
child2 = transform.new_file('child2', parent1, 'contents')
1341
transform.cancel_creation(parent1)
1343
self.fail('Failed to move child1 before deleting parent1')
1344
transform.cancel_creation(child2)
1345
transform.create_directory(parent1)
1347
transform.cancel_creation(parent1)
1348
# If the transform incorrectly believes that child2 is still in
1349
# parent1's limbo directory, it will try to rename it and fail
1350
# because was already moved by the first cancel_creation.
1352
self.fail('Transform still thinks child2 is a child of parent1')
1353
parent2 = transform.new_directory('parent2', root)
1354
transform.adjust_path('child1', parent2, child1)
1356
self.assertPathDoesNotExist(self.wt.abspath('parent1'))
1357
self.assertPathExists(self.wt.abspath('parent2/child1'))
1358
# rename limbo/new-3 => parent2, rename limbo/new-2 => child1
1359
self.assertEqual(2, transform.rename_count)
1361
def test_adjust_and_cancel(self):
1362
"""Make sure adjust_path keeps track of limbo children properly"""
1363
transform, root = self.get_transform()
1364
parent1 = transform.new_directory('parent1', root)
1365
child1 = transform.new_file('child1', parent1, 'contents')
1366
parent2 = transform.new_directory('parent2', root)
1367
transform.adjust_path('child1', parent2, child1)
1368
transform.cancel_creation(child1)
1370
transform.cancel_creation(parent1)
1371
# if the transform thinks child1 is still in parent1's limbo
1372
# directory, it will attempt to move it and fail.
1374
self.fail('Transform still thinks child1 is a child of parent1')
1375
transform.finalize()
1377
def test_noname_contents(self):
1378
"""TreeTransform should permit deferring naming files."""
1379
transform, root = self.get_transform()
1380
parent = transform.trans_id_file_id('parent-id')
1382
transform.create_directory(parent)
1384
self.fail("Can't handle contents with no name")
1385
transform.finalize()
1387
def test_noname_contents_nested(self):
1388
"""TreeTransform should permit deferring naming files."""
1389
transform, root = self.get_transform()
1390
parent = transform.trans_id_file_id('parent-id')
1392
transform.create_directory(parent)
1394
self.fail("Can't handle contents with no name")
1395
child = transform.new_directory('child', parent)
1396
transform.adjust_path('parent', root, parent)
1398
self.assertPathExists(self.wt.abspath('parent/child'))
1399
self.assertEqual(1, transform.rename_count)
1401
def test_reuse_name(self):
1402
"""Avoid reusing the same limbo name for different files"""
1403
transform, root = self.get_transform()
1404
parent = transform.new_directory('parent', root)
1405
child1 = transform.new_directory('child', parent)
1407
child2 = transform.new_directory('child', parent)
1409
self.fail('Tranform tried to use the same limbo name twice')
1410
transform.adjust_path('child2', parent, child2)
1412
# limbo/new-1 => parent, limbo/new-3 => parent/child2
1413
# child2 is put into top-level limbo because child1 has already
1414
# claimed the direct limbo path when child2 is created. There is no
1415
# advantage in renaming files once they're in top-level limbo, except
1417
self.assertEqual(2, transform.rename_count)
1419
def test_reuse_when_first_moved(self):
1420
"""Don't avoid direct paths when it is safe to use them"""
1421
transform, root = self.get_transform()
1422
parent = transform.new_directory('parent', root)
1423
child1 = transform.new_directory('child', parent)
1424
transform.adjust_path('child1', parent, child1)
1425
child2 = transform.new_directory('child', parent)
1427
# limbo/new-1 => parent
1428
self.assertEqual(1, transform.rename_count)
1430
def test_reuse_after_cancel(self):
1431
"""Don't avoid direct paths when it is safe to use them"""
1432
transform, root = self.get_transform()
1433
parent2 = transform.new_directory('parent2', root)
1434
child1 = transform.new_directory('child1', parent2)
1435
transform.cancel_creation(parent2)
1436
transform.create_directory(parent2)
1437
child2 = transform.new_directory('child1', parent2)
1438
transform.adjust_path('child2', parent2, child1)
1440
# limbo/new-1 => parent2, limbo/new-2 => parent2/child1
1441
self.assertEqual(2, transform.rename_count)
1443
def test_finalize_order(self):
1444
"""Finalize must be done in child-to-parent order"""
1445
transform, root = self.get_transform()
1446
parent = transform.new_directory('parent', root)
1447
child = transform.new_directory('child', parent)
1449
transform.finalize()
1451
self.fail('Tried to remove parent before child1')
1453
def test_cancel_with_cancelled_child_should_succeed(self):
1454
transform, root = self.get_transform()
1455
parent = transform.new_directory('parent', root)
1456
child = transform.new_directory('child', parent)
1457
transform.cancel_creation(child)
1458
transform.cancel_creation(parent)
1459
transform.finalize()
1461
def test_rollback_on_directory_clash(self):
1463
wt = self.make_branch_and_tree('.')
1464
tt = TreeTransform(wt) # TreeTransform obtains write lock
1466
foo = tt.new_directory('foo', tt.root)
1467
tt.new_file('bar', foo, 'foobar')
1468
baz = tt.new_directory('baz', tt.root)
1469
tt.new_file('qux', baz, 'quux')
1470
# Ask for a rename 'foo' -> 'baz'
1471
tt.adjust_path('baz', tt.root, foo)
1472
# Lie to tt that we've already resolved all conflicts.
1473
tt.apply(no_conflicts=True)
1477
# The rename will fail because the target directory is not empty (but
1478
# raises FileExists anyway).
1479
err = self.assertRaises(errors.FileExists, tt_helper)
1480
self.assertEndsWith(err.path, "/baz")
1482
def test_two_directories_clash(self):
1484
wt = self.make_branch_and_tree('.')
1485
tt = TreeTransform(wt) # TreeTransform obtains write lock
1487
foo_1 = tt.new_directory('foo', tt.root)
1488
tt.new_directory('bar', foo_1)
1489
# Adding the same directory with a different content
1490
foo_2 = tt.new_directory('foo', tt.root)
1491
tt.new_directory('baz', foo_2)
1492
# Lie to tt that we've already resolved all conflicts.
1493
tt.apply(no_conflicts=True)
1497
err = self.assertRaises(errors.FileExists, tt_helper)
1498
self.assertEndsWith(err.path, "/foo")
1500
def test_two_directories_clash_finalize(self):
1502
wt = self.make_branch_and_tree('.')
1503
tt = TreeTransform(wt) # TreeTransform obtains write lock
1505
foo_1 = tt.new_directory('foo', tt.root)
1506
tt.new_directory('bar', foo_1)
1507
# Adding the same directory with a different content
1508
foo_2 = tt.new_directory('foo', tt.root)
1509
tt.new_directory('baz', foo_2)
1510
# Lie to tt that we've already resolved all conflicts.
1511
tt.apply(no_conflicts=True)
1515
err = self.assertRaises(errors.FileExists, tt_helper)
1516
self.assertEndsWith(err.path, "/foo")
1518
def test_file_to_directory(self):
1519
wt = self.make_branch_and_tree('.')
1520
self.build_tree(['foo'])
1523
tt = TreeTransform(wt)
1524
self.addCleanup(tt.finalize)
1525
foo_trans_id = tt.trans_id_tree_path("foo")
1526
tt.delete_contents(foo_trans_id)
1527
tt.create_directory(foo_trans_id)
1528
bar_trans_id = tt.trans_id_tree_path("foo/bar")
1529
tt.create_file(["aa\n"], bar_trans_id)
1530
tt.version_file("bar-1", bar_trans_id)
1532
self.assertPathExists("foo/bar")
1535
self.assertEqual(wt.kind(wt.path2id("foo")), "directory")
1539
changes = wt.changes_from(wt.basis_tree())
1540
self.assertFalse(changes.has_changed(), changes)
1542
def test_file_to_symlink(self):
1543
self.requireFeature(SymlinkFeature)
1544
wt = self.make_branch_and_tree('.')
1545
self.build_tree(['foo'])
1548
tt = TreeTransform(wt)
1549
self.addCleanup(tt.finalize)
1550
foo_trans_id = tt.trans_id_tree_path("foo")
1551
tt.delete_contents(foo_trans_id)
1552
tt.create_symlink("bar", foo_trans_id)
1554
self.assertPathExists("foo")
1556
self.addCleanup(wt.unlock)
1557
self.assertEqual(wt.kind(wt.path2id("foo")), "symlink")
1559
def test_dir_to_file(self):
1560
wt = self.make_branch_and_tree('.')
1561
self.build_tree(['foo/', 'foo/bar'])
1562
wt.add(['foo', 'foo/bar'])
1564
tt = TreeTransform(wt)
1565
self.addCleanup(tt.finalize)
1566
foo_trans_id = tt.trans_id_tree_path("foo")
1567
bar_trans_id = tt.trans_id_tree_path("foo/bar")
1568
tt.delete_contents(foo_trans_id)
1569
tt.delete_versioned(bar_trans_id)
1570
tt.create_file(["aa\n"], foo_trans_id)
1572
self.assertPathExists("foo")
1574
self.addCleanup(wt.unlock)
1575
self.assertEqual(wt.kind(wt.path2id("foo")), "file")
1577
def test_dir_to_hardlink(self):
1578
self.requireFeature(HardlinkFeature)
1579
wt = self.make_branch_and_tree('.')
1580
self.build_tree(['foo/', 'foo/bar'])
1581
wt.add(['foo', 'foo/bar'])
1583
tt = TreeTransform(wt)
1584
self.addCleanup(tt.finalize)
1585
foo_trans_id = tt.trans_id_tree_path("foo")
1586
bar_trans_id = tt.trans_id_tree_path("foo/bar")
1587
tt.delete_contents(foo_trans_id)
1588
tt.delete_versioned(bar_trans_id)
1589
self.build_tree(['baz'])
1590
tt.create_hardlink("baz", foo_trans_id)
1592
self.assertPathExists("foo")
1593
self.assertPathExists("baz")
1595
self.addCleanup(wt.unlock)
1596
self.assertEqual(wt.kind(wt.path2id("foo")), "file")
1598
def test_no_final_path(self):
1599
transform, root = self.get_transform()
1600
trans_id = transform.trans_id_file_id('foo')
1601
transform.create_file('bar', trans_id)
1602
transform.cancel_creation(trans_id)
1605
def test_create_from_tree(self):
1606
tree1 = self.make_branch_and_tree('tree1')
1607
self.build_tree_contents([('tree1/foo/',), ('tree1/bar', 'baz')])
1608
tree1.add(['foo', 'bar'], ['foo-id', 'bar-id'])
1609
tree2 = self.make_branch_and_tree('tree2')
1610
tt = TreeTransform(tree2)
1611
foo_trans_id = tt.create_path('foo', tt.root)
1612
create_from_tree(tt, foo_trans_id, tree1, 'foo-id')
1613
bar_trans_id = tt.create_path('bar', tt.root)
1614
create_from_tree(tt, bar_trans_id, tree1, 'bar-id')
1616
self.assertEqual('directory', osutils.file_kind('tree2/foo'))
1617
self.assertFileEqual('baz', 'tree2/bar')
1619
def test_create_from_tree_bytes(self):
1620
"""Provided lines are used instead of tree content."""
1621
tree1 = self.make_branch_and_tree('tree1')
1622
self.build_tree_contents([('tree1/foo', 'bar'),])
1623
tree1.add('foo', 'foo-id')
1624
tree2 = self.make_branch_and_tree('tree2')
1625
tt = TreeTransform(tree2)
1626
foo_trans_id = tt.create_path('foo', tt.root)
1627
create_from_tree(tt, foo_trans_id, tree1, 'foo-id', bytes='qux')
1629
self.assertFileEqual('qux', 'tree2/foo')
1631
def test_create_from_tree_symlink(self):
1632
self.requireFeature(SymlinkFeature)
1633
tree1 = self.make_branch_and_tree('tree1')
1634
os.symlink('bar', 'tree1/foo')
1635
tree1.add('foo', 'foo-id')
1636
tt = TreeTransform(self.make_branch_and_tree('tree2'))
1637
foo_trans_id = tt.create_path('foo', tt.root)
1638
create_from_tree(tt, foo_trans_id, tree1, 'foo-id')
1640
self.assertEqual('bar', os.readlink('tree2/foo'))
520
1643
class TransformGroup(object):
521
def __init__(self, dirname):
1645
def __init__(self, dirname, root_id):
522
1646
self.name = dirname
523
1647
os.mkdir(dirname)
524
self.wt = BzrDir.create_standalone_workingtree(dirname)
1648
self.wt = ControlDir.create_standalone_workingtree(dirname)
1649
self.wt.set_root_id(root_id)
525
1650
self.b = self.wt.branch
526
1651
self.tt = TreeTransform(self.wt)
527
1652
self.root = self.tt.trans_id_tree_file_id(self.wt.get_root_id())
529
1655
def conflict_text(tree, merge):
530
1656
template = '%s TREE\n%s%s\n%s%s MERGE-SOURCE\n'
531
1657
return template % ('<' * 7, tree, '=' * 7, merge, '>' * 7)
1660
class TestInventoryAltered(tests.TestCaseWithTransport):
1662
def test_inventory_altered_unchanged(self):
1663
tree = self.make_branch_and_tree('tree')
1664
self.build_tree(['tree/foo'])
1665
tree.add('foo', 'foo-id')
1666
with TransformPreview(tree) as tt:
1667
self.assertEqual([], tt._inventory_altered())
1669
def test_inventory_altered_changed_parent_id(self):
1670
tree = self.make_branch_and_tree('tree')
1671
self.build_tree(['tree/foo'])
1672
tree.add('foo', 'foo-id')
1673
with TransformPreview(tree) as tt:
1674
tt.unversion_file(tt.root)
1675
tt.version_file('new-id', tt.root)
1676
foo_trans_id = tt.trans_id_tree_file_id('foo-id')
1677
foo_tuple = ('foo', foo_trans_id)
1678
root_tuple = ('', tt.root)
1679
self.assertEqual([root_tuple, foo_tuple], tt._inventory_altered())
1681
def test_inventory_altered_noop_changed_parent_id(self):
1682
tree = self.make_branch_and_tree('tree')
1683
self.build_tree(['tree/foo'])
1684
tree.add('foo', 'foo-id')
1685
with TransformPreview(tree) as tt:
1686
tt.unversion_file(tt.root)
1687
tt.version_file(tree.get_root_id(), tt.root)
1688
foo_trans_id = tt.trans_id_tree_file_id('foo-id')
1689
self.assertEqual([], tt._inventory_altered())
534
1692
class TestTransformMerge(TestCaseInTempDir):
535
1694
def test_text_merge(self):
536
base = TransformGroup("base")
1695
root_id = generate_ids.gen_root_id()
1696
base = TransformGroup("base", root_id)
537
1697
base.tt.new_file('a', base.root, 'a\nb\nc\nd\be\n', 'a')
538
1698
base.tt.new_file('b', base.root, 'b1', 'b')
539
1699
base.tt.new_file('c', base.root, 'c', 'c')
712
1875
self.assertIs(os.path.lexists(this.wt.abspath('b/h1.OTHER')), False)
713
1876
self.assertEqual(this.wt.id2path('i'), pathjoin('b/i1.OTHER'))
715
class TestBuildTree(TestCaseInTempDir):
716
def test_build_tree(self):
717
if not has_symlinks():
718
raise TestSkipped('Test requires symlink support')
1879
class TestBuildTree(tests.TestCaseWithTransport):
1881
def test_build_tree_with_symlinks(self):
1882
self.requireFeature(SymlinkFeature)
720
a = BzrDir.create_standalone_workingtree('a')
1884
a = ControlDir.create_standalone_workingtree('a')
721
1885
os.mkdir('a/foo')
722
file('a/foo/bar', 'wb').write('contents')
1886
with file('a/foo/bar', 'wb') as f: f.write('contents')
723
1887
os.symlink('a/foo/bar', 'a/foo/baz')
724
1888
a.add(['foo', 'foo/bar', 'foo/baz'])
725
1889
a.commit('initial commit')
726
b = BzrDir.create_standalone_workingtree('b')
727
build_tree(a.basis_tree(), b)
1890
b = ControlDir.create_standalone_workingtree('b')
1891
basis = a.basis_tree()
1893
self.addCleanup(basis.unlock)
1894
build_tree(basis, b)
728
1895
self.assertIs(os.path.isdir('b/foo'), True)
729
1896
self.assertEqual(file('b/foo/bar', 'rb').read(), "contents")
730
1897
self.assertEqual(os.readlink('b/foo/baz'), 'a/foo/bar')
732
class MockTransform(object):
734
def has_named_child(self, by_parent, parent_id, name):
735
for child_id in by_parent[parent_id]:
739
elif name == "name.~%s~" % child_id:
743
class MockEntry(object):
745
object.__init__(self)
748
class TestGetBackupName(TestCase):
749
def test_get_backup_name(self):
751
name = get_backup_name(MockEntry(), {'a':[]}, 'a', tt)
752
self.assertEqual(name, 'name.~1~')
753
name = get_backup_name(MockEntry(), {'a':['1']}, 'a', tt)
754
self.assertEqual(name, 'name.~2~')
755
name = get_backup_name(MockEntry(), {'a':['2']}, 'a', tt)
756
self.assertEqual(name, 'name.~1~')
757
name = get_backup_name(MockEntry(), {'a':['2'], 'b':[]}, 'b', tt)
758
self.assertEqual(name, 'name.~1~')
759
name = get_backup_name(MockEntry(), {'a':['1', '2', '3']}, 'a', tt)
760
self.assertEqual(name, 'name.~4~')
1899
def test_build_with_references(self):
1900
tree = self.make_branch_and_tree('source',
1901
format='development-subtree')
1902
subtree = self.make_branch_and_tree('source/subtree',
1903
format='development-subtree')
1904
tree.add_reference(subtree)
1905
tree.commit('a revision')
1906
tree.branch.create_checkout('target')
1907
self.assertPathExists('target')
1908
self.assertPathExists('target/subtree')
1910
def test_file_conflict_handling(self):
1911
"""Ensure that when building trees, conflict handling is done"""
1912
source = self.make_branch_and_tree('source')
1913
target = self.make_branch_and_tree('target')
1914
self.build_tree(['source/file', 'target/file'])
1915
source.add('file', 'new-file')
1916
source.commit('added file')
1917
build_tree(source.basis_tree(), target)
1918
self.assertEqual([DuplicateEntry('Moved existing file to',
1919
'file.moved', 'file', None, 'new-file')],
1921
target2 = self.make_branch_and_tree('target2')
1922
target_file = file('target2/file', 'wb')
1924
source_file = file('source/file', 'rb')
1926
target_file.write(source_file.read())
1931
build_tree(source.basis_tree(), target2)
1932
self.assertEqual([], target2.conflicts())
1934
def test_symlink_conflict_handling(self):
1935
"""Ensure that when building trees, conflict handling is done"""
1936
self.requireFeature(SymlinkFeature)
1937
source = self.make_branch_and_tree('source')
1938
os.symlink('foo', 'source/symlink')
1939
source.add('symlink', 'new-symlink')
1940
source.commit('added file')
1941
target = self.make_branch_and_tree('target')
1942
os.symlink('bar', 'target/symlink')
1943
build_tree(source.basis_tree(), target)
1944
self.assertEqual([DuplicateEntry('Moved existing file to',
1945
'symlink.moved', 'symlink', None, 'new-symlink')],
1947
target = self.make_branch_and_tree('target2')
1948
os.symlink('foo', 'target2/symlink')
1949
build_tree(source.basis_tree(), target)
1950
self.assertEqual([], target.conflicts())
1952
def test_directory_conflict_handling(self):
1953
"""Ensure that when building trees, conflict handling is done"""
1954
source = self.make_branch_and_tree('source')
1955
target = self.make_branch_and_tree('target')
1956
self.build_tree(['source/dir1/', 'source/dir1/file', 'target/dir1/'])
1957
source.add(['dir1', 'dir1/file'], ['new-dir1', 'new-file'])
1958
source.commit('added file')
1959
build_tree(source.basis_tree(), target)
1960
self.assertEqual([], target.conflicts())
1961
self.assertPathExists('target/dir1/file')
1963
# Ensure contents are merged
1964
target = self.make_branch_and_tree('target2')
1965
self.build_tree(['target2/dir1/', 'target2/dir1/file2'])
1966
build_tree(source.basis_tree(), target)
1967
self.assertEqual([], target.conflicts())
1968
self.assertPathExists('target2/dir1/file2')
1969
self.assertPathExists('target2/dir1/file')
1971
# Ensure new contents are suppressed for existing branches
1972
target = self.make_branch_and_tree('target3')
1973
self.make_branch('target3/dir1')
1974
self.build_tree(['target3/dir1/file2'])
1975
build_tree(source.basis_tree(), target)
1976
self.assertPathDoesNotExist('target3/dir1/file')
1977
self.assertPathExists('target3/dir1/file2')
1978
self.assertPathExists('target3/dir1.diverted/file')
1979
self.assertEqual([DuplicateEntry('Diverted to',
1980
'dir1.diverted', 'dir1', 'new-dir1', None)],
1983
target = self.make_branch_and_tree('target4')
1984
self.build_tree(['target4/dir1/'])
1985
self.make_branch('target4/dir1/file')
1986
build_tree(source.basis_tree(), target)
1987
self.assertPathExists('target4/dir1/file')
1988
self.assertEqual('directory', file_kind('target4/dir1/file'))
1989
self.assertPathExists('target4/dir1/file.diverted')
1990
self.assertEqual([DuplicateEntry('Diverted to',
1991
'dir1/file.diverted', 'dir1/file', 'new-file', None)],
1994
def test_mixed_conflict_handling(self):
1995
"""Ensure that when building trees, conflict handling is done"""
1996
source = self.make_branch_and_tree('source')
1997
target = self.make_branch_and_tree('target')
1998
self.build_tree(['source/name', 'target/name/'])
1999
source.add('name', 'new-name')
2000
source.commit('added file')
2001
build_tree(source.basis_tree(), target)
2002
self.assertEqual([DuplicateEntry('Moved existing file to',
2003
'name.moved', 'name', None, 'new-name')], target.conflicts())
2005
def test_raises_in_populated(self):
2006
source = self.make_branch_and_tree('source')
2007
self.build_tree(['source/name'])
2009
source.commit('added name')
2010
target = self.make_branch_and_tree('target')
2011
self.build_tree(['target/name'])
2013
self.assertRaises(errors.WorkingTreeAlreadyPopulated,
2014
build_tree, source.basis_tree(), target)
2016
def test_build_tree_rename_count(self):
2017
source = self.make_branch_and_tree('source')
2018
self.build_tree(['source/file1', 'source/dir1/'])
2019
source.add(['file1', 'dir1'])
2020
source.commit('add1')
2021
target1 = self.make_branch_and_tree('target1')
2022
transform_result = build_tree(source.basis_tree(), target1)
2023
self.assertEqual(2, transform_result.rename_count)
2025
self.build_tree(['source/dir1/file2'])
2026
source.add(['dir1/file2'])
2027
source.commit('add3')
2028
target2 = self.make_branch_and_tree('target2')
2029
transform_result = build_tree(source.basis_tree(), target2)
2030
# children of non-root directories should not be renamed
2031
self.assertEqual(2, transform_result.rename_count)
2033
def create_ab_tree(self):
2034
"""Create a committed test tree with two files"""
2035
source = self.make_branch_and_tree('source')
2036
self.build_tree_contents([('source/file1', 'A')])
2037
self.build_tree_contents([('source/file2', 'B')])
2038
source.add(['file1', 'file2'], ['file1-id', 'file2-id'])
2039
source.commit('commit files')
2041
self.addCleanup(source.unlock)
2044
def test_build_tree_accelerator_tree(self):
2045
source = self.create_ab_tree()
2046
self.build_tree_contents([('source/file2', 'C')])
2048
real_source_get_file = source.get_file
2049
def get_file(file_id, path=None):
2050
calls.append(file_id)
2051
return real_source_get_file(file_id, path)
2052
source.get_file = get_file
2053
target = self.make_branch_and_tree('target')
2054
revision_tree = source.basis_tree()
2055
revision_tree.lock_read()
2056
self.addCleanup(revision_tree.unlock)
2057
build_tree(revision_tree, target, source)
2058
self.assertEqual(['file1-id'], calls)
2060
self.addCleanup(target.unlock)
2061
self.assertEqual([], list(target.iter_changes(revision_tree)))
2063
def test_build_tree_accelerator_tree_observes_sha1(self):
2064
source = self.create_ab_tree()
2065
sha1 = osutils.sha_string('A')
2066
target = self.make_branch_and_tree('target')
2068
self.addCleanup(target.unlock)
2069
state = target.current_dirstate()
2070
state._cutoff_time = time.time() + 60
2071
build_tree(source.basis_tree(), target, source)
2072
entry = state._get_entry(0, path_utf8='file1')
2073
self.assertEqual(sha1, entry[1][0][1])
2075
def test_build_tree_accelerator_tree_missing_file(self):
2076
source = self.create_ab_tree()
2077
os.unlink('source/file1')
2078
source.remove(['file2'])
2079
target = self.make_branch_and_tree('target')
2080
revision_tree = source.basis_tree()
2081
revision_tree.lock_read()
2082
self.addCleanup(revision_tree.unlock)
2083
build_tree(revision_tree, target, source)
2085
self.addCleanup(target.unlock)
2086
self.assertEqual([], list(target.iter_changes(revision_tree)))
2088
def test_build_tree_accelerator_wrong_kind(self):
2089
self.requireFeature(SymlinkFeature)
2090
source = self.make_branch_and_tree('source')
2091
self.build_tree_contents([('source/file1', '')])
2092
self.build_tree_contents([('source/file2', '')])
2093
source.add(['file1', 'file2'], ['file1-id', 'file2-id'])
2094
source.commit('commit files')
2095
os.unlink('source/file2')
2096
self.build_tree_contents([('source/file2/', 'C')])
2097
os.unlink('source/file1')
2098
os.symlink('file2', 'source/file1')
2100
real_source_get_file = source.get_file
2101
def get_file(file_id, path=None):
2102
calls.append(file_id)
2103
return real_source_get_file(file_id, path)
2104
source.get_file = get_file
2105
target = self.make_branch_and_tree('target')
2106
revision_tree = source.basis_tree()
2107
revision_tree.lock_read()
2108
self.addCleanup(revision_tree.unlock)
2109
build_tree(revision_tree, target, source)
2110
self.assertEqual([], calls)
2112
self.addCleanup(target.unlock)
2113
self.assertEqual([], list(target.iter_changes(revision_tree)))
2115
def test_build_tree_hardlink(self):
2116
self.requireFeature(HardlinkFeature)
2117
source = self.create_ab_tree()
2118
target = self.make_branch_and_tree('target')
2119
revision_tree = source.basis_tree()
2120
revision_tree.lock_read()
2121
self.addCleanup(revision_tree.unlock)
2122
build_tree(revision_tree, target, source, hardlink=True)
2124
self.addCleanup(target.unlock)
2125
self.assertEqual([], list(target.iter_changes(revision_tree)))
2126
source_stat = os.stat('source/file1')
2127
target_stat = os.stat('target/file1')
2128
self.assertEqual(source_stat, target_stat)
2130
# Explicitly disallowing hardlinks should prevent them.
2131
target2 = self.make_branch_and_tree('target2')
2132
build_tree(revision_tree, target2, source, hardlink=False)
2134
self.addCleanup(target2.unlock)
2135
self.assertEqual([], list(target2.iter_changes(revision_tree)))
2136
source_stat = os.stat('source/file1')
2137
target2_stat = os.stat('target2/file1')
2138
self.assertNotEqual(source_stat, target2_stat)
2140
def test_build_tree_accelerator_tree_moved(self):
2141
source = self.make_branch_and_tree('source')
2142
self.build_tree_contents([('source/file1', 'A')])
2143
source.add(['file1'], ['file1-id'])
2144
source.commit('commit files')
2145
source.rename_one('file1', 'file2')
2147
self.addCleanup(source.unlock)
2148
target = self.make_branch_and_tree('target')
2149
revision_tree = source.basis_tree()
2150
revision_tree.lock_read()
2151
self.addCleanup(revision_tree.unlock)
2152
build_tree(revision_tree, target, source)
2154
self.addCleanup(target.unlock)
2155
self.assertEqual([], list(target.iter_changes(revision_tree)))
2157
def test_build_tree_hardlinks_preserve_execute(self):
2158
self.requireFeature(HardlinkFeature)
2159
source = self.create_ab_tree()
2160
tt = TreeTransform(source)
2161
trans_id = tt.trans_id_tree_file_id('file1-id')
2162
tt.set_executability(True, trans_id)
2164
self.assertTrue(source.is_executable('file1-id'))
2165
target = self.make_branch_and_tree('target')
2166
revision_tree = source.basis_tree()
2167
revision_tree.lock_read()
2168
self.addCleanup(revision_tree.unlock)
2169
build_tree(revision_tree, target, source, hardlink=True)
2171
self.addCleanup(target.unlock)
2172
self.assertEqual([], list(target.iter_changes(revision_tree)))
2173
self.assertTrue(source.is_executable('file1-id'))
2175
def install_rot13_content_filter(self, pattern):
2177
# self.addCleanup(filters._reset_registry, filters._reset_registry())
2178
# below, but that looks a bit... hard to read even if it's exactly
2180
original_registry = filters._reset_registry()
2181
def restore_registry():
2182
filters._reset_registry(original_registry)
2183
self.addCleanup(restore_registry)
2184
def rot13(chunks, context=None):
2185
return [''.join(chunks).encode('rot13')]
2186
rot13filter = filters.ContentFilter(rot13, rot13)
2187
filters.filter_stacks_registry.register(
2188
'rot13', {'yes': [rot13filter]}.get)
2189
os.mkdir(self.test_home_dir + '/.bazaar')
2190
rules_filename = self.test_home_dir + '/.bazaar/rules'
2191
f = open(rules_filename, 'wb')
2192
f.write('[name %s]\nrot13=yes\n' % (pattern,))
2194
def uninstall_rules():
2195
os.remove(rules_filename)
2197
self.addCleanup(uninstall_rules)
2200
def test_build_tree_content_filtered_files_are_not_hardlinked(self):
2201
"""build_tree will not hardlink files that have content filtering rules
2202
applied to them (but will still hardlink other files from the same tree
2205
self.requireFeature(HardlinkFeature)
2206
self.install_rot13_content_filter('file1')
2207
source = self.create_ab_tree()
2208
target = self.make_branch_and_tree('target')
2209
revision_tree = source.basis_tree()
2210
revision_tree.lock_read()
2211
self.addCleanup(revision_tree.unlock)
2212
build_tree(revision_tree, target, source, hardlink=True)
2214
self.addCleanup(target.unlock)
2215
self.assertEqual([], list(target.iter_changes(revision_tree)))
2216
source_stat = os.stat('source/file1')
2217
target_stat = os.stat('target/file1')
2218
self.assertNotEqual(source_stat, target_stat)
2219
source_stat = os.stat('source/file2')
2220
target_stat = os.stat('target/file2')
2221
self.assertEqualStat(source_stat, target_stat)
2223
def test_case_insensitive_build_tree_inventory(self):
2224
if (features.CaseInsensitiveFilesystemFeature.available()
2225
or features.CaseInsCasePresFilenameFeature.available()):
2226
raise tests.UnavailableFeature('Fully case sensitive filesystem')
2227
source = self.make_branch_and_tree('source')
2228
self.build_tree(['source/file', 'source/FILE'])
2229
source.add(['file', 'FILE'], ['lower-id', 'upper-id'])
2230
source.commit('added files')
2231
# Don't try this at home, kids!
2232
# Force the tree to report that it is case insensitive
2233
target = self.make_branch_and_tree('target')
2234
target.case_sensitive = False
2235
build_tree(source.basis_tree(), target, source, delta_from_tree=True)
2236
self.assertEqual('file.moved', target.id2path('lower-id'))
2237
self.assertEqual('FILE', target.id2path('upper-id'))
2239
def test_build_tree_observes_sha(self):
2240
source = self.make_branch_and_tree('source')
2241
self.build_tree(['source/file1', 'source/dir/', 'source/dir/file2'])
2242
source.add(['file1', 'dir', 'dir/file2'],
2243
['file1-id', 'dir-id', 'file2-id'])
2244
source.commit('new files')
2245
target = self.make_branch_and_tree('target')
2247
self.addCleanup(target.unlock)
2248
# We make use of the fact that DirState caches its cutoff time. So we
2249
# set the 'safe' time to one minute in the future.
2250
state = target.current_dirstate()
2251
state._cutoff_time = time.time() + 60
2252
build_tree(source.basis_tree(), target)
2253
entry1_sha = osutils.sha_file_by_name('source/file1')
2254
entry2_sha = osutils.sha_file_by_name('source/dir/file2')
2255
# entry[1] is the state information, entry[1][0] is the state of the
2256
# working tree, entry[1][0][1] is the sha value for the current working
2258
entry1 = state._get_entry(0, path_utf8='file1')
2259
self.assertEqual(entry1_sha, entry1[1][0][1])
2260
# The 'size' field must also be set.
2261
self.assertEqual(25, entry1[1][0][2])
2262
entry1_state = entry1[1][0]
2263
entry2 = state._get_entry(0, path_utf8='dir/file2')
2264
self.assertEqual(entry2_sha, entry2[1][0][1])
2265
self.assertEqual(29, entry2[1][0][2])
2266
entry2_state = entry2[1][0]
2267
# Now, make sure that we don't have to re-read the content. The
2268
# packed_stat should match exactly.
2269
self.assertEqual(entry1_sha, target.get_file_sha1('file1-id', 'file1'))
2270
self.assertEqual(entry2_sha,
2271
target.get_file_sha1('file2-id', 'dir/file2'))
2272
self.assertEqual(entry1_state, entry1[1][0])
2273
self.assertEqual(entry2_state, entry2[1][0])
2276
class TestCommitTransform(tests.TestCaseWithTransport):
2278
def get_branch(self):
2279
tree = self.make_branch_and_tree('tree')
2281
self.addCleanup(tree.unlock)
2282
tree.commit('empty commit')
2285
def get_branch_and_transform(self):
2286
branch = self.get_branch()
2287
tt = TransformPreview(branch.basis_tree())
2288
self.addCleanup(tt.finalize)
2291
def test_commit_wrong_basis(self):
2292
branch = self.get_branch()
2293
basis = branch.repository.revision_tree(
2294
_mod_revision.NULL_REVISION)
2295
tt = TransformPreview(basis)
2296
self.addCleanup(tt.finalize)
2297
e = self.assertRaises(ValueError, tt.commit, branch, '')
2298
self.assertEqual('TreeTransform not based on branch basis: null:',
2301
def test_empy_commit(self):
2302
branch, tt = self.get_branch_and_transform()
2303
rev = tt.commit(branch, 'my message')
2304
self.assertEqual(2, branch.revno())
2305
repo = branch.repository
2306
self.assertEqual('my message', repo.get_revision(rev).message)
2308
def test_merge_parents(self):
2309
branch, tt = self.get_branch_and_transform()
2310
rev = tt.commit(branch, 'my message', ['rev1b', 'rev1c'])
2311
self.assertEqual(['rev1b', 'rev1c'],
2312
branch.basis_tree().get_parent_ids()[1:])
2314
def test_first_commit(self):
2315
branch = self.make_branch('branch')
2317
self.addCleanup(branch.unlock)
2318
tt = TransformPreview(branch.basis_tree())
2319
self.addCleanup(tt.finalize)
2320
tt.new_directory('', ROOT_PARENT, 'TREE_ROOT')
2321
rev = tt.commit(branch, 'my message')
2322
self.assertEqual([], branch.basis_tree().get_parent_ids())
2323
self.assertNotEqual(_mod_revision.NULL_REVISION,
2324
branch.last_revision())
2326
def test_first_commit_with_merge_parents(self):
2327
branch = self.make_branch('branch')
2329
self.addCleanup(branch.unlock)
2330
tt = TransformPreview(branch.basis_tree())
2331
self.addCleanup(tt.finalize)
2332
e = self.assertRaises(ValueError, tt.commit, branch,
2333
'my message', ['rev1b-id'])
2334
self.assertEqual('Cannot supply merge parents for first commit.',
2336
self.assertEqual(_mod_revision.NULL_REVISION, branch.last_revision())
2338
def test_add_files(self):
2339
branch, tt = self.get_branch_and_transform()
2340
tt.new_file('file', tt.root, 'contents', 'file-id')
2341
trans_id = tt.new_directory('dir', tt.root, 'dir-id')
2342
if SymlinkFeature.available():
2343
tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')
2344
rev = tt.commit(branch, 'message')
2345
tree = branch.basis_tree()
2346
self.assertEqual('file', tree.id2path('file-id'))
2347
self.assertEqual('contents', tree.get_file_text('file-id'))
2348
self.assertEqual('dir', tree.id2path('dir-id'))
2349
if SymlinkFeature.available():
2350
self.assertEqual('dir/symlink', tree.id2path('symlink-id'))
2351
self.assertEqual('target', tree.get_symlink_target('symlink-id'))
2353
def test_add_unversioned(self):
2354
branch, tt = self.get_branch_and_transform()
2355
tt.new_file('file', tt.root, 'contents')
2356
self.assertRaises(errors.StrictCommitFailed, tt.commit, branch,
2357
'message', strict=True)
2359
def test_modify_strict(self):
2360
branch, tt = self.get_branch_and_transform()
2361
tt.new_file('file', tt.root, 'contents', 'file-id')
2362
tt.commit(branch, 'message', strict=True)
2363
tt = TransformPreview(branch.basis_tree())
2364
self.addCleanup(tt.finalize)
2365
trans_id = tt.trans_id_file_id('file-id')
2366
tt.delete_contents(trans_id)
2367
tt.create_file('contents', trans_id)
2368
tt.commit(branch, 'message', strict=True)
2370
def test_commit_malformed(self):
2371
"""Committing a malformed transform should raise an exception.
2373
In this case, we are adding a file without adding its parent.
2375
branch, tt = self.get_branch_and_transform()
2376
parent_id = tt.trans_id_file_id('parent-id')
2377
tt.new_file('file', parent_id, 'contents', 'file-id')
2378
self.assertRaises(errors.MalformedTransform, tt.commit, branch,
2381
def test_commit_rich_revision_data(self):
2382
branch, tt = self.get_branch_and_transform()
2383
rev_id = tt.commit(branch, 'message', timestamp=1, timezone=43201,
2384
committer='me <me@example.com>',
2385
revprops={'foo': 'bar'}, revision_id='revid-1',
2386
authors=['Author1 <author1@example.com>',
2387
'Author2 <author2@example.com>',
2389
self.assertEqual('revid-1', rev_id)
2390
revision = branch.repository.get_revision(rev_id)
2391
self.assertEqual(1, revision.timestamp)
2392
self.assertEqual(43201, revision.timezone)
2393
self.assertEqual('me <me@example.com>', revision.committer)
2394
self.assertEqual(['Author1 <author1@example.com>',
2395
'Author2 <author2@example.com>'],
2396
revision.get_apparent_authors())
2397
del revision.properties['authors']
2398
self.assertEqual({'foo': 'bar',
2399
'branch-nick': 'tree'},
2400
revision.properties)
2402
def test_no_explicit_revprops(self):
2403
branch, tt = self.get_branch_and_transform()
2404
rev_id = tt.commit(branch, 'message', authors=[
2405
'Author1 <author1@example.com>',
2406
'Author2 <author2@example.com>', ])
2407
revision = branch.repository.get_revision(rev_id)
2408
self.assertEqual(['Author1 <author1@example.com>',
2409
'Author2 <author2@example.com>'],
2410
revision.get_apparent_authors())
2411
self.assertEqual('tree', revision.properties['branch-nick'])
2414
class TestFileMover(tests.TestCaseWithTransport):
2416
def test_file_mover(self):
2417
self.build_tree(['a/', 'a/b', 'c/', 'c/d'])
2418
mover = _FileMover()
2419
mover.rename('a', 'q')
2420
self.assertPathExists('q')
2421
self.assertPathDoesNotExist('a')
2422
self.assertPathExists('q/b')
2423
self.assertPathExists('c')
2424
self.assertPathExists('c/d')
2426
def test_pre_delete_rollback(self):
2427
self.build_tree(['a/'])
2428
mover = _FileMover()
2429
mover.pre_delete('a', 'q')
2430
self.assertPathExists('q')
2431
self.assertPathDoesNotExist('a')
2433
self.assertPathDoesNotExist('q')
2434
self.assertPathExists('a')
2436
def test_apply_deletions(self):
2437
self.build_tree(['a/', 'b/'])
2438
mover = _FileMover()
2439
mover.pre_delete('a', 'q')
2440
mover.pre_delete('b', 'r')
2441
self.assertPathExists('q')
2442
self.assertPathExists('r')
2443
self.assertPathDoesNotExist('a')
2444
self.assertPathDoesNotExist('b')
2445
mover.apply_deletions()
2446
self.assertPathDoesNotExist('q')
2447
self.assertPathDoesNotExist('r')
2448
self.assertPathDoesNotExist('a')
2449
self.assertPathDoesNotExist('b')
2451
def test_file_mover_rollback(self):
2452
self.build_tree(['a/', 'a/b', 'c/', 'c/d/', 'c/e/'])
2453
mover = _FileMover()
2454
mover.rename('c/d', 'c/f')
2455
mover.rename('c/e', 'c/d')
2457
mover.rename('a', 'c')
2458
except errors.FileExists, e:
2460
self.assertPathExists('a')
2461
self.assertPathExists('c/d')
2464
class Bogus(Exception):
2468
class TestTransformRollback(tests.TestCaseWithTransport):
2470
class ExceptionFileMover(_FileMover):
2472
def __init__(self, bad_source=None, bad_target=None):
2473
_FileMover.__init__(self)
2474
self.bad_source = bad_source
2475
self.bad_target = bad_target
2477
def rename(self, source, target):
2478
if (self.bad_source is not None and
2479
source.endswith(self.bad_source)):
2481
elif (self.bad_target is not None and
2482
target.endswith(self.bad_target)):
2485
_FileMover.rename(self, source, target)
2487
def test_rollback_rename(self):
2488
tree = self.make_branch_and_tree('.')
2489
self.build_tree(['a/', 'a/b'])
2490
tt = TreeTransform(tree)
2491
self.addCleanup(tt.finalize)
2492
a_id = tt.trans_id_tree_path('a')
2493
tt.adjust_path('c', tt.root, a_id)
2494
tt.adjust_path('d', a_id, tt.trans_id_tree_path('a/b'))
2495
self.assertRaises(Bogus, tt.apply,
2496
_mover=self.ExceptionFileMover(bad_source='a'))
2497
self.assertPathExists('a')
2498
self.assertPathExists('a/b')
2500
self.assertPathExists('c')
2501
self.assertPathExists('c/d')
2503
def test_rollback_rename_into_place(self):
2504
tree = self.make_branch_and_tree('.')
2505
self.build_tree(['a/', 'a/b'])
2506
tt = TreeTransform(tree)
2507
self.addCleanup(tt.finalize)
2508
a_id = tt.trans_id_tree_path('a')
2509
tt.adjust_path('c', tt.root, a_id)
2510
tt.adjust_path('d', a_id, tt.trans_id_tree_path('a/b'))
2511
self.assertRaises(Bogus, tt.apply,
2512
_mover=self.ExceptionFileMover(bad_target='c/d'))
2513
self.assertPathExists('a')
2514
self.assertPathExists('a/b')
2516
self.assertPathExists('c')
2517
self.assertPathExists('c/d')
2519
def test_rollback_deletion(self):
2520
tree = self.make_branch_and_tree('.')
2521
self.build_tree(['a/', 'a/b'])
2522
tt = TreeTransform(tree)
2523
self.addCleanup(tt.finalize)
2524
a_id = tt.trans_id_tree_path('a')
2525
tt.delete_contents(a_id)
2526
tt.adjust_path('d', tt.root, tt.trans_id_tree_path('a/b'))
2527
self.assertRaises(Bogus, tt.apply,
2528
_mover=self.ExceptionFileMover(bad_target='d'))
2529
self.assertPathExists('a')
2530
self.assertPathExists('a/b')
2533
class TestFinalizeRobustness(tests.TestCaseWithTransport):
2534
"""Ensure treetransform creation errors can be safely cleaned up after"""
2536
def _override_globals_in_method(self, instance, method_name, globals):
2537
"""Replace method on instance with one with updated globals"""
2539
func = getattr(instance, method_name).im_func
2540
new_globals = dict(func.func_globals)
2541
new_globals.update(globals)
2542
new_func = types.FunctionType(func.func_code, new_globals,
2543
func.func_name, func.func_defaults)
2544
setattr(instance, method_name,
2545
types.MethodType(new_func, instance, instance.__class__))
2546
self.addCleanup(delattr, instance, method_name)
2549
def _fake_open_raises_before(name, mode):
2550
"""Like open() but raises before doing anything"""
2554
def _fake_open_raises_after(name, mode):
2555
"""Like open() but raises after creating file without returning"""
2556
open(name, mode).close()
2559
def create_transform_and_root_trans_id(self):
2560
"""Setup a transform creating a file in limbo"""
2561
tree = self.make_branch_and_tree('.')
2562
tt = TreeTransform(tree)
2563
return tt, tt.create_path("a", tt.root)
2565
def create_transform_and_subdir_trans_id(self):
2566
"""Setup a transform creating a directory containing a file in limbo"""
2567
tree = self.make_branch_and_tree('.')
2568
tt = TreeTransform(tree)
2569
d_trans_id = tt.create_path("d", tt.root)
2570
tt.create_directory(d_trans_id)
2571
f_trans_id = tt.create_path("a", d_trans_id)
2572
tt.adjust_path("a", d_trans_id, f_trans_id)
2573
return tt, f_trans_id
2575
def test_root_create_file_open_raises_before_creation(self):
2576
tt, trans_id = self.create_transform_and_root_trans_id()
2577
self._override_globals_in_method(tt, "create_file",
2578
{"open": self._fake_open_raises_before})
2579
self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)
2580
path = tt._limbo_name(trans_id)
2581
self.assertPathDoesNotExist(path)
2583
self.assertPathDoesNotExist(tt._limbodir)
2585
def test_root_create_file_open_raises_after_creation(self):
2586
tt, trans_id = self.create_transform_and_root_trans_id()
2587
self._override_globals_in_method(tt, "create_file",
2588
{"open": self._fake_open_raises_after})
2589
self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)
2590
path = tt._limbo_name(trans_id)
2591
self.assertPathExists(path)
2593
self.assertPathDoesNotExist(path)
2594
self.assertPathDoesNotExist(tt._limbodir)
2596
def test_subdir_create_file_open_raises_before_creation(self):
2597
tt, trans_id = self.create_transform_and_subdir_trans_id()
2598
self._override_globals_in_method(tt, "create_file",
2599
{"open": self._fake_open_raises_before})
2600
self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)
2601
path = tt._limbo_name(trans_id)
2602
self.assertPathDoesNotExist(path)
2604
self.assertPathDoesNotExist(tt._limbodir)
2606
def test_subdir_create_file_open_raises_after_creation(self):
2607
tt, trans_id = self.create_transform_and_subdir_trans_id()
2608
self._override_globals_in_method(tt, "create_file",
2609
{"open": self._fake_open_raises_after})
2610
self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)
2611
path = tt._limbo_name(trans_id)
2612
self.assertPathExists(path)
2614
self.assertPathDoesNotExist(path)
2615
self.assertPathDoesNotExist(tt._limbodir)
2617
def test_rename_in_limbo_rename_raises_after_rename(self):
2618
tt, trans_id = self.create_transform_and_root_trans_id()
2619
parent1 = tt.new_directory('parent1', tt.root)
2620
child1 = tt.new_file('child1', parent1, 'contents')
2621
parent2 = tt.new_directory('parent2', tt.root)
2623
class FakeOSModule(object):
2624
def rename(self, old, new):
2627
self._override_globals_in_method(tt, "_rename_in_limbo",
2628
{"os": FakeOSModule()})
2630
RuntimeError, tt.adjust_path, "child1", parent2, child1)
2631
path = osutils.pathjoin(tt._limbo_name(parent2), "child1")
2632
self.assertPathExists(path)
2634
self.assertPathDoesNotExist(path)
2635
self.assertPathDoesNotExist(tt._limbodir)
2637
def test_rename_in_limbo_rename_raises_before_rename(self):
2638
tt, trans_id = self.create_transform_and_root_trans_id()
2639
parent1 = tt.new_directory('parent1', tt.root)
2640
child1 = tt.new_file('child1', parent1, 'contents')
2641
parent2 = tt.new_directory('parent2', tt.root)
2643
class FakeOSModule(object):
2644
def rename(self, old, new):
2646
self._override_globals_in_method(tt, "_rename_in_limbo",
2647
{"os": FakeOSModule()})
2649
RuntimeError, tt.adjust_path, "child1", parent2, child1)
2650
path = osutils.pathjoin(tt._limbo_name(parent1), "child1")
2651
self.assertPathExists(path)
2653
self.assertPathDoesNotExist(path)
2654
self.assertPathDoesNotExist(tt._limbodir)
2657
class TestTransformMissingParent(tests.TestCaseWithTransport):
2659
def make_tt_with_versioned_dir(self):
2660
wt = self.make_branch_and_tree('.')
2661
self.build_tree(['dir/',])
2662
wt.add(['dir'], ['dir-id'])
2663
wt.commit('Create dir')
2664
tt = TreeTransform(wt)
2665
self.addCleanup(tt.finalize)
2668
def test_resolve_create_parent_for_versioned_file(self):
2669
wt, tt = self.make_tt_with_versioned_dir()
2670
dir_tid = tt.trans_id_tree_file_id('dir-id')
2671
file_tid = tt.new_file('file', dir_tid, 'Contents', file_id='file-id')
2672
tt.delete_contents(dir_tid)
2673
tt.unversion_file(dir_tid)
2674
conflicts = resolve_conflicts(tt)
2675
# one conflict for the missing directory, one for the unversioned
2677
self.assertLength(2, conflicts)
2679
def test_non_versioned_file_create_conflict(self):
2680
wt, tt = self.make_tt_with_versioned_dir()
2681
dir_tid = tt.trans_id_tree_file_id('dir-id')
2682
tt.new_file('file', dir_tid, 'Contents')
2683
tt.delete_contents(dir_tid)
2684
tt.unversion_file(dir_tid)
2685
conflicts = resolve_conflicts(tt)
2686
# no conflicts or rather: orphaning 'file' resolve the 'dir' conflict
2687
self.assertLength(1, conflicts)
2688
self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
2692
A_ENTRY = ('a-id', ('a', 'a'), True, (True, True),
2693
('TREE_ROOT', 'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
2695
ROOT_ENTRY = ('TREE_ROOT', ('', ''), False, (True, True), (None, None),
2696
('', ''), ('directory', 'directory'), (False, False))
2699
class TestTransformPreview(tests.TestCaseWithTransport):
2701
def create_tree(self):
2702
tree = self.make_branch_and_tree('.')
2703
self.build_tree_contents([('a', 'content 1')])
2704
tree.set_root_id('TREE_ROOT')
2705
tree.add('a', 'a-id')
2706
tree.commit('rev1', rev_id='rev1')
2707
return tree.branch.repository.revision_tree('rev1')
2709
def get_empty_preview(self):
2710
repository = self.make_repository('repo')
2711
tree = repository.revision_tree(_mod_revision.NULL_REVISION)
2712
preview = TransformPreview(tree)
2713
self.addCleanup(preview.finalize)
2716
def test_transform_preview(self):
2717
revision_tree = self.create_tree()
2718
preview = TransformPreview(revision_tree)
2719
self.addCleanup(preview.finalize)
2721
def test_transform_preview_tree(self):
2722
revision_tree = self.create_tree()
2723
preview = TransformPreview(revision_tree)
2724
self.addCleanup(preview.finalize)
2725
preview.get_preview_tree()
2727
def test_transform_new_file(self):
2728
revision_tree = self.create_tree()
2729
preview = TransformPreview(revision_tree)
2730
self.addCleanup(preview.finalize)
2731
preview.new_file('file2', preview.root, 'content B\n', 'file2-id')
2732
preview_tree = preview.get_preview_tree()
2733
self.assertEqual(preview_tree.kind('file2-id'), 'file')
2735
preview_tree.get_file('file2-id').read(), 'content B\n')
2737
def test_diff_preview_tree(self):
2738
revision_tree = self.create_tree()
2739
preview = TransformPreview(revision_tree)
2740
self.addCleanup(preview.finalize)
2741
preview.new_file('file2', preview.root, 'content B\n', 'file2-id')
2742
preview_tree = preview.get_preview_tree()
2744
show_diff_trees(revision_tree, preview_tree, out)
2745
lines = out.getvalue().splitlines()
2746
self.assertEqual(lines[0], "=== added file 'file2'")
2747
# 3 lines of diff administrivia
2748
self.assertEqual(lines[4], "+content B")
2750
def test_transform_conflicts(self):
2751
revision_tree = self.create_tree()
2752
preview = TransformPreview(revision_tree)
2753
self.addCleanup(preview.finalize)
2754
preview.new_file('a', preview.root, 'content 2')
2755
resolve_conflicts(preview)
2756
trans_id = preview.trans_id_file_id('a-id')
2757
self.assertEqual('a.moved', preview.final_name(trans_id))
2759
def get_tree_and_preview_tree(self):
2760
revision_tree = self.create_tree()
2761
preview = TransformPreview(revision_tree)
2762
self.addCleanup(preview.finalize)
2763
a_trans_id = preview.trans_id_file_id('a-id')
2764
preview.delete_contents(a_trans_id)
2765
preview.create_file('b content', a_trans_id)
2766
preview_tree = preview.get_preview_tree()
2767
return revision_tree, preview_tree
2769
def test_iter_changes(self):
2770
revision_tree, preview_tree = self.get_tree_and_preview_tree()
2771
root = revision_tree.get_root_id()
2772
self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
2773
(root, root), ('a', 'a'), ('file', 'file'),
2775
list(preview_tree.iter_changes(revision_tree)))
2777
def test_include_unchanged_succeeds(self):
2778
revision_tree, preview_tree = self.get_tree_and_preview_tree()
2779
changes = preview_tree.iter_changes(revision_tree,
2780
include_unchanged=True)
2781
root = revision_tree.get_root_id()
2783
self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
2785
def test_specific_files(self):
2786
revision_tree, preview_tree = self.get_tree_and_preview_tree()
2787
changes = preview_tree.iter_changes(revision_tree,
2788
specific_files=[''])
2789
self.assertEqual([A_ENTRY], list(changes))
2791
def test_want_unversioned(self):
2792
revision_tree, preview_tree = self.get_tree_and_preview_tree()
2793
changes = preview_tree.iter_changes(revision_tree,
2794
want_unversioned=True)
2795
self.assertEqual([A_ENTRY], list(changes))
2797
def test_ignore_extra_trees_no_specific_files(self):
2798
# extra_trees is harmless without specific_files, so we'll silently
2799
# accept it, even though we won't use it.
2800
revision_tree, preview_tree = self.get_tree_and_preview_tree()
2801
preview_tree.iter_changes(revision_tree, extra_trees=[preview_tree])
2803
def test_ignore_require_versioned_no_specific_files(self):
2804
# require_versioned is meaningless without specific_files.
2805
revision_tree, preview_tree = self.get_tree_and_preview_tree()
2806
preview_tree.iter_changes(revision_tree, require_versioned=False)
2808
def test_ignore_pb(self):
2809
# pb could be supported, but TT.iter_changes doesn't support it.
2810
revision_tree, preview_tree = self.get_tree_and_preview_tree()
2811
preview_tree.iter_changes(revision_tree)
2813
def test_kind(self):
2814
revision_tree = self.create_tree()
2815
preview = TransformPreview(revision_tree)
2816
self.addCleanup(preview.finalize)
2817
preview.new_file('file', preview.root, 'contents', 'file-id')
2818
preview.new_directory('directory', preview.root, 'dir-id')
2819
preview_tree = preview.get_preview_tree()
2820
self.assertEqual('file', preview_tree.kind('file-id'))
2821
self.assertEqual('directory', preview_tree.kind('dir-id'))
2823
def test_get_file_mtime(self):
2824
preview = self.get_empty_preview()
2825
file_trans_id = preview.new_file('file', preview.root, 'contents',
2827
limbo_path = preview._limbo_name(file_trans_id)
2828
preview_tree = preview.get_preview_tree()
2829
self.assertEqual(os.stat(limbo_path).st_mtime,
2830
preview_tree.get_file_mtime('file-id'))
2832
def test_get_file_mtime_renamed(self):
2833
work_tree = self.make_branch_and_tree('tree')
2834
self.build_tree(['tree/file'])
2835
work_tree.add('file', 'file-id')
2836
preview = TransformPreview(work_tree)
2837
self.addCleanup(preview.finalize)
2838
file_trans_id = preview.trans_id_tree_file_id('file-id')
2839
preview.adjust_path('renamed', preview.root, file_trans_id)
2840
preview_tree = preview.get_preview_tree()
2841
preview_mtime = preview_tree.get_file_mtime('file-id', 'renamed')
2842
work_mtime = work_tree.get_file_mtime('file-id', 'file')
2844
def test_get_file_size(self):
2845
work_tree = self.make_branch_and_tree('tree')
2846
self.build_tree_contents([('tree/old', 'old')])
2847
work_tree.add('old', 'old-id')
2848
preview = TransformPreview(work_tree)
2849
self.addCleanup(preview.finalize)
2850
new_id = preview.new_file('name', preview.root, 'contents', 'new-id',
2852
tree = preview.get_preview_tree()
2853
self.assertEqual(len('old'), tree.get_file_size('old-id'))
2854
self.assertEqual(len('contents'), tree.get_file_size('new-id'))
2856
def test_get_file(self):
2857
preview = self.get_empty_preview()
2858
preview.new_file('file', preview.root, 'contents', 'file-id')
2859
preview_tree = preview.get_preview_tree()
2860
tree_file = preview_tree.get_file('file-id')
2862
self.assertEqual('contents', tree_file.read())
2866
def test_get_symlink_target(self):
2867
self.requireFeature(SymlinkFeature)
2868
preview = self.get_empty_preview()
2869
preview.new_symlink('symlink', preview.root, 'target', 'symlink-id')
2870
preview_tree = preview.get_preview_tree()
2871
self.assertEqual('target',
2872
preview_tree.get_symlink_target('symlink-id'))
2874
def test_all_file_ids(self):
2875
tree = self.make_branch_and_tree('tree')
2876
self.build_tree(['tree/a', 'tree/b', 'tree/c'])
2877
tree.add(['a', 'b', 'c'], ['a-id', 'b-id', 'c-id'])
2878
preview = TransformPreview(tree)
2879
self.addCleanup(preview.finalize)
2880
preview.unversion_file(preview.trans_id_file_id('b-id'))
2881
c_trans_id = preview.trans_id_file_id('c-id')
2882
preview.unversion_file(c_trans_id)
2883
preview.version_file('c-id', c_trans_id)
2884
preview_tree = preview.get_preview_tree()
2885
self.assertEqual(set(['a-id', 'c-id', tree.get_root_id()]),
2886
preview_tree.all_file_ids())
2888
def test_path2id_deleted_unchanged(self):
2889
tree = self.make_branch_and_tree('tree')
2890
self.build_tree(['tree/unchanged', 'tree/deleted'])
2891
tree.add(['unchanged', 'deleted'], ['unchanged-id', 'deleted-id'])
2892
preview = TransformPreview(tree)
2893
self.addCleanup(preview.finalize)
2894
preview.unversion_file(preview.trans_id_file_id('deleted-id'))
2895
preview_tree = preview.get_preview_tree()
2896
self.assertEqual('unchanged-id', preview_tree.path2id('unchanged'))
2897
self.assertIs(None, preview_tree.path2id('deleted'))
2899
def test_path2id_created(self):
2900
tree = self.make_branch_and_tree('tree')
2901
self.build_tree(['tree/unchanged'])
2902
tree.add(['unchanged'], ['unchanged-id'])
2903
preview = TransformPreview(tree)
2904
self.addCleanup(preview.finalize)
2905
preview.new_file('new', preview.trans_id_file_id('unchanged-id'),
2906
'contents', 'new-id')
2907
preview_tree = preview.get_preview_tree()
2908
self.assertEqual('new-id', preview_tree.path2id('unchanged/new'))
2910
def test_path2id_moved(self):
2911
tree = self.make_branch_and_tree('tree')
2912
self.build_tree(['tree/old_parent/', 'tree/old_parent/child'])
2913
tree.add(['old_parent', 'old_parent/child'],
2914
['old_parent-id', 'child-id'])
2915
preview = TransformPreview(tree)
2916
self.addCleanup(preview.finalize)
2917
new_parent = preview.new_directory('new_parent', preview.root,
2919
preview.adjust_path('child', new_parent,
2920
preview.trans_id_file_id('child-id'))
2921
preview_tree = preview.get_preview_tree()
2922
self.assertIs(None, preview_tree.path2id('old_parent/child'))
2923
self.assertEqual('child-id', preview_tree.path2id('new_parent/child'))
2925
def test_path2id_renamed_parent(self):
2926
tree = self.make_branch_and_tree('tree')
2927
self.build_tree(['tree/old_name/', 'tree/old_name/child'])
2928
tree.add(['old_name', 'old_name/child'],
2929
['parent-id', 'child-id'])
2930
preview = TransformPreview(tree)
2931
self.addCleanup(preview.finalize)
2932
preview.adjust_path('new_name', preview.root,
2933
preview.trans_id_file_id('parent-id'))
2934
preview_tree = preview.get_preview_tree()
2935
self.assertIs(None, preview_tree.path2id('old_name/child'))
2936
self.assertEqual('child-id', preview_tree.path2id('new_name/child'))
2938
def assertMatchingIterEntries(self, tt, specific_file_ids=None):
2939
preview_tree = tt.get_preview_tree()
2940
preview_result = list(preview_tree.iter_entries_by_dir(
2944
actual_result = list(tree.iter_entries_by_dir(specific_file_ids))
2945
self.assertEqual(actual_result, preview_result)
2947
def test_iter_entries_by_dir_new(self):
2948
tree = self.make_branch_and_tree('tree')
2949
tt = TreeTransform(tree)
2950
tt.new_file('new', tt.root, 'contents', 'new-id')
2951
self.assertMatchingIterEntries(tt)
2953
def test_iter_entries_by_dir_deleted(self):
2954
tree = self.make_branch_and_tree('tree')
2955
self.build_tree(['tree/deleted'])
2956
tree.add('deleted', 'deleted-id')
2957
tt = TreeTransform(tree)
2958
tt.delete_contents(tt.trans_id_file_id('deleted-id'))
2959
self.assertMatchingIterEntries(tt)
2961
def test_iter_entries_by_dir_unversioned(self):
2962
tree = self.make_branch_and_tree('tree')
2963
self.build_tree(['tree/removed'])
2964
tree.add('removed', 'removed-id')
2965
tt = TreeTransform(tree)
2966
tt.unversion_file(tt.trans_id_file_id('removed-id'))
2967
self.assertMatchingIterEntries(tt)
2969
def test_iter_entries_by_dir_moved(self):
2970
tree = self.make_branch_and_tree('tree')
2971
self.build_tree(['tree/moved', 'tree/new_parent/'])
2972
tree.add(['moved', 'new_parent'], ['moved-id', 'new_parent-id'])
2973
tt = TreeTransform(tree)
2974
tt.adjust_path('moved', tt.trans_id_file_id('new_parent-id'),
2975
tt.trans_id_file_id('moved-id'))
2976
self.assertMatchingIterEntries(tt)
2978
def test_iter_entries_by_dir_specific_file_ids(self):
2979
tree = self.make_branch_and_tree('tree')
2980
tree.set_root_id('tree-root-id')
2981
self.build_tree(['tree/parent/', 'tree/parent/child'])
2982
tree.add(['parent', 'parent/child'], ['parent-id', 'child-id'])
2983
tt = TreeTransform(tree)
2984
self.assertMatchingIterEntries(tt, ['tree-root-id', 'child-id'])
2986
def test_symlink_content_summary(self):
2987
self.requireFeature(SymlinkFeature)
2988
preview = self.get_empty_preview()
2989
preview.new_symlink('path', preview.root, 'target', 'path-id')
2990
summary = preview.get_preview_tree().path_content_summary('path')
2991
self.assertEqual(('symlink', None, None, 'target'), summary)
2993
def test_missing_content_summary(self):
2994
preview = self.get_empty_preview()
2995
summary = preview.get_preview_tree().path_content_summary('path')
2996
self.assertEqual(('missing', None, None, None), summary)
2998
def test_deleted_content_summary(self):
2999
tree = self.make_branch_and_tree('tree')
3000
self.build_tree(['tree/path/'])
3002
preview = TransformPreview(tree)
3003
self.addCleanup(preview.finalize)
3004
preview.delete_contents(preview.trans_id_tree_path('path'))
3005
summary = preview.get_preview_tree().path_content_summary('path')
3006
self.assertEqual(('missing', None, None, None), summary)
3008
def test_file_content_summary_executable(self):
3009
preview = self.get_empty_preview()
3010
path_id = preview.new_file('path', preview.root, 'contents', 'path-id')
3011
preview.set_executability(True, path_id)
3012
summary = preview.get_preview_tree().path_content_summary('path')
3013
self.assertEqual(4, len(summary))
3014
self.assertEqual('file', summary[0])
3015
# size must be known
3016
self.assertEqual(len('contents'), summary[1])
3018
self.assertEqual(True, summary[2])
3019
# will not have hash (not cheap to determine)
3020
self.assertIs(None, summary[3])
3022
def test_change_executability(self):
3023
tree = self.make_branch_and_tree('tree')
3024
self.build_tree(['tree/path'])
3026
preview = TransformPreview(tree)
3027
self.addCleanup(preview.finalize)
3028
path_id = preview.trans_id_tree_path('path')
3029
preview.set_executability(True, path_id)
3030
summary = preview.get_preview_tree().path_content_summary('path')
3031
self.assertEqual(True, summary[2])
3033
def test_file_content_summary_non_exec(self):
3034
preview = self.get_empty_preview()
3035
preview.new_file('path', preview.root, 'contents', 'path-id')
3036
summary = preview.get_preview_tree().path_content_summary('path')
3037
self.assertEqual(4, len(summary))
3038
self.assertEqual('file', summary[0])
3039
# size must be known
3040
self.assertEqual(len('contents'), summary[1])
3042
self.assertEqual(False, summary[2])
3043
# will not have hash (not cheap to determine)
3044
self.assertIs(None, summary[3])
3046
def test_dir_content_summary(self):
3047
preview = self.get_empty_preview()
3048
preview.new_directory('path', preview.root, 'path-id')
3049
summary = preview.get_preview_tree().path_content_summary('path')
3050
self.assertEqual(('directory', None, None, None), summary)
3052
def test_tree_content_summary(self):
3053
preview = self.get_empty_preview()
3054
path = preview.new_directory('path', preview.root, 'path-id')
3055
preview.set_tree_reference('rev-1', path)
3056
summary = preview.get_preview_tree().path_content_summary('path')
3057
self.assertEqual(4, len(summary))
3058
self.assertEqual('tree-reference', summary[0])
3060
def test_annotate(self):
3061
tree = self.make_branch_and_tree('tree')
3062
self.build_tree_contents([('tree/file', 'a\n')])
3063
tree.add('file', 'file-id')
3064
tree.commit('a', rev_id='one')
3065
self.build_tree_contents([('tree/file', 'a\nb\n')])
3066
preview = TransformPreview(tree)
3067
self.addCleanup(preview.finalize)
3068
file_trans_id = preview.trans_id_file_id('file-id')
3069
preview.delete_contents(file_trans_id)
3070
preview.create_file('a\nb\nc\n', file_trans_id)
3071
preview_tree = preview.get_preview_tree()
3077
annotation = preview_tree.annotate_iter('file-id', 'me:')
3078
self.assertEqual(expected, annotation)
3080
def test_annotate_missing(self):
3081
preview = self.get_empty_preview()
3082
preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')
3083
preview_tree = preview.get_preview_tree()
3089
annotation = preview_tree.annotate_iter('file-id', 'me:')
3090
self.assertEqual(expected, annotation)
3092
def test_annotate_rename(self):
3093
tree = self.make_branch_and_tree('tree')
3094
self.build_tree_contents([('tree/file', 'a\n')])
3095
tree.add('file', 'file-id')
3096
tree.commit('a', rev_id='one')
3097
preview = TransformPreview(tree)
3098
self.addCleanup(preview.finalize)
3099
file_trans_id = preview.trans_id_file_id('file-id')
3100
preview.adjust_path('newname', preview.root, file_trans_id)
3101
preview_tree = preview.get_preview_tree()
3105
annotation = preview_tree.annotate_iter('file-id', 'me:')
3106
self.assertEqual(expected, annotation)
3108
def test_annotate_deleted(self):
3109
tree = self.make_branch_and_tree('tree')
3110
self.build_tree_contents([('tree/file', 'a\n')])
3111
tree.add('file', 'file-id')
3112
tree.commit('a', rev_id='one')
3113
self.build_tree_contents([('tree/file', 'a\nb\n')])
3114
preview = TransformPreview(tree)
3115
self.addCleanup(preview.finalize)
3116
file_trans_id = preview.trans_id_file_id('file-id')
3117
preview.delete_contents(file_trans_id)
3118
preview_tree = preview.get_preview_tree()
3119
annotation = preview_tree.annotate_iter('file-id', 'me:')
3120
self.assertIs(None, annotation)
3122
def test_stored_kind(self):
3123
preview = self.get_empty_preview()
3124
preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')
3125
preview_tree = preview.get_preview_tree()
3126
self.assertEqual('file', preview_tree.stored_kind('file-id'))
3128
def test_is_executable(self):
3129
preview = self.get_empty_preview()
3130
preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')
3131
preview.set_executability(True, preview.trans_id_file_id('file-id'))
3132
preview_tree = preview.get_preview_tree()
3133
self.assertEqual(True, preview_tree.is_executable('file-id'))
3135
def test_get_set_parent_ids(self):
3136
revision_tree, preview_tree = self.get_tree_and_preview_tree()
3137
self.assertEqual([], preview_tree.get_parent_ids())
3138
preview_tree.set_parent_ids(['rev-1'])
3139
self.assertEqual(['rev-1'], preview_tree.get_parent_ids())
3141
def test_plan_file_merge(self):
3142
work_a = self.make_branch_and_tree('wta')
3143
self.build_tree_contents([('wta/file', 'a\nb\nc\nd\n')])
3144
work_a.add('file', 'file-id')
3145
base_id = work_a.commit('base version')
3146
tree_b = work_a.bzrdir.sprout('wtb').open_workingtree()
3147
preview = TransformPreview(work_a)
3148
self.addCleanup(preview.finalize)
3149
trans_id = preview.trans_id_file_id('file-id')
3150
preview.delete_contents(trans_id)
3151
preview.create_file('b\nc\nd\ne\n', trans_id)
3152
self.build_tree_contents([('wtb/file', 'a\nc\nd\nf\n')])
3153
tree_a = preview.get_preview_tree()
3154
tree_a.set_parent_ids([base_id])
3156
('killed-a', 'a\n'),
3157
('killed-b', 'b\n'),
3158
('unchanged', 'c\n'),
3159
('unchanged', 'd\n'),
3162
], list(tree_a.plan_file_merge('file-id', tree_b)))
3164
def test_plan_file_merge_revision_tree(self):
3165
work_a = self.make_branch_and_tree('wta')
3166
self.build_tree_contents([('wta/file', 'a\nb\nc\nd\n')])
3167
work_a.add('file', 'file-id')
3168
base_id = work_a.commit('base version')
3169
tree_b = work_a.bzrdir.sprout('wtb').open_workingtree()
3170
preview = TransformPreview(work_a.basis_tree())
3171
self.addCleanup(preview.finalize)
3172
trans_id = preview.trans_id_file_id('file-id')
3173
preview.delete_contents(trans_id)
3174
preview.create_file('b\nc\nd\ne\n', trans_id)
3175
self.build_tree_contents([('wtb/file', 'a\nc\nd\nf\n')])
3176
tree_a = preview.get_preview_tree()
3177
tree_a.set_parent_ids([base_id])
3179
('killed-a', 'a\n'),
3180
('killed-b', 'b\n'),
3181
('unchanged', 'c\n'),
3182
('unchanged', 'd\n'),
3185
], list(tree_a.plan_file_merge('file-id', tree_b)))
3187
def test_walkdirs(self):
3188
preview = self.get_empty_preview()
3189
root = preview.new_directory('', ROOT_PARENT, 'tree-root')
3190
# FIXME: new_directory should mark root.
3191
preview.fixup_new_roots()
3192
preview_tree = preview.get_preview_tree()
3193
file_trans_id = preview.new_file('a', preview.root, 'contents',
3195
expected = [(('', 'tree-root'),
3196
[('a', 'a', 'file', None, 'a-id', 'file')])]
3197
self.assertEqual(expected, list(preview_tree.walkdirs()))
3199
def test_extras(self):
3200
work_tree = self.make_branch_and_tree('tree')
3201
self.build_tree(['tree/removed-file', 'tree/existing-file',
3202
'tree/not-removed-file'])
3203
work_tree.add(['removed-file', 'not-removed-file'])
3204
preview = TransformPreview(work_tree)
3205
self.addCleanup(preview.finalize)
3206
preview.new_file('new-file', preview.root, 'contents')
3207
preview.new_file('new-versioned-file', preview.root, 'contents',
3209
tree = preview.get_preview_tree()
3210
preview.unversion_file(preview.trans_id_tree_path('removed-file'))
3211
self.assertEqual(set(['new-file', 'removed-file', 'existing-file']),
3214
def test_merge_into_preview(self):
3215
work_tree = self.make_branch_and_tree('tree')
3216
self.build_tree_contents([('tree/file','b\n')])
3217
work_tree.add('file', 'file-id')
3218
work_tree.commit('first commit')
3219
child_tree = work_tree.bzrdir.sprout('child').open_workingtree()
3220
self.build_tree_contents([('child/file','b\nc\n')])
3221
child_tree.commit('child commit')
3222
child_tree.lock_write()
3223
self.addCleanup(child_tree.unlock)
3224
work_tree.lock_write()
3225
self.addCleanup(work_tree.unlock)
3226
preview = TransformPreview(work_tree)
3227
self.addCleanup(preview.finalize)
3228
file_trans_id = preview.trans_id_file_id('file-id')
3229
preview.delete_contents(file_trans_id)
3230
preview.create_file('a\nb\n', file_trans_id)
3231
preview_tree = preview.get_preview_tree()
3232
merger = Merger.from_revision_ids(None, preview_tree,
3233
child_tree.branch.last_revision(),
3234
other_branch=child_tree.branch,
3235
tree_branch=work_tree.branch)
3236
merger.merge_type = Merge3Merger
3237
tt = merger.make_merger().make_preview_transform()
3238
self.addCleanup(tt.finalize)
3239
final_tree = tt.get_preview_tree()
3240
self.assertEqual('a\nb\nc\n', final_tree.get_file_text('file-id'))
3242
def test_merge_preview_into_workingtree(self):
3243
tree = self.make_branch_and_tree('tree')
3244
tree.set_root_id('TREE_ROOT')
3245
tt = TransformPreview(tree)
3246
self.addCleanup(tt.finalize)
3247
tt.new_file('name', tt.root, 'content', 'file-id')
3248
tree2 = self.make_branch_and_tree('tree2')
3249
tree2.set_root_id('TREE_ROOT')
3250
merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
3251
None, tree.basis_tree())
3252
merger.merge_type = Merge3Merger
3255
def test_merge_preview_into_workingtree_handles_conflicts(self):
3256
tree = self.make_branch_and_tree('tree')
3257
self.build_tree_contents([('tree/foo', 'bar')])
3258
tree.add('foo', 'foo-id')
3260
tt = TransformPreview(tree)
3261
self.addCleanup(tt.finalize)
3262
trans_id = tt.trans_id_file_id('foo-id')
3263
tt.delete_contents(trans_id)
3264
tt.create_file('baz', trans_id)
3265
tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
3266
self.build_tree_contents([('tree2/foo', 'qux')])
3268
merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
3269
pb, tree.basis_tree())
3270
merger.merge_type = Merge3Merger
3273
def test_has_filename(self):
3274
wt = self.make_branch_and_tree('tree')
3275
self.build_tree(['tree/unmodified', 'tree/removed', 'tree/modified'])
3276
tt = TransformPreview(wt)
3277
removed_id = tt.trans_id_tree_path('removed')
3278
tt.delete_contents(removed_id)
3279
tt.new_file('new', tt.root, 'contents')
3280
modified_id = tt.trans_id_tree_path('modified')
3281
tt.delete_contents(modified_id)
3282
tt.create_file('modified-contents', modified_id)
3283
self.addCleanup(tt.finalize)
3284
tree = tt.get_preview_tree()
3285
self.assertTrue(tree.has_filename('unmodified'))
3286
self.assertFalse(tree.has_filename('not-present'))
3287
self.assertFalse(tree.has_filename('removed'))
3288
self.assertTrue(tree.has_filename('new'))
3289
self.assertTrue(tree.has_filename('modified'))
3291
def test_is_executable(self):
3292
tree = self.make_branch_and_tree('tree')
3293
preview = TransformPreview(tree)
3294
self.addCleanup(preview.finalize)
3295
preview.new_file('foo', preview.root, 'bar', 'baz-id')
3296
preview_tree = preview.get_preview_tree()
3297
self.assertEqual(False, preview_tree.is_executable('baz-id',
3299
self.assertEqual(False, preview_tree.is_executable('baz-id'))
3301
def test_commit_preview_tree(self):
3302
tree = self.make_branch_and_tree('tree')
3303
rev_id = tree.commit('rev1')
3304
tree.branch.lock_write()
3305
self.addCleanup(tree.branch.unlock)
3306
tt = TransformPreview(tree)
3307
tt.new_file('file', tt.root, 'contents', 'file_id')
3308
self.addCleanup(tt.finalize)
3309
preview = tt.get_preview_tree()
3310
preview.set_parent_ids([rev_id])
3311
builder = tree.branch.get_commit_builder([rev_id])
3312
list(builder.record_iter_changes(preview, rev_id, tt.iter_changes()))
3313
builder.finish_inventory()
3314
rev2_id = builder.commit('rev2')
3315
rev2_tree = tree.branch.repository.revision_tree(rev2_id)
3316
self.assertEqual('contents', rev2_tree.get_file_text('file_id'))
3318
def test_ascii_limbo_paths(self):
3319
self.requireFeature(features.UnicodeFilenameFeature)
3320
branch = self.make_branch('any')
3321
tree = branch.repository.revision_tree(_mod_revision.NULL_REVISION)
3322
tt = TransformPreview(tree)
3323
self.addCleanup(tt.finalize)
3324
foo_id = tt.new_directory('', ROOT_PARENT)
3325
bar_id = tt.new_file(u'\u1234bar', foo_id, 'contents')
3326
limbo_path = tt._limbo_name(bar_id)
3327
self.assertEqual(limbo_path.encode('ascii', 'replace'), limbo_path)
3330
class FakeSerializer(object):
3331
"""Serializer implementation that simply returns the input.
3333
The input is returned in the order used by pack.ContainerPushParser.
3336
def bytes_record(bytes, names):
3340
class TestSerializeTransform(tests.TestCaseWithTransport):
3342
_test_needs_features = [features.UnicodeFilenameFeature]
3344
def get_preview(self, tree=None):
3346
tree = self.make_branch_and_tree('tree')
3347
tt = TransformPreview(tree)
3348
self.addCleanup(tt.finalize)
3351
def assertSerializesTo(self, expected, tt):
3352
records = list(tt.serialize(FakeSerializer()))
3353
self.assertEqual(expected, records)
3356
def default_attribs():
3361
'_new_executability': {},
3363
'_tree_path_ids': {'': 'new-0'},
3365
'_removed_contents': [],
3366
'_non_present_ids': {},
3369
def make_records(self, attribs, contents):
3371
(((('attribs'),),), bencode.bencode(attribs))]
3372
records.extend([(((n, k),), c) for n, k, c in contents])
3375
def creation_records(self):
3376
attribs = self.default_attribs()
3377
attribs['_id_number'] = 3
3378
attribs['_new_name'] = {
3379
'new-1': u'foo\u1234'.encode('utf-8'), 'new-2': 'qux'}
3380
attribs['_new_id'] = {'new-1': 'baz', 'new-2': 'quxx'}
3381
attribs['_new_parent'] = {'new-1': 'new-0', 'new-2': 'new-0'}
3382
attribs['_new_executability'] = {'new-1': 1}
3384
('new-1', 'file', 'i 1\nbar\n'),
3385
('new-2', 'directory', ''),
3387
return self.make_records(attribs, contents)
3389
def test_serialize_creation(self):
3390
tt = self.get_preview()
3391
tt.new_file(u'foo\u1234', tt.root, 'bar', 'baz', True)
3392
tt.new_directory('qux', tt.root, 'quxx')
3393
self.assertSerializesTo(self.creation_records(), tt)
3395
def test_deserialize_creation(self):
3396
tt = self.get_preview()
3397
tt.deserialize(iter(self.creation_records()))
3398
self.assertEqual(3, tt._id_number)
3399
self.assertEqual({'new-1': u'foo\u1234',
3400
'new-2': 'qux'}, tt._new_name)
3401
self.assertEqual({'new-1': 'baz', 'new-2': 'quxx'}, tt._new_id)
3402
self.assertEqual({'new-1': tt.root, 'new-2': tt.root}, tt._new_parent)
3403
self.assertEqual({'baz': 'new-1', 'quxx': 'new-2'}, tt._r_new_id)
3404
self.assertEqual({'new-1': True}, tt._new_executability)
3405
self.assertEqual({'new-1': 'file',
3406
'new-2': 'directory'}, tt._new_contents)
3407
foo_limbo = open(tt._limbo_name('new-1'), 'rb')
3409
foo_content = foo_limbo.read()
3412
self.assertEqual('bar', foo_content)
3414
def symlink_creation_records(self):
3415
attribs = self.default_attribs()
3416
attribs['_id_number'] = 2
3417
attribs['_new_name'] = {'new-1': u'foo\u1234'.encode('utf-8')}
3418
attribs['_new_parent'] = {'new-1': 'new-0'}
3419
contents = [('new-1', 'symlink', u'bar\u1234'.encode('utf-8'))]
3420
return self.make_records(attribs, contents)
3422
def test_serialize_symlink_creation(self):
3423
self.requireFeature(features.SymlinkFeature)
3424
tt = self.get_preview()
3425
tt.new_symlink(u'foo\u1234', tt.root, u'bar\u1234')
3426
self.assertSerializesTo(self.symlink_creation_records(), tt)
3428
def test_deserialize_symlink_creation(self):
3429
self.requireFeature(features.SymlinkFeature)
3430
tt = self.get_preview()
3431
tt.deserialize(iter(self.symlink_creation_records()))
3432
abspath = tt._limbo_name('new-1')
3433
foo_content = osutils.readlink(abspath)
3434
self.assertEqual(u'bar\u1234', foo_content)
3436
def make_destruction_preview(self):
3437
tree = self.make_branch_and_tree('.')
3438
self.build_tree([u'foo\u1234', 'bar'])
3439
tree.add([u'foo\u1234', 'bar'], ['foo-id', 'bar-id'])
3440
return self.get_preview(tree)
3442
def destruction_records(self):
3443
attribs = self.default_attribs()
3444
attribs['_id_number'] = 3
3445
attribs['_removed_id'] = ['new-1']
3446
attribs['_removed_contents'] = ['new-2']
3447
attribs['_tree_path_ids'] = {
3449
u'foo\u1234'.encode('utf-8'): 'new-1',
3452
return self.make_records(attribs, [])
3454
def test_serialize_destruction(self):
3455
tt = self.make_destruction_preview()
3456
foo_trans_id = tt.trans_id_tree_file_id('foo-id')
3457
tt.unversion_file(foo_trans_id)
3458
bar_trans_id = tt.trans_id_tree_file_id('bar-id')
3459
tt.delete_contents(bar_trans_id)
3460
self.assertSerializesTo(self.destruction_records(), tt)
3462
def test_deserialize_destruction(self):
3463
tt = self.make_destruction_preview()
3464
tt.deserialize(iter(self.destruction_records()))
3465
self.assertEqual({u'foo\u1234': 'new-1',
3467
'': tt.root}, tt._tree_path_ids)
3468
self.assertEqual({'new-1': u'foo\u1234',
3470
tt.root: ''}, tt._tree_id_paths)
3471
self.assertEqual(set(['new-1']), tt._removed_id)
3472
self.assertEqual(set(['new-2']), tt._removed_contents)
3474
def missing_records(self):
3475
attribs = self.default_attribs()
3476
attribs['_id_number'] = 2
3477
attribs['_non_present_ids'] = {
3479
return self.make_records(attribs, [])
3481
def test_serialize_missing(self):
3482
tt = self.get_preview()
3483
boo_trans_id = tt.trans_id_file_id('boo')
3484
self.assertSerializesTo(self.missing_records(), tt)
3486
def test_deserialize_missing(self):
3487
tt = self.get_preview()
3488
tt.deserialize(iter(self.missing_records()))
3489
self.assertEqual({'boo': 'new-1'}, tt._non_present_ids)
3491
def make_modification_preview(self):
3492
LINES_ONE = 'aa\nbb\ncc\ndd\n'
3493
LINES_TWO = 'z\nbb\nx\ndd\n'
3494
tree = self.make_branch_and_tree('tree')
3495
self.build_tree_contents([('tree/file', LINES_ONE)])
3496
tree.add('file', 'file-id')
3497
return self.get_preview(tree), LINES_TWO
3499
def modification_records(self):
3500
attribs = self.default_attribs()
3501
attribs['_id_number'] = 2
3502
attribs['_tree_path_ids'] = {
3505
attribs['_removed_contents'] = ['new-1']
3506
contents = [('new-1', 'file',
3507
'i 1\nz\n\nc 0 1 1 1\ni 1\nx\n\nc 0 3 3 1\n')]
3508
return self.make_records(attribs, contents)
3510
def test_serialize_modification(self):
3511
tt, LINES = self.make_modification_preview()
3512
trans_id = tt.trans_id_file_id('file-id')
3513
tt.delete_contents(trans_id)
3514
tt.create_file(LINES, trans_id)
3515
self.assertSerializesTo(self.modification_records(), tt)
3517
def test_deserialize_modification(self):
3518
tt, LINES = self.make_modification_preview()
3519
tt.deserialize(iter(self.modification_records()))
3520
self.assertFileEqual(LINES, tt._limbo_name('new-1'))
3522
def make_kind_change_preview(self):
3523
LINES = 'a\nb\nc\nd\n'
3524
tree = self.make_branch_and_tree('tree')
3525
self.build_tree(['tree/foo/'])
3526
tree.add('foo', 'foo-id')
3527
return self.get_preview(tree), LINES
3529
def kind_change_records(self):
3530
attribs = self.default_attribs()
3531
attribs['_id_number'] = 2
3532
attribs['_tree_path_ids'] = {
3535
attribs['_removed_contents'] = ['new-1']
3536
contents = [('new-1', 'file',
3537
'i 4\na\nb\nc\nd\n\n')]
3538
return self.make_records(attribs, contents)
3540
def test_serialize_kind_change(self):
3541
tt, LINES = self.make_kind_change_preview()
3542
trans_id = tt.trans_id_file_id('foo-id')
3543
tt.delete_contents(trans_id)
3544
tt.create_file(LINES, trans_id)
3545
self.assertSerializesTo(self.kind_change_records(), tt)
3547
def test_deserialize_kind_change(self):
3548
tt, LINES = self.make_kind_change_preview()
3549
tt.deserialize(iter(self.kind_change_records()))
3550
self.assertFileEqual(LINES, tt._limbo_name('new-1'))
3552
def make_add_contents_preview(self):
3553
LINES = 'a\nb\nc\nd\n'
3554
tree = self.make_branch_and_tree('tree')
3555
self.build_tree(['tree/foo'])
3557
os.unlink('tree/foo')
3558
return self.get_preview(tree), LINES
3560
def add_contents_records(self):
3561
attribs = self.default_attribs()
3562
attribs['_id_number'] = 2
3563
attribs['_tree_path_ids'] = {
3566
contents = [('new-1', 'file',
3567
'i 4\na\nb\nc\nd\n\n')]
3568
return self.make_records(attribs, contents)
3570
def test_serialize_add_contents(self):
3571
tt, LINES = self.make_add_contents_preview()
3572
trans_id = tt.trans_id_tree_path('foo')
3573
tt.create_file(LINES, trans_id)
3574
self.assertSerializesTo(self.add_contents_records(), tt)
3576
def test_deserialize_add_contents(self):
3577
tt, LINES = self.make_add_contents_preview()
3578
tt.deserialize(iter(self.add_contents_records()))
3579
self.assertFileEqual(LINES, tt._limbo_name('new-1'))
3581
def test_get_parents_lines(self):
3582
LINES_ONE = 'aa\nbb\ncc\ndd\n'
3583
LINES_TWO = 'z\nbb\nx\ndd\n'
3584
tree = self.make_branch_and_tree('tree')
3585
self.build_tree_contents([('tree/file', LINES_ONE)])
3586
tree.add('file', 'file-id')
3587
tt = self.get_preview(tree)
3588
trans_id = tt.trans_id_tree_path('file')
3589
self.assertEqual((['aa\n', 'bb\n', 'cc\n', 'dd\n'],),
3590
tt._get_parents_lines(trans_id))
3592
def test_get_parents_texts(self):
3593
LINES_ONE = 'aa\nbb\ncc\ndd\n'
3594
LINES_TWO = 'z\nbb\nx\ndd\n'
3595
tree = self.make_branch_and_tree('tree')
3596
self.build_tree_contents([('tree/file', LINES_ONE)])
3597
tree.add('file', 'file-id')
3598
tt = self.get_preview(tree)
3599
trans_id = tt.trans_id_tree_path('file')
3600
self.assertEqual((LINES_ONE,),
3601
tt._get_parents_texts(trans_id))
3604
class TestOrphan(tests.TestCaseWithTransport):
3606
def test_no_orphan_for_transform_preview(self):
3607
tree = self.make_branch_and_tree('tree')
3608
tt = transform.TransformPreview(tree)
3609
self.addCleanup(tt.finalize)
3610
self.assertRaises(NotImplementedError, tt.new_orphan, 'foo', 'bar')
3612
def _set_orphan_policy(self, wt, policy):
3613
wt.branch.get_config_stack().set('bzr.transform.orphan_policy',
3616
def _prepare_orphan(self, wt):
3617
self.build_tree(['dir/', 'dir/file', 'dir/foo'])
3618
wt.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
3619
wt.commit('add dir and file ignoring foo')
3620
tt = transform.TreeTransform(wt)
3621
self.addCleanup(tt.finalize)
3622
# dir and bar are deleted
3623
dir_tid = tt.trans_id_tree_path('dir')
3624
file_tid = tt.trans_id_tree_path('dir/file')
3625
orphan_tid = tt.trans_id_tree_path('dir/foo')
3626
tt.delete_contents(file_tid)
3627
tt.unversion_file(file_tid)
3628
tt.delete_contents(dir_tid)
3629
tt.unversion_file(dir_tid)
3630
# There should be a conflict because dir still contain foo
3631
raw_conflicts = tt.find_conflicts()
3632
self.assertLength(1, raw_conflicts)
3633
self.assertEqual(('missing parent', 'new-1'), raw_conflicts[0])
3634
return tt, orphan_tid
3636
def test_new_orphan_created(self):
3637
wt = self.make_branch_and_tree('.')
3638
self._set_orphan_policy(wt, 'move')
3639
tt, orphan_tid = self._prepare_orphan(wt)
3642
warnings.append(args[0] % args[1:])
3643
self.overrideAttr(trace, 'warning', warning)
3644
remaining_conflicts = resolve_conflicts(tt)
3645
self.assertEquals(['dir/foo has been orphaned in bzr-orphans'],
3647
# Yeah for resolved conflicts !
3648
self.assertLength(0, remaining_conflicts)
3649
# We have a new orphan
3650
self.assertEquals('foo.~1~', tt.final_name(orphan_tid))
3651
self.assertEquals('bzr-orphans',
3652
tt.final_name(tt.final_parent(orphan_tid)))
3654
def test_never_orphan(self):
3655
wt = self.make_branch_and_tree('.')
3656
self._set_orphan_policy(wt, 'conflict')
3657
tt, orphan_tid = self._prepare_orphan(wt)
3658
remaining_conflicts = resolve_conflicts(tt)
3659
self.assertLength(1, remaining_conflicts)
3660
self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
3661
remaining_conflicts.pop())
3663
def test_orphan_error(self):
3664
def bogus_orphan(tt, orphan_id, parent_id):
3665
raise transform.OrphaningError(tt.final_name(orphan_id),
3666
tt.final_name(parent_id))
3667
transform.orphaning_registry.register('bogus', bogus_orphan,
3668
'Raise an error when orphaning')
3669
wt = self.make_branch_and_tree('.')
3670
self._set_orphan_policy(wt, 'bogus')
3671
tt, orphan_tid = self._prepare_orphan(wt)
3672
remaining_conflicts = resolve_conflicts(tt)
3673
self.assertLength(1, remaining_conflicts)
3674
self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
3675
remaining_conflicts.pop())
3677
def test_unknown_orphan_policy(self):
3678
wt = self.make_branch_and_tree('.')
3679
# Set a fictional policy nobody ever implemented
3680
self._set_orphan_policy(wt, 'donttouchmypreciouuus')
3681
tt, orphan_tid = self._prepare_orphan(wt)
3684
warnings.append(args[0] % args[1:])
3685
self.overrideAttr(trace, 'warning', warning)
3686
remaining_conflicts = resolve_conflicts(tt)
3687
# We fallback to the default policy which create a conflict
3688
self.assertLength(1, remaining_conflicts)
3689
self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
3690
remaining_conflicts.pop())
3691
self.assertLength(1, warnings)
3692
self.assertStartsWith(warnings[0], 'Value "donttouchmypreciouuus" ')
3695
class TestTransformHooks(tests.TestCaseWithTransport):
3698
super(TestTransformHooks, self).setUp()
3699
self.wt = self.make_branch_and_tree('.')
3702
def get_transform(self):
3703
transform = TreeTransform(self.wt)
3704
self.addCleanup(transform.finalize)
3705
return transform, transform.root
3707
def test_pre_commit_hooks(self):
3709
def record_pre_transform(tree, tt):
3710
calls.append((tree, tt))
3711
MutableTree.hooks.install_named_hook('pre_transform',
3712
record_pre_transform, "Pre transform")
3713
transform, root = self.get_transform()
3714
old_root_id = transform.tree_file_id(root)
3716
self.assertEqual(old_root_id, self.wt.get_root_id())
3717
self.assertEquals([(self.wt, transform)], calls)
3719
def test_post_commit_hooks(self):
3721
def record_post_transform(tree, tt):
3722
calls.append((tree, tt))
3723
MutableTree.hooks.install_named_hook('post_transform',
3724
record_post_transform, "Post transform")
3725
transform, root = self.get_transform()
3726
old_root_id = transform.tree_file_id(root)
3728
self.assertEqual(old_root_id, self.wt.get_root_id())
3729
self.assertEquals([(self.wt, transform)], calls)
added
removed
bzrlib/tests/test_transform.py
