← 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: Canonical.com Patch Queue Manager
  • Date: 2006-08-17 07:52:09 UTC
  • mfrom: (1910.3.4 trivial)
  • Revision ID: pqm@pqm.ubuntu.com-20060817075209-e85a1f9e05ff8b87
(andrew) Trivial fixes to NotImplemented errors.

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) 2005, 2006 by 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
16
16
 
17
17
 
18
18
import os
19
 
import sys
20
19
 
21
 
from bzrlib.tests import TestSkipped
22
20
from bzrlib.tests.blackbox import ExternalBase
23
21
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
22
 
33
23
 
34
24
class TestRemove(ExternalBase):
35
25
 
36
 
    def _make_add_and_assert_tree(self, files):
37
 
        tree = self.make_branch_and_tree('.')
38
 
        self.build_tree(files)
39
 
        for f in files:
40
 
            id=str(f).replace('/', '_') + _id
41
 
            tree.add(f, id)
42
 
            self.assertEqual(tree.path2id(f), id)
43
 
            self.failUnlessExists(f)
44
 
            self.assertInWorkingTree(f)
45
 
        return tree
46
 
 
47
 
    def assertFilesDeleted(self, files):
48
 
        for f in files:
49
 
            id=f+_id
50
 
            self.assertNotInWorkingTree(f)
51
 
            self.failIfExists(f)
52
 
 
53
 
    def assertFilesUnversioned(self, files):
54
 
        for f in files:
55
 
            self.assertNotInWorkingTree(f)
56
 
            self.failUnlessExists(f)
57
 
 
58
 
    def changeFile(self, file_name):
59
 
        f = file(file_name, 'ab')
60
 
        f.write("\nsome other new content!")
61
 
        f.close()
62
 
 
63
 
    def run_bzr_remove_changed_files(self, error_regexes, files_to_remove):
64
 
        error_regexes.extend(["Can't safely remove modified or unknown files:",
65
 
            'Use --keep to not delete them,'
66
 
            ' or --force to delete them regardless.'
67
 
            ])
68
 
        self.run_bzr_error(error_regexes,
69
 
            ['remove'] + list(files_to_remove))
70
 
        #see if we can force it now
71
 
        self.run_bzr(['remove', '--force'] + list(files_to_remove))
72
 
 
73
 
    def test_remove_no_files_specified(self):
74
 
        tree = self._make_add_and_assert_tree([])
75
 
        self.run_bzr_error(["bzr: ERROR: Specify one or more files to remove, "
76
 
            "or use --new."], 'remove')
77
 
 
78
 
        self.run_bzr_error(["bzr: ERROR: No matching files."], 'remove --new')
79
 
 
80
 
        self.run_bzr_error(["bzr: ERROR: No matching files."],
81
 
            'remove --new .')
82
 
 
83
 
    def test_rm_one_file(self):
84
 
        tree = self._make_add_and_assert_tree([a])
85
 
        self.run_bzr("commit -m 'added a'")
86
 
        self.run_bzr('rm a', error_regexes=["deleted a"])
87
 
        self.assertFilesDeleted([a])
88
 
 
89
 
    def test_remove_one_file(self):
90
 
        tree = self._make_add_and_assert_tree([a])
91
 
        self.run_bzr("commit -m 'added a'")
92
 
        self.run_bzr('remove a', error_regexes=["deleted a"])
93
 
        self.assertFilesDeleted([a])
94
 
 
95
 
    def test_remove_keep_one_file(self):
96
 
        tree = self._make_add_and_assert_tree([a])
97
 
        self.run_bzr('remove --keep a', error_regexes=["removed a"])
98
 
        self.assertFilesUnversioned([a])
99
 
 
100
 
    def test_remove_one_deleted_file(self):
101
 
        tree = self._make_add_and_assert_tree([a])
102
 
        self.run_bzr("commit -m 'added a'")
103
 
        os.unlink(a)
104
 
        self.assertInWorkingTree(a)
