/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

  • Committer: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

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 breezy.tests import (
22
 
    script,
23
 
    features,
24
 
    TestCaseWithTransport,
25
 
    TestSkipped,
26
 
    TestNotApplicable,
27
 
    )
28
 
from breezy.workingtree import WorkingTree
29
 
from breezy import osutils
30
 
 
31
 
_id = b'-id'
32
 
a = 'a'
33
 
b = 'b/'
34
 
c = 'b/c'
35
 
d = 'd/'
36
 
files = (a, b, c, d)
37
 
 
38
 
 
39
 
class TestRemove(TestCaseWithTransport):
 
21
from bzrlib.tests import SymlinkFeature, TestSkipped
 
22
from bzrlib.tests.blackbox import ExternalBase
 
23
from bzrlib.workingtree import WorkingTree
 
24
from bzrlib import osutils
 
25
 
 
26
_id='-id'
 
27
a='a'
 
28
b='b/'
 
29
c='b/c'
 
30
d='d/'
 
31
files=(a, b, c, d)
 
32
 
 
33
 
 
34
class TestRemove(ExternalBase):
40
35
 
41
36
    def _make_tree_and_add(self, paths):
42
37
        tree = self.make_branch_and_tree('.')
43
 
        with tree.lock_write():
 
38
        tree.lock_write()
 
39
        try:
44
40
            self.build_tree(paths)
45
41
            for path in paths:
46
 
                file_id = path.replace('/', '_').encode('utf-8') + _id
 
42
                file_id=str(path).replace('/', '_') + _id
47
43
                tree.add(path, file_id)
 
44
        finally:
 
45
            tree.unlock()
48
46
        return tree
49
47
 
50
48
    def assertFilesDeleted(self, files):
51
49
        for f in files:
52
 
            id = f.encode('utf-8') + _id
 
50
            id=f+_id
53
51
            self.assertNotInWorkingTree(f)
54
 
            self.assertPathDoesNotExist(f)
 
52
            self.failIfExists(f)
55
53
 
56
54
    def assertFilesUnversioned(self, files):
57
55
        for f in files:
58
56
            self.assertNotInWorkingTree(f)
59
 
            self.assertPathExists(f)
 
57
            self.failUnlessExists(f)
60
58
 
61
59
    def changeFile(self, file_name):
62
 
        with open(file_name, 'ab') as f:
63
 
            f.write(b"\nsome other new content!")
 
60
        f = file(file_name, 'ab')
 
61
        f.write("\nsome other new content!")
 
62
        f.close()
64
63
 
65
 
    def run_bzr_remove_changed_files(self, files_to_remove, working_dir=None):
66
 
        self.run_bzr(['remove'] + list(files_to_remove),
 
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),
67
75
                     working_dir=working_dir)
68
76
 
69
77
    def test_remove_new_no_files_specified(self):
70
78
        tree = self.make_branch_and_tree('.')
71
 
        self.run_bzr_error(["brz: ERROR: No matching files."], 'remove --new')
72
 
        self.run_bzr_error(
73
 
            ["brz: ERROR: No matching files."], 'remove --new .')
 
79
        self.run_bzr_error(["bzr: ERROR: No matching files."], 'remove --new')
 
80
        self.run_bzr_error(["bzr: ERROR: No matching files."], 'remove --new .')
74
81
 
75
82
    def test_remove_no_files_specified(self):
76
83
        tree = self._make_tree_and_add(['foo'])
78
85
        self.assertEqual('', err)
79
86
        self.assertEqual('', out)
80
87
        self.assertInWorkingTree('foo', tree=tree)
81
 
        self.assertPathExists('foo')
 
88
        self.failUnlessExists('foo')
82
89
 
83
90
    def test_remove_no_files_specified_missing_dir_and_contents(self):
84
91
        tree = self._make_tree_and_add(
92
99
            err)
93
100
        # non-missing paths not touched:
94
101
        self.assertInWorkingTree('foo', tree=tree)
