/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/test_smart_add.py

  • Committer: John Arbash Meinel
  • Date: 2006-07-18 18:57:54 UTC
  • mto: This revision was merged to the branch mainline in revision 1868.
  • Revision ID: john@arbash-meinel.com-20060718185754-4007745748e28db9
Commit timestamp restricted to 1ms precision.

The old code would restrict to 1s resolution if the timestamp was
supplied, while it preserved full resolution if the timestamp was
auto generated. Now both paths preserve only 1ms resolution.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart_add.py
 
1
import os
 
2
import unittest
 
3
 
 
4
from bzrlib import errors, osutils
 
5
from bzrlib.add import smart_add, smart_add_tree
 
6
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
7
from bzrlib.errors import NoSuchFile
 
8
from bzrlib.inventory import InventoryFile, Inventory
 
9
from bzrlib.workingtree import WorkingTree
 
10
 
 
11
 
 
12
class TestSmartAdd(TestCaseWithTransport):
 
13
 
 
14
    def test_add_dot_from_root(self):
 
15
        """Test adding . from the root of the tree.""" 
 
16
        from bzrlib.add import smart_add
 
17
        paths = ("original/", "original/file1", "original/file2")
 
18
        self.build_tree(paths)
 
19
        wt = self.make_branch_and_tree('.')
 
20
        smart_add_tree(wt, (u".",))
 
21
        for path in paths:
 
22
            self.assertNotEqual(wt.path2id(path), None)
 
23
 
 
24
    def test_add_dot_from_subdir(self):
 
25
        """Test adding . from a subdir of the tree.""" 
 
26
        from bzrlib.add import smart_add
 
27
        paths = ("original/", "original/file1", "original/file2")
 
28
        self.build_tree(paths)
 
29
        wt = self.make_branch_and_tree('.')
 
30
        os.chdir("original")
 
31
        smart_add_tree(wt, (u".",))
 
32
        for path in paths:
 
33
            self.assertNotEqual(wt.path2id(path), None)
 
34
 
 
35
    def test_add_tree_from_above_tree(self):
 
36
        """Test adding a tree from above the tree.""" 
 
37
        from bzrlib.add import smart_add
 
38
        paths = ("original/", "original/file1", "original/file2")
 
39
        branch_paths = ("branch/", "branch/original/", "branch/original/file1",
 
40
                        "branch/original/file2")
 
41
        self.build_tree(branch_paths)
 
42
        wt = self.make_branch_and_tree('branch')
 
43
        smart_add_tree(wt, ("branch",))
 
44
        for path in paths:
 
45
            self.assertNotEqual(wt.path2id(path), None)
 
46
 
 
47
    def test_add_above_tree_preserves_tree(self):
 
48
        """Test nested trees are not affect by an add above them."""
 
49
        from bzrlib.add import smart_add
 
50
        paths = ("original/", "original/file1", "original/file2")
 
51
        child_paths = ("path",)
 
52
        full_child_paths = ("original/child", "original/child/path")
 
53
        build_paths = ("original/", "original/file1", "original/file2", 
 
54
                       "original/child/", "original/child/path")
 
55
        
 
56
        self.build_tree(build_paths)
 
57
        wt = self.make_branch_and_tree('.')
 
58
        child_tree = self.make_branch_and_tree('original/child')
 
59
        smart_add_tree(wt, (".",))
 
60
        for path in paths:
 
61
            self.assertNotEqual((path, wt.path2id(path)),
 
62
                                (path, None))
 
63
        for path in full_child_paths:
 
64
            self.assertEqual((path, wt.path2id(path)),
 
65
                             (path, None))
 
66
        for path in child_paths:
 
67
            self.assertEqual(child_tree.path2id(path), None)
 
68
 
 
69
    def test_add_paths(self):
 
70
        """Test smart-adding a list of paths."""
 
71
        from bzrlib.add import smart_add
 
72
        paths = ("file1", "file2")
 
73
        self.build_tree(paths)
 
74
        wt = self.make_branch_and_tree('.')
 
75
        smart_add_tree(wt, paths)
 
76
        for path in paths:
 
77
            self.assertNotEqual(wt.path2id(path), None)
 
78
    
 
79
    def test_add_ignored_nested_paths(self):
 
80
        """Test smart-adding a list of paths which includes ignored ones."""
 
81
        wt = self.make_branch_and_tree('.')
 
82
        tree_shape = ("adir/", "adir/CVS/", "adir/CVS/afile", "adir/CVS/afile2")
 
83
        add_paths = ("adir/CVS", "adir/CVS/afile", "adir")
 
84
        expected_paths = ("adir", "adir/CVS", "adir/CVS/afile", "adir/CVS/afile2")
 
85
        self.build_tree(tree_shape)
 
86
        smart_add_tree(wt, add_paths)
 
87
        for path in expected_paths:
 
88
            self.assertNotEqual(wt.path2id(path), None, "No id added for %s" % path)
 
