/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_transform.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-09-03 08:32:49 UTC
  • mfrom: (1739.2.13 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080903083249-e76ygekseh1peidm
Fix typo in ReadDirFeature.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
import os
 
18
import stat
18
19
from StringIO import StringIO
19
20
import sys
20
 
import time
21
21
 
22
22
from bzrlib import (
23
 
    bencode,
24
23
    errors,
25
 
    filters,
26
24
    generate_ids,
27
25
    osutils,
 
26
    progress,
28
27
    revision as _mod_revision,
29
 
    rules,
 
28
    symbol_versioning,
30
29
    tests,
31
30
    urlutils,
32
31
    )
33
32
from bzrlib.bzrdir import BzrDir
34
 
from bzrlib.conflicts import (
35
 
    DeletingParent,
36
 
    DuplicateEntry,
37
 
    DuplicateID,
38
 
    MissingParent,
39
 
    NonDirectoryParent,
40
 
    ParentLoop,
41
 
    UnversionedParent,
42
 
)
 
33
from bzrlib.conflicts import (DuplicateEntry, DuplicateID, MissingParent,
 
34
                              UnversionedParent, ParentLoop, DeletingParent,
 
35
                              NonDirectoryParent)
43
36
from bzrlib.diff import show_diff_trees
44
 
from bzrlib.errors import (
45
 
    DuplicateKey,
46
 
    ExistingLimbo,
47
 
    ExistingPendingDeletion,
48
 
    ImmortalLimbo,
49
 
    ImmortalPendingDeletion,
50
 
    LockError,
51
 
    MalformedTransform,
52
 
    NoSuchFile,
53
 
    ReusingTransform,
54
 
)
55
 
from bzrlib.osutils import (
56
 
    file_kind,
57
 
    pathjoin,
58
 
)
59
 
from bzrlib.merge import Merge3Merger, Merger
 
37
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
 
38
                           ReusingTransform, CantMoveRoot, 
 
39
                           PathsNotVersionedError, ExistingLimbo,
 
40
                           ExistingPendingDeletion, ImmortalLimbo,
 
41
                           ImmortalPendingDeletion, LockError)
 
42
from bzrlib.osutils import file_kind, pathjoin
 
43
from bzrlib.merge import Merge3Merger
60
44
from bzrlib.tests import (
 
45
    CaseInsensitiveFilesystemFeature,
61
46
    HardlinkFeature,
62
47
    SymlinkFeature,
63
48
    TestCase,
64
49
    TestCaseInTempDir,
65
50
    TestSkipped,
66
 
)
67
 
from bzrlib.transform import (
68
 
    build_tree,
69
 
    create_from_tree,
70
 
    cook_conflicts,
71
 
    _FileMover,
72
 
    FinalPaths,
73
 
    get_backup_name,
74
 
    resolve_conflicts,
75
 
    resolve_checkout,
76
 
    ROOT_PARENT,
77
 
    TransformPreview,
78
 
    TreeTransform,
79
 
)
80
 
 
 
51
    )
 
52
from bzrlib.transform import (TreeTransform, ROOT_PARENT, FinalPaths, 
 
53
                              resolve_conflicts, cook_conflicts, 
 
54
                              build_tree, get_backup_name,
 
55
                              _FileMover, resolve_checkout,
 
56
                              TransformPreview)
81
57
 
82
58
class TestTreeTransform(tests.TestCaseWithTransport):
83
59
 
152
128
        self.assertIs(self.wt.is_executable('my_pretties2'), False)
153
129
        self.assertEqual('directory', file_kind(self.wt.abspath('oz')))
154
130
        self.assertEqual(len(modified_paths), 3)
155
 
        tree_mod_paths = [self.wt.id2abspath(f) for f in
 
131
        tree_mod_paths = [self.wt.id2abspath(f) for f in 
156
132
                          ('ozzie', 'my_pretties', 'my_pretties2')]
157
133
        self.assertSubset(tree_mod_paths, modified_paths)
158
134
        # is it safe to finalize repeatedly?
159
135
        transform.finalize()
160
136
        transform.finalize()
161
137
 
162
 
    def test_create_files_same_timestamp(self):
163
 
        transform, root = self.get_transform()
164
 
        self.wt.lock_tree_write()
165
 
        self.addCleanup(self.wt.unlock)
166
 
        # Roll back the clock, so that we know everything is being set to the
167
 
        # exact time
168
 
        transform._creation_mtime = creation_mtime = time.time() - 20.0
169
 
        transform.create_file('content-one',
170
 
                              transform.create_path('one', root))
171
 
        time.sleep(1) # *ugly*
172
 
        transform.create_file('content-two',
173
 
                              transform.create_path('two', root))
174
 
        transform.apply()
175
 
        fo, st1 = self.wt.get_file_with_stat(None, path='one', filtered=False)
176
 
        fo.close()
177
 
        fo, st2 = self.wt.get_file_with_stat(None, path='two', filtered=False)
178
 
        fo.close()
179
 
        # We only guarantee 2s resolution
180
 
        self.assertTrue(abs(creation_mtime - st1.st_mtime) < 2.0,
181
 
            "%s != %s within 2 seconds" % (creation_mtime, st1.st_mtime))
182
 
        # But if we have more than that, all files should get the same result
183
 
        self.assertEqual(st1.st_mtime, st2.st_mtime)
184
 
 
185
 
    def test_change_root_id(self):
186
 
        transform, root = self.get_transform()
187
 
        self.assertNotEqual('new-root-id', self.wt.get_root_id())
188
 
        transform.new_directory('', ROOT_PARENT, 'new-root-id')
189
 
        transform.delete_contents(root)
190
 
        transform.unversion_file(root)
191
 
        transform.fixup_new_roots()
192
 
        transform.apply()
193
 
        self.assertEqual('new-root-id', self.wt.get_root_id())
194
 
 
195
 
    def test_change_root_id_add_files(self):
196
 
        transform, root = self.get_transform()
197
 
        self.assertNotEqual('new-root-id', self.wt.get_root_id())
198
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
199
 
        transform.new_file('file', new_trans_id, ['new-contents\n'],
200
 
                           'new-file-id')
201
 
        transform.delete_contents(root)
202
 
        transform.unversion_file(root)
203
 
        transform.fixup_new_roots()
204
 
        transform.apply()
205
 
        self.assertEqual('new-root-id', self.wt.get_root_id())
206
 
        self.assertEqual('new-file-id', self.wt.path2id('file'))
207
 
        self.assertFileEqual('new-contents\n', self.wt.abspath('file'))
208
 
 
209
 
    def test_add_two_roots(self):
210
 
        transform, root = self.get_transform()
211
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
212
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'alt-root-id')
213
 
        self.assertRaises(ValueError, transform.fixup_new_roots)
214
 
 
215
138
    def test_hardlink(self):
216
139
        self.requireFeature(HardlinkFeature)
217
140
        transform, root = self.get_transform()
231
154
        transform, root = self.get_transform()
232
155
        self.wt.lock_tree_write()
233
156
        self.addCleanup(self.wt.unlock)