95
 
        self.assertPathExists('foo')
 
102
        self.failUnlessExists('foo')
96
103
        self.assertInWorkingTree('dir', tree=tree)
97
 
        self.assertPathExists('dir')
 
104
        self.failUnlessExists('dir')
98
105
        # missing files unversioned
99
106
        self.assertNotInWorkingTree('dir/missing', tree=tree)
100
107
        self.assertNotInWorkingTree('dir/missing/child', tree=tree)
104
111
        tree.commit('save foo and bar')
105
112
        os.unlink('bar')
106
113
        self.run_bzr(['rm'])
107
 
        self.assertFalse(tree.is_versioned('bar'))
 
114
        self.assertEqual(None, tree.path2id('bar'))
108
115
        # Running rm with a deleted file does not error.
109
116
        out, err = self.run_bzr(['rm'])
110
117
        self.assertEqual('', out)
118
125
        self.assertEqual('removed bar\n', err)
119
126
        # non-missing files not touched:
120
127
        self.assertInWorkingTree('foo', tree=tree)
121
 
        self.assertPathExists('foo')
 
128
        self.failUnlessExists('foo')
122
129
        # missing files unversioned
123
130
        self.assertNotInWorkingTree('bar', tree=tree)
124
131
 
125
132
    def test_remove_no_files_specified_missing_link(self):
126
 
        self.requireFeature(features.SymlinkFeature)
 
133
        self.requireFeature(SymlinkFeature)
127
134
        tree = self._make_tree_and_add(['foo'])
128
135
        os.symlink('foo', 'linkname')
129
136
        tree.add(['linkname'])
133
140
        self.assertEqual('removed linkname\n', err)
134
141
        # non-missing files not touched:
135
142
        self.assertInWorkingTree('foo', tree=tree)
136
 
        self.assertPathExists('foo')
 
143
        self.failUnlessExists('foo')
137
144
        # missing files unversioned
138
145
        self.assertNotInWorkingTree('linkname', tree=tree)
139
146
 
170
177
    def test_remove_unversioned_files(self):
171
178
        self.build_tree(files)
172
179
        tree = self.make_branch_and_tree('.')
173
 
        self.run_bzr_remove_changed_files(files)
 
180
        self.run_bzr_remove_changed_files(
 
181
            ['unknown:[.\s]*d/[.\s]*b/c[.\s]*b/[.\s]*a'], files)
174
182
 
175
183
    def test_remove_changed_files(self):
176
184
        tree = self._make_tree_and_add(files)
177
185
        self.run_bzr("commit -m 'added files'")
178
186
        self.changeFile(a)
179
187
        self.changeFile(c)
180
 
        self.run_bzr_remove_changed_files(files)
 
188
        self.run_bzr_remove_changed_files(['modified:[.\s]*a[.\s]*b/c'], files)
181
189
 
182
190
    def test_remove_changed_ignored_files(self):
183
191
        tree = self._make_tree_and_add(['a'])
184
192
        self.run_bzr(['ignore', 'a'])
185
 
        self.run_bzr_remove_changed_files(['a'])
 
193
        self.run_bzr_remove_changed_files(['added:[.\s]*a'], ['a'])
186
194
 
187
195
    def test_remove_changed_files_from_child_dir(self):
188
196
        if sys.platform == 'win32':
192
200
        self.changeFile(a)
193
201
        self.changeFile(c)
194
202
        self.run_bzr_remove_changed_files(
 
203
            ['modified:[.\s]*a[.\s]*b/c'],
195
204
            ['../a', 'c', '.', '../d'], working_dir='b')
196
205
        self.assertNotInWorkingTree(files)
197
 
        self.assertPathDoesNotExist(files)
 
206
        self.failIfExists(files)
198
207
 
199
208
    def test_remove_keep_unversioned_files(self):
200
209
        self.build_tree(files)
202
211
        self.run_bzr('remove --keep a', error_regexes=["a is not versioned."])
