/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: 2007-09-19 05:14:14 UTC
  • mto: (2835.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2836.
  • Revision ID: robertc@robertcollins.net-20070919051414-2tgjqteg7k3ps4h0
* ``pull``, ``merge`` and ``push`` will no longer silently correct some
  repository index errors that occured as a result of the Weave disk format.
  Instead the ``reconcile`` command needs to be run to correct those
  problems if they exist (and it has been able to fix most such problems
  since bzr 0.8). Some new problems have been identified during this release
  and you should run ``bzr check`` once on every repository to see if you
  need to reconcile. If you cannot ``pull`` or ``merge`` from a remote
  repository due to mismatched parent errors - a symptom of index errors -
  you should simply take a full copy of that remote repository to a clean
  directory outside any local repositories, then run reconcile on it, and
  finally pull from it locally. (And naturally email the repositories owner
  to ask them to upgrade and run reconcile).
  (Robert Collins)

* ``VersionedFile.fix_parents`` has been removed as a harmful API.
  ``VersionedFile.join`` will no longer accept different parents on either
  side of a join - it will either ignore them, or error, depending on the
  implementation. See notes when upgrading for more information.
  (Robert Collins)

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
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
import os
 
19
 
 
20
from bzrlib.tests.blackbox import ExternalBase
 
21
from bzrlib.workingtree import WorkingTree
 
22
from bzrlib import osutils
 
23
 
 
24
_id='-id'
 
25
a='a'
 
26
b='b/'
 
27
c='b/c'
 
28
d='d/'
 
29
files=(a, b, c, d)
 
30
 
 
31
 
 
32
class TestRemove(ExternalBase):
 
33
 
 
34
    def _make_add_and_assert_tree(self, files):
 
35
        tree = self.make_branch_and_tree('.')
 
36
        self.build_tree(files)
 
37
        for f in files:
 
38
            id=str(f).replace('/', '_') + _id
 
39
            tree.add(f, id)
 
40
            self.assertEqual(tree.path2id(f), id)
 
41
            self.failUnlessExists(f)
 
42
            self.assertInWorkingTree(f)
 
43
        return tree
 
44
 
 
45
    def assertFilesDeleted(self, files):
 
46
        for f in files:
 
47
            id=f+_id
 
48
            self.assertNotInWorkingTree(f)
 
49
            self.failIfExists(f)
 
50
 
 
51
    def assertFilesUnversioned(self, files):
 
52
        for f in files:
 
53
            self.assertNotInWorkingTree(f)
 
54
            self.failUnlessExists(f)
 
55
 
 
56
    def changeFile(self, file_name):
 
57
        f = file(file_name, 'ab')
 
58
        f.write("\nsome other new content!")
 
59
        f.close()
 
60
 
 
61
    def run_bzr_remove_changed_files(self, error_regexes, files_to_remove):
 
62
        error_regexes.extend(["Can't safely remove modified or unknown files:",
 
63
            'Use --keep to not delete them,'
 
64
            ' or --force to delete them regardless.'
 
65
            ])
 
66
        self.run_bzr_error(error_regexes,
 
67
            ['remove'] + list(files_to_remove))
 
68
        #see if we can force it now
 
69
        self.run_bzr(['remove', '--force'] + list(files_to_remove))
 
70
 
 
71
    def test_remove_no_files_specified(self):
 
72
        tree = self._make_add_and_assert_tree([])
 
73
        self.run_bzr_error(["bzr: ERROR: Specify one or more files to remove, "
 
74
            "or use --new."], 'remove')
 
75
 
 
76
        self.run_bzr_error(["bzr: ERROR: No matching files."], 'remove --new')
 
77
 
 
78
        self.run_bzr_error(["bzr: ERROR: No matching files."],
 
79
            'remove --new .')
 
80
 
 
81
    def test_rm_one_file(self):
 
82
        tree = self._make_add_and_assert_tree([a])
 
83
        self.run_bzr("commit -m 'added a'")
 
84
        self.run_bzr('rm a', error_regexes=["deleted a"])
 
85
        self.assertFilesDeleted([a])
 
86
 
 
87
    def test_remove_one_file(self):
 
88
        tree = self._make_add_and_assert_tree([a])
 
89
        self.run_bzr("commit -m 'added a'")
 
90
        self.run_bzr('remove a', error_regexes=["deleted a"])
 
91
        self.assertFilesDeleted([a])
 
92
 
 
93
    def test_remove_keep_one_file(self):
 
94
        tree = self._make_add_and_assert_tree([a])
 
95
        self.run_bzr('remove --keep a', error_regexes=["removed a"])
 
96
        self.assertFilesUnversioned([a])
 
97
 
 
98
    def test_remove_one_deleted_file(self):
 
99
        tree = self._make_add_and_assert_tree([a])
 
100
        self.run_bzr("commit -m 'added a'")
 
101
        os.unlink(a)
 
102
        self.assertInWorkingTree(a)
 
103
        self.run_bzr('remove a')
 
104
        self.assertNotInWorkingTree(a)
 
105
 
 
106
    def test_remove_invalid_files(self):
 
107
        self.build_tree(files)
 
108
        tree = self.make_branch_and_tree('.')
 
109
        self.run_bzr(['remove', '.', 'xyz', 'abc/def'])
 
110
 
 
111
    def test_remove_unversioned_files(self):
 
112
        self.build_tree(files)
 
113
        tree = self.make_branch_and_tree('.')
 
114
        self.run_bzr_remove_changed_files(
 
115
            ['unknown:[.\s]*d/[.\s]*b/c[.\s]*b/[.\s]*a'], files)
 
116
 
 
117
    def test_remove_changed_files(self):
 
118
        tree = self._make_add_and_assert_tree(files)
 
119
        self.run_bzr("commit -m 'added files'")
 
120
        self.changeFile(a)
 
121
        self.changeFile(c)
 
122
        self.run_bzr_remove_changed_files(['modified:[.\s]*a[.\s]*b/c'], files)
 
123
 
 
124
    def test_remove_changed_files_from_child_dir(self):
 
125
        tree = self._make_add_and_assert_tree(files)
 
126
        self.run_bzr("commit -m 'added files'")
 
127
        self.changeFile(a)
 
128
        self.changeFile(c)
 
129
        os.chdir('b')
 
130
        self.run_bzr_remove_changed_files(['modified:[.\s]*a[.\s]*b/c'],
 
131
            ['../a', 'c', '.', '../d'])
 
132
        os.chdir('..')
 
133
        self.assertNotInWorkingTree(files)
 
134
        self.failIfExists(files)
 
135
 
 
136
    def test_remove_keep_unversioned_files(self):
 
137
        self.build_tree(files)
 
138
        tree = self.make_branch_and_tree('.')
 
139
        self.run_bzr('remove --keep a', error_regexes=["a is not versioned."])
 
140
        self.assertFilesUnversioned(files)
 
141
 
 
142
    def test_remove_force_unversioned_files(self):
 
143
        self.build_tree(files)
 
144
        tree = self.make_branch_and_tree('.')
 
145
        self.run_bzr(['remove', '--force'] + list(files),
 
146
                     error_regexes=["deleted a", "deleted b",
 
147
                                    "deleted b/c", "deleted d"])
 
148
        self.assertFilesDeleted(files)
 
149
 
 
150
    def test_remove_deleted_files(self):
 
151
        tree = self._make_add_and_assert_tree(files)
 
152
        self.run_bzr("commit -m 'added files'")
 
153
        my_files=[f for f in files]
 
154
        my_files.sort(reverse=True)
 
155
        for f in my_files:
 
156
            osutils.delete_any(f)
 
157
        self.assertInWorkingTree(files)
 
158
        self.failIfExists(files)
 
159
        self.run_bzr('remove ' + ' '.join(files))
 
160
        self.assertNotInWorkingTree(a)
 
161
        self.failIfExists(files)
 
162
 
 
163
    def test_remove_non_existing_files(self):
 
164
        tree = self._make_add_and_assert_tree([])
 
165
        self.run_bzr(['remove', 'b'])
 
166
 
 
167
    def test_remove_keep_non_existing_files(self):
 
168
        tree = self._make_add_and_assert_tree([])
 
169
        self.run_bzr('remove --keep b', error_regexes=["b is not versioned."])
 
170
 
 
171
    def test_remove_files(self):
 
172
        tree = self._make_add_and_assert_tree(files)
 
173
        self.run_bzr("commit -m 'added files'")
 
174
        self.run_bzr('remove a b b/c d',
 
175
                     error_regexes=["deleted a", "deleted b", "deleted b/c",
 
176
                     "deleted d"])
 
177
        self.assertFilesDeleted(files)
 
178
 
 
179
    def test_remove_keep_files(self):
 
180
        tree = self._make_add_and_assert_tree(files)
 
181
        self.run_bzr("commit -m 'added files'")
 
182
        self.run_bzr('remove --keep a b b/c d',
 
183
                     error_regexes=["removed a", "removed b", "removed b/c",
 
184
                     "removed d"])
 
185
        self.assertFilesUnversioned(files)
 
186
 
 
187
    def test_remove_with_new(self):
 
188
        tree = self._make_add_and_assert_tree(files)
 
189
        self.run_bzr('remove --new --keep',
 
190
                     error_regexes=["removed a", "removed b", "removed b/c"])
 
191
        self.assertFilesUnversioned(files)
 
192
 
 
193
    def test_remove_with_new_in_dir1(self):
 
194
        tree = self._make_add_and_assert_tree(files)
 
195
        self.run_bzr('remove --new --keep b b/c',
 
196
                     error_regexes=["removed b", "removed b/c"])
 
197
        tree = WorkingTree.open('.')
 
198
        self.assertInWorkingTree(a)
 
199
        self.assertEqual(tree.path2id(a), a + _id)
 
200
        self.assertFilesUnversioned([b,c])
 
201
 
 
202
    def test_remove_with_new_in_dir2(self):
 
203
        tree = self._make_add_and_assert_tree(files)
 
204
        self.run_bzr('remove --new --keep .',
 
205
                     error_regexes=["removed a", "removed b", "removed b/c"])
 
206
        tree = WorkingTree.open('.')
 
207
        self.assertFilesUnversioned(files)