/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

Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
36
36
from bzrlib.osutils import file_kind, pathjoin
37
37
from bzrlib.merge import Merge3Merger
38
38
from bzrlib.tests import (
 
39
    CaseInsensitiveFilesystemFeature,
39
40
    SymlinkFeature,
40
41
    TestCase,
41
42
    TestCaseInTempDir,
44
45
from bzrlib.transform import (TreeTransform, ROOT_PARENT, FinalPaths, 
45
46
                              resolve_conflicts, cook_conflicts, 
46
47
                              find_interesting, build_tree, get_backup_name,
47
 
                              change_entry, _FileMover)
 
48
                              change_entry, _FileMover, resolve_checkout)
48
49
 
49
50
 
50
51
class TestTreeTransform(tests.TestCaseWithTransport):
84
85
        self.assertRaises(ExistingPendingDeletion, self.get_transform)
85
86
 
86
87
    def test_build(self):
87
 
        transform, root = self.get_transform() 
 
88
        transform, root = self.get_transform()
 
89
        self.wt.lock_tree_write()
 
90
        self.addCleanup(self.wt.unlock)
88
91
        self.assertIs(transform.get_tree_parent(root), ROOT_PARENT)
89
92
        imaginary_id = transform.trans_id_tree_path('imaginary')
90
93
        imaginary_id2 = transform.trans_id_tree_path('imaginary/')
127
130
 
128
131
    def test_convenience(self):
129
132
        transform, root = self.get_transform()
 
133
        self.wt.lock_tree_write()
 
134
        self.addCleanup(self.wt.unlock)
130
135
        trans_id = transform.new_file('name', root, 'contents', 
131
136
                                      'my_pretties', True)
132
137
        oz = transform.new_directory('oz', root, 'oz-id')
233
238
        transform3.adjust_path('tip', root_id, tip_id)
234
239
        transform3.apply()
235
240
 
 
241
    def test_conflict_on_case_insensitive(self):
 
242
        tree = self.make_branch_and_tree('tree')
 
243
        # Don't try this at home, kids!
 
244
        # Force the tree to report that it is case sensitive, for conflict
 
245
        # resolution tests
 
246
        tree.case_sensitive = True
 
247
        transform = TreeTransform(tree)
 
248
        self.addCleanup(transform.finalize)
 
249
        transform.new_file('file', transform.root, 'content')
 
250
        transform.new_file('FiLe', transform.root, 'content')
 
251
        result = transform.find_conflicts()
 
252
        self.assertEqual([], result)
 
253
        # Force the tree to report that it is case insensitive, for conflict
 
254
        # generation tests
 
255
        tree.case_sensitive = False
 
256
        result = transform.find_conflicts()
 
257
        self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
 
258
 
 
259
    def test_conflict_on_case_insensitive_existing(self):
 
260
        tree = self.make_branch_and_tree('tree')
 
261
        self.build_tree(['tree/FiLe'])
 
262
        # Don't try this at home, kids!
 
263
        # Force the tree to report that it is case sensitive, for conflict
 
264
        # resolution tests
 
265
        tree.case_sensitive = True
 
266
        transform = TreeTransform(tree)
 
267
        self.addCleanup(transform.finalize)
 
268
        transform.new_file('file', transform.root, 'content')
 
269
        result = transform.find_conflicts()
 
270
        self.assertEqual([], result)
 
271
        # Force the tree to report that it is case insensitive, for conflict
 
272
        # generation tests
 
273
        tree.case_sensitive = False
 
274
        result = transform.find_conflicts()
 
275
        self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
 
276
 
 
277
    def test_resolve_case_insensitive_conflict(self):
 
278
        tree = self.make_branch_and_tree('tree')
 
279
        # Don't try this at home, kids!
 
280
        # Force the tree to report that it is case insensitive, for conflict
 
281
        # resolution tests
 
282
        tree.case_sensitive = False
 
283
        transform = TreeTransform(tree)
 
284
        self.addCleanup(transform.finalize)
 
285
        transform.new_file('file', transform.root, 'content')
 
286
        transform.new_file('FiLe', transform.root, 'content')
 
287
        resolve_conflicts(transform)
 
288
        transform.apply()
 
289
        self.failUnlessExists('tree/file')
 
290
        self.failUnlessExists('tree/FiLe.moved')
 
291
 
 
292
    def test_resolve_checkout_case_conflict(self):
 
293
        tree = self.make_branch_and_tree('tree')
 
294
        # Don't try this at home, kids!
 
295
        # Force the tree to report that it is case insensitive, for conflict
 
296
        # resolution tests
 
297
        tree.case_sensitive = False
 
298
        transform = TreeTransform(tree)
 
299
        self.addCleanup(transform.finalize)
 
300
        transform.new_file('file', transform.root, 'content')
 
301
        transform.new_file('FiLe', transform.root, 'content')
 
302
        resolve_conflicts(transform,
 
303
                          pass_func=lambda t, c: resolve_checkout(t, c, []))
 
304
        transform.apply()
 
305
        self.failUnlessExists('tree/file')
 
306
        self.failUnlessExists('tree/FiLe.moved')
 
