/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 breezy/tests/per_workingtree/test_move.py

  • Committer: Jelmer Vernooij
  • Date: 2018-11-16 23:15:15 UTC
  • mfrom: (7180 work)
  • mto: This revision was merged to the branch mainline in revision 7183.
  • Revision ID: jelmer@jelmer.uk-20181116231515-zqd2yn6kj8lfydyp
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/per_workingtree/test_move.py
66
66
        tree.add(['a1', 'sub1'])
67
67
        tree.commit('initial commit')
68
68
        self.assertEqual([('a1', 'sub1/a1')],
69
 
            tree.move(['a1'], to_dir='sub1', after=False))
 
69
                         tree.move(['a1'], to_dir='sub1', after=False))
70
70
        tree._validate()
71
71
 
72
72
    def test_move_correct_call_unnamed(self):
79
79
        tree.add(['a1', 'sub1'])
80
80
        tree.commit('initial commit')
81
81
        self.assertEqual([('a1', 'sub1/a1')],
82
 
            tree.move(['a1'], 'sub1', after=False))
 
82
                         tree.move(['a1'], 'sub1', after=False))
83
83
        tree._validate()
84
84
 
85
85
    def test_move_target_not_dir(self):
143
143
        else:
144
144
            self.assertPathRelations(
145
145
                tree.basis_tree(), tree,
146
 
                [('', ''), ( 'a/', 'a/'), ('c', 'c'), ('d', 'd')])
 
146
                [('', ''), ('a/', 'a/'), ('c', 'c'), ('d', 'd')])
147
147
        tree._validate()
148
148
 
149
149
    def test_move_over_deleted(self):
155
155
        tree.remove(['a/b'], keep_files=False)
156
156
        self.assertEqual([('b', 'a/b')], tree.move(['b'], 'a'))
157
157
        self.assertPathRelations(
158
 
                tree.basis_tree(), tree,
159
 
                [('', ''), ('a/', 'a/'), ('a/b', 'b')])
 
158
            tree.basis_tree(), tree,
 
159
            [('', ''), ('a/', 'a/'), ('a/b', 'b')])
160
160
        tree._validate()
161
161
 
162
162
    def test_move_subdir(self):
165
165
        tree.add(['a', 'b', 'b/c'])
166
166
        tree.commit('initial')
167
167
        self.assertPathRelations(
168
 
                tree.basis_tree(), tree,
169
 
                [('', ''), ('a', 'a'), ('b/', 'b/'), ('b/c', 'b/c')])
 
168
            tree.basis_tree(), tree,
 
169
            [('', ''), ('a', 'a'), ('b/', 'b/'), ('b/c', 'b/c')])
170
170
        a_contents = tree.get_file_text('a')
171
171
        self.assertEqual([('a', 'b/a')], tree.move(['a'], 'b'))
172
172
        self.assertPathRelations(
173
 
                tree.basis_tree(), tree,
174
 
                [('', ''), ('b/', 'b/'), ('b/a', 'a'), ('b/c', 'b/c')])
 
173
            tree.basis_tree(), tree,
 
174
            [('', ''), ('b/', 'b/'), ('b/a', 'a'), ('b/c', 'b/c')])
175
175
        self.assertPathDoesNotExist('a')
176
176
        self.assertFileEqual(a_contents, 'b/a')
177
177
        tree._validate()
183
183
        tree.commit('initial')
184
184
        c_contents = tree.get_file_text('b/c')
185
185
        self.assertEqual([('b/c', 'c')],
186
 
            tree.move(['b/c'], ''))
 
186
                         tree.move(['b/c'], ''))
187
187
        self.assertPathRelations(
188
 
                tree.basis_tree(), tree,
189
 
                [('', ''), ('a', 'a'), ('b/', 'b/'), ('c', 'b/c')])
 
188
            tree.basis_tree(), tree,
 
189
            [('', ''), ('a', 'a'), ('b/', 'b/'), ('c', 'b/c')])
190
190
        self.assertPathDoesNotExist('b/c')
191
191
        self.assertFileEqual(c_contents, 'c')
192
192
        tree._validate()
203
203
        # maintain a consistent state.
204
204
        if osutils.lexists('c'):
205
205
            self.assertPathRelations(
206
 
                    tree.basis_tree(), tree,
207
 
                    [('', ''), ('a', 'a'), ('b/', 'b/'), ('c', 'c')])
 
206
                tree.basis_tree(), tree,
 
207
                [('', ''), ('a', 'a'), ('b/', 'b/'), ('c', 'c')])
208
208
        else:
209
209
            self.assertPathExists('b/c')
210
210
            self.assertPathRelations(
211
 
                    tree.basis_tree(), tree,
212
 
                    [('', ''), ('a', 'a'), ('b/', 'b/'), ('b/c', 'c')])
 
211
                tree.basis_tree(), tree,
 
212
                [('', ''), ('a', 'a'), ('b/', 'b/'), ('b/c', 'c')])
213
213
        tree._validate()
214
214
 
215
215
    def test_move_onto_self(self):
240
240
        os.rename('a', 'b/a')
241
241
 
242
242
        self.assertPathRelations(
243
 
                tree.basis_tree(), tree,
244
 
                [('', ''), ('a', 'a'), ('b/', 'b/')])
 
243
            tree.basis_tree(), tree,
 
244
            [('', ''), ('a', 'a'), ('b/', 'b/')])
245
245
        # We don't need after=True as long as source is missing and target
246
246
        # exists.
247
247
        self.assertEqual([('a', 'b/a')],
248
 
            tree.move(['a'], 'b'))
 
248
                         tree.move(['a'], 'b'))
249
249
        self.assertPathRelations(
250
 
                tree.basis_tree(), tree,
251
 
                [('', ''), ('b/', 'b/'), ('b/a', 'a')])
 
250
            tree.basis_tree(), tree,
 
251
            [('', ''), ('b/', 'b/'), ('b/a', 'a')])
252
252
        tree._validate()
253
253
 
254
254
    def test_move_after_with_after(self):
259
259
        os.rename('a', 'b/a')
260
260
 
261
261
        self.assertPathRelations(
262
 
                tree.basis_tree(), tree,
263
 
                [('', ''), ('a', 'a'), ('b/', 'b/')])
 
262
            tree.basis_tree(), tree,
 
263
            [('', ''), ('a', 'a'), ('b/', 'b/')])
264
264
        # Passing after=True should work as well
265
265
        self.assertEqual([('a', 'b/a')], tree.move(['a'], 'b', after=True))
266
266
        self.assertPathRelations(
267
 
                tree.basis_tree(), tree,
268
 
                [('', ''), ('b/', 'b/'), ('b/a', 'a')])
 
267
            tree.basis_tree(), tree,
 
268
            [('', ''), ('b/', 'b/'), ('b/a', 'a')])
269
269
        tree._validate()
270
270
 
271
271
    def test_move_after_no_target(self):
278
278
        self.assertRaises(errors.BzrMoveFailedError,
279
279
                          tree.move, ['a'], 'b', after=True)
280
280
 
281
 
        self.assertTreeLayout(['', 'a','b/'], tree.basis_tree())
 
281
        self.assertTreeLayout(['', 'a', 'b/'], tree.basis_tree())
282
282
        tree._validate()
283
283
 
284
284
    def test_move_after_source_and_dest(self):
302
302
        self.assertFileEqual(ba_text, 'b/a')
303
303
        # But you can pass after=True
304
304
        self.assertEqual([('a', 'b/a')],
305
 
            tree.move(['a'], 'b', after=True))
 
305
                         tree.move(['a'], 'b', after=True))
306
306
        self.assertPathRelations(
307
 
                tree.basis_tree(), tree,
308
 
                [('', ''), ('b/', 'b/'), ('b/a', 'a')])
 
307
            tree.basis_tree(), tree,
 
308
            [('', ''), ('b/', 'b/'), ('b/a', 'a')])
309
309
        # But it shouldn't actually move anything
310
310
        self.assertFileEqual(a_text, 'a')
311
311
        self.assertFileEqual(ba_text, 'b/a')
319
319
 
320
320
        self.assertEqual([('a', 'e/a')], tree.move(['a'], 'e'))
321
321
        self.assertPathRelations(
322
 
                tree.basis_tree(), tree,
323
 
                [('', ''), ('e/', 'e/'), ('e/a/', 'a/'), ('e/a/b', 'a/b'),
324
 
                 ('e/a/c/', 'a/c/'), ('e/a/c/d', 'a/c/d')])
 
322
            tree.basis_tree(), tree,
 
323
            [('', ''), ('e/', 'e/'), ('e/a/', 'a/'), ('e/a/b', 'a/b'),
 
324
             ('e/a/c/', 'a/c/'), ('e/a/c/d', 'a/c/d')])
325
325
        tree._validate()
326
326
 
327
327
    def test_move_directory_into_parent(self):
336
336
        self.assertEqual([('c/b', 'b')],
337
337
                         tree.move(['c/b'], ''))
