← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/test_smart_add.py

  • Committer: Martin Pool
  • Date: 2005-09-06 02:26:28 UTC
  • Revision ID: mbp@sourcefrog.net-20050906022628-66d65f0feb4a9e80
- implement version 5 xml storage, and tests

  This stores files identified by the version that introduced the 
  text, and the version that introduced the name.  Entry kinds are
  given by the xml tag not an explicit kind field.

Show diffs side-by-side

added added

removed removed

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