/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: Michael Ellerman
  • Date: 2006-03-09 00:24:48 UTC
  • mto: (1610.1.8 bzr.mbp.integration)
  • mto: This revision was merged to the branch mainline in revision 1616.
  • Revision ID: michael@ellerman.id.au-20060309002448-70cce15e3d605130
Make the "ignore line" in the commit message editor the "right" width, so
that if you make your message that wide it won't wrap in bzr log output.
Just as a visual aid.

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.add import smart_add, smart_add_tree
 
5
from bzrlib.tests import TestCaseWithTransport, TestCase
 
6
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
 
10
 
 
11
class TestSmartAdd(TestCaseWithTransport):
 
12
 
 
13
    def test_add_dot_from_root(self):
 
14
        """Test adding . from the root of the tree.""" 
 
15
        from bzrlib.add import smart_add
 
16
        paths = ("original/", "original/file1", "original/file2")
 
17
        self.build_tree(paths)
 
18
        wt = self.make_branch_and_tree('.')
 
19
        branch = wt.branch
 
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
        branch = wt.branch
 
31
        os.chdir("original")
 
32
        smart_add_tree(wt, (u".",))
 
33
        for path in paths:
 
34
            self.assertNotEqual(wt.path2id(path), None)
 
35
 
 
36
    def test_add_tree_from_above_tree(self):
 
37
        """Test adding a tree from above the tree.""" 
 
38
        from bzrlib.add import smart_add
 
39
        paths = ("original/", "original/file1", "original/file2")
 
40
        branch_paths = ("branch/", "branch/original/", "branch/original/file1",
 
41
                        "branch/original/file2")
 
42
        self.build_tree(branch_paths)
 
43
        wt = self.make_branch_and_tree('branch')
 
44
        branch = wt.branch
 
45
        smart_add_tree(wt, ("branch",))
 
46
        for path in paths:
 
47
            self.assertNotEqual(wt.path2id(path), None)
 
48
 
 
49
    def test_add_above_tree_preserves_tree(self):
 
50
        """Test nested trees are not affect by an add above them."""
 
51
        from bzrlib.add import smart_add
 
52
        paths = ("original/", "original/file1", "original/file2")
 
53
        child_paths = ("path",)
 
54
        full_child_paths = ("original/child", "original/child/path")
 
55
        build_paths = ("original/", "original/file1", "original/file2", 
 
56
                       "original/child/", "original/child/path")
 
57
        
 
58
        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".",))
 
63
        for path in paths:
 
64
            self.assertNotEqual((path, wt.path2id(path)),
 
65
                                (path, None))
 
66
        for path in full_child_paths:
 
67
            self.assertEqual((path, wt.path2id(path)),
 
68
                             (path, None))
 
69
        for path in child_paths:
 
70
            self.assertEqual(child_tree.path2id(path), None)
 
71
 
 
72
    def test_add_paths(self):
 
73
        """Test smart-adding a list of paths."""
 
74
        from bzrlib.add import smart_add
 
75
        paths = ("file1", "file2")
 
76
        self.build_tree(paths)
 
77
        wt = self.make_branch_and_tree('.')
 
78
        branch = wt.branch
 
79
        smart_add_tree(wt, paths)
 
80
        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):
 
116
    """Test smart adds with a specified branch."""
 
117
 
 
118
    def test_add_dot_from_root(self):
 
119
        """Test adding . from the root of the tree.""" 
 
120
        paths = ("original/", "original/file1", "original/file2")
 
121
        self.build_tree(paths)
 
122
        wt = self.make_branch_and_tree('.')
 
123
        branch = wt.branch
 
124
        smart_add_tree(wt, (u".",))
 
125
        for path in paths:
 
126
            self.assertNotEqual(wt.path2id(path), None)
 
127
 
 
128
    def test_add_dot_from_subdir(self):
 
129
        """Test adding . from a subdir of the tree.""" 
 
130
        from bzrlib.add import smart_add_tree
 
131
        paths = ("original/", "original/file1", "original/file2")
 
132
        self.build_tree(paths)
 
133
        wt = self.make_branch_and_tree('.')
 
134
        branch = wt.branch
 
135
        os.chdir("original")
 
136
        smart_add_tree(wt, (u".",))
 
137
        for path in paths:
 
138
            self.assertNotEqual(wt.path2id(path), None)
 
139
 
 
140
    def test_add_tree_from_above_tree(self):
 
141
        """Test adding a tree from above the tree.""" 
 
142
        from bzrlib.add import smart_add_tree
 
143
        paths = ("original/", "original/file1", "original/file2")
 
144
        branch_paths = ("branch/", "branch/original/", "branch/original/file1",
 
145
                        "branch/original/file2")
 
146
        self.build_tree(branch_paths)
 
147
        tree = self.make_branch_and_tree('branch')
 
148
        branch = tree.branch
 
149
        smart_add_tree(tree, ("branch",))
 
150
        for path in paths:
 
151
            self.assertNotEqual(tree.path2id(path), None)
 
152
 
 
153
    def test_add_above_tree_preserves_tree(self):
 
154
        """Test nested trees are not affect by an add above them."""
 
155
        from bzrlib.add import smart_add_tree
 
156
        paths = ("original/", "original/file1", "original/file2")
 
157
        child_paths = ("path")
 
158
        full_child_paths = ("original/child", "original/child/path")
 
159
        build_paths = ("original/", "original/file1", "original/file2", 
 
160
                       "original/child/", "original/child/path")
 
161
        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".",))
 
166
        for path in paths:
 
167
            self.assertNotEqual((path, tree.path2id(path)),
 
168
                                (path, None))
 
169
        for path in full_child_paths:
 
170
            self.assertEqual((path, tree.path2id(path)),
 
171
                             (path, None))
 
172
        for path in child_paths:
 
173
            self.assertEqual(child_tree.path2id(path), None)
 
174
 
 
175
    def test_add_paths(self):
 
176
        """Test smart-adding a list of paths."""
 
177
        from bzrlib.add import smart_add_tree
 
178
        paths = ("file1", "file2")
 
179
        self.build_tree(paths)
 
180
        wt = self.make_branch_and_tree('.')
 
181
        branch = wt.branch
 
182
        smart_add_tree(wt, paths)
 
183
        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):
 
207
        from StringIO import StringIO
 
208
        inv = Inventory()
 
209
        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)