/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: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

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
 
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
25
29
 
26
30
_id='-id'
27
31
a='a'
31
35
files=(a, b, c, d)
32
36
 
33
37
 
34
 
class TestRemove(ExternalBase):
 
38
class TestRemove(TestCaseWithTransport):
35
39
 
36
40
    def _make_tree_and_add(self, paths):
37
41
        tree = self.make_branch_and_tree('.')
49
53
        for f in files:
50
54
            id=f+_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),
75
 
                     working_dir=working_dir)
 
67
    def run_bzr_remove_changed_files(self, files_to_remove, working_dir=None):
 
68
        self.run_bzr(['remove'] + list(files_to_remove),
 
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([b"brz: ERROR: No matching files."], 'remove --new')
 
74
        self.run_bzr_error([b"brz: ERROR: No matching files."], 'remove --new .')
81
75
 
82
76
    def test_remove_no_files_specified(self):
83
77
        tree = self._make_tree_and_add(['foo'])
84
78
        out, err = self.run_bzr(['rm'])
85
 
        self.assertEqual('', err)
86
 
        self.assertEqual('', out)
 
79
        self.assertEqual(b'', err)
 
80
        self.assertEqual(b'', out)
87
81
        self.assertInWorkingTree('foo', tree=tree)
88
 
        self.failUnlessExists('foo')
 
82
        self.assertPathExists('foo')
89
83
 
90
84
    def test_remove_no_files_specified_missing_dir_and_contents(self):
91
85
        tree = self._make_tree_and_add(
92
86
            ['foo', 'dir/', 'dir/missing/', 'dir/missing/child'])
93
87
        self.get_transport('.').delete_tree('dir/missing')
94
88
        out, err = self.run_bzr(['rm'])
95
 
        self.assertEqual('', out)
 
89
        self.assertEqual(b'', out)
96
90
        self.assertEqual(
97
 
            'removed dir/missing/child\n'
98
 
            'removed dir/missing\n',
 
91
            b'removed dir/missing/child\n'
 
92
            b'removed dir/missing\n',
99
93
            err)
100
94
        # non-missing paths not touched:
101
95
        self.assertInWorkingTree('foo', tree=tree)
102
 
        self.failUnlessExists('foo')
 
96
        self.assertPathExists('foo')
103
97
        self.assertInWorkingTree('dir', tree=tree)
104
 
        self.failUnlessExists('dir')
 
98
        self.assertPathExists('dir')
105
99
        # missing files unversioned
106
100
        self.assertNotInWorkingTree('dir/missing', tree=tree)
107
101
        self.assertNotInWorkingTree('dir/missing/child', tree=tree)
111
105
        tree.commit('save foo and bar')
112
106
        os.unlink('bar')
113
107
        self.run_bzr(['rm'])
114
 
        self.assertEqual(None, tree.path2id('bar'))
 
108
        self.assertFalse(tree.is_versioned('bar'))
115
109
        # Running rm with a deleted file does not error.
116
110
        out, err = self.run_bzr(['rm'])
117
 
        self.assertEqual('', out)
118
 
        self.assertEqual('', err)
 
111
        self.assertEqual(b'', out)
 
112
        self.assertEqual(b'', err)
119
113
 
120
114
    def test_remove_no_files_specified_missing_file(self):
121
115
        tree = self._make_tree_and_add(['foo', 'bar'])
122
116
        os.unlink('bar')
123
117
        out, err = self.run_bzr(['rm'])
124
 
        self.assertEqual('', out)
125
 
        self.assertEqual('removed bar\n', err)
 
118
        self.assertEqual(b'', out)
 
119
        self.assertEqual(b'removed bar\n', err)
126
120
        # non-missing files not touched:
127
121
        self.assertInWorkingTree('foo', tree=tree)
128
 
        self.failUnlessExists('foo')
 
122
        self.assertPathExists('foo')
129
123
        # missing files unversioned
130
124
        self.assertNotInWorkingTree('bar', tree=tree)
131
125
 
132
126
    def test_remove_no_files_specified_missing_link(self):
133
 
        self.requireFeature(SymlinkFeature)
 
127
        self.requireFeature(features.SymlinkFeature)
134
128
        tree = self._make_tree_and_add(['foo'])
135
129
        os.symlink('foo', 'linkname')
136
130
        tree.add(['linkname'])
137
131
        os.unlink('linkname')
138
132
        out, err = self.run_bzr(['rm'])
139
 
        self.assertEqual('', out)
140
 
        self.assertEqual('removed linkname\n', err)
 
133
        self.assertEqual(b'', out)
 
134
        self.assertEqual(b'removed linkname\n', err)
141
135
        # non-missing files not touched:
142
136
        self.assertInWorkingTree('foo', tree=tree)
143
 
        self.failUnlessExists('foo')
 
137
        self.assertPathExists('foo')
144
138
        # missing files unversioned
145
139
        self.assertNotInWorkingTree('linkname', tree=tree)
146
140
 
177
171
    def test_remove_unversioned_files(self):
178
172
        self.build_tree(files)
179
173
        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)
 