338
338
        self.assertPathRelations(
339
 
                tree.basis_tree(), tree,
340
 
                [('', ''),
341
 
                 ('b/', 'c/b/'),
342
 
                 ('c/', 'c/'),
343
 
                 ('b/d/', 'c/b/d/')])
 
339
            tree.basis_tree(), tree,
 
340
            [('', ''),
 
341
             ('b/', 'c/b/'),
 
342
             ('c/', 'c/'),
 
343
             ('b/d/', 'c/b/d/')])
344
344
        tree._validate()
345
345
 
346
346
    def test_move_directory_with_children_in_subdir(self):
399
399
 
400
400
        self.assertEqual([('a', 'b/a')], tree.move(['a'], 'b'))
401
401
        self.assertPathRelations(
402
 
                tree.basis_tree(), tree,
403
 
                [('', ''),
404
 
                 ('b/', 'b/'),
405
 
                 ('b/a/', 'a/'),
406
 
                 ('b/a/b', None),
407
 
                 ('b/a/c', 'a/c'),
408
 
                 ('b/a/d', None),
409
 
                 ])
 
402
            tree.basis_tree(), tree,
 
403
            [('', ''),
 
404
             ('b/', 'b/'),
 
405
             ('b/a/', 'a/'),
 
406
             ('b/a/b', None),
 
407
             ('b/a/c', 'a/c'),
 
408
             ('b/a/d', None),
 
409
             ])
410
410
        tree._validate()
411
411
 
412
412
    def test_move_directory_with_moved_children(self):
486
486
        tree.rename_one('a/d', 'a/b')
487
487
        tree.rename_one('a/bb', 'a/d')
488
488
        self.assertPathRelations(
489
 
                tree.basis_tree(), tree,
490
 
                [('', ''),
491
 
                 ('a/', 'a/'),
492
 
                 ('e/', 'e/'),
493
 
                 ('a/b', 'a/d'),
494
 
                 ('a/c', 'a/c'),
495
 
                 ('a/d', 'a/b')])
 
489
            tree.basis_tree(), tree,
 
490
            [('', ''),
 
491
             ('a/', 'a/'),
 
492
             ('e/', 'e/'),
 
493
             ('a/b', 'a/d'),
 
494
             ('a/c', 'a/c'),
 
495
             ('a/d', 'a/b')])
496
496
        self.assertEqual([('a', 'e/a')],
497
497
                         tree.move(['a'], 'e'))
498
498
        self.assertPathRelations(
499
 
                tree.basis_tree(), tree,
500
 
                [('', ''),
501
 
                 ('e/', 'e/'),
502
 
                 ('e/a/', 'a/'),
503
 
                 ('e/a/b', 'a/d'),
504
 
                 ('e/a/c', 'a/c'),
505
 
                 ('e/a/d', 'a/b')])
 
499
            tree.basis_tree(), tree,
 
500
            [('', ''),
 
501
             ('e/', 'e/'),
 
502
             ('e/a/', 'a/'),
 
503
             ('e/a/b', 'a/d'),
 
504
             ('e/a/c', 'a/c'),
 
505
             ('e/a/d', 'a/b')])
506
506
        tree._validate()
507
507
 
508
508
    def test_move_moved(self):
513
513
        tree.commit('initial')
514
514
 
515
515
        self.assertEqual([('a/b', 'c/b')],
516
 
            tree.move(['a/b'], 'c'))
 
516
                         tree.move(['a/b'], 'c'))
517
517
        self.assertPathRelations(
518
518
            tree.basis_tree(), tree,
519
519
            [('', ''), ('a/', 'a/'), ('c/', 'c/'), ('c/b', 'a/b')])
532
532
        tree.add(["a"])
533
533
        if tree.has_versioned_directories():
534
534
            e = self.assertRaises(errors.BzrMoveFailedError,
535
 
                tree.move, ["a"], u"\xA7")
 
535
                                  tree.move, ["a"], u"\xA7")
536
536
            self.assertIsInstance(e.extra, errors.NotVersionedError)
537
537
            self.assertEqual(e.extra.path, u"\xA7")
538
538
        else:
545
545
        self.build_tree([u"\xA7", "dir/"])
546
546
        tree.add("dir")
547
547
        e = self.assertRaises(errors.BzrMoveFailedError,
548
 
            tree.move, [u"\xA7"], "dir")
 
548
                              tree.move, [u"\xA7"], "dir")
549
549
        self.assertIsInstance(e.extra, errors.NotVersionedError)
550
550
        self.assertEqual(e.extra.path, u"\xA7")