← 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

  • Committer: Andrew Bennetts
  • Date: 2009-07-27 08:02:52 UTC
  • mto: This revision was merged to the branch mainline in revision 4573.
  • Revision ID: andrew.bennetts@canonical.com-20090727080252-1r4s9oqwlkzgywx7
Fix trivial bug in _vfs_set_tags_bytes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_remove.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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 (
22
 
    script,
23
 
    features,
24
 
    TestCaseWithTransport,
25
 
    TestSkipped,
26
 
    )
 
21
from bzrlib.tests import SymlinkFeature, TestSkipped
 
22
from bzrlib.tests.blackbox import ExternalBase
27
23
from bzrlib.workingtree import WorkingTree
28
24
from bzrlib import osutils
29
25
 
35
31
files=(a, b, c, d)
36
32
 
37
33
 
38
 
class TestRemove(TestCaseWithTransport):
 
34
class TestRemove(ExternalBase):
39
35
 
40
36
    def _make_tree_and_add(self, paths):
41
37
        tree = self.make_branch_and_tree('.')
53
49
        for f in files:
54
50
            id=f+_id
55
51
            self.assertNotInWorkingTree(f)
56
 
            self.assertPathDoesNotExist(f)
 
52
            self.failIfExists(f)
57
53
 
58
54
    def assertFilesUnversioned(self, files):
59
55
        for f in files:
60
56
            self.assertNotInWorkingTree(f)
61
 
            self.assertPathExists(f)
 
57
            self.failUnlessExists(f)
62
58
 
63
59
    def changeFile(self, file_name):
64
60
        f = file(file_name, 'ab')
65
61
        f.write("\nsome other new content!")
66
62
        f.close()
67
63
 
68
 
    def run_bzr_remove_changed_files(self, files_to_remove, working_dir=None):
69
 
        self.run_bzr(['remove'] + list(files_to_remove),
70
 
           working_dir=working_dir)
 
64
    def run_bzr_remove_changed_files(self, error_regexes, files_to_remove):
 
65
        error_regexes.extend(["Can't safely remove modified or unknown files:",
 
66
            'Use --keep to not delete them,'
 
67
            ' or --force to delete them regardless.'
 
68
            ])
 
69
        self.run_bzr_error(error_regexes,
 
70
            ['remove'] + list(files_to_remove))
 
71
        #see if we can force it now
 
72
        self.run_bzr(['remove', '--force'] + list(files_to_remove))
71
73
 
72
74
    def test_remove_new_no_files_specified(self):
73
75
        tree = self.make_branch_and_tree('.')
80
82
        self.assertEqual('', err)
81
83
        self.assertEqual('', out)
82
84
        self.assertInWorkingTree('foo', tree=tree)
83
 
        self.assertPathExists('foo')
 
85
        self.failUnlessExists('foo')
84
86
 
85
87
    def test_remove_no_files_specified_missing_dir_and_contents(self):
86
88
        tree = self._make_tree_and_add(
94
96
            err)
95
97
        # non-missing paths not touched:
96
98
        self.assertInWorkingTree('foo', tree=tree)
97
 
        self.assertPathExists('foo')
 
99
        self.failUnlessExists('foo')
98
100
        self.assertInWorkingTree('dir', tree=tree)
99
 
        self.assertPathExists('dir')
 
101
        self.failUnlessExists('dir')
100
102
        # missing files unversioned
101
103
        self.assertNotInWorkingTree('dir/missing', tree=tree)
102
104
        self.assertNotInWorkingTree('dir/missing/child', tree=tree)
120
122
        self.assertEqual('removed bar\n', err)
121
123
        # non-missing files not touched:
122
124
        self.assertInWorkingTree('foo', tree=tree)
123
 
        self.assertPathExists('foo')
 
125
        self.failUnlessExists('foo')
124
126
        # missing files unversioned
125
127
        self.assertNotInWorkingTree('bar', tree=tree)
126
128
 
127
129
    def test_remove_no_files_specified_missing_link(self):
128
 
        self.requireFeature(features.SymlinkFeature)
 
130
        self.requireFeature(SymlinkFeature)
129
131
        tree = self._make_tree_and_add(['foo'])
130
132
        os.symlink('foo', 'linkname')
131
133
        tree.add(['linkname'])
135
137
        self.assertEqual('removed linkname\n', err)