105
 
        self.run_bzr('remove a')
106
 
        self.assertNotInWorkingTree(a)
107
 
 
108
 
    def test_remove_invalid_files(self):
109
 
        self.build_tree(files)
110
 
        tree = self.make_branch_and_tree('.')
111
 
        self.run_bzr(['remove', '.', 'xyz', 'abc/def'])
112
 
 
113
 
    def test_remove_unversioned_files(self):
114
 
        self.build_tree(files)
115
 
        tree = self.make_branch_and_tree('.')
116
 
        self.run_bzr_remove_changed_files(
117
 
            ['unknown:[.\s]*d/[.\s]*b/c[.\s]*b/[.\s]*a'], files)
118
 
 
119
 
    def test_remove_changed_files(self):
120
 
        tree = self._make_add_and_assert_tree(files)
121
 
        self.run_bzr("commit -m 'added files'")
122
 
        self.changeFile(a)
123
 
        self.changeFile(c)
124
 
        self.run_bzr_remove_changed_files(['modified:[.\s]*a[.\s]*b/c'], files)
125
 
 
126
 
    def test_remove_changed_files_from_child_dir(self):
127
 
        if sys.platform == 'win32':
128
 
            raise TestSkipped("Windows unable to remove '.' directory")
129
 
        tree = self._make_add_and_assert_tree(files)
130
 
        self.run_bzr("commit -m 'added files'")
131
 
        self.changeFile(a)
132
 
        self.changeFile(c)
133
 
        os.chdir('b')
134
 
        self.run_bzr_remove_changed_files(['modified:[.\s]*a[.\s]*b/c'],
135
 
            ['../a', 'c', '.', '../d'])
136
 
        os.chdir('..')
137
 
        self.assertNotInWorkingTree(files)
138
 
        self.failIfExists(files)
139
 
 
140
 
    def test_remove_keep_unversioned_files(self):
141
 
        self.build_tree(files)
142
 
        tree = self.make_branch_and_tree('.')
143
 
        self.run_bzr('remove --keep a', error_regexes=["a is not versioned."])
144
 
        self.assertFilesUnversioned(files)
145
 
 
146
 
    def test_remove_force_unversioned_files(self):
147
 
        self.build_tree(files)
148
 
        tree = self.make_branch_and_tree('.')
149
 
        self.run_bzr(['remove', '--force'] + list(files),
150
 
                     error_regexes=["deleted a", "deleted b",
151
 
                                    "deleted b/c", "deleted d"])
152
 
        self.assertFilesDeleted(files)
153
 
 
154
 
    def test_remove_deleted_files(self):
155
 
        tree = self._make_add_and_assert_tree(files)
156
 
        self.run_bzr("commit -m 'added files'")
157
 
        my_files=[f for f in files]
158
 
        my_files.sort(reverse=True)
159
 
        for f in my_files:
160
 
            osutils.delete_any(f)
161
 
        self.assertInWorkingTree(files)
162
 
        self.failIfExists(files)
163
 
        self.run_bzr('remove ' + ' '.join(files))
164
 
        self.assertNotInWorkingTree(a)
165
 
        self.failIfExists(files)
166
 
 
167
 
    def test_remove_non_existing_files(self):
168
 
        tree = self._make_add_and_assert_tree([])
169
 
        self.run_bzr(['remove', 'b'])
170
 
 
171
 
    def test_remove_keep_non_existing_files(self):
172
 
        tree = self._make_add_and_assert_tree([])
173
 
        self.run_bzr('remove --keep b', error_regexes=["b is not versioned."])
174
 
 
175
 
    def test_remove_files(self):
176
 
        tree = self._make_add_and_assert_tree(files)
177
 
        self.run_bzr("commit -m 'added files'")
178
 
        self.run_bzr('remove a b b/c d',
179
 
                     error_regexes=["deleted a", "deleted b", "deleted b/c",
180
 
                     "deleted d"])