234
 
        trans_id = transform.new_file('name', root, 'contents',
 
157
        trans_id = transform.new_file('name', root, 'contents', 
235
158
                                      'my_pretties', True)
236
159
        oz = transform.new_directory('oz', root, 'oz-id')
237
160
        dorothy = transform.new_directory('dorothy', oz, 'dorothy-id')
238
 
        toto = transform.new_file('toto', dorothy, 'toto-contents',
 
161
        toto = transform.new_file('toto', dorothy, 'toto-contents', 
239
162
                                  'toto-id', False)
240
163
 
241
164
        self.assertEqual(len(transform.find_conflicts()), 0)
265
188
 
266
189
    def test_conflicts(self):
267
190
        transform, root = self.get_transform()
268
 
        trans_id = transform.new_file('name', root, 'contents',
 
191
        trans_id = transform.new_file('name', root, 'contents', 
269
192
                                      'my_pretties')
270
193
        self.assertEqual(len(transform.find_conflicts()), 0)
271
194
        trans_id2 = transform.new_file('name', root, 'Crontents', 'toto')
272
 
        self.assertEqual(transform.find_conflicts(),
 
195
        self.assertEqual(transform.find_conflicts(), 
273
196
                         [('duplicate', trans_id, trans_id2, 'name')])
274
197
        self.assertRaises(MalformedTransform, transform.apply)
275
198
        transform.adjust_path('name', trans_id, trans_id2)
276
 
        self.assertEqual(transform.find_conflicts(),
 
199
        self.assertEqual(transform.find_conflicts(), 
277
200
                         [('non-directory parent', trans_id)])
278
201
        tinman_id = transform.trans_id_tree_path('tinman')
279
202
        transform.adjust_path('name', tinman_id, trans_id2)
280
 
        self.assertEqual(transform.find_conflicts(),
281
 
                         [('unversioned parent', tinman_id),
 
203
        self.assertEqual(transform.find_conflicts(), 
 
204
                         [('unversioned parent', tinman_id), 
282
205
                          ('missing parent', tinman_id)])
283
206
        lion_id = transform.create_path('lion', root)
284
 
        self.assertEqual(transform.find_conflicts(),
285
 
                         [('unversioned parent', tinman_id),
 
207
        self.assertEqual(transform.find_conflicts(), 
 
208
                         [('unversioned parent', tinman_id), 
286
209
                          ('missing parent', tinman_id)])
287
210
        transform.adjust_path('name', lion_id, trans_id2)
288
 
        self.assertEqual(transform.find_conflicts(),
 
211
        self.assertEqual(transform.find_conflicts(), 
289
212
                         [('unversioned parent', lion_id),
290
213
                          ('missing parent', lion_id)])
291
214
        transform.version_file("Courage", lion_id)
292
 
        self.assertEqual(transform.find_conflicts(),
293
 
                         [('missing parent', lion_id),
 
215
        self.assertEqual(transform.find_conflicts(), 
 
216
                         [('missing parent', lion_id), 
294
217
                          ('versioning no contents', lion_id)])
295
218
        transform.adjust_path('name2', root, trans_id2)
296
 
        self.assertEqual(transform.find_conflicts(),
 
219
        self.assertEqual(transform.find_conflicts(), 
297
220
                         [('versioning no contents', lion_id)])
298
221
        transform.create_file('Contents, okay?', lion_id)
299
222
        transform.adjust_path('name2', trans_id2, trans_id2)
300
 
        self.assertEqual(transform.find_conflicts(),
301
 
                         [('parent loop', trans_id2),
 
223
        self.assertEqual(transform.find_conflicts(), 
 
224
                         [('parent loop', trans_id2), 
302
225
                          ('non-directory parent', trans_id2)])
303
226
        transform.adjust_path('name2', root, trans_id2)
304
227
        oz_id = transform.new_directory('oz', root)
305
228
        transform.set_executability(True, oz_id)
306
 
        self.assertEqual(transform.find_conflicts(),
 
229
        self.assertEqual(transform.find_conflicts(), 
307
230
                         [('unversioned executability', oz_id)])
308
231
        transform.version_file('oz-id', oz_id)
309
 
        self.assertEqual(transform.find_conflicts(),
 
232
        self.assertEqual(transform.find_conflicts(), 
310
233
                         [('non-file executability', oz_id)])
311
234
        transform.set_executability(None, oz_id)
312
235
        tip_id = transform.new_file('tip', oz_id, 'ozma', 'tip-id')
321
244
        self.assert_('oz/tip' in transform2._tree_path_ids)
322
245
        self.assertEqual(fp.get_path(newtip), pathjoin('oz', 'tip'))
323
246
        self.assertEqual(len(result), 2)
324
 
        self.assertEqual((result[0][0], result[0][1]),
 
247
        self.assertEqual((result[0][0], result[0][1]), 
325
248
                         ('duplicate', newtip))
326
 
        self.assertEqual((result[1][0], result[1][2]),
 
249
        self.assertEqual((result[1][0], result[1][2]), 
327
250
                         ('duplicate id', newtip))
328
251
        transform2.finalize()
329
252
        transform3 = TreeTransform(self.wt)
330
253
        self.addCleanup(transform3.finalize)
331
254
        oz_id = transform3.trans_id_tree_file_id('oz-id')
332
255
        transform3.delete_contents(oz_id)
333
 
        self.assertEqual(transform3.find_conflicts(),
 
256
        self.assertEqual(transform3.find_conflicts(), 
334
257
                         [('missing parent', oz_id)])
335
258
        root_id = transform3.root
336
259
        tip_id = transform3.trans_id_tree_file_id('tip-id')
445
368
        self.assertContainsRe(transform._limbo_name(first), 'new-1/file')
446
369
        self.assertNotContainsRe(transform._limbo_name(second), 'new-1/FiLe')
447
370
 
448
 
    def test_adjust_path_updates_child_limbo_names(self):
449
 
        tree = self.make_branch_and_tree('tree')
450
 
        transform = TreeTransform(tree)
451
 
        self.addCleanup(transform.finalize)
452
 
        foo_id = transform.new_directory('foo', transform.root)
453
 
        bar_id = transform.new_directory('bar', foo_id)
454
 
        baz_id = transform.new_directory('baz', bar_id)
455
 
        qux_id = transform.new_directory('qux', baz_id)
456
 
        transform.adjust_path('quxx', foo_id, bar_id)
457
 
        self.assertStartsWith(transform._limbo_name(qux_id),
458
 
                              transform._limbo_name(bar_id))
459
 
 
460
371
    def test_add_del(self):
461
372
        start, root = self.get_transform()
462
373
        start.new_directory('a', root, 'a')
475
386
        self.addCleanup(unversion.finalize)
476
387
        parent = unversion.trans_id_tree_path('parent')
477
388
        unversion.unversion_file(parent)
478
 
        self.assertEqual(unversion.find_conflicts(),
 
389
        self.assertEqual(unversion.find_conflicts(), 
479
390
                         [('unversioned parent', parent_id)])
480
391
        file_id = unversion.trans_id_tree_file_id('child-id')
481
392
        unversion.unversion_file(file_id)
501
412
        mangle_tree.adjust_path('name2', root, name1)
502
413
        mangle_tree.adjust_path('name1', root, name2)
503
414
 
504
 
        #tests for deleting parent directories
 
415
        #tests for deleting parent directories 
505
416
        ddir = mangle_tree.trans_id_tree_file_id('ddir')
506
417
        mangle_tree.delete_contents(ddir)
507
418
        dfile = mangle_tree.trans_id_tree_file_id('dfile')
536
447
        create_tree,root = self.get_transform()
537
448
        newdir = create_tree.new_directory('selftest', root, 'selftest-id')
538
449
        create_tree.new_file('blackbox.py', newdir, 'hello1', 'blackbox-id')
539
 
        create_tree.apply()
 
450
        create_tree.apply()        
540
451
        mangle_tree,root = self.get_transform()
541
452
        selftest = mangle_tree.trans_id_tree_file_id('selftest-id')
542
453
        blackbox = mangle_tree.trans_id_tree_file_id('blackbox-id')
550
461
        bzrlib = create_tree.new_directory('bzrlib', root, 'bzrlib-id')
551
462
        tests = create_tree.new_directory('tests', bzrlib, 'tests-id')
552
463
        blackbox = create_tree.new_directory('blackbox', tests, 'blackbox-id')
553
 
        create_tree.new_file('test_too_much.py', blackbox, 'hello1',
 
464
        create_tree.new_file('test_too_much.py', blackbox, 'hello1', 
554
465
                             'test_too_much-id')
555
 
        create_tree.apply()
 
466
        create_tree.apply()        
556
467
        mangle_tree,root = self.get_transform()
557
468
        bzrlib = mangle_tree.trans_id_tree_file_id('bzrlib-id')
558
469
        tests = mangle_tree.trans_id_tree_file_id('tests-id')
559
470
        test_too_much = mangle_tree.trans_id_tree_file_id('test_too_much-id')
560
471
        mangle_tree.adjust_path('selftest', bzrlib, tests)
561
 
        mangle_tree.adjust_path('blackbox.py', tests, test_too_much)
 
472
        mangle_tree.adjust_path('blackbox.py', tests, test_too_much) 
562
473
        mangle_tree.set_executability(True, test_too_much)
563
474
        mangle_tree.apply()
564
475
 
565
476
    def test_both_rename3(self):
566
477
        create_tree,root = self.get_transform()
567
478
        tests = create_tree.new_directory('tests', root, 'tests-id')
568
 
        create_tree.new_file('test_too_much.py', tests, 'hello1',
 
479
        create_tree.new_file('test_too_much.py', tests, 'hello1', 
569
480
                             'test_too_much-id')
570
 
        create_tree.apply()
 
481
        create_tree.apply()        
571
482
        mangle_tree,root = self.get_transform()
572
483
        tests = mangle_tree.trans_id_tree_file_id('tests-id')
573
484
        test_too_much = mangle_tree.trans_id_tree_file_id('test_too_much-id')
574
485
        mangle_tree.adjust_path('selftest', root, tests)
575
 
        mangle_tree.adjust_path('blackbox.py', tests, test_too_much)
 
486
        mangle_tree.adjust_path('blackbox.py', tests, test_too_much) 
576
487
        mangle_tree.set_executability(True, test_too_much)
577
488
        mangle_tree.apply()
578
489
 
591
502
        newdir = move_id.new_directory('dir', root, 'newdir')
592
503
        move_id.adjust_path('name2', newdir, name1)
593
504
        move_id.apply()
594
 
 
 
505
        
595
506
    def test_replace_dangling_ie(self):
596
507
        create_tree, root = self.get_transform()
597
508
        # prepare tree
613
524
        resolve_conflicts(replace)
614
525
        replace.apply()
615
526
 
616
 
    def _test_symlinks(self, link_name1,link_target1,
617
 
                       link_name2, link_target2):
618
 
 
619
 
        def ozpath(p): return 'oz/' + p
620
 
 
 
527
    def test_symlinks(self):
621
528
        self.requireFeature(SymlinkFeature)
622
 
        transform, root = self.get_transform()
 
529
        transform,root = self.get_transform()
623
530
        oz_id = transform.new_directory('oz', root, 'oz-id')
624
 
        wizard = transform.new_symlink(link_name1, oz_id, link_target1,
 
531
        wizard = transform.new_symlink('wizard', oz_id, 'wizard-target', 
625
532
                                       'wizard-id')
626
 
        wiz_id = transform.create_path(link_name2, oz_id)
627
 
        transform.create_symlink(link_target2, wiz_id)
628
 
        transform.version_file('wiz-id2', wiz_id)
 
533
        wiz_id = transform.create_path('wizard2', oz_id)
 
534
        transform.create_symlink('behind_curtain', wiz_id)
 
535
        transform.version_file('wiz-id2', wiz_id)            
629
536
        transform.set_executability(True, wiz_id)
630
 
        self.assertEqual(transform.find_conflicts(),
 
537
        self.assertEqual(transform.find_conflicts(), 
631
538
                         [('non-file executability', wiz_id)])
632
539
        transform.set_executability(None, wiz_id)
633
540
        transform.apply()
634
 
        self.assertEqual(self.wt.path2id(ozpath(link_name1)), 'wizard-id')
635
 
        self.assertEqual('symlink',
636
 
                         file_kind(self.wt.abspath(ozpath(link_name1))))
637
 
        self.assertEqual(link_target2,
638
 
                         osutils.readlink(self.wt.abspath(ozpath(link_name2))))
639
 
        self.assertEqual(link_target1,
640
 
                         osutils.readlink(self.wt.abspath(ozpath(link_name1))))
641
 
 
642
 
    def test_symlinks(self):
643
 
        self._test_symlinks('wizard', 'wizard-target',
644
 
                            'wizard2', 'behind_curtain')
645
 
 
646
 
    def test_symlinks_unicode(self):
647
 
        self.requireFeature(tests.UnicodeFilenameFeature)
648
 
        self._test_symlinks(u'\N{Euro Sign}wizard',
649
 
                            u'wizard-targ\N{Euro Sign}t',
650
 
                            u'\N{Euro Sign}wizard2',
651
 
                            u'b\N{Euro Sign}hind_curtain')
 
541
        self.assertEqual(self.wt.path2id('oz/wizard'), 'wizard-id')
 
542
        self.assertEqual(file_kind(self.wt.abspath('oz/wizard')), 'symlink')
 
543
        self.assertEqual(os.readlink(self.wt.abspath('oz/wizard2')), 
 
544
                         'behind_curtain')
 
545
        self.assertEqual(os.readlink(self.wt.abspath('oz/wizard')),
 
546
                         'wizard-target')
652
547
 
653
548
    def test_unable_create_symlink(self):
654
549
        def tt_helper():
678
573
        create.apply()
679
574
        conflicts,root = self.get_transform()
680
575
        # set up duplicate entry, duplicate id
681
 
        new_dorothy = conflicts.new_file('dorothy', root, 'dorothy',
 
576
        new_dorothy = conflicts.new_file('dorothy', root, 'dorothy', 
682
577
                                         'dorothy-id')
683
578
        old_dorothy = conflicts.trans_id_tree_file_id('dorothy-id')
684
579
        oz = conflicts.trans_id_tree_file_id('oz-id')
708
603
        tt, emerald, oz, old_dorothy, new_dorothy = self.get_conflicted()
709
604
        raw_conflicts = resolve_conflicts(tt)
710
605
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
711
 
        duplicate = DuplicateEntry('Moved existing file to', 'dorothy.moved',
 
606
        duplicate = DuplicateEntry('Moved existing file to', 'dorothy.moved', 
712
607
                                   'dorothy', None, 'dorothy-id')
713
608
        self.assertEqual(cooked_conflicts[0], duplicate)
714
 
        duplicate_id = DuplicateID('Unversioned existing file',
 
609
        duplicate_id = DuplicateID('Unversioned existing file', 
715
610
                                   'dorothy.moved', 'dorothy', None,
716
611
                                   'dorothy-id')
717
612
        self.assertEqual(cooked_conflicts[1], duplicate_id)
725
620
        unversioned_parent2 = UnversionedParent('Versioned directory', 'oz',
726
621
                                               'oz-id')
727
622
        self.assertEqual(cooked_conflicts[3], unversioned_parent)
728
 
        parent_loop = ParentLoop('Cancelled move', 'oz/emeraldcity',
 
623
        parent_loop = ParentLoop('Cancelled move', 'oz/emeraldcity', 
729
624
                                 'oz/emeraldcity', 'emerald-id', 'emerald-id')
730
625
        self.assertEqual(cooked_conflicts[4], deleted_parent)
731
626
        self.assertEqual(cooked_conflicts[5], unversioned_parent2)
757
652
                                         ' versioned, but has versioned'
758
653
                                         ' children.  Versioned directory.')
759
654
        self.assertEqual(conflicts_s[6], 'Conflict moving oz/emeraldcity into'
760
 
                                         ' oz/emeraldcity. Cancelled move.')
 
655
                                         ' oz/emeraldcity.  Cancelled move.')
761
656
 
762
657
    def prepare_wrong_parent_kind(self):
763
658
        tt, root = self.get_transform()
834
729
        create.apply()
835
730
        transform, root = self.get_transform()
836
731
        transform.adjust_root_path('oldroot', fun)
837
 
        new_root = transform.trans_id_tree_path('')
 
732
        new_root=transform.trans_id_tree_path('')
838
733
        transform.version_file('new-root', new_root)
839
734
        transform.apply()
840
735
 
854
749
 
855
750
    def test_set_executability_order(self):
856
751
        """Ensure that executability behaves the same, no matter what order.
857
 
 
 
752
        
858
753
        - create file and set executability simultaneously
859
754
        - create file and set executability afterward
860
755
        - unsetting the executability of a file whose executability has not been
1267
1162
        transform.cancel_creation(parent)
1268
1163
        transform.finalize()
1269
1164
 
1270
 
    def test_rollback_on_directory_clash(self):
 
1165
    def test_case_insensitive_clash(self):
 
1166
        self.requireFeature(CaseInsensitiveFilesystemFeature)
1271
1167
        def tt_helper():
1272
1168
            wt = self.make_branch_and_tree('.')
1273
1169
            tt = TreeTransform(wt)  # TreeTransform obtains write lock
1274
1170
            try:
1275
 
                foo = tt.new_directory('foo', tt.root)
1276
 
                tt.new_file('bar', foo, 'foobar')
1277
 
                baz = tt.new_directory('baz', tt.root)
1278
 
                tt.new_file('qux', baz, 'quux')
1279
 
                # Ask for a rename 'foo' -> 'baz'
1280
 
                tt.adjust_path('baz', tt.root, foo)
 
1171
                tt.new_file('foo', tt.root, 'bar')
 
1172
                tt.new_file('Foo', tt.root, 'spam')
1281
1173
                # Lie to tt that we've already resolved all conflicts.
1282
1174
                tt.apply(no_conflicts=True)
1283
1175
            except:
1284
1176
                wt.unlock()
1285
1177
                raise
1286
 
        # The rename will fail because the target directory is not empty (but
1287
 
        # raises FileExists anyway).
1288
1178
        err = self.assertRaises(errors.FileExists, tt_helper)
1289
1179
        self.assertContainsRe(str(err),
1290
 
            "^File exists: .+/baz")
 
1180
            "^File exists: .+/foo")
1291
1181
 
1292
1182
    def test_two_directories_clash(self):
1293
1183
        def tt_helper():
1296
1186
            try:
1297
1187
                foo_1 = tt.new_directory('foo', tt.root)
1298
1188
                tt.new_directory('bar', foo_1)
1299
 
                # Adding the same directory with a different content
1300
1189
                foo_2 = tt.new_directory('foo', tt.root)
1301
1190
                tt.new_directory('baz', foo_2)
1302
1191
                # Lie to tt that we've already resolved all conflicts.
1315
1204
            try:
1316
1205
                foo_1 = tt.new_directory('foo', tt.root)
1317
1206
                tt.new_directory('bar', foo_1)
1318
 
                # Adding the same directory with a different content
1319
1207
                foo_2 = tt.new_directory('foo', tt.root)
1320
1208
                tt.new_directory('baz', foo_2)
1321
1209
                # Lie to tt that we've already resolved all conflicts.
1418
1306
        transform.cancel_creation(trans_id)
1419
1307
        transform.apply()
1420
1308
 
1421
 
    def test_create_from_tree(self):
1422
 
        tree1 = self.make_branch_and_tree('tree1')
1423
 
        self.build_tree_contents([('tree1/foo/',), ('tree1/bar', 'baz')])
1424
 
        tree1.add(['foo', 'bar'], ['foo-id', 'bar-id'])
1425
 
        tree2 = self.make_branch_and_tree('tree2')
1426
 
        tt = TreeTransform(tree2)
1427
 
        foo_trans_id = tt.create_path('foo', tt.root)
1428
 
        create_from_tree(tt, foo_trans_id, tree1, 'foo-id')
1429
 
        bar_trans_id = tt.create_path('bar', tt.root)
1430
 
        create_from_tree(tt, bar_trans_id, tree1, 'bar-id')
1431
 
        tt.apply()
1432
 
        self.assertEqual('directory', osutils.file_kind('tree2/foo'))
1433
 
        self.assertFileEqual('baz', 'tree2/bar')
1434
 
 
1435
 
    def test_create_from_tree_bytes(self):
1436
 
        """Provided lines are used instead of tree content."""
1437
 
        tree1 = self.make_branch_and_tree('tree1')
1438
 
        self.build_tree_contents([('tree1/foo', 'bar'),])
1439
 
        tree1.add('foo', 'foo-id')
1440
 
        tree2 = self.make_branch_and_tree('tree2')
1441
 
        tt = TreeTransform(tree2)
1442
 
        foo_trans_id = tt.create_path('foo', tt.root)
1443
 
        create_from_tree(tt, foo_trans_id, tree1, 'foo-id', bytes='qux')
1444
 
        tt.apply()
1445
 
        self.assertFileEqual('qux', 'tree2/foo')
1446
 
 
1447
 
    def test_create_from_tree_symlink(self):
1448
 
        self.requireFeature(SymlinkFeature)
1449
 
        tree1 = self.make_branch_and_tree('tree1')
1450
 
        os.symlink('bar', 'tree1/foo')
1451
 
        tree1.add('foo', 'foo-id')
1452
 
        tt = TreeTransform(self.make_branch_and_tree('tree2'))
1453
 
        foo_trans_id = tt.create_path('foo', tt.root)
1454
 
        create_from_tree(tt, foo_trans_id, tree1, 'foo-id')
1455
 
        tt.apply()
1456
 
        self.assertEqual('bar', os.readlink('tree2/foo'))
1457
 
 
1458
1309
 
1459
1310
class TransformGroup(object):
1460
1311
 
1514
1365
        # textual merge
1515
1366
        self.assertEqual(this.wt.get_file('a').read(), 'y\nb\nc\nd\bz\n')
1516
1367
        # three-way text conflict
1517
 
        self.assertEqual(this.wt.get_file('b').read(),
 
1368
        self.assertEqual(this.wt.get_file('b').read(), 
1518
1369
                         conflict_text('b', 'b2'))
1519
1370
        # OTHER wins
1520
1371
        self.assertEqual(this.wt.get_file('c').read(), 'c2')
1524
1375
        self.assertEqual(this.wt.get_file('e').read(), 'e2')
1525
1376
        # No change
1526
1377
        self.assertEqual(this.wt.get_file('f').read(), 'f')
1527
 
        # Correct correct results when THIS == OTHER
 
1378
        # Correct correct results when THIS == OTHER 
1528
1379
        self.assertEqual(this.wt.get_file('g').read(), 'g')
1529
1380
        # Text conflict when THIS & OTHER are text and BASE is dir
1530
 
        self.assertEqual(this.wt.get_file('h').read(),
 
1381
        self.assertEqual(this.wt.get_file('h').read(), 
1531
1382
                         conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))
1532
1383
        self.assertEqual(this.wt.get_file_byname('h.THIS').read(),
1533
1384
                         '1\n2\n3\n4\n')
1534
1385
        self.assertEqual(this.wt.get_file_byname('h.OTHER').read(),
1535
1386
                         'h\ni\nj\nk\n')
1536
1387
        self.assertEqual(file_kind(this.wt.abspath('h.BASE')), 'directory')
1537
 
        self.assertEqual(this.wt.get_file('i').read(),
 
1388
        self.assertEqual(this.wt.get_file('i').read(), 
1538
1389
                         conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))
1539
1390
        self.assertEqual(this.wt.get_file_byname('i.THIS').read(),
1540
1391
                         '1\n2\n3\n4\n')
1564
1415
            tg.tt.new_symlink('b', tg.root, 'b', 'b')
1565
1416
            tg.tt.new_file('c', tg.root, 'c', 'c')
1566
1417
            tg.tt.new_symlink('d', tg.root, tg.name, 'd')
1567
 
        targets = ((base, 'base-e', 'base-f', None, None),
1568
 
                   (this, 'other-e', 'this-f', 'other-g', 'this-h'),
 
1418
        targets = ((base, 'base-e', 'base-f', None, None), 
 
1419
                   (this, 'other-e', 'this-f', 'other-g', 'this-h'), 
1569
1420
                   (other, 'other-e', None, 'other-g', 'other-h'))
1570
1421
        for tg, e_target, f_target, g_target, h_target in targets:
1571
 
            for link, target in (('e', e_target), ('f', f_target),
 
1422
            for link, target in (('e', e_target), ('f', f_target), 
1572
1423
                                 ('g', g_target), ('h', h_target)):
1573
1424
                if target is not None:
1574
1425
                    tg.tt.new_symlink(link, tg.root, target, link)
1600
1451
        base = TransformGroup("BASE", root_id)
1601
1452
        this = TransformGroup("THIS", root_id)
1602
1453
        other = TransformGroup("OTHER", root_id)
1603
 
        base_a, this_a, other_a = [t.tt.new_directory('a', t.root, 'a')
 
1454
        base_a, this_a, other_a = [t.tt.new_directory('a', t.root, 'a') 
1604
1455
                                   for t in [base, this, other]]
1605
 
        base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b')
 
1456
        base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b') 
1606
1457
                                   for t in [base, this, other]]
1607
1458
        base.tt.new_directory('c', base_a, 'c')
1608
1459
        this.tt.new_directory('c1', this_a, 'c')
1633
1484
        base = TransformGroup("BASE", root_id)
1634
1485
        this = TransformGroup("THIS", root_id)
1635
1486
        other = TransformGroup("OTHER", root_id)
1636
 
        base_a, this_a, other_a = [t.tt.new_directory('a', t.root, 'a')
 
1487
        base_a, this_a, other_a = [t.tt.new_directory('a', t.root, 'a') 
1637
1488
                                   for t in [base, this, other]]
1638
 
        base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b')
 
1489
        base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b') 
1639
1490
                                   for t in [base, this, other]]
1640
1491
 
1641
1492
        base.tt.new_file('g', base_a, 'g', 'g')
1732
1583
        os.symlink('foo', 'target2/symlink')
1733
1584
        build_tree(source.basis_tree(), target)
1734
1585
        self.assertEqual([], target.conflicts())
1735
 
 
 
1586
        
1736
1587
    def test_directory_conflict_handling(self):
1737
1588
        """Ensure that when building trees, conflict handling is done"""
1738
1589
        source = self.make_branch_and_tree('source')
1794
1645
        target = self.make_branch_and_tree('target')
1795
1646
        self.build_tree(['target/name'])
1796
1647
        target.add('name')
1797
 
        self.assertRaises(errors.WorkingTreeAlreadyPopulated,
 
1648
        self.assertRaises(errors.WorkingTreeAlreadyPopulated, 
1798
1649
            build_tree, source.basis_tree(), target)
1799
1650
 
1800
1651
    def test_build_tree_rename_count(self):
1944
1795
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1945
1796
        self.assertTrue(source.is_executable('file1-id'))
1946
1797
 
1947
 
    def install_rot13_content_filter(self, pattern):
1948
 
        # We could use
1949
 
        # self.addCleanup(filters._reset_registry, filters._reset_registry())
1950
 
        # below, but that looks a bit... hard to read even if it's exactly
1951
 
        # the same thing.
1952
 
        original_registry = filters._reset_registry()
1953
 
        def restore_registry():
1954
 
            filters._reset_registry(original_registry)
1955
 
        self.addCleanup(restore_registry)
1956
 
        def rot13(chunks, context=None):
1957
 
            return [''.join(chunks).encode('rot13')]
1958
 
        rot13filter = filters.ContentFilter(rot13, rot13)
1959
 
        filters.register_filter_stack_map('rot13', {'yes': [rot13filter]}.get)
1960
 
        os.mkdir(self.test_home_dir + '/.bazaar')
1961
 
        rules_filename = self.test_home_dir + '/.bazaar/rules'
1962
 
        f = open(rules_filename, 'wb')
1963
 
        f.write('[name %s]\nrot13=yes\n' % (pattern,))
1964
 
        f.close()
1965
 
        def uninstall_rules():
1966
 
            os.remove(rules_filename)
1967
 
            rules.reset_rules()
1968
 
        self.addCleanup(uninstall_rules)
1969
 
        rules.reset_rules()
1970
 
 
1971
 
    def test_build_tree_content_filtered_files_are_not_hardlinked(self):
1972
 
        """build_tree will not hardlink files that have content filtering rules
1973
 
        applied to them (but will still hardlink other files from the same tree
1974
 
        if it can).
1975
 
        """
1976
 
        self.requireFeature(HardlinkFeature)
1977
 
        self.install_rot13_content_filter('file1')
1978
 
        source = self.create_ab_tree()
1979
 
        target = self.make_branch_and_tree('target')
1980
 
        revision_tree = source.basis_tree()
1981
 
        revision_tree.lock_read()
1982
 
        self.addCleanup(revision_tree.unlock)
1983
 
        build_tree(revision_tree, target, source, hardlink=True)
1984
 
        target.lock_read()
1985
 
        self.addCleanup(target.unlock)
1986
 
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1987
 
        source_stat = os.stat('source/file1')
1988
 
        target_stat = os.stat('target/file1')
1989
 
        self.assertNotEqual(source_stat, target_stat)
1990
 
        source_stat = os.stat('source/file2')
1991
 
        target_stat = os.stat('target/file2')
1992
 
        self.assertEqualStat(source_stat, target_stat)
1993
 
 
1994
1798
    def test_case_insensitive_build_tree_inventory(self):
1995
 
        if (tests.CaseInsensitiveFilesystemFeature.available()
1996
 
            or tests.CaseInsCasePresFilenameFeature.available()):
1997
 
            raise tests.UnavailableFeature('Fully case sensitive filesystem')
1998
1799
        source = self.make_branch_and_tree('source')
1999
1800
        self.build_tree(['source/file', 'source/FILE'])
2000
1801
        source.add(['file', 'FILE'], ['lower-id', 'upper-id'])
2008
1809
        self.assertEqual('FILE', target.id2path('upper-id'))
2009
1810
 
2010
1811
 
2011
 
class TestCommitTransform(tests.TestCaseWithTransport):
2012
 
 
2013
 
    def get_branch(self):
2014
 
        tree = self.make_branch_and_tree('tree')
2015
 
        tree.lock_write()
2016
 
        self.addCleanup(tree.unlock)
2017
 
        tree.commit('empty commit')
2018
 
        return tree.branch
2019
 
 
2020
 
    def get_branch_and_transform(self):
2021
 
        branch = self.get_branch()
2022
 
        tt = TransformPreview(branch.basis_tree())
2023
 
        self.addCleanup(tt.finalize)
2024
 
        return branch, tt
2025
 
 
2026
 
    def test_commit_wrong_basis(self):
2027
 
        branch = self.get_branch()
2028
 
        basis = branch.repository.revision_tree(
2029
 
            _mod_revision.NULL_REVISION)
2030
 
        tt = TransformPreview(basis)
2031
 
        self.addCleanup(tt.finalize)
2032
 
        e = self.assertRaises(ValueError, tt.commit, branch, '')
2033
 
        self.assertEqual('TreeTransform not based on branch basis: null:',
2034
 
                         str(e))
2035
 
 
2036
 
    def test_empy_commit(self):
2037
 
        branch, tt = self.get_branch_and_transform()
2038
 
        rev = tt.commit(branch, 'my message')
2039
 
        self.assertEqual(2, branch.revno())
2040
 
        repo = branch.repository
2041
 
        self.assertEqual('my message', repo.get_revision(rev).message)
2042
 
 
2043
 
    def test_merge_parents(self):
2044
 
        branch, tt = self.get_branch_and_transform()
2045
 
        rev = tt.commit(branch, 'my message', ['rev1b', 'rev1c'])
2046
 
        self.assertEqual(['rev1b', 'rev1c'],
2047
 
                         branch.basis_tree().get_parent_ids()[1:])
2048
 
 
2049
 
    def test_first_commit(self):
2050
 
        branch = self.make_branch('branch')
2051
 
        branch.lock_write()
2052
 
        self.addCleanup(branch.unlock)
2053
 
        tt = TransformPreview(branch.basis_tree())
2054
 
        self.addCleanup(tt.finalize)
2055
 
        tt.new_directory('', ROOT_PARENT, 'TREE_ROOT')
2056
 
        rev = tt.commit(branch, 'my message')
2057
 
        self.assertEqual([], branch.basis_tree().get_parent_ids())
2058
 
        self.assertNotEqual(_mod_revision.NULL_REVISION,
2059
 
                            branch.last_revision())
2060
 
 
2061
 
    def test_first_commit_with_merge_parents(self):
2062
 
        branch = self.make_branch('branch')
2063
 
        branch.lock_write()
2064
 
        self.addCleanup(branch.unlock)
2065
 
        tt = TransformPreview(branch.basis_tree())
2066
 
        self.addCleanup(tt.finalize)
2067
 
        e = self.assertRaises(ValueError, tt.commit, branch,
2068
 
                          'my message', ['rev1b-id'])
2069
 
        self.assertEqual('Cannot supply merge parents for first commit.',
2070
 
                         str(e))
2071
 
        self.assertEqual(_mod_revision.NULL_REVISION, branch.last_revision())
2072
 
 
2073
 
    def test_add_files(self):
2074
 
        branch, tt = self.get_branch_and_transform()
2075
 
        tt.new_file('file', tt.root, 'contents', 'file-id')
2076
 
        trans_id = tt.new_directory('dir', tt.root, 'dir-id')
2077
 
        if SymlinkFeature.available():
2078
 
            tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')
2079
 
        rev = tt.commit(branch, 'message')
2080
 
        tree = branch.basis_tree()
2081
 
        self.assertEqual('file', tree.id2path('file-id'))
2082
 
        self.assertEqual('contents', tree.get_file_text('file-id'))
2083
 
        self.assertEqual('dir', tree.id2path('dir-id'))
2084
 
        if SymlinkFeature.available():
2085
 
            self.assertEqual('dir/symlink', tree.id2path('symlink-id'))
2086
 
            self.assertEqual('target', tree.get_symlink_target('symlink-id'))
2087
 
 
2088
 
    def test_add_unversioned(self):
2089
 
        branch, tt = self.get_branch_and_transform()
2090
 
        tt.new_file('file', tt.root, 'contents')
2091
 
        self.assertRaises(errors.StrictCommitFailed, tt.commit, branch,
2092
 
                          'message', strict=True)
2093
 
 
2094
 
    def test_modify_strict(self):
2095
 
        branch, tt = self.get_branch_and_transform()
2096
 
        tt.new_file('file', tt.root, 'contents', 'file-id')
2097
 
        tt.commit(branch, 'message', strict=True)
2098
 
        tt = TransformPreview(branch.basis_tree())
2099
 
        self.addCleanup(tt.finalize)
2100
 
        trans_id = tt.trans_id_file_id('file-id')
2101
 
        tt.delete_contents(trans_id)
2102
 
        tt.create_file('contents', trans_id)
2103
 
        tt.commit(branch, 'message', strict=True)
2104
 
 
2105
 
    def test_commit_malformed(self):
2106
 
        """Committing a malformed transform should raise an exception.
2107
 
 
2108
 
        In this case, we are adding a file without adding its parent.
2109
 
        """
2110
 
        branch, tt = self.get_branch_and_transform()
2111
 
        parent_id = tt.trans_id_file_id('parent-id')
2112
 
        tt.new_file('file', parent_id, 'contents', 'file-id')
2113
 
        self.assertRaises(errors.MalformedTransform, tt.commit, branch,
2114
 
                          'message')
2115
 
 
2116
 
    def test_commit_rich_revision_data(self):
2117
 
        branch, tt = self.get_branch_and_transform()
2118
 
        rev_id = tt.commit(branch, 'message', timestamp=1, timezone=43201,
2119
 
                           committer='me <me@example.com>',
2120
 
                           revprops={'foo': 'bar'}, revision_id='revid-1',
2121
 
                           authors=['Author1 <author1@example.com>',
2122
 
                              'Author2 <author2@example.com>',
2123
 
                               ])
2124
 
        self.assertEqual('revid-1', rev_id)
2125
 
        revision = branch.repository.get_revision(rev_id)
2126
 
        self.assertEqual(1, revision.timestamp)
2127
 
        self.assertEqual(43201, revision.timezone)
2128
 
        self.assertEqual('me <me@example.com>', revision.committer)
2129
 
        self.assertEqual(['Author1 <author1@example.com>',
2130
 
                          'Author2 <author2@example.com>'],
2131
 
                         revision.get_apparent_authors())
2132
 
        del revision.properties['authors']
2133
 
        self.assertEqual({'foo': 'bar',
2134
 
                          'branch-nick': 'tree'},
2135
 
                         revision.properties)
2136
 
 
2137
 
    def test_no_explicit_revprops(self):
2138
 
        branch, tt = self.get_branch_and_transform()
2139
 
        rev_id = tt.commit(branch, 'message', authors=[
2140
 
            'Author1 <author1@example.com>',
2141
 
            'Author2 <author2@example.com>', ])
2142
 
        revision = branch.repository.get_revision(rev_id)
2143
 
        self.assertEqual(['Author1 <author1@example.com>',
2144
 
                          'Author2 <author2@example.com>'],
2145
 
                         revision.get_apparent_authors())
2146
 
        self.assertEqual('tree', revision.properties['branch-nick'])
2147
 
 
2148
 
 
2149
1812
class MockTransform(object):
2150
1813
 
2151
1814
    def has_named_child(self, by_parent, parent_id, name):
2306
1969
        resolve_conflicts(tt)
2307
1970
 
2308
1971
 
2309
 
A_ENTRY = ('a-id', ('a', 'a'), True, (True, True),
2310
 
                  ('TREE_ROOT', 'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
2311
 
                  (False, False))
2312
 
ROOT_ENTRY = ('TREE_ROOT', ('', ''), False, (True, True), (None, None),
2313
 
              ('', ''), ('directory', 'directory'), (False, None))
2314
 
 
2315
 
 
2316
1972
class TestTransformPreview(tests.TestCaseWithTransport):
2317
1973
 
2318
1974
    def create_tree(self):
2319
1975
        tree = self.make_branch_and_tree('.')
2320
1976
        self.build_tree_contents([('a', 'content 1')])
2321
 
        tree.set_root_id('TREE_ROOT')
2322
1977
        tree.add('a', 'a-id')
2323
1978
        tree.commit('rev1', rev_id='rev1')
2324
1979
        return tree.branch.repository.revision_tree('rev1')
2391
2046
                          (False, False))],
2392
2047
                          list(preview_tree.iter_changes(revision_tree)))
2393
2048
 
2394
 
    def test_include_unchanged_succeeds(self):
 
2049
    def test_wrong_tree_value_error(self):
2395
2050
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2396
 
        changes = preview_tree.iter_changes(revision_tree,
2397
 
                                            include_unchanged=True)
2398
 
        root = revision_tree.inventory.root.file_id
 
2051
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
 
2052
                              preview_tree)
 
2053
        self.assertEqual('from_tree must be transform source tree.', str(e))
2399
2054
 
2400
 
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
 
2055
    def test_include_unchanged_value_error(self):
 
2056
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
 
2057
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
 
2058
                              revision_tree, include_unchanged=True)
 
2059
        self.assertEqual('include_unchanged is not supported', str(e))
2401
2060
 
2402
2061
    def test_specific_files(self):
2403
2062
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2404
 
        changes = preview_tree.iter_changes(revision_tree,
2405
 
                                            specific_files=[''])
2406
 
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
 
2063
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
 
2064
                              revision_tree, specific_files=['pete'])
 
2065
        self.assertEqual('specific_files is not supported', str(e))
2407
2066
 
2408
 
    def test_want_unversioned(self):
 
2067
    def test_want_unversioned_value_error(self):
2409
2068
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2410
 
        changes = preview_tree.iter_changes(revision_tree,
2411
 
                                            want_unversioned=True)
2412
 
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
 
2069
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
 
2070
                              revision_tree, want_unversioned=True)
 
2071
        self.assertEqual('want_unversioned is not supported', str(e))
2413
2072
 
2414
2073
    def test_ignore_extra_trees_no_specific_files(self):
2415
2074
        # extra_trees is harmless without specific_files, so we'll silently
2425
2084
    def test_ignore_pb(self):
2426
2085
        # pb could be supported, but TT.iter_changes doesn't support it.
2427
2086
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2428
 
        preview_tree.iter_changes(revision_tree)
 
2087
        preview_tree.iter_changes(revision_tree, pb=progress.DummyProgress())
2429
2088
 
2430
2089
    def test_kind(self):
2431
2090
        revision_tree = self.create_tree()
2446
2105
        self.assertEqual(os.stat(limbo_path).st_mtime,
2447
2106
                         preview_tree.get_file_mtime('file-id'))
2448
2107
 
2449
 
    def test_get_file_mtime_renamed(self):
2450
 
        work_tree = self.make_branch_and_tree('tree')
2451
 
        self.build_tree(['tree/file'])
2452
 
        work_tree.add('file', 'file-id')
2453
 
        preview = TransformPreview(work_tree)
2454
 
        self.addCleanup(preview.finalize)
2455
 
        file_trans_id = preview.trans_id_tree_file_id('file-id')
2456
 
        preview.adjust_path('renamed', preview.root, file_trans_id)
2457
 
        preview_tree = preview.get_preview_tree()
2458
 
        preview_mtime = preview_tree.get_file_mtime('file-id', 'renamed')
2459
 
        work_mtime = work_tree.get_file_mtime('file-id', 'file')
2460
 
 
2461
2108
    def test_get_file(self):
2462
2109
        preview = self.get_empty_preview()
2463
2110
        preview.new_file('file', preview.root, 'contents', 'file-id')
2611
2258
        self.assertEqual(('missing', None, None, None), summary)
2612
2259
 
2613
2260
    def test_file_content_summary_executable(self):
 
2261
        if not osutils.supports_executable():
 
2262
            raise TestNotApplicable()
2614
2263
        preview = self.get_empty_preview()
2615
2264
        path_id = preview.new_file('path', preview.root, 'contents', 'path-id')
2616
2265
        preview.set_executability(True, path_id)
2625
2274
        self.assertIs(None, summary[3])
2626
2275
 
2627
2276
    def test_change_executability(self):
 
2277
        if not osutils.supports_executable():
 
2278
            raise TestNotApplicable()
2628
2279
        tree = self.make_branch_and_tree('tree')
2629
2280
        self.build_tree(['tree/path'])
2630
2281
        tree.add('path')
2644
2295
        # size must be known
2645
2296
        self.assertEqual(len('contents'), summary[1])
2646
2297
        # not executable
2647
 
        self.assertEqual(False, summary[2])
 
2298
        if osutils.supports_executable():
 
2299
            self.assertEqual(False, summary[2])
 
2300
        else:
 
2301
            self.assertEqual(None, summary[2])
2648
2302
        # will not have hash (not cheap to determine)
2649
2303
        self.assertIs(None, summary[3])
2650
2304
 
2791
2445
 
2792
2446
    def test_walkdirs(self):
2793
2447
        preview = self.get_empty_preview()
2794
 
        root = preview.new_directory('', ROOT_PARENT, 'tree-root')
2795
 
        # FIXME: new_directory should mark root.
2796
 
        preview.fixup_new_roots()
 
2448
        preview.version_file('tree-root', preview.root)
2797
2449
        preview_tree = preview.get_preview_tree()
2798
2450
        file_trans_id = preview.new_file('a', preview.root, 'contents',
2799
2451
                                         'a-id')
2800
2452
        expected = [(('', 'tree-root'),
2801
2453
                    [('a', 'a', 'file', None, 'a-id', 'file')])]
2802
2454
        self.assertEqual(expected, list(preview_tree.walkdirs()))
2803
 
 
2804
 
    def test_extras(self):
2805
 
        work_tree = self.make_branch_and_tree('tree')
2806
 
        self.build_tree(['tree/removed-file', 'tree/existing-file',
2807
 
                         'tree/not-removed-file'])
2808
 
        work_tree.add(['removed-file', 'not-removed-file'])
2809
 
        preview = TransformPreview(work_tree)
2810
 
        self.addCleanup(preview.finalize)
2811
 
        preview.new_file('new-file', preview.root, 'contents')
2812
 
        preview.new_file('new-versioned-file', preview.root, 'contents',
2813
 
                         'new-versioned-id')
2814
 
        tree = preview.get_preview_tree()
2815
 
        preview.unversion_file(preview.trans_id_tree_path('removed-file'))
2816
 
        self.assertEqual(set(['new-file', 'removed-file', 'existing-file']),
2817
 
                         set(tree.extras()))
2818
 
 
2819
 
    def test_merge_into_preview(self):
2820
 
        work_tree = self.make_branch_and_tree('tree')
2821
 
        self.build_tree_contents([('tree/file','b\n')])
2822
 
        work_tree.add('file', 'file-id')
2823
 
        work_tree.commit('first commit')
2824
 
        child_tree = work_tree.bzrdir.sprout('child').open_workingtree()
2825
 
        self.build_tree_contents([('child/file','b\nc\n')])
2826
 
        child_tree.commit('child commit')
2827
 
        child_tree.lock_write()
2828
 
        self.addCleanup(child_tree.unlock)
2829
 
        work_tree.lock_write()
2830
 
        self.addCleanup(work_tree.unlock)
2831
 
        preview = TransformPreview(work_tree)
2832
 
        self.addCleanup(preview.finalize)
2833
 
        file_trans_id = preview.trans_id_file_id('file-id')
2834
 
        preview.delete_contents(file_trans_id)
2835
 
        preview.create_file('a\nb\n', file_trans_id)
2836
 
        preview_tree = preview.get_preview_tree()
2837
 
        merger = Merger.from_revision_ids(None, preview_tree,
2838
 
                                          child_tree.branch.last_revision(),
2839
 
                                          other_branch=child_tree.branch,
2840
 
                                          tree_branch=work_tree.branch)
2841
 
        merger.merge_type = Merge3Merger
2842
 
        tt = merger.make_merger().make_preview_transform()
2843
 
        self.addCleanup(tt.finalize)
2844
 
        final_tree = tt.get_preview_tree()
2845
 
        self.assertEqual('a\nb\nc\n', final_tree.get_file_text('file-id'))
2846
 
 
2847
 
    def test_merge_preview_into_workingtree(self):
2848
 
        tree = self.make_branch_and_tree('tree')
2849
 
        tree.set_root_id('TREE_ROOT')
2850
 
        tt = TransformPreview(tree)
2851
 
        self.addCleanup(tt.finalize)
2852
 
        tt.new_file('name', tt.root, 'content', 'file-id')
2853
 
        tree2 = self.make_branch_and_tree('tree2')
2854
 
        tree2.set_root_id('TREE_ROOT')
2855
 
        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
2856
 
                                         None, tree.basis_tree())
2857
 
        merger.merge_type = Merge3Merger
2858
 
        merger.do_merge()
2859
 
 
2860
 
    def test_merge_preview_into_workingtree_handles_conflicts(self):
2861
 
        tree = self.make_branch_and_tree('tree')
2862
 
        self.build_tree_contents([('tree/foo', 'bar')])
2863
 
        tree.add('foo', 'foo-id')
2864
 
        tree.commit('foo')
2865
 
        tt = TransformPreview(tree)
2866
 
        self.addCleanup(tt.finalize)
2867
 
        trans_id = tt.trans_id_file_id('foo-id')
2868
 
        tt.delete_contents(trans_id)
2869
 
        tt.create_file('baz', trans_id)
2870
 
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
2871
 
        self.build_tree_contents([('tree2/foo', 'qux')])
2872
 
        pb = None
2873
 
        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
2874
 
                                         pb, tree.basis_tree())
2875
 
        merger.merge_type = Merge3Merger
2876
 
        merger.do_merge()
2877
 
 
2878
 
    def test_is_executable(self):
2879
 
        tree = self.make_branch_and_tree('tree')
2880
 
        preview = TransformPreview(tree)
2881
 
        self.addCleanup(preview.finalize)
2882
 
        preview.new_file('foo', preview.root, 'bar', 'baz-id')
2883
 
        preview_tree = preview.get_preview_tree()
2884
 
        self.assertEqual(False, preview_tree.is_executable('baz-id',
2885
 
                                                           'tree/foo'))
2886
 
        self.assertEqual(False, preview_tree.is_executable('baz-id'))
2887
 
 
2888
 
    def test_commit_preview_tree(self):
2889
 
        tree = self.make_branch_and_tree('tree')
2890
 
        rev_id = tree.commit('rev1')
2891
 
        tree.branch.lock_write()
2892
 
        self.addCleanup(tree.branch.unlock)
2893
 
        tt = TransformPreview(tree)
2894
 
        tt.new_file('file', tt.root, 'contents', 'file_id')
2895
 
        self.addCleanup(tt.finalize)
2896
 
        preview = tt.get_preview_tree()
2897
 
        preview.set_parent_ids([rev_id])
2898
 
        builder = tree.branch.get_commit_builder([rev_id])
2899
 
        list(builder.record_iter_changes(preview, rev_id, tt.iter_changes()))
2900
 
        builder.finish_inventory()
2901
 
        rev2_id = builder.commit('rev2')
2902
 
        rev2_tree = tree.branch.repository.revision_tree(rev2_id)
2903
 
        self.assertEqual('contents', rev2_tree.get_file_text('file_id'))
2904
 
 
2905
 
    def test_ascii_limbo_paths(self):
2906
 
        self.requireFeature(tests.UnicodeFilenameFeature)
2907
 
        branch = self.make_branch('any')
2908
 
        tree = branch.repository.revision_tree(_mod_revision.NULL_REVISION)
2909
 
        tt = TransformPreview(tree)
2910
 
        self.addCleanup(tt.finalize)
2911
 
        foo_id = tt.new_directory('', ROOT_PARENT)
2912
 
        bar_id = tt.new_file(u'\u1234bar', foo_id, 'contents')
2913
 
        limbo_path = tt._limbo_name(bar_id)
2914
 
        self.assertEqual(limbo_path.encode('ascii', 'replace'), limbo_path)
2915
 
 
2916
 
 
2917
 
class FakeSerializer(object):
2918
 
    """Serializer implementation that simply returns the input.
2919
 
 
2920
 
    The input is returned in the order used by pack.ContainerPushParser.
2921
 
    """
2922
 
    @staticmethod
2923
 
    def bytes_record(bytes, names):
2924
 
        return names, bytes
2925
 
 
2926
 
 
2927
 
class TestSerializeTransform(tests.TestCaseWithTransport):
2928
 
 
2929
 
    _test_needs_features = [tests.UnicodeFilenameFeature]
2930
 
 
2931
 
    def get_preview(self, tree=None):
2932
 
        if tree is None:
2933
 
            tree = self.make_branch_and_tree('tree')
2934
 
        tt = TransformPreview(tree)
2935
 
        self.addCleanup(tt.finalize)
2936
 
        return tt
2937
 
 
2938
 
    def assertSerializesTo(self, expected, tt):
2939
 
        records = list(tt.serialize(FakeSerializer()))
2940
 
        self.assertEqual(expected, records)
2941
 
 
2942
 
    @staticmethod
2943
 
    def default_attribs():
2944
 
        return {
2945
 
            '_id_number': 1,
2946
 
            '_new_name': {},
2947
 
            '_new_parent': {},
2948
 
            '_new_executability': {},
2949
 
            '_new_id': {},
2950
 
            '_tree_path_ids': {'': 'new-0'},
2951
 
            '_removed_id': [],
2952
 
            '_removed_contents': [],
2953
 
            '_non_present_ids': {},
2954
 
            }
2955
 
 
2956
 
    def make_records(self, attribs, contents):
2957
 
        records = [
2958
 
            (((('attribs'),),), bencode.bencode(attribs))]
2959
 
        records.extend([(((n, k),), c) for n, k, c in contents])
2960
 
        return records
2961
 
 
2962
 
    def creation_records(self):
2963
 
        attribs = self.default_attribs()
2964
 
        attribs['_id_number'] = 3
2965
 
        attribs['_new_name'] = {
2966
 
            'new-1': u'foo\u1234'.encode('utf-8'), 'new-2': 'qux'}
2967
 
        attribs['_new_id'] = {'new-1': 'baz', 'new-2': 'quxx'}
2968
 
        attribs['_new_parent'] = {'new-1': 'new-0', 'new-2': 'new-0'}
2969
 
        attribs['_new_executability'] = {'new-1': 1}
2970
 
        contents = [
2971
 
            ('new-1', 'file', 'i 1\nbar\n'),
2972
 
            ('new-2', 'directory', ''),
2973
 
            ]
2974
 
        return self.make_records(attribs, contents)
2975
 
 
2976
 
    def test_serialize_creation(self):
2977
 
        tt = self.get_preview()
2978
 
        tt.new_file(u'foo\u1234', tt.root, 'bar', 'baz', True)
2979
 
        tt.new_directory('qux', tt.root, 'quxx')
2980
 
        self.assertSerializesTo(self.creation_records(), tt)
2981
 
 
2982
 
    def test_deserialize_creation(self):
2983
 
        tt = self.get_preview()
2984
 
        tt.deserialize(iter(self.creation_records()))
2985
 
        self.assertEqual(3, tt._id_number)
2986
 
        self.assertEqual({'new-1': u'foo\u1234',
2987
 
                          'new-2': 'qux'}, tt._new_name)
2988
 
        self.assertEqual({'new-1': 'baz', 'new-2': 'quxx'}, tt._new_id)
2989
 
        self.assertEqual({'new-1': tt.root, 'new-2': tt.root}, tt._new_parent)
2990
 
        self.assertEqual({'baz': 'new-1', 'quxx': 'new-2'}, tt._r_new_id)
2991
 
        self.assertEqual({'new-1': True}, tt._new_executability)
2992
 
        self.assertEqual({'new-1': 'file',
2993
 
                          'new-2': 'directory'}, tt._new_contents)
2994
 
        foo_limbo = open(tt._limbo_name('new-1'), 'rb')
2995
 
        try:
2996
 
            foo_content = foo_limbo.read()
2997
 
        finally:
2998
 
            foo_limbo.close()
2999
 
        self.assertEqual('bar', foo_content)
3000
 
 
3001
 
    def symlink_creation_records(self):
3002
 
        attribs = self.default_attribs()
3003
 
        attribs['_id_number'] = 2
3004
 
        attribs['_new_name'] = {'new-1': u'foo\u1234'.encode('utf-8')}
3005
 
        attribs['_new_parent'] = {'new-1': 'new-0'}
3006
 
        contents = [('new-1', 'symlink', u'bar\u1234'.encode('utf-8'))]
3007
 
        return self.make_records(attribs, contents)
3008
 
 
3009
 
    def test_serialize_symlink_creation(self):
3010
 
        self.requireFeature(tests.SymlinkFeature)
3011
 
        tt = self.get_preview()
3012
 
        tt.new_symlink(u'foo\u1234', tt.root, u'bar\u1234')
3013
 
        self.assertSerializesTo(self.symlink_creation_records(), tt)
3014
 
 
3015
 
    def test_deserialize_symlink_creation(self):
3016
 
        self.requireFeature(tests.SymlinkFeature)
3017
 
        tt = self.get_preview()
3018
 
        tt.deserialize(iter(self.symlink_creation_records()))
3019
 
        abspath = tt._limbo_name('new-1')
3020
 
        foo_content = osutils.readlink(abspath)
3021
 
        self.assertEqual(u'bar\u1234', foo_content)
3022
 
 
3023
 
    def make_destruction_preview(self):
3024
 
        tree = self.make_branch_and_tree('.')
3025
 
        self.build_tree([u'foo\u1234', 'bar'])
3026
 
        tree.add([u'foo\u1234', 'bar'], ['foo-id', 'bar-id'])
3027
 
        return self.get_preview(tree)
3028
 
 
3029
 
    def destruction_records(self):
3030
 
        attribs = self.default_attribs()
3031
 
        attribs['_id_number'] = 3
3032
 
        attribs['_removed_id'] = ['new-1']
3033
 
        attribs['_removed_contents'] = ['new-2']
3034
 
        attribs['_tree_path_ids'] = {
3035
 
            '': 'new-0',
3036
 
            u'foo\u1234'.encode('utf-8'): 'new-1',
3037
 
            'bar': 'new-2',
3038
 
            }
3039
 
        return self.make_records(attribs, [])
3040
 
 
3041
 
    def test_serialize_destruction(self):
3042
 
        tt = self.make_destruction_preview()
3043
 
        foo_trans_id = tt.trans_id_tree_file_id('foo-id')
3044
 
        tt.unversion_file(foo_trans_id)
3045
 
        bar_trans_id = tt.trans_id_tree_file_id('bar-id')
3046
 
        tt.delete_contents(bar_trans_id)
3047
 
        self.assertSerializesTo(self.destruction_records(), tt)
3048
 
 
3049
 
    def test_deserialize_destruction(self):
3050
 
        tt = self.make_destruction_preview()
3051
 
        tt.deserialize(iter(self.destruction_records()))
3052
 
        self.assertEqual({u'foo\u1234': 'new-1',
3053
 
                          'bar': 'new-2',
3054
 
                          '': tt.root}, tt._tree_path_ids)
3055
 
        self.assertEqual({'new-1': u'foo\u1234',
3056
 
                          'new-2': 'bar',
3057
 
                          tt.root: ''}, tt._tree_id_paths)
3058
 
        self.assertEqual(set(['new-1']), tt._removed_id)
3059
 
        self.assertEqual(set(['new-2']), tt._removed_contents)
3060
 
 
3061
 
    def missing_records(self):
3062
 
        attribs = self.default_attribs()
3063
 
        attribs['_id_number'] = 2
3064
 
        attribs['_non_present_ids'] = {
3065
 
            'boo': 'new-1',}
3066
 
        return self.make_records(attribs, [])
3067
 
 
3068
 
    def test_serialize_missing(self):
3069
 
        tt = self.get_preview()
3070
 
        boo_trans_id = tt.trans_id_file_id('boo')
3071
 
        self.assertSerializesTo(self.missing_records(), tt)
3072
 
 
3073
 
    def test_deserialize_missing(self):
3074
 
        tt = self.get_preview()
3075
 
        tt.deserialize(iter(self.missing_records()))
3076
 
        self.assertEqual({'boo': 'new-1'}, tt._non_present_ids)
3077
 
 
3078
 
    def make_modification_preview(self):
3079
 
        LINES_ONE = 'aa\nbb\ncc\ndd\n'
3080
 
        LINES_TWO = 'z\nbb\nx\ndd\n'
3081
 
        tree = self.make_branch_and_tree('tree')
3082
 
        self.build_tree_contents([('tree/file', LINES_ONE)])
3083
 
        tree.add('file', 'file-id')
3084
 
        return self.get_preview(tree), LINES_TWO
3085
 
 
3086
 
    def modification_records(self):
3087
 
        attribs = self.default_attribs()
3088
 
        attribs['_id_number'] = 2
3089
 
        attribs['_tree_path_ids'] = {
3090
 
            'file': 'new-1',
3091
 
            '': 'new-0',}
3092
 
        attribs['_removed_contents'] = ['new-1']
3093
 
        contents = [('new-1', 'file',
3094
 
                     'i 1\nz\n\nc 0 1 1 1\ni 1\nx\n\nc 0 3 3 1\n')]
3095
 
        return self.make_records(attribs, contents)
3096
 
 
3097
 
    def test_serialize_modification(self):
3098
 
        tt, LINES = self.make_modification_preview()
3099
 
        trans_id = tt.trans_id_file_id('file-id')
3100
 
        tt.delete_contents(trans_id)
3101
 
        tt.create_file(LINES, trans_id)
3102
 
        self.assertSerializesTo(self.modification_records(), tt)
3103
 
 
3104
 
    def test_deserialize_modification(self):
3105
 
        tt, LINES = self.make_modification_preview()
3106
 
        tt.deserialize(iter(self.modification_records()))
3107
 
        self.assertFileEqual(LINES, tt._limbo_name('new-1'))
3108
 
 
3109
 
    def make_kind_change_preview(self):
3110
 
        LINES = 'a\nb\nc\nd\n'
3111
 
        tree = self.make_branch_and_tree('tree')
3112
 
        self.build_tree(['tree/foo/'])
3113
 
        tree.add('foo', 'foo-id')
3114
 
        return self.get_preview(tree), LINES
3115
 
 
3116
 
    def kind_change_records(self):
3117
 
        attribs = self.default_attribs()
3118
 
        attribs['_id_number'] = 2
3119
 
        attribs['_tree_path_ids'] = {
3120
 
            'foo': 'new-1',
3121
 
            '': 'new-0',}
3122
 
        attribs['_removed_contents'] = ['new-1']
3123
 
        contents = [('new-1', 'file',
3124
 
                     'i 4\na\nb\nc\nd\n\n')]
3125
 
        return self.make_records(attribs, contents)
3126
 
 
3127
 
    def test_serialize_kind_change(self):
3128
 
        tt, LINES = self.make_kind_change_preview()
3129
 
        trans_id = tt.trans_id_file_id('foo-id')
3130
 
        tt.delete_contents(trans_id)
3131
 
        tt.create_file(LINES, trans_id)
3132
 
        self.assertSerializesTo(self.kind_change_records(), tt)
3133
 
 
3134
 
    def test_deserialize_kind_change(self):
3135
 
        tt, LINES = self.make_kind_change_preview()
3136
 
        tt.deserialize(iter(self.kind_change_records()))
3137
 
        self.assertFileEqual(LINES, tt._limbo_name('new-1'))
3138
 
 
3139
 
    def make_add_contents_preview(self):
3140
 
        LINES = 'a\nb\nc\nd\n'
3141
 
        tree = self.make_branch_and_tree('tree')
3142
 
        self.build_tree(['tree/foo'])
3143
 
        tree.add('foo')
3144
 
        os.unlink('tree/foo')
3145
 
        return self.get_preview(tree), LINES
3146
 
 
3147
 
    def add_contents_records(self):
3148
 
        attribs = self.default_attribs()
3149
 
        attribs['_id_number'] = 2
3150
 
        attribs['_tree_path_ids'] = {
3151
 
            'foo': 'new-1',
3152
 
            '': 'new-0',}
3153
 
        contents = [('new-1', 'file',
3154
 
                     'i 4\na\nb\nc\nd\n\n')]
3155
 
        return self.make_records(attribs, contents)
3156
 
 
3157
 
    def test_serialize_add_contents(self):
3158
 
        tt, LINES = self.make_add_contents_preview()
3159
 
        trans_id = tt.trans_id_tree_path('foo')
3160
 
        tt.create_file(LINES, trans_id)
3161
 
        self.assertSerializesTo(self.add_contents_records(), tt)
3162
 
 
3163
 
    def test_deserialize_add_contents(self):
3164
 
        tt, LINES = self.make_add_contents_preview()
3165
 
        tt.deserialize(iter(self.add_contents_records()))
3166
 
        self.assertFileEqual(LINES, tt._limbo_name('new-1'))
3167
 
 
3168
 
    def test_get_parents_lines(self):
3169
 
        LINES_ONE = 'aa\nbb\ncc\ndd\n'
3170
 
        LINES_TWO = 'z\nbb\nx\ndd\n'
3171
 
        tree = self.make_branch_and_tree('tree')
3172
 
        self.build_tree_contents([('tree/file', LINES_ONE)])
3173
 
        tree.add('file', 'file-id')
3174
 
        tt = self.get_preview(tree)
3175
 
        trans_id = tt.trans_id_tree_path('file')
3176
 
        self.assertEqual((['aa\n', 'bb\n', 'cc\n', 'dd\n'],),
3177
 
            tt._get_parents_lines(trans_id))
3178
 
 
3179
 
    def test_get_parents_texts(self):
3180
 
        LINES_ONE = 'aa\nbb\ncc\ndd\n'
3181
 
        LINES_TWO = 'z\nbb\nx\ndd\n'
3182
 
        tree = self.make_branch_and_tree('tree')
3183
 
        self.build_tree_contents([('tree/file', LINES_ONE)])
3184
 
        tree.add('file', 'file-id')
3185
 
        tt = self.get_preview(tree)
3186
 
        trans_id = tt.trans_id_tree_path('file')
3187
 
        self.assertEqual((LINES_ONE,),
3188
 
            tt._get_parents_texts(trans_id))