136
138
        # non-missing files not touched:
137
139
        self.assertInWorkingTree('foo', tree=tree)
138
 
        self.assertPathExists('foo')
 
140
        self.failUnlessExists('foo')
139
141
        # missing files unversioned
140
142
        self.assertNotInWorkingTree('linkname', tree=tree)
141
143
 
172
174
    def test_remove_unversioned_files(self):
173
175
        self.build_tree(files)
174
176
        tree = self.make_branch_and_tree('.')
175
 
        self.run_bzr_remove_changed_files(files)
 
177
        self.run_bzr_remove_changed_files(
 
178
            ['unknown:[.\s]*d/[.\s]*b/c[.\s]*b/[.\s]*a'], files)
176
179
 
177
180
    def test_remove_changed_files(self):
178
181
        tree = self._make_tree_and_add(files)
179
182
        self.run_bzr("commit -m 'added files'")
180
183
        self.changeFile(a)
181
184
        self.changeFile(c)
182
 
        self.run_bzr_remove_changed_files(files)
 
185
        self.run_bzr_remove_changed_files(['modified:[.\s]*a[.\s]*b/c'], files)
183
186
 
184
187
    def test_remove_changed_ignored_files(self):
185
188
        tree = self._make_tree_and_add(['a'])
186
189
        self.run_bzr(['ignore', 'a'])
187
 
        self.run_bzr_remove_changed_files(['a'])
 
190
        self.run_bzr_remove_changed_files(['added:[.\s]*a'], ['a'])
188
191
 
189
192
    def test_remove_changed_files_from_child_dir(self):
190
193
        if sys.platform == 'win32':
193
196
        self.run_bzr("commit -m 'added files'")
194
197
        self.changeFile(a)
195
198
        self.changeFile(c)
196
 
        self.run_bzr_remove_changed_files(
197
 
            ['../a', 'c', '.', '../d'], working_dir='b')
 
199
        os.chdir('b')
 
200
        self.run_bzr_remove_changed_files(['modified:[.\s]*a[.\s]*b/c'],
 
201
            ['../a', 'c', '.', '../d'])
 
202
        os.chdir('..')
198
203
        self.assertNotInWorkingTree(files)
199
 
        self.assertPathDoesNotExist(files)
 
204
        self.failIfExists(files)
200
205
 
201
206
    def test_remove_keep_unversioned_files(self):
202
207
        self.build_tree(files)
204
209
        self.run_bzr('remove --keep a', error_regexes=["a is not versioned."])
205
210
        self.assertFilesUnversioned(files)
206
211
 
207
 
    def test_remove_no_backup_unversioned_files(self):
208
 
        self.build_tree(files)
209
 
        tree = self.make_branch_and_tree('.')
210
 
        script.ScriptRunner().run_script(self, '''
211
 
        $ bzr 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
 
        ''')
217
 
        self.assertFilesDeleted(files)
218
 
 
219
212
    def test_remove_force_unversioned_files(self):
220
213
        self.build_tree(files)
221
214
        tree = self.make_branch_and_tree('.')
222
 
        script.ScriptRunner().run_script(self, '''
223
 
        $ bzr remove --force a b/ b/c d/
224
 
        2>(The --force option is deprecated, rather use --no-backup in future.)
225
 
        2>deleted d
226
 
        2>removed b/c (but kept a copy: b/c.~1~)
227
 
        2>deleted b
228
 
        2>deleted a
229
 
        ''')
 
215
        self.run_bzr(['remove', '--force'] + list(files),
 
216
                     error_regexes=["deleted a", "deleted b",
 
217
                                    "deleted b/c", "deleted d"])
230
218
        self.assertFilesDeleted(files)
231
219
 
232
220
    def test_remove_deleted_files(self):
237
225
        for f in my_files:
238
226
            osutils.delete_any(f)
239
227
        self.assertInWorkingTree(files)
240
 
        self.assertPathDoesNotExist(files)
 
228
        self.failIfExists(files)
241
229
        self.run_bzr('remove ' + ' '.join(files))
242
230
        self.assertNotInWorkingTree(a)
243
 
        self.assertPathDoesNotExist(files)
 
231
        self.failIfExists(files)
244
232
 
245
233
    def test_remove_non_existing_files(self):
246
234
        tree = self._make_tree_and_add([])