← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart_add.py

Late bind to PatienceSequenceMatcher to allow plugin to override.

Show diffs side-by-side

added added

removed removed

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