/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/blackbox/test_remove.py

  • Committer: Jelmer Vernooij
  • Date: 2019-06-15 13:39:46 UTC
  • mto: This revision was merged to the branch mainline in revision 7342.
  • Revision ID: jelmer@jelmer.uk-20190615133946-uywh9ix0lfpqw0hy
Install quilt.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_remove.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
18
18
import os
19
19
import sys
20
20
 
21
 
from bzrlib.tests import SymlinkFeature, TestSkipped
22
 
from bzrlib.tests.blackbox import ExternalBase
23
 
from bzrlib.workingtree import WorkingTree
24
 
from bzrlib import osutils
25
 
 
26
 
_id='-id'
27
 
a='a'
28
 
b='b/'
29
 
c='b/c'
30
 
d='d/'
31
 
files=(a, b, c, d)
32
 
 
33
 
 
34
 
class TestRemove(ExternalBase):
 
21
from breezy.tests import (
 
22
    script,
 
23
    features,
 
24
    TestCaseWithTransport,
 
25
    TestSkipped,
 
26
    TestNotApplicable,
 
27
    )
 
28
from breezy.workingtree import WorkingTree
 
29
from breezy import osutils
 
30
 
 
31
_id = b'-id'
 
32
a = 'a'
 
33
b = 'b/'
 
34
c = 'b/c'
 
35
d = 'd/'
 
36
files = (a, b, c, d)
 
37
 
 
38
 
 
39
class TestRemove(TestCaseWithTransport):
35
40
 
36
41
    def _make_tree_and_add(self, paths):
37
42
        tree = self.make_branch_and_tree('.')
39
44
        try:
40
45
            self.build_tree(paths)
41
46
            for path in paths:
42
 
                file_id=str(path).replace('/', '_') + _id
 
47
                file_id = path.replace('/', '_').encode('utf-8') + _id
43
48
                tree.add(path, file_id)
44
49
        finally:
45
50
            tree.unlock()
47
52
 
48
53
    def assertFilesDeleted(self, files):
49
54
        for f in files:
50
 
            id=f+_id
 
55
            id = f.encode('utf-8') + _id
51
56
            self.assertNotInWorkingTree(f)
52
 
            self.failIfExists(f)
 
57
            self.assertPathDoesNotExist(f)
53
58
 
54
59
    def assertFilesUnversioned(self, files):
55
60
        for f in files:
56
61
            self.assertNotInWorkingTree(f)
57
 
            self.failUnlessExists(f)
 
62
            self.assertPathExists(f)
58
63
 
59
64
    def changeFile(self, file_name):
60
 
        f = file(file_name, 'ab')
61
 
        f.write("\nsome other new content!")
62
 
        f.close()
 
65
        with open(file_name, 'ab') as f:
 
66
            f.write(b"\nsome other new content!")
63
67
 
64
 
    def run_bzr_remove_changed_files(self, error_regexes, files_to_remove,
65
 
                                     working_dir=None):
66
 
        error_regexes.extend(["Can't safely remove modified or unknown files:",
67
 
            'Use --keep to not delete them,'
68
 
            ' or --force to delete them regardless.'
69
 
            ])
70
 
        self.run_bzr_error(error_regexes,
71
 
                           ['remove'] + list(files_to_remove),
72
 
                           working_dir=working_dir)
73
 
        #see if we can force it now
