← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_remove.py

urlutils.rebase_url handles '..' path segments in 'url'

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_remove.py
18
18
import os
19
19
import sys
20
20
 
21
 
from bzrlib.tests import SymlinkFeature, TestSkipped
 
21
from bzrlib.tests import TestSkipped
22
22
from bzrlib.tests.blackbox import ExternalBase
23
23
from bzrlib.workingtree import WorkingTree
24
24
from bzrlib import osutils
33
33
 
34
34
class TestRemove(ExternalBase):
35
35
 
36
 
    def _make_tree_and_add(self, paths):
 
36
    def _make_add_and_assert_tree(self, files):
37
37
        tree = self.make_branch_and_tree('.')
38
 
        tree.lock_write()
39
 
        try:
40
 
            self.build_tree(paths)
41
 
            for path in paths:
42
 
                file_id=str(path).replace('/', '_') + _id
43
 
                tree.add(path, file_id)
44
 
        finally:
45
 
            tree.unlock()
 
38
        self.build_tree(files)
 
39
        for f in files:
 
40
            id=str(f).replace('/', '_') + _id
 
41
            tree.add(f, id)
 
42
            self.assertEqual(tree.path2id(f), id)
 
43
            self.failUnlessExists(f)
 
44
            self.assertInWorkingTree(f)
46
45
        return tree
47
46
 
48
47
    def assertFilesDeleted(self, files):
71
70
        #see if we can force it now
72
71
        self.run_bzr(['remove', '--force'] + list(files_to_remove))
73
72
 
74
 
    def test_remove_new_no_files_specified(self):
75
 
        tree = self.make_branch_and_tree('.')
 
73
    def test_remove_no_files_specified(self):
 
74
        tree = self._make_add_and_assert_tree([])
 
75
        self.run_bzr_error(["bzr: ERROR: Specify one or more files to remove, "
 
76
            "or use --new."], 'remove')
 
77
 
76
78
        self.run_bzr_error(["bzr: ERROR: No matching files."], 'remove --new')
77
 
        self.run_bzr_error(["bzr: ERROR: No matching files."], 'remove --new .')
78
 
 
79
 
    def test_remove_no_files_specified(self):
80
 
        tree = self._make_tree_and_add(['foo'])
81
 
        out, err = self.run_bzr(['rm'])
82
 
        self.assertEqual('', err)
83
 
        self.assertEqual('', out)
84
 
        self.assertInWorkingTree('foo', tree=tree)
85
 
        self.failUnlessExists('foo')
86
 
 
87
 
    def test_remove_no_files_specified_missing_dir_and_contents(self):
88
 
        tree = self._make_tree_and_add(
89
 
            ['foo', 'dir/', 'dir/missing/', 'dir/missing/child'])
90
 
        self.get_transport('.').delete_tree('dir/missing')
91
 
        out, err = self.run_bzr(['rm'])
92
 
        self.assertEqual('', out)
93
 
        self.assertEqual(
94
 
            'removed dir/missing/child\n'
95
 
            'removed dir/missing\n',
96
 
            err)
97
 
        # non-missing paths not touched:
98
 
        self.assertInWorkingTree('foo', tree=tree)
99
 
        self.failUnlessExists('foo')
100
 
        self.assertInWorkingTree('dir', tree=tree)
101
 
        self.failUnlessExists('dir')
102
 
        # missing files unversioned
103
 
        self.assertNotInWorkingTree('dir/missing', tree=tree)
104
 
        self.assertNotInWorkingTree('dir/missing/child', tree=tree)
105
 
 
106
 
    def test_remove_no_files_specified_already_deleted(self):
107
 
        tree = self._make_tree_and_add(['foo', 'bar'])
108
 
        tree.commit('save foo and bar')
109
 
        os.unlink('bar')
110
 
        self.run_bzr(['rm'])
111
 
        self.assertEqual(None, tree.path2id('bar'))
112
 
        # Running rm with a deleted file does not error.
113
 
        out, err = self.run_bzr(['rm'])
114
 
        self.assertEqual('', out)
115
 
        self.assertEqual('', err)
116
 
 
117
 
    def test_remove_no_files_specified_missing_file(self):
118
 
        tree = self._make_tree_and_add(['foo', 'bar'])
119
 
        os.unlink('bar')
120
 
        out, err = self.run_bzr(['rm'])
121
 
        self.assertEqual('', out)
122
 
        self.assertEqual('removed bar\n', err)
123
 
        # non-missing files not touched:
124
 
        self.assertInWorkingTree('foo', tree=tree)
125
 
        self.failUnlessExists('foo')
126
 
        # missing files unversioned
127
 
        self.assertNotInWorkingTree('bar', tree=tree)
128
 
 
129
 
    def test_remove_no_files_specified_missing_link(self):
130
 
        self.requireFeature(SymlinkFeature)
131
 
        tree = self._make_tree_and_add(['foo'])
132
 
        os.symlink('foo', 'linkname')
133
 
        tree.add(['linkname'])
134
 
        os.unlink('linkname')
135
 
        out, err = self.run_bzr(['rm'])
136
 
        self.assertEqual('', out)
137
 
        self.assertEqual('removed linkname\n', err)
138
 
        # non-missing files not touched:
139
 
        self.assertInWorkingTree('foo', tree=tree)
140
 
        self.failUnlessExists('foo')
141
 
        # missing files unversioned
142
 
        self.assertNotInWorkingTree('linkname', tree=tree)
 
79
 
 
80
        self.run_bzr_error(["bzr: ERROR: No matching files."],
 
81
            'remove --new .')
143
82
 
144
83
    def test_rm_one_file(self):