181
 
        self.assertFilesDeleted(files)
182
 
 
183
 
    def test_remove_keep_files(self):
184
 
        tree = self._make_add_and_assert_tree(files)
185
 
        self.run_bzr("commit -m 'added files'")
186
 
        self.run_bzr('remove --keep a b b/c d',
187
 
                     error_regexes=["removed a", "removed b", "removed b/c",
188
 
                     "removed d"])
189
 
        self.assertFilesUnversioned(files)
190
 
 
191
 
    def test_remove_with_new(self):
192
 
        tree = self._make_add_and_assert_tree(files)
193
 
        self.run_bzr('remove --new --keep',
194
 
                     error_regexes=["removed a", "removed b", "removed b/c"])
195
 
        self.assertFilesUnversioned(files)
196
 
 
197
 
    def test_remove_with_new_in_dir1(self):
198
 
        tree = self._make_add_and_assert_tree(files)
199
 
        self.run_bzr('remove --new --keep b b/c',
200
 
                     error_regexes=["removed b", "removed b/c"])
201
 
        tree = WorkingTree.open('.')
202
 
        self.assertInWorkingTree(a)
203
 
        self.assertEqual(tree.path2id(a), a + _id)
204
 
        self.assertFilesUnversioned([b,c])
205
 
 
206
 
    def test_remove_with_new_in_dir2(self):
207
 
        tree = self._make_add_and_assert_tree(files)
208
 
        self.run_bzr('remove --new --keep .',
209
 
                     error_regexes=["removed a", "removed b", "removed b/c"])
210
 
        tree = WorkingTree.open('.')
211
 
        self.assertFilesUnversioned(files)
 
26
    def test_remove_deleted(self):
 
27
        self.runbzr("init")
 
28
        self.build_tree(['a'])
 
29
        self.runbzr(['add', 'a'])
 
30
        self.runbzr(['commit', '-m', 'added a'])
 
31
        os.unlink('a')
 
32
        self.runbzr(['remove', 'a'])
 
33
 
 
34
    def test_remove_new(self):
 
35
        self.build_tree(['filefile',
 
36
                         'dir/',
 
37
                         'dir/filefilefile'])
 
38
        wt = self.make_branch_and_tree('.')
 
39
        wt.add(['filefile', 'dir', 'dir/filefilefile'], 
 
40
               ['filefile-id', 'dir-id', 'filefilefile-id'])
 
41
        self.assertEqual(wt.path2id('filefile'), 'filefile-id')
 
42
        self.assertEqual(wt.path2id('dir/filefilefile'), 'filefilefile-id')
 
43
        self.assertEqual(wt.path2id('dir'), 'dir-id')
 
44
        self.runbzr('remove --new')
 
45
        wt = WorkingTree.open('.')
 
46
        self.assertIs(wt.path2id('filefile'), None)
 
47
        self.assertIs(wt.path2id('dir/filefilefile'), None)
 
48
        self.assertIs(wt.path2id('dir'), None)
 
49
        wt.add(['filefile', 'dir', 'dir/filefilefile'], 
 
50
               ['filefile-id', 'dir-id', 'filefilefile-id'])
 
51
        self.assertEqual(wt.path2id('filefile'), 'filefile-id')
 
52
        self.assertEqual(wt.path2id('dir/filefilefile'), 'filefilefile-id')
 
53
        self.assertEqual(wt.path2id('dir'), 'dir-id')
 
54
        self.runbzr('remove --new dir')
 
55
        wt = WorkingTree.open('.')
 
56
        self.assertEqual(wt.path2id('filefile'), 'filefile-id')
 
57
        self.assertIs(wt.path2id('dir/filefilefile'), None)
 
58
        self.assertIs(wt.path2id('dir'), None)
 
59
        self.runbzr('remove --new .')
 
60
        wt = WorkingTree.open('.')
 
61
        self.assertIs(wt.path2id('filefile'), None)
 
62
        self.runbzr('remove --new .', retcode=3)