74
 
        self.run_bzr(['remove', '--force'] + list(files_to_remove),
 
68
    def run_bzr_remove_changed_files(self, files_to_remove, working_dir=None):
 
69
        self.run_bzr(['remove'] + list(files_to_remove),
75
70
                     working_dir=working_dir)
76
71
 
77
72
    def test_remove_new_no_files_specified(self):
78
73
        tree = self.make_branch_and_tree('.')
79
 
        self.run_bzr_error(["bzr: ERROR: No matching files."], 'remove --new')
80
 
        self.run_bzr_error(["bzr: ERROR: No matching files."], 'remove --new .')
 
74
        self.run_bzr_error(["brz: ERROR: No matching files."], 'remove --new')
 
75
        self.run_bzr_error(
 
76
            ["brz: ERROR: No matching files."], 'remove --new .')
81
77
 
82
78
    def test_remove_no_files_specified(self):
83
79
        tree = self._make_tree_and_add(['foo'])
85
81
        self.assertEqual('', err)
86
82
        self.assertEqual('', out)
87
83
        self.assertInWorkingTree('foo', tree=tree)
88
 
        self.failUnlessExists('foo')
 
84
        self.assertPathExists('foo')
89
85
 
90
86
    def test_remove_no_files_specified_missing_dir_and_contents(self):
91
87
        tree = self._make_tree_and_add(
99
95
            err)
100
96
        # non-missing paths not touched:
101
97
        self.assertInWorkingTree('foo', tree=tree)
102
 
        self.failUnlessExists('foo')
 
98
        self.assertPathExists('foo')
103
99
        self.assertInWorkingTree('dir', tree=tree)
104
 
        self.failUnlessExists('dir')
 
100
        self.assertPathExists('dir')
105
101
        # missing files unversioned
106
102
        self.assertNotInWorkingTree('dir/missing', tree=tree)
107
103
        self.assertNotInWorkingTree('dir/missing/child', tree=tree)
111
107
        tree.commit('save foo and bar')
112
108
        os.unlink('bar')
113
109
        self.run_bzr(['rm'])
114
 
        self.assertEqual(None, tree.path2id('bar'))
 
110
        self.assertFalse(tree.is_versioned('bar'))
115
111
        # Running rm with a deleted file does not error.
116
112
        out, err = self.run_bzr(['rm'])
117
113
        self.assertEqual('', out)
125
121
        self.assertEqual('removed bar\n', err)
126
122
        # non-missing files not touched:
127
123
        self.assertInWorkingTree('foo', tree=tree)
128
 
        self.failUnlessExists('foo')
 
124
        self.assertPathExists('foo')
129
125
        # missing files unversioned
130
126
        self.assertNotInWorkingTree('bar', tree=tree)
131
127
 
132
128
    def test_remove_no_files_specified_missing_link(self):
133
 
        self.requireFeature(SymlinkFeature)
 
129
        self.requireFeature(features.SymlinkFeature)
134
130
        tree = self._make_tree_and_add(['foo'])
135
131
        os.symlink('foo', 'linkname')
136
132
        tree.add(['linkname'])
140
136
        self.assertEqual('removed linkname\n', err)
141
137
        # non-missing files not touched:
142
138
        self.assertInWorkingTree('foo', tree=tree)
143
 
        self.failUnlessExists('foo')
 
139
        self.assertPathExists('foo')
144
140
        # missing files unversioned
145
141
        self.assertNotInWorkingTree('linkname', tree=tree)
146
142
 
177
173
    def test_remove_unversioned_files(self):
178
174
        self.build_tree(files)
179
175
        tree = self.make_branch_and_tree('.')
180
 
        self.run_bzr_remove_changed_files(
181
 
            ['unknown:[.\s]*d/[.\s]*b/c[.\s]*b/[.\s]*a'], files)
 
176
        self.run_bzr_remove_changed_files(files)
182
177
 
183
178
    def test_remove_changed_files(self):
184
179
        tree = self._make_tree_and_add(files)
185
180
        self.run_bzr("commit -m 'added files'")
186
181
        self.changeFile(a)
187
182
        self.changeFile(c)
188
 
        self.run_bzr_remove_changed_files(['modified:[.\s]*a[.\s]*b/c'], files)
 
183
        self.run_bzr_remove_changed_files(files)
189
184
 
190
185
    def test_remove_changed_ignored_files(self):
191
186
        tree = self._make_tree_and_add(['a'])
192
187
        self.run_bzr(['ignore', 'a'])
193
 
        self.run_bzr_remove_changed_files(['added:[.\s]*a'], ['a'])
 
188
        self.run_bzr_remove_changed_files(['a'])
194
189
 
195
190
    def test_remove_changed_files_from_child_dir(self):
196
191
        if sys.platform == 'win32':
200
195
        self.changeFile(a)
201
196
        self.changeFile(c)
202
197
        self.run_bzr_remove_changed_files(
203
 
            ['modified:[.\s]*a[.\s]*b/c'],
204
198
            ['../a', 'c', '.', '../d'], working_dir='b')
205
199
        self.assertNotInWorkingTree(files)
206
 
        self.failIfExists(files)
 
200
        self.assertPathDoesNotExist(files)
207
201
 
208
202
    def test_remove_keep_unversioned_files(self):
209
203
        self.build_tree(files)
211
205
        self.run_bzr('remove --keep a', error_regexes=["a is not versioned."])
212
206
        self.assertFilesUnversioned(files)
213
207
 
214
 
    def test_remove_force_unversioned_files(self):
 
208
    def test_remove_no_backup_unversioned_files(self):
215
209
        self.build_tree(files)
216
210
        tree = self.make_branch_and_tree('.')
217
 
        self.run_bzr(['remove', '--force'] + list(files),
218
 
                     error_regexes=["deleted a", "deleted b",
219
 
                                    "deleted b/c", "deleted d"])
 
211
        script.ScriptRunner().run_script(self, '''
 
212
        $ brz remove --no-backup a b/ b/c d/
 
213
        2>deleted d
 
214
        2>removed b/c (but kept a copy: b/c.~1~)
 
215
        2>deleted b
 
216
        2>deleted a
 
217
        ''')
220
218
        self.assertFilesDeleted(files)
221
219
 
222
220
    def test_remove_deleted_files(self):
223
221
        tree = self._make_tree_and_add(files)
224
222
        self.run_bzr("commit -m 'added files'")
225
 
        my_files=[f for f in files]
 
223
        my_files = [f for f in files]
226
224
        my_files.sort(reverse=True)
227
225
        for f in my_files:
228
226
            osutils.delete_any(f)
229
227
        self.assertInWorkingTree(files)
230
 
        self.failIfExists(files)
 
228
        self.assertPathDoesNotExist(files)
231
229
        self.run_bzr('remove ' + ' '.join(files))
232
230
        self.assertNotInWorkingTree(a)
233
 
        self.failIfExists(files)
 
231
        self.assertPathDoesNotExist(files)
234
232
 
235
233
    def test_remove_non_existing_files(self):
236
234
        tree = self._make_tree_and_add([])
245
243
        self.run_bzr("commit -m 'added files'")
246
244
        self.run_bzr('remove a b b/c d',
247
245
                     error_regexes=["deleted a", "deleted b", "deleted b/c",
248
 
                     "deleted d"])
 
246
                                    "deleted d"])
