← 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

 * Two new commands 'bzr checkout' and 'bzr update' allow for CVS/SVN-alike
   behaviour. They use the existing serverless-mode and store no data
   locally. As such they are not suitable for use except in high bandwidth
   low latency environments like LAN's or local disk. (Robert Collins)

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.selftest import TestCaseInTempDir, TestCase
 
4
from bzrlib.add import smart_add, smart_add_tree
 
5
from bzrlib.tests import TestCaseWithTransport, TestCase
5
6
from bzrlib.branch import Branch
6
 
from bzrlib.errors import NotBranchError, NotVersionedError
 
7
from bzrlib.errors import NotBranchError, NoSuchFile
 
8
from bzrlib.inventory import InventoryFile, Inventory
 
9
from bzrlib.workingtree import WorkingTree
7
10
 
8
 
class TestSmartAdd(TestCaseInTempDir):
 
11
class TestSmartAdd(TestCaseWithTransport):
9
12
 
10
13
    def test_add_dot_from_root(self):
11
14
        """Test adding . from the root of the tree.""" 
12
15
        from bzrlib.add import smart_add
13
16
        paths = ("original/", "original/file1", "original/file2")
14
17
        self.build_tree(paths)
15
 
        branch = Branch(".", init=True)
16
 
        smart_add((".",), recurse=True)
 
18
        wt = self.make_branch_and_tree('.')
 
19
        branch = wt.branch
 
20
        smart_add_tree(wt, (u".",))
17
21
        for path in paths:
18
 
            self.assertNotEqual(branch.inventory.path2id(path), None)
 
22
            self.assertNotEqual(wt.path2id(path), None)
19
23
 
20
24
    def test_add_dot_from_subdir(self):
21
25
        """Test adding . from a subdir of the tree.""" 
22
26
        from bzrlib.add import smart_add
23
27
        paths = ("original/", "original/file1", "original/file2")
24
28
        self.build_tree(paths)
25
 
        branch = Branch(".", init=True)
 
29
        wt = self.make_branch_and_tree('.')
 
30
        branch = wt.branch
26
31
        os.chdir("original")
27
 
        smart_add((".",), recurse=True)
 
32
        smart_add_tree(wt, (u".",))
28
33
        for path in paths:
29
 
            self.assertNotEqual(branch.inventory.path2id(path), None)
 
34
            self.assertNotEqual(wt.path2id(path), None)
30
35
 
31
36
    def test_add_tree_from_above_tree(self):
32
37
        """Test adding a tree from above the tree.""" 
35
40
        branch_paths = ("branch/", "branch/original/", "branch/original/file1",
36
41
                        "branch/original/file2")
37
42
        self.build_tree(branch_paths)
38
 
        branch = Branch("branch", init=True)
39
 
        smart_add(("branch",))
 
43
        wt = self.make_branch_and_tree('branch')
 
44
        branch = wt.branch
 
45
        smart_add_tree(wt, ("branch",))
40
46
        for path in paths:
41
 
            self.assertNotEqual(branch.inventory.path2id(path), None)
 
47
            self.assertNotEqual(wt.path2id(path), None)
42
48
 
43
49
    def test_add_above_tree_preserves_tree(self):
44
50
        """Test nested trees are not affect by an add above them."""
45
 
        from bzrlib.add import smart_add, add_reporter_null
46
 
        
 
51
        from bzrlib.add import smart_add
47
52
        paths = ("original/", "original/file1", "original/file2")
48
53
        child_paths = ("path",)
49
54
        full_child_paths = ("original/child", "original/child/path")
51
56
                       "original/child/", "original/child/path")
52
57
        
53
58
        self.build_tree(build_paths)
54
 
        branch = Branch(".", init=True)
55
 
        child_branch = Branch("original/child", init=True)
56
 
        smart_add((".",), True, add_reporter_null)
 
59
        wt = self.make_branch_and_tree('.')
 
60
        branch = wt.branch
 
61
        child_tree = self.make_branch_and_tree('original/child')
 
62
        smart_add_tree(wt, (u".",))
57
63
        for path in paths:
58
 
            self.assertNotEqual((path, branch.inventory.path2id(path)),
 
64
            self.assertNotEqual((path, wt.path2id(path)),
59
65
                                (path, None))
60
66
        for path in full_child_paths:
61
 
            self.assertEqual((path, branch.inventory.path2id(path)),
 
67
            self.assertEqual((path, wt.path2id(path)),
62
68
                             (path, None))
63
69
        for path in child_paths:
64
 
            self.assertEqual(child_branch.inventory.path2id(path), None)
 
70
            self.assertEqual(child_tree.path2id(path), None)
65
71
 
66
72
    def test_add_paths(self):
67
73
        """Test smart-adding a list of paths."""
68
74
        from bzrlib.add import smart_add
69
75
        paths = ("file1", "file2")
70
76
        self.build_tree(paths)
71
 
        branch = Branch(".", init=True)
72
 
        smart_add(paths)
 
77
        wt = self.make_branch_and_tree('.')
 
78
        branch = wt.branch
 
79
        smart_add_tree(wt, paths)
73
80
        for path in paths:
74
 
            self.assertNotEqual(branch.inventory.path2id(path), None)
75
 
            
76
 
class TestSmartAddBranch(TestCaseInTempDir):
 
81
            self.assertNotEqual(wt.path2id(path), None)
 
82
 
 
83
    def test_add_dry_run(self):
 
84
        """Test a dry run add, make sure nothing is added."""
 
85
        from bzrlib.commands import run_bzr
 
86
        eq = self.assertEqual
 
87
        wt = self.make_branch_and_tree('.')
 
88
        branch = wt.branch
 
89
        self.build_tree(['inertiatic/', 'inertiatic/esp'])
 
90
        eq(list(wt.unknowns()), ['inertiatic'])
 
91
        self.capture('add --dry-run .')
 
92
        eq(list(wt.unknowns()), ['inertiatic'])
 
93
 
 
94
    def test_add_non_existant(self):
 
95
        """Test smart-adding a file that does not exist."""
 
96
        from bzrlib.add import smart_add
 
97
        wt = self.make_branch_and_tree('.')
 
98
        branch = wt.branch
 
99
        self.assertRaises(NoSuchFile, smart_add_tree, wt, 'non-existant-file')
 
100
 
 
101
    def test_returns(self):
 
102
        """Correctly returns added/ignored files"""
 
103
        from bzrlib.commands import run_bzr
 
104
        wt = self.make_branch_and_tree('.')
 
105
        branch = wt.branch
 
106
        self.build_tree(['inertiatic/', 'inertiatic/esp', 'inertiatic/CVS', 
 
107
                        'inertiatic/foo.pyc'])
 
108
        added, ignored = smart_add_tree(wt, u'.')
 
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):
77
116
    """Test smart adds with a specified branch."""
78
117
 
79
118
    def test_add_dot_from_root(self):
80
119
        """Test adding . from the root of the tree.""" 
81
 
        from bzrlib.add import smart_add_branch
82
120
        paths = ("original/", "original/file1", "original/file2")
83
121
        self.build_tree(paths)
84
 
        branch = Branch(".", init=True)
85
 
        smart_add_branch(branch, (".",))
 
122
        wt = self.make_branch_and_tree('.')
 
123
        branch = wt.branch
 
124
        smart_add_tree(wt, (u".",))
86
125
        for path in paths:
87
 
            self.assertNotEqual(branch.inventory.path2id(path), None)
 
126
            self.assertNotEqual(wt.path2id(path), None)
88
127
 
89
128
    def test_add_dot_from_subdir(self):
90
129
        """Test adding . from a subdir of the tree.""" 
91
 
        from bzrlib.add import smart_add_branch
 
130
        from bzrlib.add import smart_add_tree
92
131
        paths = ("original/", "original/file1", "original/file2")
93
132
        self.build_tree(paths)
94
 
        branch = Branch(".", init=True)
 
133
        wt = self.make_branch_and_tree('.')
 
134
        branch = wt.branch
95
135
        os.chdir("original")
96
 
        smart_add_branch(branch, (".",))
 
136
        smart_add_tree(wt, (u".",))
97
137
        for path in paths:
98
 
            self.assertNotEqual(branch.inventory.path2id(path), None)
 
138
            self.assertNotEqual(wt.path2id(path), None)
99
139
 
100
140
    def test_add_tree_from_above_tree(self):
101
141
        """Test adding a tree from above the tree.""" 
102
 
        from bzrlib.add import smart_add_branch
 
142
        from bzrlib.add import smart_add_tree
103
143
        paths = ("original/", "original/file1", "original/file2")
104
144
        branch_paths = ("branch/", "branch/original/", "branch/original/file1",
105
145
                        "branch/original/file2")
106
146
        self.build_tree(branch_paths)
107
 
        branch = Branch("branch", init=True)
108
 
        smart_add_branch(branch, ("branch",))
 
147
        tree = self.make_branch_and_tree('branch')
 
148
        branch = tree.branch
 
149
        smart_add_tree(tree, ("branch",))
109
150
        for path in paths:
110
 
            self.assertNotEqual(branch.inventory.path2id(path), None)
 
151
            self.assertNotEqual(tree.path2id(path), None)
111
152
 
112
153
    def test_add_above_tree_preserves_tree(self):
113
154
        """Test nested trees are not affect by an add above them."""
114
 
        from bzrlib.add import smart_add_branch
 
155
        from bzrlib.add import smart_add_tree
115
156
        paths = ("original/", "original/file1", "original/file2")
116
157
        child_paths = ("path")
117
158
        full_child_paths = ("original/child", "original/child/path")
118
159
        build_paths = ("original/", "original/file1", "original/file2", 
119
160
                       "original/child/", "original/child/path")
120
161
        self.build_tree(build_paths)
121
 
        branch = Branch(".", init=True)
122
 
        child_branch = Branch("original/child", init=True)
123
 
        smart_add_branch(branch, (".",))
 
162
        tree = self.make_branch_and_tree('.')
 
163
        branch = tree.branch
 
164
        child_tree = self.make_branch_and_tree("original/child")
 
165
        smart_add_tree(tree, (u".",))
124
166
        for path in paths:
125
 
            self.assertNotEqual((path, branch.inventory.path2id(path)),
 
167
            self.assertNotEqual((path, tree.path2id(path)),
126
168
                                (path, None))
127
169
        for path in full_child_paths:
128
 
            self.assertEqual((path, branch.inventory.path2id(path)),
 
170
            self.assertEqual((path, tree.path2id(path)),
129
171
                             (path, None))
130
172
        for path in child_paths:
131
 
            self.assertEqual(child_branch.inventory.path2id(path), None)
 
173
            self.assertEqual(child_tree.path2id(path), None)
132
174
 
133
175
    def test_add_paths(self):
134
176
        """Test smart-adding a list of paths."""
135
 
        from bzrlib.add import smart_add_branch
 
177
        from bzrlib.add import smart_add_tree
136
178
        paths = ("file1", "file2")
137
179
        self.build_tree(paths)
138
 
        branch = Branch(".", init=True)
139
 
        smart_add_branch(branch, paths)
 
180
        wt = self.make_branch_and_tree('.')
 
181
        branch = wt.branch
 
182
        smart_add_tree(wt, paths)
140
183
        for path in paths:
141
 
            self.assertNotEqual(branch.inventory.path2id(path), None)
142
 
 
143
 
class TestAddCallbacks(TestCaseInTempDir):
144
 
 
145
 
    def setUp(self):
146
 
        from bzrlib.inventory import InventoryEntry
147
 
        super(TestAddCallbacks, self).setUp()
148
 
        self.entry = InventoryEntry("id", "name", "file", None)
149
 
 
150
 
    def test_null_callback(self):
151
 
        from bzrlib.add import add_reporter_null
152
 
        add_reporter_null('path', 'file', self.entry)
153
 
 
154
 
    def test_print_callback(self):
155
 
        from bzrlib.add import add_reporter_print
 
184
            self.assertNotEqual(wt.path2id(path), None)
 
185
 
 
186
 
 
187
class TestAddActions(TestCase):
 
188
 
 
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):
156
207
        from StringIO import StringIO
 
208
        inv = Inventory()
157
209
        stdout = StringIO()
158
 
        self.apply_redirected(None, stdout, None, add_reporter_print,
159
 
                              'path', 'file', self.entry)
160
 
        self.assertEqual(stdout.getvalue(), "added path\n")
 
210
 
 
211
        self.apply_redirected(None, stdout, None, action, inv, 'path', 'file')
 
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)