174
        self.run_bzr_remove_changed_files(files)
182
175
 
183
176
    def test_remove_changed_files(self):
184
177
        tree = self._make_tree_and_add(files)
185
178
        self.run_bzr("commit -m 'added files'")
186
179
        self.changeFile(a)
187
180
        self.changeFile(c)
188
 
        self.run_bzr_remove_changed_files(['modified:[.\s]*a[.\s]*b/c'], files)
 
181
        self.run_bzr_remove_changed_files(files)
189
182
 
190
183
    def test_remove_changed_ignored_files(self):
191
184
        tree = self._make_tree_and_add(['a'])
192
185
        self.run_bzr(['ignore', 'a'])
193
 
        self.run_bzr_remove_changed_files(['added:[.\s]*a'], ['a'])
 
186
        self.run_bzr_remove_changed_files(['a'])
194
187
 
195
188
    def test_remove_changed_files_from_child_dir(self):
196
189
        if sys.platform == 'win32':
200
193
        self.changeFile(a)
201
194
        self.changeFile(c)
202
195
        self.run_bzr_remove_changed_files(
203
 
            ['modified:[.\s]*a[.\s]*b/c'],
204
196
            ['../a', 'c', '.', '../d'], working_dir='b')
205
197
        self.assertNotInWorkingTree(files)
206
 
        self.failIfExists(files)
 
198
        self.assertPathDoesNotExist(files)
207
199
 
208
200
    def test_remove_keep_unversioned_files(self):
209
201
        self.build_tree(files)
211
203
        self.run_bzr('remove --keep a', error_regexes=["a is not versioned."])
212
204
        self.assertFilesUnversioned(files)
213
205
 
214
 
    def test_remove_force_unversioned_files(self):
 
206
    def test_remove_no_backup_unversioned_files(self):
215
207
        self.build_tree(files)
216
208
        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"])
 
209
        script.ScriptRunner().run_script(self, '''
 
210
        $ brz remove --no-backup a b/ b/c d/
 
211
        2>deleted d
 
212
        2>removed b/c (but kept a copy: b/c.~1~)
 
213
        2>deleted b
 
214
        2>deleted a
 
215
        ''')
220
216
        self.assertFilesDeleted(files)
221
217
 
222
218
    def test_remove_deleted_files(self):
227
223
        for f in my_files:
228
224
            osutils.delete_any(f)
229
225
        self.assertInWorkingTree(files)
230
 
        self.failIfExists(files)
 
226
        self.assertPathDoesNotExist(files)
231
227
        self.run_bzr('remove ' + ' '.join(files))
232
228
        self.assertNotInWorkingTree(a)
233
 
        self.failIfExists(files)
 
229
        self.assertPathDoesNotExist(files)
234
230
 
235
231
    def test_remove_non_existing_files(self):
236
232
        tree = self._make_tree_and_add([])
269
265
        tree = WorkingTree.open('.')
270
266
        self.assertInWorkingTree(a)
271
267
        self.assertEqual(tree.path2id(a), a + _id)
272
 
        self.assertFilesUnversioned([b,c])
 
268
        self.assertFilesUnversioned([b, c])
273
269
 
274
270
    def test_remove_with_new_in_dir2(self):
275
271
        tree = self._make_tree_and_add(files)