← 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: Launchpad Translations on behalf of bzr-core
  • Date: 2013-03-29 04:30:34 UTC
  • mto: (6581.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6582.
  • Revision ID: launchpad_translations_on_behalf_of_bzr-core-20130329043034-xbst4001gnhtm0mi
Launchpad automatic translations update.

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
22
 
from bzrlib.tests import TestCaseWithTransport
 
21
from bzrlib.tests import (
 
22
    script,
 
23
    features,
 
24
    TestCaseWithTransport,
 
25
    TestSkipped,
 
26
    )
23
27
from bzrlib.workingtree import WorkingTree
24
28
from bzrlib import osutils
25
29
 
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
64
        f = file(file_name, 'ab')
61
65
        f.write("\nsome other new content!")
62
66
        f.close()
63
67
 
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)
 
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)
76
71
 
77
72
    def test_remove_new_no_files_specified(self):
78
73
        tree = self.make_branch_and_tree('.')
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)
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
        $ 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
        ''')
220
217
        self.assertFilesDeleted(files)
221
218
 
222
219
    def test_remove_deleted_files(self):
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([])