145
 
        tree = self._make_tree_and_add([a])
 
84
        tree = self._make_add_and_assert_tree([a])
146
85
        self.run_bzr("commit -m 'added a'")
147
86
        self.run_bzr('rm a', error_regexes=["deleted a"])
148
87
        self.assertFilesDeleted([a])
149
88
 
150
89
    def test_remove_one_file(self):
151
 
        tree = self._make_tree_and_add([a])
 
90
        tree = self._make_add_and_assert_tree([a])
152
91
        self.run_bzr("commit -m 'added a'")
153
92
        self.run_bzr('remove a', error_regexes=["deleted a"])
154
93
        self.assertFilesDeleted([a])
155
94
 
156
95
    def test_remove_keep_one_file(self):
157
 
        tree = self._make_tree_and_add([a])
 
96
        tree = self._make_add_and_assert_tree([a])
158
97
        self.run_bzr('remove --keep a', error_regexes=["removed a"])
159
98
        self.assertFilesUnversioned([a])
160
99
 
161
100
    def test_remove_one_deleted_file(self):
162
 
        tree = self._make_tree_and_add([a])
 
101
        tree = self._make_add_and_assert_tree([a])
163
102
        self.run_bzr("commit -m 'added a'")
164
103
        os.unlink(a)
165
104
        self.assertInWorkingTree(a)
178
117
            ['unknown:[.\s]*d/[.\s]*b/c[.\s]*b/[.\s]*a'], files)
179
118
 
180
119
    def test_remove_changed_files(self):
181
 
        tree = self._make_tree_and_add(files)
 
120
        tree = self._make_add_and_assert_tree(files)
182
121
        self.run_bzr("commit -m 'added files'")
183
122
        self.changeFile(a)
184
123
        self.changeFile(c)
185
124
        self.run_bzr_remove_changed_files(['modified:[.\s]*a[.\s]*b/c'], files)
186
125
 
187
126
    def test_remove_changed_ignored_files(self):
188
 
        tree = self._make_tree_and_add(['a'])
 
127
        tree = self._make_add_and_assert_tree(['a'])
189
128
        self.run_bzr(['ignore', 'a'])
190
129
        self.run_bzr_remove_changed_files(['added:[.\s]*a'], ['a'])
191
130
 
192
131
    def test_remove_changed_files_from_child_dir(self):
193
132
        if sys.platform == 'win32':
194
133
            raise TestSkipped("Windows unable to remove '.' directory")
195
 
        tree = self._make_tree_and_add(files)
 
134
        tree = self._make_add_and_assert_tree(files)
196
135
        self.run_bzr("commit -m 'added files'")
197
136
        self.changeFile(a)
198
137
        self.changeFile(c)
218
157
        self.assertFilesDeleted(files)
219
158
 
220
159
    def test_remove_deleted_files(self):
221
 
        tree = self._make_tree_and_add(files)
 
160
        tree = self._make_add_and_assert_tree(files)
222
161
        self.run_bzr("commit -m 'added files'")
223
162
        my_files=[f for f in files]
224
163
        my_files.sort(reverse=True)
231
170
        self.failIfExists(files)
232
171
 
233
172
    def test_remove_non_existing_files(self):
234
 
        tree = self._make_tree_and_add([])
 
173
        tree = self._make_add_and_assert_tree([])
235
174
        self.run_bzr(['remove', 'b'])
236
175
 
237
176
    def test_remove_keep_non_existing_files(self):
238
 
        tree = self._make_tree_and_add([])
 
177
        tree = self._make_add_and_assert_tree([])
239
178
        self.run_bzr('remove --keep b', error_regexes=["b is not versioned."])
240
179
 
241
180
    def test_remove_files(self):
242
 
        tree = self._make_tree_and_add(files)
 
181
        tree = self._make_add_and_assert_tree(files)
243
182
        self.run_bzr("commit -m 'added files'")
244
183
        self.run_bzr('remove a b b/c d',
245
184
                     error_regexes=["deleted a", "deleted b", "deleted b/c",
247
186
        self.assertFilesDeleted(files)
248
187
 
249
188
    def test_remove_keep_files(self):
250
 
        tree = self._make_tree_and_add(files)
 
189
        tree = self._make_add_and_assert_tree(files)
251
190
        self.run_bzr("commit -m 'added files'")
252
191
        self.run_bzr('remove --keep a b b/c d',
253
192
                     error_regexes=["removed a", "removed b", "removed b/c",
255
194
        self.assertFilesUnversioned(files)
256
195
 
257
196
    def test_remove_with_new(self):
258
 
        tree = self._make_tree_and_add(files)
 
197
        tree = self._make_add_and_assert_tree(files)
259
198
        self.run_bzr('remove --new --keep',
260
199
                     error_regexes=["removed a", "removed b", "removed b/c"])
261
200
        self.assertFilesUnversioned(files)
262
201
 
263
202
    def test_remove_with_new_in_dir1(self):
264
 
        tree = self._make_tree_and_add(files)
 
203
        tree = self._make_add_and_assert_tree(files)
265
204
        self.run_bzr('remove --new --keep b b/c',
266
205
                     error_regexes=["removed b", "removed b/c"])
267
206
        tree = WorkingTree.open('.')
270
209
        self.assertFilesUnversioned([b,c])
271
210
 
272
211
    def test_remove_with_new_in_dir2(self):
273
 
        tree = self._make_tree_and_add(files)
 
212
        tree = self._make_add_and_assert_tree(files)
274
213
        self.run_bzr('remove --new --keep .',
275
214
                     error_regexes=["removed a", "removed b", "removed b/c"])
276
215
        tree = WorkingTree.open('.')