203
212
        self.assertFilesUnversioned(files)
204
213
 
205
 
    def test_remove_no_backup_unversioned_files(self):
 
214
    def test_remove_force_unversioned_files(self):
206
215
        self.build_tree(files)
207
216
        tree = self.make_branch_and_tree('.')
208
 
        script.ScriptRunner().run_script(self, '''
209
 
        $ brz remove --no-backup a b/ b/c d/
210
 
        2>deleted d
211
 
        2>removed b/c (but kept a copy: b/c.~1~)
212
 
        2>deleted b
213
 
        2>deleted a
214
 
        ''')
 
217
        self.run_bzr(['remove', '--force'] + list(files),
 
218
                     error_regexes=["deleted a", "deleted b",
 
219
                                    "deleted b/c", "deleted d"])
215
220
        self.assertFilesDeleted(files)
216
221
 
217
222
    def test_remove_deleted_files(self):
218
223
        tree = self._make_tree_and_add(files)
219
224
        self.run_bzr("commit -m 'added files'")
220
 
        my_files = [f for f in files]
 
225
        my_files=[f for f in files]
221
226
        my_files.sort(reverse=True)
222
227
        for f in my_files:
223
228
            osutils.delete_any(f)
224
229
        self.assertInWorkingTree(files)
225
 
        self.assertPathDoesNotExist(files)
 
230
        self.failIfExists(files)
226
231
        self.run_bzr('remove ' + ' '.join(files))
227
232
        self.assertNotInWorkingTree(a)
228
 
        self.assertPathDoesNotExist(files)
 
233
        self.failIfExists(files)
229
234
 
230
235
    def test_remove_non_existing_files(self):
231
236
        tree = self._make_tree_and_add([])
240
245
        self.run_bzr("commit -m 'added files'")
241
246
        self.run_bzr('remove a b b/c d',
242
247
                     error_regexes=["deleted a", "deleted b", "deleted b/c",
243
 
                                    "deleted d"])
 
248
                     "deleted d"])
244
249
        self.assertFilesDeleted(files)
245
250
 
246
251
    def test_remove_keep_files(self):
248
253
        self.run_bzr("commit -m 'added files'")
249
254
        self.run_bzr('remove --keep a b b/c d',
250
255
                     error_regexes=["removed a", "removed b", "removed b/c",
251
 
                                    "removed d"])
 
256
                     "removed d"])
252
257
        self.assertFilesUnversioned(files)
253
258
 
254
259
    def test_remove_with_new(self):
263
268
                     error_regexes=["removed b", "removed b/c"])
264
269
        tree = WorkingTree.open('.')
265
270
        self.assertInWorkingTree(a)
266
 
        self.assertEqual(tree.path2id(a), a.encode('utf-8') + _id)
267
 
        self.assertFilesUnversioned([b, c])
 
271
        self.assertEqual(tree.path2id(a), a + _id)
 
272
        self.assertFilesUnversioned([b,c])
268
273
 
269
274
    def test_remove_with_new_in_dir2(self):
270
275
        tree = self._make_tree_and_add(files)
272
277
                     error_regexes=["removed a", "removed b", "removed b/c"])
273
278
        tree = WorkingTree.open('.')
274
279
        self.assertFilesUnversioned(files)
275
 
 
276
 
    def test_remove_backslash(self):
277
 
        # pad.lv/176263
278
 
        if os.path.sep == '\\':
279
 
            raise TestNotApplicable(
280
 
                'unable to add filenames with backslashes where '
281
 
                ' it is the path separator')
282
 
        tree = self.make_branch_and_tree('.')
283
 
        self.build_tree(['\\'])
284
 
        self.assertEqual('adding \\\n', self.run_bzr('add \\\\')[0])
285
 
        self.assertEqual('\\\n', self.run_bzr('ls --versioned')[0])
286
 
        self.assertEqual('', self.run_bzr('rm \\\\')[0])
287
 
        self.assertEqual('', self.run_bzr('ls --versioned')[0])