34
31
class TestRemove(ExternalBase):
36
def _make_tree_and_add(self, paths):
33
def _make_add_and_assert_tree(self,files):
37
34
tree = self.make_branch_and_tree('.')
40
self.build_tree(paths)
42
file_id=str(path).replace('/', '_') + _id
43
tree.add(path, file_id)
35
self.build_tree(files)
39
self.assertEqual(tree.path2id(f), id)
40
self.failUnlessExists(f)
41
self.assertInWorkingTree(f)
48
def assertFilesDeleted(self, files):
44
def assertFilesDeleted(self,files):
51
47
self.assertNotInWorkingTree(f)
52
48
self.failIfExists(f)
54
def assertFilesUnversioned(self, files):
50
def assertFilesUnversioned(self,files):
56
52
self.assertNotInWorkingTree(f)
57
53
self.failUnlessExists(f)
59
def changeFile(self, file_name):
60
f = file(file_name, 'ab')
61
f.write("\nsome other new content!")
64
def run_bzr_remove_changed_files(self, error_regexes, files_to_remove,
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.'
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)
77
def test_remove_new_no_files_specified(self):
78
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 .')
82
55
def test_remove_no_files_specified(self):
83
tree = self._make_tree_and_add(['foo'])
84
out, err = self.run_bzr(['rm'])
85
self.assertEqual('', err)
86
self.assertEqual('', out)
87
self.assertInWorkingTree('foo', tree=tree)
88
self.failUnlessExists('foo')
90
def test_remove_no_files_specified_missing_dir_and_contents(self):
91
tree = self._make_tree_and_add(
92
['foo', 'dir/', 'dir/missing/', 'dir/missing/child'])
93
self.get_transport('.').delete_tree('dir/missing')
94
out, err = self.run_bzr(['rm'])
95
self.assertEqual('', out)
97
'removed dir/missing/child\n'
98
'removed dir/missing\n',
100
# non-missing paths not touched:
101
self.assertInWorkingTree('foo', tree=tree)
102
self.failUnlessExists('foo')
103
self.assertInWorkingTree('dir', tree=tree)
104
self.failUnlessExists('dir')
105
# missing files unversioned
106
self.assertNotInWorkingTree('dir/missing', tree=tree)
107
self.assertNotInWorkingTree('dir/missing/child', tree=tree)
109
def test_remove_no_files_specified_already_deleted(self):
110
tree = self._make_tree_and_add(['foo', 'bar'])
111
tree.commit('save foo and bar')
114
self.assertEqual(None, tree.path2id('bar'))
115
# Running rm with a deleted file does not error.
116
out, err = self.run_bzr(['rm'])
117
self.assertEqual('', out)
118
self.assertEqual('', err)
120
def test_remove_no_files_specified_missing_file(self):
121
tree = self._make_tree_and_add(['foo', 'bar'])
123
out, err = self.run_bzr(['rm'])
124
self.assertEqual('', out)
125
self.assertEqual('removed bar\n', err)
126
# non-missing files not touched:
127
self.assertInWorkingTree('foo', tree=tree)
128
self.failUnlessExists('foo')
129
# missing files unversioned
130
self.assertNotInWorkingTree('bar', tree=tree)
132
def test_remove_no_files_specified_missing_link(self):
133
self.requireFeature(SymlinkFeature)
134
tree = self._make_tree_and_add(['foo'])
135
os.symlink('foo', 'linkname')
136
tree.add(['linkname'])
137
os.unlink('linkname')
138
out, err = self.run_bzr(['rm'])
139
self.assertEqual('', out)
140
self.assertEqual('removed linkname\n', err)
141
# non-missing files not touched:
142
self.assertInWorkingTree('foo', tree=tree)
143
self.failUnlessExists('foo')
144
# missing files unversioned
145
self.assertNotInWorkingTree('linkname', tree=tree)
147
def test_rm_one_file(self):
148
tree = self._make_tree_and_add([a])
149
self.run_bzr("commit -m 'added a'")
150
self.run_bzr('rm a', error_regexes=["deleted a"])
151
self.assertFilesDeleted([a])
153
def test_remove_one_file(self):
154
tree = self._make_tree_and_add([a])
155
self.run_bzr("commit -m 'added a'")
156
self.run_bzr('remove a', error_regexes=["deleted a"])
157
self.assertFilesDeleted([a])
159
def test_remove_keep_one_file(self):
160
tree = self._make_tree_and_add([a])
161
self.run_bzr('remove --keep a', error_regexes=["removed a"])
162
self.assertFilesUnversioned([a])
164
def test_remove_one_deleted_file(self):
165
tree = self._make_tree_and_add([a])
166
self.run_bzr("commit -m 'added a'")
168
self.assertInWorkingTree(a)
169
self.run_bzr('remove a')
170
self.assertNotInWorkingTree(a)
56
tree = self._make_add_and_assert_tree([])
58
(out, err) = self.run_bzr_captured(['remove'], retcode=3)
59
self.assertEquals(err.strip(),
60
"bzr: ERROR: Specify one or more files to remove, or use --new.")
62
(out, err) = self.run_bzr_captured(['remove', '--new'], retcode=3)
63
self.assertEquals(err.strip(),"bzr: ERROR: No matching files.")
64
(out, err) = self.run_bzr_captured(['remove', '--new', '.'], retcode=3)
65
self.assertEquals(out.strip(), "")
66
self.assertEquals(err.strip(), "bzr: ERROR: No matching files.")
172
68
def test_remove_invalid_files(self):
173
self.build_tree(files)
174
70
tree = self.make_branch_and_tree('.')
175
self.run_bzr(['remove', '.', 'xyz', 'abc/def'])
72
(out, err) = self.run_bzr_captured(['remove', '.'])
73
self.assertEquals(out.strip(), "")
74
self.assertEquals(err.strip(), "")
177
76
def test_remove_unversioned_files(self):
178
self.build_tree(files)
179
78
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)
183
def test_remove_changed_files(self):
184
tree = self._make_tree_and_add(files)
185
self.run_bzr("commit -m 'added files'")
188
self.run_bzr_remove_changed_files(['modified:[.\s]*a[.\s]*b/c'], files)
190
def test_remove_changed_ignored_files(self):
191
tree = self._make_tree_and_add(['a'])
192
self.run_bzr(['ignore', 'a'])
193
self.run_bzr_remove_changed_files(['added:[.\s]*a'], ['a'])
195
def test_remove_changed_files_from_child_dir(self):
196
if sys.platform == 'win32':
197
raise TestSkipped("Windows unable to remove '.' directory")
198
tree = self._make_tree_and_add(files)
199
self.run_bzr("commit -m 'added files'")
202
self.run_bzr_remove_changed_files(
203
['modified:[.\s]*a[.\s]*b/c'],
204
['../a', 'c', '.', '../d'], working_dir='b')
205
self.assertNotInWorkingTree(files)
206
self.failIfExists(files)
80
(out, err) = self.run_bzr_captured(['remove', 'a'])
81
self.assertEquals(out.strip(), "")
82
self.assertEquals(err.strip(), "a is not versioned.")
208
84
def test_remove_keep_unversioned_files(self):
209
self.build_tree(files)
210
86
tree = self.make_branch_and_tree('.')
211
self.run_bzr('remove --keep a', error_regexes=["a is not versioned."])
212
self.assertFilesUnversioned(files)
88
(out, err) = self.run_bzr_captured(['remove', '--keep', 'a'])
89
self.assertEquals(out.strip(), "")
90
self.assertEquals(err.strip(), "a is not versioned.")
214
92
def test_remove_force_unversioned_files(self):
215
self.build_tree(files)
216
94
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"])
220
self.assertFilesDeleted(files)
222
def test_remove_deleted_files(self):
223
tree = self._make_tree_and_add(files)
224
self.run_bzr("commit -m 'added files'")
225
my_files=[f for f in files]
226
my_files.sort(reverse=True)
228
osutils.delete_any(f)
229
self.assertInWorkingTree(files)
230
self.failIfExists(files)
231
self.run_bzr('remove ' + ' '.join(files))
232
self.assertNotInWorkingTree(a)
233
self.failIfExists(files)
96
(out, err) = self.run_bzr_captured(['remove', '--force', 'a'])
97
self.assertEquals(out.strip(), "")
98
self.assertEquals(err.strip(), "deleted a")
99
self.assertFilesDeleted([a])
235
101
def test_remove_non_existing_files(self):
236
tree = self._make_tree_and_add([])
237
self.run_bzr(['remove', 'b'])
102
tree = self._make_add_and_assert_tree([])
103
(out, err) = self.run_bzr_captured(['remove', 'b'])
104
self.assertEquals(out.strip(), "")
105
self.assertEquals(err.strip(), "b does not exist.")
239
107
def test_remove_keep_non_existing_files(self):
240
tree = self._make_tree_and_add([])
241
self.run_bzr('remove --keep b', error_regexes=["b is not versioned."])
243
def test_remove_files(self):
244
tree = self._make_tree_and_add(files)
245
self.run_bzr("commit -m 'added files'")
246
self.run_bzr('remove a b b/c d',
247
error_regexes=["deleted a", "deleted b", "deleted b/c",
249
self.assertFilesDeleted(files)
251
def test_remove_keep_files(self):
252
tree = self._make_tree_and_add(files)
253
self.run_bzr("commit -m 'added files'")
254
self.run_bzr('remove --keep a b b/c d',
255
error_regexes=["removed a", "removed b", "removed b/c",
257
self.assertFilesUnversioned(files)
259
def test_remove_with_new(self):
260
tree = self._make_tree_and_add(files)
261
self.run_bzr('remove --new --keep',
262
error_regexes=["removed a", "removed b", "removed b/c"])
263
self.assertFilesUnversioned(files)
265
def test_remove_with_new_in_dir1(self):
266
tree = self._make_tree_and_add(files)
267
self.run_bzr('remove --new --keep b b/c',
268
error_regexes=["removed b", "removed b/c"])
108
tree = self._make_add_and_assert_tree([])
109
(out, err) = self.run_bzr_captured(['remove', '--keep', 'b'])
110
self.assertEquals(out.strip(), "")
111
self.assertEquals(err.strip(), "b is not versioned.")
113
def test_remove_one_file(self):
114
tree = self._make_add_and_assert_tree([a])
115
(out, err) = self.run_bzr_captured(['remove', 'a'])
116
self.assertEquals(out.strip(), "")
117
self.assertEquals(err.strip(), "a has changed and won't be deleted.")
118
self.assertFilesUnversioned([a])
120
def test_remove_keep_one_file(self):
121
tree = self._make_add_and_assert_tree([a])
122
(out, err) = self.run_bzr_captured(['remove', '--keep', 'a'])
123
self.assertEquals(out.strip(), "")
124
self.assertEquals(err.strip(), "removed a")
125
self.assertFilesUnversioned([a])
127
def test_command_on_deleted(self):
128
tree = self._make_add_and_assert_tree([a])
129
self.run_bzr_captured(['commit', '-m', 'added a'])
131
self.assertInWorkingTree(a)
132
self.run_bzr_captured(['remove', 'a'])
133
self.assertNotInWorkingTree(a)
135
def test_command_with_new(self):
136
tree = self._make_add_and_assert_tree(files)
138
self.run_bzr_captured(['remove', '--new'])
139
self.assertFilesUnversioned(files)
141
def test_command_with_new_in_dir1(self):
142
tree = self._make_add_and_assert_tree(files)
143
self.run_bzr_captured(['remove', '--new', b, c])
269
144
tree = WorkingTree.open('.')
270
145
self.assertInWorkingTree(a)
271
self.assertEqual(tree.path2id(a), a + _id)
146
self.assertEqual(tree.path2id(a), a+_id)
272
147
self.assertFilesUnversioned([b,c])
274
def test_remove_with_new_in_dir2(self):
275
tree = self._make_tree_and_add(files)
276
self.run_bzr('remove --new --keep .',
277
error_regexes=["removed a", "removed b", "removed b/c"])
149
def test_command_with_new_in_dir2(self):
150
tree = self._make_add_and_assert_tree(files)
151
self.run_bzr_captured(['remove', '--new', '.'])
278
152
tree = WorkingTree.open('.')
279
self.assertFilesUnversioned(files)
153
self.assertFilesUnversioned([a])
added
removed
bzrlib/tests/blackbox/test_remove.py
