/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-10-28 01:38:39 UTC
  • mto: This revision was merged to the branch mainline in revision 7412.
  • Revision ID: jelmer@jelmer.uk-20191028013839-q63zzm4yr0id9b3o
Allow unknown extras in git commits when just inspecting revisions, rather than importing.

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