← 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

 * The internal storage of history, and logical branch identity have now
   been split into Branch, and Repository. The common locking and file 
   management routines are now in bzrlib.lockablefiles. 
   (Aaron Bentley, Robert Collins, Martin Pool)

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