89
 
 
90
    def test_save_false(self):
 
91
        """Test smart-adding a path with save set to false."""
 
92
        wt = self.make_branch_and_tree('.')
 
93
        self.build_tree(['file'])
 
94
        smart_add_tree(wt, ['file'], save=False)
 
95
        self.assertNotEqual(wt.path2id('file'), None, "No id added for 'file'")
 
96
        wt.read_working_inventory()
 
97
        self.assertEqual(wt.path2id('file'), None)
 
98
 
 
99
    def test_add_dry_run(self):
 
100
        """Test a dry run add, make sure nothing is added."""
 
101
        from bzrlib.commands import run_bzr
 
102
        eq = self.assertEqual
 
103
        wt = self.make_branch_and_tree('.')
 
104
        self.build_tree(['inertiatic/', 'inertiatic/esp'])
 
105
        eq(list(wt.unknowns()), ['inertiatic'])
 
106
        self.capture('add --dry-run .')
 
107
        eq(list(wt.unknowns()), ['inertiatic'])
 
108
 
 
109
    def test_add_non_existant(self):
 
110
        """Test smart-adding a file that does not exist."""
 
111
        from bzrlib.add import smart_add
 
112
        wt = self.make_branch_and_tree('.')
 
113
        self.assertRaises(NoSuchFile, smart_add_tree, wt, 'non-existant-file')
 
114
 
 
115
    def test_returns_and_ignores(self):
 
116
        """Correctly returns added/ignored files"""
 
117
        from bzrlib.commands import run_bzr
 
118
        wt = self.make_branch_and_tree('.')
 
119
        # no files should be ignored by default, so we need to create
 
120
        # an ignore rule - we create one for the pyc files, which means
 
121
        # CVS should not be ignored.
 
122
        self.build_tree(['inertiatic/', 'inertiatic/esp', 'inertiatic/CVS', 
 
123
                        'inertiatic/foo.pyc'])
 
124
        self.build_tree_contents([('.bzrignore', '*.py[oc]\n')])
 
125
        added, ignored = smart_add_tree(wt, u'.')
 
126
        self.assertSubset(('inertiatic', 'inertiatic/esp', 'inertiatic/CVS'),
 
127
                          added)
 
128
        self.assertSubset(('*.py[oc]',), ignored)
 
129
        self.assertSubset(('inertiatic/foo.pyc',), ignored['*.py[oc]'])
 
130
 
 
131
 
 
132
class TestSmartAddTree(TestCaseWithTransport):
 
133
    """Test smart adds with a specified branch."""
 
134
 
 
135
    def test_add_dot_from_root(self):
 
136
        """Test adding . from the root of the tree.""" 
 
137
        paths = ("original/", "original/file1", "original/file2")
 
138
        self.build_tree(paths)
 
139
        wt = self.make_branch_and_tree('.')
 
140
        smart_add_tree(wt, (u".",))
 
141
        for path in paths:
 
142
            self.assertNotEqual(wt.path2id(path), None)
 
143
 
 
144
    def test_add_dot_from_subdir(self):
 
145
        """Test adding . from a subdir of the tree.""" 
 
146
        paths = ("original/", "original/file1", "original/file2")
 
147
        self.build_tree(paths)
 
148
        wt = self.make_branch_and_tree('.')
 
149
        os.chdir("original")
 
150
        smart_add_tree(wt, (u".",))
 
151
        for path in paths:
 
152
            self.assertNotEqual(wt.path2id(path), None)
 
153
 
 
154
    def test_add_tree_from_above_tree(self):
 
155
        """Test adding a tree from above the tree.""" 
 
156
        paths = ("original/", "original/file1", "original/file2")
 
157
        branch_paths = ("branch/", "branch/original/", "branch/original/file1",
 
158
                        "branch/original/file2")
 
159
        self.build_tree(branch_paths)
 
160
        tree = self.make_branch_and_tree('branch')
 
161
        smart_add_tree(tree, ("branch",))
 
162
        for path in paths:
 
163
            self.assertNotEqual(tree.path2id(path), None)
 
164
 
 
165
    def test_add_above_tree_preserves_tree(self):
 
166
        """Test nested trees are not affect by an add above them."""
 
167
        paths = ("original/", "original/file1", "original/file2")
 
168
        child_paths = ("path")
 
169
        full_child_paths = ("original/child", "original/child/path")
 
170
        build_paths = ("original/", "original/file1", "original/file2", 
 
171
                       "original/child/", "original/child/path")
 
172
        self.build_tree(build_paths)
 
173
        tree = self.make_branch_and_tree('.')
 
174
        child_tree = self.make_branch_and_tree("original/child")
 
175
        smart_add_tree(tree, (u".",))
 
176
        for path in paths:
 
177
            self.assertNotEqual((path, tree.path2id(path)),
 
178
                                (path, None))
 
179
        for path in full_child_paths:
 
180
            self.assertEqual((path, tree.path2id(path)),
 
181
                             (path, None))
 