307
 
 
308
    def test_apply_case_conflict(self):
 
309
        """Ensure that a transform with case conflicts can always be applied"""
 
310
        tree = self.make_branch_and_tree('tree')
 
311
        transform = TreeTransform(tree)
 
312
        self.addCleanup(transform.finalize)
 
313
        transform.new_file('file', transform.root, 'content')
 
314
        transform.new_file('FiLe', transform.root, 'content')
 
315
        dir = transform.new_directory('dir', transform.root)
 
316
        transform.new_file('dirfile', dir, 'content')
 
317
        transform.new_file('dirFiLe', dir, 'content')
 
318
        resolve_conflicts(transform)
 
319
        transform.apply()
 
320
        self.failUnlessExists('tree/file')
 
321
        if not os.path.exists('tree/FiLe.moved'):
 
322
            self.failUnlessExists('tree/FiLe')
 
323
        self.failUnlessExists('tree/dir/dirfile')
 
324
        if not os.path.exists('tree/dir/dirFiLe.moved'):
 
325
            self.failUnlessExists('tree/dir/dirFiLe')
 
326
 
 
327
    def test_case_insensitive_limbo(self):
 
328
        tree = self.make_branch_and_tree('tree')
 
329
        # Don't try this at home, kids!
 
330
        # Force the tree to report that it is case insensitive
 
331
        tree.case_sensitive = False
 
332
        transform = TreeTransform(tree)
 
333
        self.addCleanup(transform.finalize)
 
334
        dir = transform.new_directory('dir', transform.root)
 
335
        first = transform.new_file('file', dir, 'content')
 
336
        second = transform.new_file('FiLe', dir, 'content')
 
337
        self.assertContainsRe(transform._limbo_name(first), 'new-1/file')
 
338
        self.assertNotContainsRe(transform._limbo_name(second), 'new-1/FiLe')
 
339
 
236
340
    def test_add_del(self):
237
341
        start, root = self.get_transform()
238
342
        start.new_directory('a', root, 'a')
578
682
        """
579
683
        transform, root = self.get_transform()
580
684
        wt = transform._tree
 
685
        wt.lock_read()
 
686
        self.addCleanup(wt.unlock)
581
687
        transform.new_file('set_on_creation', root, 'Set on creation', 'soc',
582
688
                           True)
583
689
        sac = transform.new_file('set_after_creation', root,
983
1089
        self.callDeprecated([txt], change_entry, None, None, None, None, None,
984
1090
            None, None, None)
985
1091
 
 
1092
    def test_case_insensitive_clash(self):
 
1093
        self.requireFeature(CaseInsensitiveFilesystemFeature)
 
1094
        def tt_helper():
 
1095
            wt = self.make_branch_and_tree('.')
 
1096
            tt = TreeTransform(wt)  # TreeTransform obtains write lock
 
1097
            try:
 
1098
                tt.new_file('foo', tt.root, 'bar')
 
1099
                tt.new_file('Foo', tt.root, 'spam')
 
1100
                # Lie to tt that we've already resolved all conflicts.
 
1101
                tt.apply(no_conflicts=True)
 
1102
            except:
 
1103
                wt.unlock()
 
1104
                raise
 
1105
        err = self.assertRaises(errors.FileExists, tt_helper)
 
1106
        self.assertContainsRe(str(err),
 
1107
            "^File exists: .+/foo")
 
1108
 
 
1109
    def test_two_directories_clash(self):
 
1110
        def tt_helper():
 
1111
            wt = self.make_branch_and_tree('.')
 
1112
            tt = TreeTransform(wt)  # TreeTransform obtains write lock
 
1113
            try:
 
1114
                foo_1 = tt.new_directory('foo', tt.root)
 
1115
                tt.new_directory('bar', foo_1)
 
1116
                foo_2 = tt.new_directory('foo', tt.root)
 
1117
                tt.new_directory('baz', foo_2)
 
1118
                # Lie to tt that we've already resolved all conflicts.
 
1119
                tt.apply(no_conflicts=True)
 
1120
            except:
 
1121
                wt.unlock()
 
1122
                raise
 
1123
        err = self.assertRaises(errors.FileExists, tt_helper)
 
1124
        self.assertContainsRe(str(err),
 
1125
            "^File exists: .+/foo")
 
1126
 
986
1127
 
987
1128
class TransformGroup(object):
 
1129
 
988
1130
    def __init__(self, dirname, root_id):
989
1131
        self.name = dirname
990
1132
        os.mkdir(dirname)
1357
1499
        object.__init__(self)
1358
1500
        self.name = "name"
1359
1501
 
 
1502
 
1360
1503
class TestGetBackupName(TestCase):
1361
1504
    def test_get_backup_name(self):
1362
1505
        tt = MockTransform()
1416
1559
        mover.rename('c/e', 'c/d')
1417
1560
        try:
1418
1561
            mover.rename('a', 'c')
1419
 
        except OSError, e:
 
1562
        except errors.FileExists, e:
1420
1563
            mover.rollback()
1421
1564
        self.failUnlessExists('a')
1422
1565
        self.failUnlessExists('c/d')