← 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: Patch Queue Manager
  • Date: 2016-02-01 19:56:05 UTC
  • mfrom: (6615.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20160201195605-o7rl92wf6uyum3fk
(vila) Open trunk again as 2.8b1 (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/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
 
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
 
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
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([])