182
        for path in child_paths:
 
183
            self.assertEqual(child_tree.path2id(path), None)
 
184
 
 
185
    def test_add_paths(self):
 
186
        """Test smart-adding a list of paths."""
 
187
        paths = ("file1", "file2")
 
188
        self.build_tree(paths)
 
189
        wt = self.make_branch_and_tree('.')
 
190
        smart_add_tree(wt, paths)
 
191
        for path in paths:
 
192
            self.assertNotEqual(wt.path2id(path), None)
 
193
 
 
194
    def test_add_multiple_dirs(self):
 
195
        """Test smart adding multiple directories at once."""
 
196
        added_paths = ['file1', 'file2',
 
197
                       'dir1/', 'dir1/file3',
 
198
                       'dir1/subdir2/', 'dir1/subdir2/file4',
 
199
                       'dir2/', 'dir2/file5',
 
200
                      ]
 
201
        not_added = ['file6', 'dir3/', 'dir3/file7', 'dir3/file8']
 
202
        self.build_tree(added_paths)
 
203
        self.build_tree(not_added)
 
204
 
 
205
        wt = self.make_branch_and_tree('.')
 
206
        smart_add_tree(wt, ['file1', 'file2', 'dir1', 'dir2'])
 
207
 
 
208
        for path in added_paths:
 
209
            self.assertNotEqual(None, wt.path2id(path.rstrip('/')),
 
210
                    'Failed to add path: %s' % (path,))
 
211
        for path in not_added:
 
212
            self.assertEqual(None, wt.path2id(path.rstrip('/')),
 
213
                    'Accidentally added path: %s' % (path,))
 
214
 
 
215
 
 
216
class TestAddNonNormalized(TestCaseWithTransport):
 
217
 
 
218
    def make(self):
 
219
        try:
 
220
            self.build_tree([u'a\u030a'])
 
221
        except UnicodeError:
 
222
            raise TestSkipped('Filesystem cannot create unicode filenames')
 
223
 
 
224
        self.wt = self.make_branch_and_tree('.')
 
225
 
 
226
    def test_accessible_explicit(self):
 
227
        self.make()
 
228
        orig = osutils.normalized_filename
 
229
        osutils.normalized_filename = osutils._accessible_normalized_filename
 
230
        try:
 
231
            smart_add_tree(self.wt, [u'a\u030a'])
 
232
            self.assertEqual([(u'\xe5', 'file')],
 
233
                    [(path, ie.kind) for path,ie in 
 
234
                        self.wt.inventory.iter_entries()])
 
235
        finally:
 
236
            osutils.normalized_filename = orig
 
237
 
 
238
    def test_accessible_implicit(self):
 
239
        self.make()
 
240
        orig = osutils.normalized_filename
 
241
        osutils.normalized_filename = osutils._accessible_normalized_filename
 
242
        try:
 
243
            smart_add_tree(self.wt, [])
 
244
            self.assertEqual([(u'\xe5', 'file')],
 
245
                    [(path, ie.kind) for path,ie in 
 
246
                        self.wt.inventory.iter_entries()])
 
247
        finally:
 
248
            osutils.normalized_filename = orig
 
249
 
 
250
    def test_inaccessible_explicit(self):
 
251
        self.make()
 
252
        orig = osutils.normalized_filename
 
253
        osutils.normalized_filename = osutils._inaccessible_normalized_filename
 
254
        try:
 
255
            self.assertRaises(errors.InvalidNormalization,
 
256
                    smart_add_tree, self.wt, [u'a\u030a'])
 
257
        finally:
 
258
            osutils.normalized_filename = orig
 
259
 
 
260
    def test_inaccessible_implicit(self):
 
261
        self.make()
 
262
        orig = osutils.normalized_filename
 
263
        osutils.normalized_filename = osutils._inaccessible_normalized_filename
 
264
        try:
 
265
            # TODO: jam 20060701 In the future, this should probably
 
266
            #       just ignore files that don't fit the normalization
 
267
            #       rules, rather than exploding
 
268
            self.assertRaises(errors.InvalidNormalization,
 
269
                    smart_add_tree, self.wt, [])
 
270
        finally:
 
271
            osutils.normalized_filename = orig
 
272
 
 
273
 
 
274
class TestAddActions(TestCase):
 
275
 
 
276
    def test_quiet(self):
 
277
        self.run_action("")
 
278
 
 
279
    def test__print(self):
 
280
        self.run_action("added path\n")
 
281
 
 
282
    def run_action(self, output):
 
283
        from bzrlib.add import AddAction, FastPath
 
284
        from cStringIO import StringIO
 
285
        inv = Inventory()
 
286
        stdout = StringIO()
 
287
        action = AddAction(to_file=stdout, should_print=bool(output))
 
288
 
 
289
        self.apply_redirected(None, stdout, None, action, inv, None, FastPath('path'), 'file')
 
290
        self.assertEqual(stdout.getvalue(), output)