/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2019-01-28 23:51:14 UTC
  • mfrom: (7251.1.1 skip-crypto-deprecation)
  • Revision ID: breezy.the.bot@gmail.com-20190128235114-wurthh67hpldlyip
Ignore UserWarning on travis.

Merged from https://code.launchpad.net/~jelmer/brz/skip-crypto-deprecation/+merge/362227

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