249
247
        self.assertFilesDeleted(files)
250
248
 
251
249
    def test_remove_keep_files(self):
253
251
        self.run_bzr("commit -m 'added files'")
254
252
        self.run_bzr('remove --keep a b b/c d',
255
253
                     error_regexes=["removed a", "removed b", "removed b/c",
256
 
                     "removed d"])
 
254
                                    "removed d"])
257
255
        self.assertFilesUnversioned(files)
258
256
 
259
257
    def test_remove_with_new(self):
268
266
                     error_regexes=["removed b", "removed b/c"])
269
267
        tree = WorkingTree.open('.')
270
268
        self.assertInWorkingTree(a)
271
 
        self.assertEqual(tree.path2id(a), a + _id)
272
 
        self.assertFilesUnversioned([b,c])
 
269
        self.assertEqual(tree.path2id(a), a.encode('utf-8') + _id)
 
270
        self.assertFilesUnversioned([b, c])
273
271
 
274
272
    def test_remove_with_new_in_dir2(self):
275
273
        tree = self._make_tree_and_add(files)
277
275
                     error_regexes=["removed a", "removed b", "removed b/c"])
278
276
        tree = WorkingTree.open('.')
279
277
        self.assertFilesUnversioned(files)
 
278
 
 
279
    def test_remove_backslash(self):
 
280
        # pad.lv/176263
 
281
        if os.path.sep == '\\':
 
282
            raise TestNotApplicable(
 
283
                'unable to add filenames with backslashes where '
 
284
                ' it is the path separator')
 
285
        tree = self.make_branch_and_tree('.')
 
286
        self.build_tree(['\\'])
 
287
        self.assertEqual('adding \\\n', self.run_bzr('add \\\\')[0])
 
288
        self.assertEqual('\\\n', self.run_bzr('ls --versioned')[0])
 
289
        self.assertEqual('', self.run_bzr('rm \\\\')[0])
 
290
        self.assertEqual('', self.run_bzr('ls --versioned')[0])