/brz/remove-bazaar : revision 6992

101

trans, root = self.get_transform()

102

self.wt.lock_tree_write()

103

self.addCleanup(self.wt.unlock)

104

contents = ['just some content\n']

104

contents = [b'just some content\n']

105

sha1 = osutils.sha_strings(contents)

106

# Roll back the clock

107

trans._creation_mtime = time.time() - 20.0

145

trans_id = transform.create_path('name', root)

146

self.assertIs(transform.final_file_id(trans_id), None)

147

self.assertIs(None, transform.final_kind(trans_id))

148

transform.create_file('contents', trans_id)

148

transform.create_file([b'contents'], trans_id)

149

transform.set_executability(True, trans_id)

150

transform.version_file('my_pretties', trans_id)

151

self.assertRaises(DuplicateKey, transform.version_file,

158

transform.create_directory(oz_id)

159

transform.version_file('ozzie', oz_id)

160

trans_id2 = transform.create_path('name2', root)

161

transform.create_file('contents', trans_id2)

161

transform.create_file([b'contents'], trans_id2)

162

transform.set_executability(False, trans_id2)

163

transform.version_file('my_pretties2', trans_id2)

164

modified_paths = transform.apply().modified_paths

243

# Roll back the clock, so that we know everything is being set to the

244

# exact time

245

transform._creation_mtime = creation_mtime = time.time() - 20.0

246

transform.create_file('content-one',

246

transform.create_file([b'content-one'],

247

transform.create_path('one', root))

248

time.sleep(1) # *ugly*

249

transform.create_file('content-two',

249

transform.create_file([b'content-two'],

250

transform.create_path('two', root))

251

transform.apply()

252

fo, st1 = self.wt.get_file_with_stat('one', filtered=False)

354

def test_hardlink(self):

355

self.requireFeature(HardlinkFeature)

356

transform, root = self.get_transform()

357

transform.new_file('file1', root, 'contents')

357

transform.new_file('file1', root, b'contents')

358

transform.apply()

359

target = self.make_branch_and_tree('target')

360

target_transform = TreeTransform(target)

370

transform, root = self.get_transform()

371

self.wt.lock_tree_write()

372

self.addCleanup(self.wt.unlock)

373

trans_id = transform.new_file('name', root, 'contents',

373

trans_id = transform.new_file('name', root, b'contents',

374

'my_pretties', True)

375

oz = transform.new_directory('oz', root, 'oz-id')

376

dorothy = transform.new_directory('dorothy', oz, 'dorothy-id')

377

toto = transform.new_file('toto', dorothy, 'toto-contents',

377

toto = transform.new_file('toto', dorothy, b'toto-contents',

378

'toto-id', False)

379

380

self.assertEqual(len(transform.find_conflicts()), 0)

404

405

def test_conflicts(self):

406

transform, root = self.get_transform()

407

trans_id = transform.new_file('name', root, 'contents',

407

trans_id = transform.new_file('name', root, b'contents',

408

'my_pretties')

409

self.assertEqual(len(transform.find_conflicts()), 0)

410

trans_id2 = transform.new_file('name', root, 'Crontents', 'toto')

410

trans_id2 = transform.new_file('name', root, b'Crontents', 'toto')

411

self.assertEqual(transform.find_conflicts(),

412

[('duplicate', trans_id, trans_id2, 'name')])

413

self.assertRaises(MalformedTransform, transform.apply)

434

transform.adjust_path('name2', root, trans_id2)

435

self.assertEqual(transform.find_conflicts(),

436

[('versioning no contents', lion_id)])

437

transform.create_file('Contents, okay?', lion_id)

437

transform.create_file([b'Contents, okay?'], lion_id)

438

transform.adjust_path('name2', trans_id2, trans_id2)

439

self.assertEqual(transform.find_conflicts(),

440

[('parent loop', trans_id2),

448

self.assertEqual(transform.find_conflicts(),

449

[('non-file executability', oz_id)])

450

transform.set_executability(None, oz_id)

451

tip_id = transform.new_file('tip', oz_id, 'ozma', 'tip-id')

451

tip_id = transform.new_file('tip', oz_id, b'ozma', 'tip-id')

452

transform.apply()

453

self.assertEqual(self.wt.path2id('name'), 'my_pretties')

454

self.assertEqual('contents', file(self.wt.abspath('name')).read())

455

transform2, root = self.get_transform()

456

oz_id = transform2.trans_id_tree_path('oz')

457

newtip = transform2.new_file('tip', oz_id, 'other', 'tip-id')

457

newtip = transform2.new_file('tip', oz_id, b'other', 'tip-id')

458

result = transform2.find_conflicts()

459

fp = FinalPaths(transform2)

460

self.assertTrue('oz/tip' in transform2._tree_path_ids)

484

tree.case_sensitive = True

485

transform = TreeTransform(tree)

486

self.addCleanup(transform.finalize)

487

transform.new_file('file', transform.root, 'content')

488

transform.new_file('FiLe', transform.root, 'content')

487

transform.new_file('file', transform.root, b'content')

488

transform.new_file('FiLe', transform.root, b'content')

489

result = transform.find_conflicts()

490

self.assertEqual([], result)

491

transform.finalize()

494

tree.case_sensitive = False

495

transform = TreeTransform(tree)

496

self.addCleanup(transform.finalize)

497

transform.new_file('file', transform.root, 'content')

498

transform.new_file('FiLe', transform.root, 'content')

497

transform.new_file('file', transform.root, b'content')

498

transform.new_file('FiLe', transform.root, b'content')

499

result = transform.find_conflicts()

500

self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)

501

508

tree.case_sensitive = True

509

transform = TreeTransform(tree)

510

self.addCleanup(transform.finalize)

511

transform.new_file('file', transform.root, 'content')

511

transform.new_file('file', transform.root, b'content')

512

result = transform.find_conflicts()

513

self.assertEqual([], result)

514

transform.finalize()

517

tree.case_sensitive = False

518

transform = TreeTransform(tree)

519

self.addCleanup(transform.finalize)

520

transform.new_file('file', transform.root, 'content')

520

transform.new_file('file', transform.root, b'content')

521

result = transform.find_conflicts()

522

self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)

523

529

tree.case_sensitive = False

530

transform = TreeTransform(tree)

531

self.addCleanup(transform.finalize)

532

transform.new_file('file', transform.root, 'content')

533

transform.new_file('FiLe', transform.root, 'content')

532

transform.new_file('file', transform.root, b'content')

533

transform.new_file('FiLe', transform.root, b'content')

534

resolve_conflicts(transform)

535

transform.apply()

536

self.assertPathExists('tree/file')

544

tree.case_sensitive = False

545

transform = TreeTransform(tree)

546

self.addCleanup(transform.finalize)

547

transform.new_file('file', transform.root, 'content')

548

transform.new_file('FiLe', transform.root, 'content')

547

transform.new_file('file', transform.root, b'content')

548

transform.new_file('FiLe', transform.root, b'content')

549

resolve_conflicts(transform,

550

pass_func=lambda t, c: resolve_checkout(t, c, []))

551

transform.apply()

557

tree = self.make_branch_and_tree('tree')

558

transform = TreeTransform(tree)

559

self.addCleanup(transform.finalize)

560

transform.new_file('file', transform.root, 'content')

561

transform.new_file('FiLe', transform.root, 'content')

560

transform.new_file('file', transform.root, b'content')

561

transform.new_file('FiLe', transform.root, b'content')

562

dir = transform.new_directory('dir', transform.root)

563

transform.new_file('dirfile', dir, 'content')

564

transform.new_file('dirFiLe', dir, 'content')

563

transform.new_file('dirfile', dir, b'content')

564

transform.new_file('dirFiLe', dir, b'content')

565

resolve_conflicts(transform)

566

transform.apply()

567

self.assertPathExists('tree/file')

579

transform = TreeTransform(tree)

580

self.addCleanup(transform.finalize)

581

dir = transform.new_directory('dir', transform.root)

582

first = transform.new_file('file', dir, 'content')

583

second = transform.new_file('FiLe', dir, 'content')

582

first = transform.new_file('file', dir, b'content')

583

second = transform.new_file('FiLe', dir, b'content')

584

self.assertContainsRe(transform._limbo_name(first), 'new-1/file')

585

self.assertNotContainsRe(transform._limbo_name(second), 'new-1/FiLe')

586

608

def test_unversioning(self):

609

create_tree, root = self.get_transform()

610

parent_id = create_tree.new_directory('parent', root, b'parent-id')

611

create_tree.new_file('child', parent_id, 'child', b'child-id')

611

create_tree.new_file('child', parent_id, b'child', b'child-id')

612

create_tree.apply()

613

unversion = TreeTransform(self.wt)

614

self.addCleanup(unversion.finalize)

624

create_tree, root = self.get_transform()

625

# prepare tree

626

root = create_tree.root

627

create_tree.new_file('name1', root, 'hello1', 'name1')

628

create_tree.new_file('name2', root, 'hello2', 'name2')

627

create_tree.new_file('name1', root, b'hello1', 'name1')

628

create_tree.new_file('name2', root, b'hello2', 'name2')

629

ddir = create_tree.new_directory('dying_directory', root, 'ddir')

630

create_tree.new_file('dying_file', ddir, 'goodbye1', 'dfile')

631

create_tree.new_file('moving_file', ddir, 'later1', 'mfile')

632

create_tree.new_file('moving_file2', root, 'later2', 'mfile2')

630

create_tree.new_file('dying_file', ddir, b'goodbye1', 'dfile')

631

create_tree.new_file('moving_file', ddir, b'later1', 'mfile')

632

create_tree.new_file('moving_file2', root, b'later2', 'mfile2')

633

create_tree.apply()

634

635

mangle_tree, root = self.get_transform()

653

newdir = mangle_tree.new_directory('new_directory', root, 'newdir')

654

mfile2 = mangle_tree.trans_id_tree_path('moving_file2')

655

mangle_tree.adjust_path('mfile2', newdir, mfile2)

656

mangle_tree.new_file('newfile', newdir, 'hello3', 'dfile')

656

mangle_tree.new_file('newfile', newdir, b'hello3', 'dfile')

657

self.assertEqual(mangle_tree.final_file_id(mfile2), 'mfile2')

658

self.assertEqual(mangle_tree.final_parent(mfile2), newdir)

659

self.assertEqual(mangle_tree.final_file_id(mfile2), 'mfile2')

674

def test_both_rename(self):

675

create_tree, root = self.get_transform()

676

newdir = create_tree.new_directory('selftest', root, 'selftest-id')

677

create_tree.new_file('blackbox.py', newdir, 'hello1', 'blackbox-id')

677

create_tree.new_file('blackbox.py', newdir, b'hello1', 'blackbox-id')

678

create_tree.apply()

679

mangle_tree, root = self.get_transform()

680

selftest = mangle_tree.trans_id_tree_path('selftest')

689

breezy = create_tree.new_directory('breezy', root, 'breezy-id')

690

tests = create_tree.new_directory('tests', breezy, 'tests-id')

691

blackbox = create_tree.new_directory('blackbox', tests, 'blackbox-id')

692

create_tree.new_file('test_too_much.py', blackbox, 'hello1',

692

create_tree.new_file('test_too_much.py', blackbox, b'hello1',

693

'test_too_much-id')

694

create_tree.apply()

695

mangle_tree, root = self.get_transform()

704

def test_both_rename3(self):

705

create_tree, root = self.get_transform()

706

tests = create_tree.new_directory('tests', root, 'tests-id')

707

create_tree.new_file('test_too_much.py', tests, 'hello1',

707

create_tree.new_file('test_too_much.py', tests, b'hello1',

708

'test_too_much-id')

709

create_tree.apply()

710

mangle_tree, root = self.get_transform()

719

create_tree, root = self.get_transform()

720

# prepare tree

721

root = create_tree.root

722

create_tree.new_file('name1', root, 'hello1', 'name1')

722

create_tree.new_file('name1', root, b'hello1', 'name1')

723

create_tree.apply()

724

delete_contents, root = self.get_transform()

725

file = delete_contents.trans_id_tree_path('name1')

735

create_tree, root = self.get_transform()

736

# prepare tree

737

root = create_tree.root

738

create_tree.new_file('name1', root, 'hello1', 'name1')

738

create_tree.new_file('name1', root, b'hello1', 'name1')

739

create_tree.apply()

740

delete_contents = TreeTransform(self.wt)

741

self.addCleanup(delete_contents.finalize)

745

delete_contents.finalize()

746

replace = TreeTransform(self.wt)

747

self.addCleanup(replace.finalize)

748

name2 = replace.new_file('name2', root, 'hello2', 'name1')

748

name2 = replace.new_file('name2', root, b'hello2', 'name1')

749

conflicts = replace.find_conflicts()

750

name1 = replace.trans_id_tree_path('name1')

751

self.assertEqual(conflicts, [('duplicate id', name1, name2)])

811

812

def get_conflicted(self):

813

create, root = self.get_transform()

814

create.new_file('dorothy', root, 'dorothy', 'dorothy-id')

814

create.new_file('dorothy', root, b'dorothy', 'dorothy-id')

815

oz = create.new_directory('oz', root, 'oz-id')

816

create.new_directory('emeraldcity', oz, 'emerald-id')

817

create.apply()

818

conflicts, root = self.get_transform()

819

# set up duplicate entry, duplicate id

820

new_dorothy = conflicts.new_file('dorothy', root, 'dorothy',

820

new_dorothy = conflicts.new_file('dorothy', root, b'dorothy',

821

'dorothy-id')

822

old_dorothy = conflicts.trans_id_tree_path('dorothy')

823

oz = conflicts.trans_id_tree_path('oz')

900

901

def prepare_wrong_parent_kind(self):

902

tt, root = self.get_transform()

903

tt.new_file('parent', root, 'contents', b'parent-id')

903

tt.new_file('parent', root, b'contents', b'parent-id')

904

tt.apply()

905

tt, root = self.get_transform()

906

parent_id = tt.trans_id_file_id('parent-id')

907

tt.new_file('child,', parent_id, 'contents2', b'file-id')

907

tt.new_file('child,', parent_id, b'contents2', b'file-id')

908

return tt

909

910

def test_find_conflicts_wrong_parent_kind(self):

926

def test_resolve_conflicts_wrong_new_parent_kind(self):

927

tt, root = self.get_transform()

928

parent_id = tt.new_directory('parent', root, b'parent-id')

929

tt.new_file('child,', parent_id, 'contents2', b'file-id')

929

tt.new_file('child,', parent_id, b'contents2', b'file-id')

930

tt.apply()

931

tt, root = self.get_transform()

932

parent_id = tt.trans_id_file_id('parent-id')

933

tt.delete_contents(parent_id)

934

tt.create_file('contents', parent_id)

934

tt.create_file([b'contents'], parent_id)

935

raw_conflicts = resolve_conflicts(tt)

936

self.assertEqual({('non-directory parent', 'Created directory',

937

'new-3')}, raw_conflicts)

942

def test_resolve_conflicts_wrong_parent_kind_unversioned(self):

943

tt, root = self.get_transform()

944

parent_id = tt.new_directory('parent', root)

945

tt.new_file('child,', parent_id, 'contents2')

945

tt.new_file('child,', parent_id, b'contents2')

946

tt.apply()

947

tt, root = self.get_transform()

948

parent_id = tt.trans_id_tree_path('parent')

949

tt.delete_contents(parent_id)

950

tt.create_file('contents', parent_id)

950

tt.create_file([b'contents'], parent_id)

951

resolve_conflicts(tt)

952

tt.apply()

953

self.assertFalse(self.wt.is_versioned('parent'))

958

tt = TreeTransform(wt)

959

self.addCleanup(tt.finalize)

960

parent = tt.trans_id_file_id('parent-id')

961

tt.new_file('file', parent, 'Contents')

961

tt.new_file('file', parent, b'Contents')

962

raw_conflicts = resolve_conflicts(tt)

963

# Since the directory doesn't exist it's seen as 'missing'. So

964

# 'resolve_conflicts' create a conflict asking for it to be created.

996

create, root = self.get_transform()

997

old = create.new_directory('old-parent', root, 'old-id')

998

intermediate = create.new_directory('intermediate', old, 'im-id')

999

myfile = create.new_file('myfile', intermediate, 'myfile-text',

999

myfile = create.new_file('myfile', intermediate, b'myfile-text',

1000

'myfile-id')

1001

create.apply()

1002

rename, root = self.get_transform()

1011

# see https://bugs.launchpad.net/bzr/+bug/491763

1012

create, root_id = self.get_transform()

1013

first_dir = create.new_directory('first-dir', root_id, 'first-id')

1014

myfile = create.new_file('myfile', root_id, 'myfile-text',

1014

myfile = create.new_file('myfile', root_id, b'myfile-text',

1015

'myfile-id')

1016

create.apply()

1017

if os.name == "posix" and sys.platform != "cygwin":

1057

wt = transform._tree

1058

wt.lock_read()

1059

self.addCleanup(wt.unlock)

1060

transform.new_file('set_on_creation', root, 'Set on creation', 'soc',

1060

transform.new_file('set_on_creation', root, b'Set on creation', 'soc',

1061

True)

1062

sac = transform.new_file('set_after_creation', root,

1063

'Set after creation', 'sac')

1064

transform.set_executability(True, sac)

1065

uws = transform.new_file('unset_without_set', root, 'Unset badly',

1065

uws = transform.new_file('unset_without_set', root, b'Unset badly',

1066

'uws')

1067

self.assertRaises(KeyError, transform.set_executability, None, uws)

1068

transform.apply()

1074

if sys.platform == 'win32':

1075

raise TestSkipped('chmod has no effect on win32')

1076

transform, root = self.get_transform()

1077

transform.new_file('file1', root, 'contents', 'file1-id', True)

1077

transform.new_file('file1', root, b'contents', b'file1-id', True)

1078

transform.apply()

1079

self.wt.lock_write()

1080

self.addCleanup(self.wt.unlock)

1082

transform, root = self.get_transform()

1083

file1_id = transform.trans_id_tree_path('file1')

1084

transform.delete_contents(file1_id)

1085

transform.create_file('contents2', file1_id)

1085

transform.create_file([b'contents2'], file1_id)

1086

transform.apply()

1087

self.assertTrue(self.wt.is_executable('file1'))

1088

1099

1100

transform, root = self.get_transform()

1101

1102

bar1_id = transform.new_file('bar', root, 'bar contents 1\n',

1103

file_id='bar-id-1', executable=False)

1102

bar1_id = transform.new_file('bar', root, b'bar contents 1\n',

1103

file_id=b'bar-id-1', executable=False)

1104

transform.apply()

1105

1106

transform, root = self.get_transform()

1108

bar2_id = transform.trans_id_tree_path('bar2')

1109

try:

1110

os.stat = instrumented_stat

1111

transform.create_file('bar2 contents\n', bar2_id, mode_id=bar1_id)

1111

transform.create_file([b'bar2 contents\n'], bar2_id, mode_id=bar1_id)

1112

finally:

1113

os.stat = real_stat

1114

transform.finalize()

1119

def test_iter_changes(self):

1120

self.wt.set_root_id(b'eert_toor')

1121

transform, root = self.get_transform()

1122

transform.new_file('old', root, 'blah', 'id-1', True)

1122

transform.new_file('old', root, b'blah', b'id-1', True)

1123

transform.apply()

1124

transform, root = self.get_transform()

1125

try:

1140

def test_iter_changes_new(self):

1141

self.wt.set_root_id(b'eert_toor')

1142

transform, root = self.get_transform()

1143

transform.new_file('old', root, 'blah')

1143

transform.new_file('old', root, b'blah')

1144

transform.apply()

1145

transform, root = self.get_transform()

1146

try:

1155

def test_iter_changes_modifications(self):

1156

self.wt.set_root_id(b'eert_toor')

1157

transform, root = self.get_transform()

1158

transform.new_file('old', root, 'blah', 'id-1')

1159

transform.new_file('new', root, 'blah')

1158

transform.new_file('old', root, b'blah', 'id-1')

1159

transform.new_file('new', root, b'blah')

1160

transform.new_directory('subdir', root, 'subdir-id')

1161

transform.apply()

1162

transform, root = self.get_transform()

1173

(False, False))], list(transform.iter_changes()))

1174

1175

#content change

1176

transform.create_file('blah', old)

1176

transform.create_file([b'blah'], old)

1177

self.assertEqual([('id-1', ('old', 'old'), True, (True, True),

1178

('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),

1179

(False, False))], list(transform.iter_changes()))

1232

# obviously can't bleed into file2's change output. But for now, it

1233

# works.

1234

transform, root = self.get_transform()

1235

transform.new_file('file1', root, 'blah', 'id-1')

1236

transform.new_file('file2', root, 'blah', 'id-2')

1235

transform.new_file('file1', root, b'blah', 'id-1')

1236

transform.new_file('file2', root, b'blah', 'id-2')

1237

transform.apply()

1238

transform, root = self.get_transform()

1239

try:

1274

"""Ensure that no-ops are not treated as modifications"""

1275

self.wt.set_root_id(b'eert_toor')

1276

transform, root = self.get_transform()

1277

transform.new_file('old', root, 'blah', 'id-1')

1278

transform.new_directory('subdir', root, 'subdir-id')

1277

transform.new_file('old', root, b'blah', b'id-1')

1278

transform.new_directory('subdir', root, b'subdir-id')

1279

transform.apply()

1280

transform, root = self.get_transform()

1281

try:

1294

1295

def test_rename_count(self):

1296

transform, root = self.get_transform()

1297

transform.new_file('name1', root, 'contents')

1297

transform.new_file('name1', root, b'contents')

1298

self.assertEqual(transform.rename_count, 0)

1299

transform.apply()

1300

self.assertEqual(transform.rename_count, 1)

1317

"""

1318

transform, root = self.get_transform()

1319

parent1 = transform.new_directory('parent1', root)

1320

child1 = transform.new_file('child1', parent1, 'contents')

1320

child1 = transform.new_file('child1', parent1, b'contents')

1321

parent2 = transform.new_directory('parent2', root)

1322

transform.adjust_path('child1', parent2, child1)

1323

transform.apply()

1336

"""

1337

transform, root = self.get_transform()

1338

parent1 = transform.new_directory('parent1', root)

1339

child1 = transform.new_file('child1', parent1, 'contents')

1340

child2 = transform.new_file('child2', parent1, 'contents')

1339

child1 = transform.new_file('child1', parent1, b'contents')

1340

child2 = transform.new_file('child2', parent1, b'contents')

1341

try:

1342

transform.cancel_creation(parent1)

1343

except OSError:

1363

"""Make sure adjust_path keeps track of limbo children properly"""

1364

transform, root = self.get_transform()

1365

parent1 = transform.new_directory('parent1', root)

1366

child1 = transform.new_file('child1', parent1, 'contents')

1366

child1 = transform.new_file('child1', parent1, b'contents')

1367

parent2 = transform.new_directory('parent2', root)

1368

transform.adjust_path('child1', parent2, child1)

1369

transform.cancel_creation(child1)

1465

tt = TreeTransform(wt) # TreeTransform obtains write lock

1466

try:

1467

foo = tt.new_directory('foo', tt.root)

1468

tt.new_file('bar', foo, 'foobar')

1468

tt.new_file('bar', foo, b'foobar')

1469

baz = tt.new_directory('baz', tt.root)

1470

tt.new_file('qux', baz, 'quux')

1470

tt.new_file('qux', baz, b'quux')

1471

# Ask for a rename 'foo' -> 'baz'

1472

tt.adjust_path('baz', tt.root, foo)

1473

# Lie to tt that we've already resolved all conflicts.

1527

tt.delete_contents(foo_trans_id)

1528

tt.create_directory(foo_trans_id)

1529

bar_trans_id = tt.trans_id_tree_path("foo/bar")

1530

tt.create_file(["aa\n"], bar_trans_id)

1530

tt.create_file([b"aa\n"], bar_trans_id)

1531

tt.version_file("bar-1", bar_trans_id)

1532

tt.apply()

1533

self.assertPathExists("foo/bar")

1568

bar_trans_id = tt.trans_id_tree_path("foo/bar")

1569

tt.delete_contents(foo_trans_id)

1570

tt.delete_versioned(bar_trans_id)

1571

tt.create_file(["aa\n"], foo_trans_id)

1571

tt.create_file([b"aa\n"], foo_trans_id)

1572

tt.apply()

1573

self.assertPathExists("foo")

1574

wt.lock_read()

1599

def test_no_final_path(self):

1600

transform, root = self.get_transform()

1601

trans_id = transform.trans_id_file_id('foo')

1602

transform.create_file('bar', trans_id)

1602

transform.create_file([b'bar'], trans_id)

1603

transform.cancel_creation(trans_id)

1604

transform.apply()

1605

1696

def test_text_merge(self):

1697

root_id = generate_ids.gen_root_id()

1698

base = TransformGroup("base", root_id)

1699

base.tt.new_file('a', base.root, 'a\nb\nc\nd\be\n', 'a')

1700

base.tt.new_file('b', base.root, 'b1', 'b')

1701

base.tt.new_file('c', base.root, 'c', 'c')

1702

base.tt.new_file('d', base.root, 'd', 'd')

1703

base.tt.new_file('e', base.root, 'e', 'e')

1704

base.tt.new_file('f', base.root, 'f', 'f')

1705

base.tt.new_directory('g', base.root, 'g')

1706

base.tt.new_directory('h', base.root, 'h')

1699

base.tt.new_file('a', base.root, b'a\nb\nc\nd\be\n', b'a')

1700

base.tt.new_file('b', base.root, b'b1', b'b')

1701

base.tt.new_file('c', base.root, b'c', b'c')

1702

base.tt.new_file('d', base.root, b'd', b'd')

1703

base.tt.new_file('e', base.root, b'e', b'e')

1704

base.tt.new_file('f', base.root, b'f', b'f')

1705

base.tt.new_directory('g', base.root, b'g')

1706

base.tt.new_directory('h', base.root, b'h')

1707

base.tt.apply()

1708

other = TransformGroup("other", root_id)

1709

other.tt.new_file('a', other.root, 'y\nb\nc\nd\be\n', 'a')

1710

other.tt.new_file('b', other.root, 'b2', 'b')

1711

other.tt.new_file('c', other.root, 'c2', 'c')

1712

other.tt.new_file('d', other.root, 'd', 'd')

1713

other.tt.new_file('e', other.root, 'e2', 'e')

1714

other.tt.new_file('f', other.root, 'f', 'f')

1715

other.tt.new_file('g', other.root, 'g', 'g')

1716

other.tt.new_file('h', other.root, 'h\ni\nj\nk\n', 'h')

1717

other.tt.new_file('i', other.root, 'h\ni\nj\nk\n', 'i')

1709

other.tt.new_file('a', other.root, b'y\nb\nc\nd\be\n', b'a')

1710

other.tt.new_file('b', other.root, b'b2', b'b')

1711

other.tt.new_file('c', other.root, b'c2', b'c')

1712

other.tt.new_file('d', other.root, b'd', b'd')

1713

other.tt.new_file('e', other.root, b'e2', b'e')

1714

other.tt.new_file('f', other.root, b'f', b'f')

1715

other.tt.new_file('g', other.root, b'g', b'g')

1716

other.tt.new_file('h', other.root, b'h\ni\nj\nk\n', b'h')

1717

other.tt.new_file('i', other.root, b'h\ni\nj\nk\n', b'i')

1718

other.tt.apply()

1719

this = TransformGroup("this", root_id)

1720

this.tt.new_file('a', this.root, 'a\nb\nc\nd\bz\n', 'a')

1721

this.tt.new_file('b', this.root, 'b', 'b')

1722

this.tt.new_file('c', this.root, 'c', 'c')

1723

this.tt.new_file('d', this.root, 'd2', 'd')

1724

this.tt.new_file('e', this.root, 'e2', 'e')

1725

this.tt.new_file('f', this.root, 'f', 'f')

1726

this.tt.new_file('g', this.root, 'g', 'g')

1727

this.tt.new_file('h', this.root, '1\n2\n3\n4\n', 'h')

1728

this.tt.new_file('i', this.root, '1\n2\n3\n4\n', 'i')

1720

this.tt.new_file('a', this.root, b'a\nb\nc\nd\bz\n', b'a')

1721

this.tt.new_file('b', this.root, b'b', b'b')

1722

this.tt.new_file('c', this.root, b'c', b'c')

1723

this.tt.new_file('d', this.root, b'd2', b'd')

1724

this.tt.new_file('e', this.root, b'e2', b'e')

1725

this.tt.new_file('f', this.root, b'f', b'f')

1726

this.tt.new_file('g', this.root, b'g', b'g')

1727

this.tt.new_file('h', this.root, b'1\n2\n3\n4\n', b'h')

1728

this.tt.new_file('i', this.root, b'1\n2\n3\n4\n', b'i')

1729

this.tt.apply()

1730

Merge3Merger(this.wt, this.wt, base.wt, other.wt)

1731

1732

# textual merge

1733

self.assertEqual(this.wt.get_file(this.wt.id2path(b'a')).read(), 'y\nb\nc\nd\bz\n')

1733

self.assertEqual(this.wt.get_file(this.wt.id2path(b'a')).read(), b'y\nb\nc\nd\bz\n')

1734

# three-way text conflict

1735

self.assertEqual(this.wt.get_file(this.wt.id2path(b'b')).read(),

1736

conflict_text('b', 'b2'))

1737

# OTHER wins

1738

self.assertEqual(this.wt.get_file(this.wt.id2path(b'c')).read(), 'c2')

1738

self.assertEqual(this.wt.get_file(this.wt.id2path(b'c')).read(), b'c2')

1739

# THIS wins

1740

self.assertEqual(this.wt.get_file(this.wt.id2path(b'd')).read(), 'd2')

1740

self.assertEqual(this.wt.get_file(this.wt.id2path(b'd')).read(), b'd2')

1741

# Ambigious clean merge

1742

self.assertEqual(this.wt.get_file(this.wt.id2path(b'e')).read(), 'e2')

1742

self.assertEqual(this.wt.get_file(this.wt.id2path(b'e')).read(), b'e2')

1743

# No change

1744

self.assertEqual(this.wt.get_file(this.wt.id2path(b'f')).read(), 'f')

1744

self.assertEqual(this.wt.get_file(this.wt.id2path(b'f')).read(), b'f')

1745

# Correct correct results when THIS == OTHER

1746

self.assertEqual(this.wt.get_file(this.wt.id2path(b'g')).read(), 'g')

1746

self.assertEqual(this.wt.get_file(this.wt.id2path(b'g')).read(), b'g')

1747

# Text conflict when THIS & OTHER are text and BASE is dir

1748

self.assertEqual(this.wt.get_file(this.wt.id2path(b'h')).read(),

1749

conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))

1750

self.assertEqual(this.wt.get_file('h.THIS').read(),

1751

'1\n2\n3\n4\n')

1751

b'1\n2\n3\n4\n')

1752

self.assertEqual(this.wt.get_file('h.OTHER').read(),

1753

'h\ni\nj\nk\n')

1753

b'h\ni\nj\nk\n')

1754

self.assertEqual(file_kind(this.wt.abspath('h.BASE')), 'directory')

1755

self.assertEqual(this.wt.get_file(this.wt.id2path(b'i')).read(),

1756

conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))

1756

conflict_text(b'1\n2\n3\n4\n', b'h\ni\nj\nk\n'))

1757

self.assertEqual(this.wt.get_file('i.THIS').read(),

1758

'1\n2\n3\n4\n')

1758

b'1\n2\n3\n4\n')

1759

self.assertEqual(this.wt.get_file('i.OTHER').read(),

1760

'h\ni\nj\nk\n')

1760

b'h\ni\nj\nk\n')

1761

self.assertEqual(os.path.exists(this.wt.abspath('i.BASE')), False)

1762

modified = ['a', 'b', 'c', 'h', 'i']

1763

merge_modified = this.wt.merge_modified()

1778

this = TransformGroup("THIS", root_id)

1779

other = TransformGroup("OTHER", root_id)

1780

for tg in this, base, other:

1781

tg.tt.new_directory('a', tg.root, 'a')

1781

tg.tt.new_directory('a', tg.root, b'a')

1782

tg.tt.new_symlink('b', tg.root, 'b', 'b')

1783

tg.tt.new_file('c', tg.root, 'c', 'c')

1784

tg.tt.new_symlink('d', tg.root, tg.name, 'd')

1783

tg.tt.new_file('c', tg.root, b'c', b'c')

1784

tg.tt.new_symlink('d', tg.root, tg.name, b'd')

1785

targets = ((base, 'base-e', 'base-f', None, None),

1786

(this, 'other-e', 'this-f', 'other-g', 'this-h'),

1787

(other, 'other-e', None, 'other-g', 'other-h'))

1914

source = self.make_branch_and_tree('source')

1915

target = self.make_branch_and_tree('target')

1916

self.build_tree(['source/file', 'target/file'])

1917

source.add('file', 'new-file')

1917

source.add('file', b'new-file')

1918

source.commit('added file')

1919

build_tree(source.basis_tree(), target)

1920

self.assertEqual([DuplicateEntry('Moved existing file to',

1938

self.requireFeature(SymlinkFeature)

1939

source = self.make_branch_and_tree('source')

1940

os.symlink('foo', 'source/symlink')

1941

source.add('symlink', 'new-symlink')

1941

source.add('symlink', b'new-symlink')

1942

source.commit('added file')

1943

target = self.make_branch_and_tree('target')

1944

os.symlink('bar', 'target/symlink')

1956

source = self.make_branch_and_tree('source')

1957

target = self.make_branch_and_tree('target')

1958

self.build_tree(['source/dir1/', 'source/dir1/file', 'target/dir1/'])

1959

source.add(['dir1', 'dir1/file'], ['new-dir1', 'new-file'])

1959

source.add(['dir1', 'dir1/file'], [b'new-dir1', b'new-file'])

1960

source.commit('added file')

1961

build_tree(source.basis_tree(), target)

1962

self.assertEqual([], target.conflicts())

1998

source = self.make_branch_and_tree('source')

1999

target = self.make_branch_and_tree('target')

2000

self.build_tree(['source/name', 'target/name/'])

2001

source.add('name', 'new-name')

2001

source.add('name', b'new-name')

2002

source.commit('added file')

2003

build_tree(source.basis_tree(), target)

2004

self.assertEqual([DuplicateEntry('Moved existing file to',

2339

2340

def test_add_files(self):

2341

branch, tt = self.get_branch_and_transform()

2342

tt.new_file('file', tt.root, 'contents', b'file-id')

2342

tt.new_file('file', tt.root, b'contents', b'file-id')

2343

trans_id = tt.new_directory('dir', tt.root, 'dir-id')

2344

if SymlinkFeature.available():

2345

tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')

2354

2355

def test_add_unversioned(self):

2356

branch, tt = self.get_branch_and_transform()

2357

tt.new_file('file', tt.root, 'contents')

2357

tt.new_file('file', tt.root, b'contents')

2358

self.assertRaises(errors.StrictCommitFailed, tt.commit, branch,

2359

'message', strict=True)

2360

2361

def test_modify_strict(self):

2362

branch, tt = self.get_branch_and_transform()

2363

tt.new_file('file', tt.root, 'contents', b'file-id')

2363

tt.new_file('file', tt.root, b'contents', b'file-id')

2364

tt.commit(branch, 'message', strict=True)

2365

tt = TransformPreview(branch.basis_tree())

2366

self.addCleanup(tt.finalize)

2367

trans_id = tt.trans_id_file_id('file-id')

2368

tt.delete_contents(trans_id)

2369

tt.create_file('contents', trans_id)

2369

tt.create_file([b'contents'], trans_id)

2370

tt.commit(branch, 'message', strict=True)

2371

2372

def test_commit_malformed(self):

2376

"""

2377

branch, tt = self.get_branch_and_transform()

2378

parent_id = tt.trans_id_file_id('parent-id')

2379

tt.new_file('file', parent_id, 'contents', b'file-id')

2379

tt.new_file('file', parent_id, b'contents', b'file-id')

2380

self.assertRaises(errors.MalformedTransform, tt.commit, branch,

2381

'message')

2382

2384

branch, tt = self.get_branch_and_transform()

2385

rev_id = tt.commit(branch, 'message', timestamp=1, timezone=43201,

2386

committer='me <me@example.com>',

2387

revprops={'foo': 'bar'}, revision_id='revid-1',

2387

revprops={'foo': 'bar'}, revision_id=b'revid-1',

2388

authors=['Author1 <author1@example.com>',

2389

'Author2 <author2@example.com>',

2390

])

2578

tt, trans_id = self.create_transform_and_root_trans_id()

2579

self._override_globals_in_method(tt, "create_file",

2580

{"open": self._fake_open_raises_before})

2581

self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)

2581

self.assertRaises(RuntimeError, tt.create_file, [b"contents"], trans_id)

2582

path = tt._limbo_name(trans_id)

2583

self.assertPathDoesNotExist(path)

2584

tt.finalize()

2588

tt, trans_id = self.create_transform_and_root_trans_id()

2589

self._override_globals_in_method(tt, "create_file",

2590

{"open": self._fake_open_raises_after})

2591

self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)

2591

self.assertRaises(RuntimeError, tt.create_file, [b"contents"], trans_id)

2592

path = tt._limbo_name(trans_id)

2593

self.assertPathExists(path)

2594

tt.finalize()

2599

tt, trans_id = self.create_transform_and_subdir_trans_id()

2600

self._override_globals_in_method(tt, "create_file",

2601

{"open": self._fake_open_raises_before})

2602

self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)

2602

self.assertRaises(RuntimeError, tt.create_file, [b"contents"], trans_id)

2603

path = tt._limbo_name(trans_id)

2604

self.assertPathDoesNotExist(path)

2605

tt.finalize()

2609

tt, trans_id = self.create_transform_and_subdir_trans_id()

2610

self._override_globals_in_method(tt, "create_file",

2611

{"open": self._fake_open_raises_after})

2612

self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)

2612

self.assertRaises(RuntimeError, tt.create_file, [b"contents"], trans_id)

2613

path = tt._limbo_name(trans_id)

2614

self.assertPathExists(path)

2615

tt.finalize()

2619

def test_rename_in_limbo_rename_raises_after_rename(self):

2620

tt, trans_id = self.create_transform_and_root_trans_id()

2621

parent1 = tt.new_directory('parent1', tt.root)

2622

child1 = tt.new_file('child1', parent1, 'contents')

2622

child1 = tt.new_file('child1', parent1, b'contents')

2623

parent2 = tt.new_directory('parent2', tt.root)

2624

2625

class FakeOSModule(object):

2639

def test_rename_in_limbo_rename_raises_before_rename(self):

2640

tt, trans_id = self.create_transform_and_root_trans_id()

2641

parent1 = tt.new_directory('parent1', tt.root)

2642

child1 = tt.new_file('child1', parent1, 'contents')

2642

child1 = tt.new_file('child1', parent1, b'contents')

2643

parent2 = tt.new_directory('parent2', tt.root)

2644

2645

class FakeOSModule(object):

2670

def test_resolve_create_parent_for_versioned_file(self):

2671

wt, tt = self.make_tt_with_versioned_dir()

2672

dir_tid = tt.trans_id_tree_path('dir')

2673

file_tid = tt.new_file('file', dir_tid, 'Contents', file_id=b'file-id')

2673

file_tid = tt.new_file('file', dir_tid, b'Contents', file_id=b'file-id')

2674

tt.delete_contents(dir_tid)

2675

tt.unversion_file(dir_tid)

2676

conflicts = resolve_conflicts(tt)

2681

def test_non_versioned_file_create_conflict(self):

2682

wt, tt = self.make_tt_with_versioned_dir()

2683

dir_tid = tt.trans_id_tree_path('dir')

2684

tt.new_file('file', dir_tid, 'Contents')

2684

tt.new_file('file', dir_tid, b'Contents')

2685

tt.delete_contents(dir_tid)

2686

tt.unversion_file(dir_tid)

2687

conflicts = resolve_conflicts(tt)

2706

tree.set_root_id(b'TREE_ROOT')

2707

tree.add('a', b'a-id')

2708

tree.commit('rev1', rev_id=b'rev1')

2709

return tree.branch.repository.revision_tree('rev1')

2709

return tree.branch.repository.revision_tree(b'rev1')

2710

2711

def get_empty_preview(self):

2712

repository = self.make_repository('repo')

2730

revision_tree = self.create_tree()

2731

preview = TransformPreview(revision_tree)

2732

self.addCleanup(preview.finalize)

2733

preview.new_file('file2', preview.root, 'content B\n', 'file2-id')

2733

preview.new_file('file2', preview.root, b'content B\n', b'file2-id')

2734

preview_tree = preview.get_preview_tree()

2735

self.assertEqual(preview_tree.kind('file2'), 'file')

2736

self.assertEqual(

2737

preview_tree.get_file('file2', 'file2-id').read(), 'content B\n')

2737

preview_tree.get_file('file2', b'file2-id').read(), b'content B\n')

2738

2739

def test_diff_preview_tree(self):

2740

revision_tree = self.create_tree()

2741

preview = TransformPreview(revision_tree)

2742

self.addCleanup(preview.finalize)

2743

preview.new_file('file2', preview.root, 'content B\n', 'file2-id')

2743

preview.new_file('file2', preview.root, b'content B\n', b'file2-id')

2744

preview_tree = preview.get_preview_tree()

2745

out = BytesIO()

2746

show_diff_trees(revision_tree, preview_tree, out)

2753

revision_tree = self.create_tree()

2754

preview = TransformPreview(revision_tree)

2755

self.addCleanup(preview.finalize)

2756

preview.new_file('a', preview.root, 'content 2')

2756

preview.new_file('a', preview.root, b'content 2')

2757

resolve_conflicts(preview)

2758

trans_id = preview.trans_id_file_id('a-id')

2759

self.assertEqual('a.moved', preview.final_name(trans_id))

2764

self.addCleanup(preview.finalize)

2765

a_trans_id = preview.trans_id_file_id('a-id')

2766

preview.delete_contents(a_trans_id)

2767

preview.create_file('b content', a_trans_id)

2767

preview.create_file([b'b content'], a_trans_id)

2768

preview_tree = preview.get_preview_tree()

2769

return revision_tree, preview_tree

2770

2816

revision_tree = self.create_tree()

2817

preview = TransformPreview(revision_tree)

2818

self.addCleanup(preview.finalize)

2819

preview.new_file('file', preview.root, 'contents', b'file-id')

2819

preview.new_file('file', preview.root, b'contents', b'file-id')

2820

preview.new_directory('directory', preview.root, 'dir-id')

2821

preview_tree = preview.get_preview_tree()

2822

self.assertEqual('file', preview_tree.kind('file'))

2824

2825

def test_get_file_mtime(self):

2826

preview = self.get_empty_preview()

2827

file_trans_id = preview.new_file('file', preview.root, 'contents',

2827

file_trans_id = preview.new_file('file', preview.root, b'contents',

2828

b'file-id')

2829

limbo_path = preview._limbo_name(file_trans_id)

2830

preview_tree = preview.get_preview_tree()

2849

work_tree.add('old', b'old-id')

2850

preview = TransformPreview(work_tree)

2851

self.addCleanup(preview.finalize)

2852

new_id = preview.new_file('name', preview.root, 'contents', b'new-id',

2852

new_id = preview.new_file('name', preview.root, b'contents', b'new-id',

2853

'executable')

2854

tree = preview.get_preview_tree()

2855

self.assertEqual(len('old'), tree.get_file_size('old'))

2857

2858

def test_get_file(self):

2859

preview = self.get_empty_preview()

2860

preview.new_file('file', preview.root, 'contents', b'file-id')

2860

preview.new_file('file', preview.root, b'contents', b'file-id')

2861

preview_tree = preview.get_preview_tree()

2862

tree_file = preview_tree.get_file('file')

2863

try:

2950

def test_iter_entries_by_dir_new(self):

2951

tree = self.make_branch_and_tree('tree')

2952

tt = TreeTransform(tree)

2953

tt.new_file('new', tt.root, 'contents', b'new-id')

2953

tt.new_file('new', tt.root, b'contents', b'new-id')

2954

self.assertMatchingIterEntries(tt)

2955

2956

def test_iter_entries_by_dir_deleted(self):

3010

3011

def test_file_content_summary_executable(self):

3012

preview = self.get_empty_preview()

3013

path_id = preview.new_file('path', preview.root, 'contents', 'path-id')

3013

path_id = preview.new_file('path', preview.root, b'contents', 'path-id')

3014

preview.set_executability(True, path_id)

3015

summary = preview.get_preview_tree().path_content_summary('path')

3016

self.assertEqual(4, len(summary))

3035

3036

def test_file_content_summary_non_exec(self):

3037

preview = self.get_empty_preview()

3038

preview.new_file('path', preview.root, 'contents', 'path-id')

3038

preview.new_file('path', preview.root, b'contents', 'path-id')

3039

summary = preview.get_preview_tree().path_content_summary('path')

3040

self.assertEqual(4, len(summary))

3041

self.assertEqual('file', summary[0])

3070

self.addCleanup(preview.finalize)

3071

file_trans_id = preview.trans_id_file_id(b'file-id')

3072

preview.delete_contents(file_trans_id)

3073

preview.create_file('a\nb\nc\n', file_trans_id)

3073

preview.create_file([b'a\nb\nc\n'], file_trans_id)

3074

preview_tree = preview.get_preview_tree()

3075

expected = [

3076

('one', 'a\n'),

3082

3083

def test_annotate_missing(self):

3084

preview = self.get_empty_preview()

3085

preview.new_file('file', preview.root, 'a\nb\nc\n', b'file-id')

3085

preview.new_file('file', preview.root, b'a\nb\nc\n', 'file-id')

3086

preview_tree = preview.get_preview_tree()

3087

expected = [

3088

('me:', 'a\n'),

3124

3125

def test_stored_kind(self):

3126

preview = self.get_empty_preview()

3127

preview.new_file('file', preview.root, 'a\nb\nc\n', b'file-id')

3127

preview.new_file('file', preview.root, b'a\nb\nc\n', b'file-id')

3128

preview_tree = preview.get_preview_tree()

3129

self.assertEqual('file', preview_tree.stored_kind('file'))

3130

3131

def test_is_executable(self):

3132

preview = self.get_empty_preview()

3133

preview.new_file('file', preview.root, 'a\nb\nc\n', b'file-id')

3133

preview.new_file('file', preview.root, b'a\nb\nc\n', b'file-id')

3134

preview.set_executability(True, preview.trans_id_file_id(b'file-id'))

3135

preview_tree = preview.get_preview_tree()

3136

self.assertEqual(True, preview_tree.is_executable('file'))

3151

self.addCleanup(preview.finalize)

3152

trans_id = preview.trans_id_file_id(b'file-id')

3153

preview.delete_contents(trans_id)

3154

preview.create_file('b\nc\nd\ne\n', trans_id)

3154

preview.create_file([b'b\nc\nd\ne\n'], trans_id)

3155

self.build_tree_contents([('wtb/file', b'a\nc\nd\nf\n')])

3156

tree_a = preview.get_preview_tree()

3157

tree_a.set_parent_ids([base_id])

3174

self.addCleanup(preview.finalize)

3175

trans_id = preview.trans_id_file_id(b'file-id')

3176

preview.delete_contents(trans_id)

3177

preview.create_file('b\nc\nd\ne\n', trans_id)

3177

preview.create_file([b'b\nc\nd\ne\n'], trans_id)

3178

self.build_tree_contents([('wtb/file', b'a\nc\nd\nf\n')])

3179

tree_a = preview.get_preview_tree()

3180

tree_a.set_parent_ids([base_id])

3193

# FIXME: new_directory should mark root.

3194

preview.fixup_new_roots()

3195

preview_tree = preview.get_preview_tree()

3196

file_trans_id = preview.new_file('a', preview.root, 'contents',

3196

file_trans_id = preview.new_file('a', preview.root, b'contents',

3197

b'a-id')

3198

expected = [(('', b'tree-root'),

3199

[('a', 'a', 'file', None, b'a-id', 'file')])]

3206

work_tree.add(['removed-file', 'not-removed-file'])

3207

preview = TransformPreview(work_tree)

3208

self.addCleanup(preview.finalize)

3209

preview.new_file('new-file', preview.root, 'contents')

3210

preview.new_file('new-versioned-file', preview.root, 'contents',

3209

preview.new_file('new-file', preview.root, b'contents')

3210

preview.new_file('new-versioned-file', preview.root, b'contents',

3211

b'new-versioned-id')

3212

tree = preview.get_preview_tree()

3213

preview.unversion_file(preview.trans_id_tree_path('removed-file'))

3230

self.addCleanup(preview.finalize)

3231

file_trans_id = preview.trans_id_file_id(b'file-id')

3232

preview.delete_contents(file_trans_id)

3233

preview.create_file('a\nb\n', file_trans_id)

3233

preview.create_file([b'a\nb\n'], file_trans_id)

3234

preview_tree = preview.get_preview_tree()

3235

merger = Merger.from_revision_ids(preview_tree,

3236

child_tree.branch.last_revision(),

3249

tree.set_root_id(b'TREE_ROOT')

3250

tt = TransformPreview(tree)

3251

self.addCleanup(tt.finalize)

3252

tt.new_file('name', tt.root, 'content', b'file-id')

3252

tt.new_file('name', tt.root, b'content', b'file-id')

3253

tree2 = self.make_branch_and_tree('tree2')

3254

tree2.set_root_id(b'TREE_ROOT')

3255

merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),

3266

self.addCleanup(tt.finalize)

3267

trans_id = tt.trans_id_file_id(b'foo-id')

3268

tt.delete_contents(trans_id)

3269

tt.create_file('baz', trans_id)

3269

tt.create_file([b'baz'], trans_id)

3270

tree2 = tree.controldir.sprout('tree2').open_workingtree()

3271

self.build_tree_contents([('tree2/foo', b'qux')])

3272

merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),

3280

tt = TransformPreview(wt)

3281

removed_id = tt.trans_id_tree_path('removed')

3282

tt.delete_contents(removed_id)

3283

tt.new_file('new', tt.root, 'contents')

3283

tt.new_file('new', tt.root, b'contents')

3284

modified_id = tt.trans_id_tree_path('modified')

3285

tt.delete_contents(modified_id)

3286

tt.create_file('modified-contents', modified_id)

3286

tt.create_file([b'modified-contents'], modified_id)

3287

self.addCleanup(tt.finalize)

3288

tree = tt.get_preview_tree()

3289

self.assertTrue(tree.has_filename('unmodified'))

3296

tree = self.make_branch_and_tree('tree')

3297

preview = TransformPreview(tree)

3298

self.addCleanup(preview.finalize)

3299

preview.new_file('foo', preview.root, 'bar', 'baz-id')

3299

preview.new_file('foo', preview.root, b'bar', 'baz-id')

3300

preview_tree = preview.get_preview_tree()

3301

self.assertEqual(False, preview_tree.is_executable('tree/foo', 'baz-id'))

3302

self.assertEqual(False, preview_tree.is_executable('tree/foo'))

3307

tree.branch.lock_write()

3308

self.addCleanup(tree.branch.unlock)

3309

tt = TransformPreview(tree)

3310

tt.new_file('file', tt.root, 'contents', 'file_id')

3310

tt.new_file('file', tt.root, b'contents', b'file_id')

3311

self.addCleanup(tt.finalize)

3312

preview = tt.get_preview_tree()

3313

preview.set_parent_ids([rev_id])

3325

tt = TransformPreview(tree)

3326

self.addCleanup(tt.finalize)

3327

foo_id = tt.new_directory('', ROOT_PARENT)

3328

bar_id = tt.new_file(u'\u1234bar', foo_id, 'contents')

3328

bar_id = tt.new_file(u'\u1234bar', foo_id, b'contents')

3329

limbo_path = tt._limbo_name(bar_id)

3330

self.assertEqual(limbo_path.encode('ascii', 'replace'), limbo_path)

3331

3391

3392

def test_serialize_creation(self):

3393

tt = self.get_preview()

3394

tt.new_file(u'foo\u1234', tt.root, 'bar', 'baz', True)

3394

tt.new_file(u'foo\u1234', tt.root, b'bar', 'baz', True)

3395

tt.new_directory('qux', tt.root, 'quxx')

3396

self.assertSerializesTo(self.creation_records(), tt)

3397