/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/blackbox/test_add.py

  • Committer: John Arbash Meinel
  • Date: 2007-05-31 20:29:04 UTC
  • mto: This revision was merged to the branch mainline in revision 2499.
  • Revision ID: john@arbash-meinel.com-20070531202904-34h7ygudo7qq9ha1
Update the code so that symlinks aren't cached at incorrect times
and fix the tests so that they don't assume files and symlinks
get cached even when the timestamp doesn't declare them 'safe'.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_add.py
1
 
# Copyright (C) 2006, 2007, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
#
17
17
 
18
18
"""Tests of the 'bzr add' command."""
19
19
 
20
20
import os
21
21
 
22
 
from bzrlib import (
23
 
    osutils,
24
 
    tests,
25
 
    )
26
 
 
27
 
 
28
 
def load_tests(standard_tests, module, loader):
29
 
    """Parameterize tests for view-aware vs not."""
30
 
    to_adapt, result = tests.split_suite_by_condition(
31
 
        standard_tests, tests.condition_isinstance(TestAdd))
32
 
    scenarios = [
33
 
        ('pre-views', {'branch_tree_format': 'pack-0.92'}),
34
 
        ('view-aware', {'branch_tree_format': 'development6-rich-root'}),
35
 
        ]
36
 
    return tests.multiply_tests(to_adapt, scenarios, result)
37
 
 
38
 
 
39
 
class TestAdd(tests.TestCaseWithTransport):
40
 
 
41
 
    def make_branch_and_tree(self, dir):
42
 
        return super(TestAdd, self).make_branch_and_tree(
43
 
            dir, format=self.branch_tree_format)
44
 
 
 
22
from bzrlib.tests.blackbox import ExternalBase
 
23
 
 
24
 
 
25
class TestAdd(ExternalBase):
 
26
        
45
27
    def test_add_reports(self):
46
28
        """add command prints the names of added files."""
47
 
        tree = self.make_branch_and_tree('.')
 
29
        self.runbzr('init')
48
30
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt', 'CVS'])
49
31
        self.build_tree_contents([('.bzrignore', 'CVS\n')])
50
 
        out = self.run_bzr('add')[0]
 
32
        out = self.run_bzr_captured(['add'], retcode=0)[0]
51
33
        # the ordering is not defined at the moment
52
34
        results = sorted(out.rstrip('\n').split('\n'))
53
 
        self.assertEquals(['adding .bzrignore',
54
 
                           'adding dir',
55
 
                           'adding dir/sub.txt',
56
 
                           'adding top.txt'],
 
35
        self.assertEquals(['If you wish to add some of these files, please'\
 
36
                           ' add them by name.',
 
37
                           'added .bzrignore',
 
38
                           'added dir',
 
39
                           'added dir/sub.txt',
 
40
                           'added top.txt',
 
41
                           'ignored 1 file(s).'],
57
42
                          results)
58
 
        out = self.run_bzr('add -v')[0]
 
43
        out = self.run_bzr_captured(['add', '-v'], retcode=0)[0]
59
44
        results = sorted(out.rstrip('\n').split('\n'))
60
 
        self.assertEquals(['ignored CVS matching "CVS"'],
 
45
        self.assertEquals(['If you wish to add some of these files, please'\
 
46
                           ' add them by name.',
 
47
                           'ignored CVS matching "CVS"'],
61
48
                          results)
62
49
 
63
50
    def test_add_quiet_is(self):
64
51
        """add -q does not print the names of added files."""
65
 
        tree = self.make_branch_and_tree('.')
 
52
        self.runbzr('init')
66
53
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
67
 
        out = self.run_bzr('add -q')[0]
 
54
        out = self.run_bzr_captured(['add', '-q'], retcode=0)[0]
68
55
        # the ordering is not defined at the moment
69
56
        results = sorted(out.rstrip('\n').split('\n'))
70
57
        self.assertEquals([''], results)
74
61
 
75
62
        "bzr add" should add the parent(s) as necessary.
76
63
        """
77
 
        tree = self.make_branch_and_tree('.')
 
64
        self.runbzr('init')
78
65
        self.build_tree(['inertiatic/', 'inertiatic/esp'])
79
 
        self.assertEquals(self.run_bzr('unknowns')[0], 'inertiatic\n')
80
 
        self.run_bzr('add inertiatic/esp')
81
 
        self.assertEquals(self.run_bzr('unknowns')[0], '')
 
66
        self.assertEquals(self.capture('unknowns'), 'inertiatic\n')
 
67
        self.run_bzr('add', 'inertiatic/esp')
 
68
        self.assertEquals(self.capture('unknowns'), '')
82
69
 
83
70
        # Multiple unversioned parents
84
71
        self.build_tree(['veil/', 'veil/cerpin/', 'veil/cerpin/taxt'])
85
 
        self.assertEquals(self.run_bzr('unknowns')[0], 'veil\n')
86
 
        self.run_bzr('add veil/cerpin/taxt')
87
 
        self.assertEquals(self.run_bzr('unknowns')[0], '')
 
72
        self.assertEquals(self.capture('unknowns'), 'veil\n')
 
73
        self.run_bzr('add', 'veil/cerpin/taxt')
 
74
        self.assertEquals(self.capture('unknowns'), '')
88
75
 
89
76
        # Check whacky paths work
90
77
        self.build_tree(['cicatriz/', 'cicatriz/esp'])
91
 
        self.assertEquals(self.run_bzr('unknowns')[0], 'cicatriz\n')
92
 
        self.run_bzr('add inertiatic/../cicatriz/esp')
93
 
        self.assertEquals(self.run_bzr('unknowns')[0], '')
 
78
        self.assertEquals(self.capture('unknowns'), 'cicatriz\n')
 
79
        self.run_bzr('add', 'inertiatic/../cicatriz/esp')
 
80
        self.assertEquals(self.capture('unknowns'), '')
94
81
 
95
82
    def test_add_in_versioned(self):
96
83
        """Try to add a file in a versioned directory.
97
84
 
98
85
        "bzr add" should do this happily.
99
86
        """
100
 
        tree = self.make_branch_and_tree('.')
 
87
        self.runbzr('init')
101
88
        self.build_tree(['inertiatic/', 'inertiatic/esp'])
102
 
        self.assertEquals(self.run_bzr('unknowns')[0], 'inertiatic\n')
103
 
        self.run_bzr('add --no-recurse inertiatic')
104
 
        self.assertEquals(self.run_bzr('unknowns')[0], 'inertiatic/esp\n')
105
 
        self.run_bzr('add inertiatic/esp')
106
 
        self.assertEquals(self.run_bzr('unknowns')[0], '')
 
89
        self.assertEquals(self.capture('unknowns'), 'inertiatic\n')
 
90
        self.run_bzr('add', '--no-recurse', 'inertiatic')
 
91
        self.assertEquals(self.capture('unknowns'), 'inertiatic/esp\n')
 
92
        self.run_bzr('add', 'inertiatic/esp')
 
93
        self.assertEquals(self.capture('unknowns'), '')
107
94
 
108
95
    def test_subdir_add(self):
109
96
        """Add in subdirectory should add only things from there down"""
111
98
 
112
99
        eq = self.assertEqual
113
100
        ass = self.assertTrue
114
 
 
 
101
        chdir = os.chdir
 
102
        
115
103
        t = self.make_branch_and_tree('.')
116
104
        b = t.branch
117
105
        self.build_tree(['src/', 'README'])
118
 
 
 
106
        
119
107
        eq(sorted(t.unknowns()),
120
108
           ['README', 'src'])
121
 
 
122
 
        self.run_bzr('add src')
123
 
 
 
109
        
 
110
        self.run_bzr('add', 'src')
 
111
        
124
112
        self.build_tree(['src/foo.c'])
125
 
 
 
113
        
126
114
        # add with no arguments in a subdirectory gets only files below that
127
115
        # subdirectory
128
 
        self.run_bzr('add', working_dir='src')
129
 
        self.assertEquals('README\n',
130
 
                          self.run_bzr('unknowns', working_dir='src')[0])
 
116
        chdir('src')
 
117
        self.run_bzr('add')
 
118
        self.assertEquals(self.capture('unknowns'), 'README\n')
131
119
        # reopen to see the new changes
132
 
        t = t.bzrdir.open_workingtree('src')
 
120
        t = t.bzrdir.open_workingtree()
133
121
        versioned = [path for path, entry in t.iter_entries_by_dir()]
134
 
        self.assertEquals(versioned, ['', 'src', 'src/foo.c'])
135
 
 
 
122
        self.assertEquals(versioned,
 
123
            ['', 'src', 'src/foo.c'])
 
124
                
136
125
        # add from the parent directory should pick up all file names
 
126
        chdir('..')
137
127
        self.run_bzr('add')
138
 
        self.assertEquals(self.run_bzr('unknowns')[0], '')
 
128
        self.assertEquals(self.capture('unknowns'), '')
139
129
        self.run_bzr('check')
140
130
 
141
131
    def test_add_missing(self):
142
132
        """bzr add foo where foo is missing should error."""
143
133
        self.make_branch_and_tree('.')
144
 
        self.run_bzr('add missing-file', retcode=3)
 
134
        self.run_bzr('add', 'missing-file', retcode=3)
145
135
 
146
136
    def test_add_from(self):
147
137
        base_tree = self.make_branch_and_tree('base')
153
143
        self.build_tree(['new/a', 'new/b/', 'new/b/c', 'd'])
154
144
 
155
145
        os.chdir('new')
156
 
        out, err = self.run_bzr('add --file-ids-from ../base')
 
146
        out, err = self.run_bzr('add', '--file-ids-from', '../base')
157
147
        self.assertEqual('', err)
158
 
        self.assertEqualDiff('adding a w/ file id from a\n'
159
 
                             'adding b w/ file id from b\n'
160
 
                             'adding b/c w/ file id from b/c\n',
 
148
        self.assertEqualDiff('added a w/ file id from a\n'
 
149
                             'added b w/ file id from b\n'
 
150
                             'added b/c w/ file id from b/c\n',
161
151
                             out)
162
152
        new_tree = new_tree.bzrdir.open_workingtree()
163
153
        self.assertEqual(base_tree.path2id('a'), new_tree.path2id('a'))
174
164
        self.build_tree(['new/c', 'new/d'])
175
165
 
176
166
        os.chdir('new')
177
 
        out, err = self.run_bzr('add --file-ids-from ../base/b')
 
167
        out, err = self.run_bzr('add', '--file-ids-from', '../base/b')
178
168
        self.assertEqual('', err)
179
 
        self.assertEqualDiff('adding c w/ file id from b/c\n'
180
 
                             'adding d w/ file id from b/d\n',
 
169
        self.assertEqualDiff('added c w/ file id from b/c\n'
 
170
                             'added d w/ file id from b/d\n',
181
171
                             out)
182
172
 
183
173
        new_tree = new_tree.bzrdir.open_workingtree()
185
175
        self.assertEqual(base_tree.path2id('b/d'), new_tree.path2id('d'))
186
176
 
187
177
    def test_add_dry_run(self):
188
 
        """Test a dry run add, make sure nothing is added."""
189
 
        wt = self.make_branch_and_tree('.')
190
 
        self.build_tree(['inertiatic/', 'inertiatic/esp'])
191
 
        self.assertEqual(list(wt.unknowns()), ['inertiatic'])
192
 
        self.run_bzr('add --dry-run')
193
 
        self.assertEqual(list(wt.unknowns()), ['inertiatic'])
 
178
        # ensure that --dry-run actually don't add anything
 
179
        base_tree = self.make_branch_and_tree('.')
 
180
        self.build_tree(['spam'])
 
181
        out = self.run_bzr_captured(['add', '--dry-run'], retcode=0)[0]
 
182
        self.assertEquals('added spam\n', out)
 
183
        out = self.run_bzr_captured(['added'], retcode=0)[0]
 
184
        self.assertEquals('', out)
194
185
 
195
186
    def test_add_control_dir(self):
196
187
        """The control dir and its content should be refused."""
197
188
        self.make_branch_and_tree('.')
198
 
        err = self.run_bzr('add .bzr', retcode=3)[1]
 
189
        err = self.run_bzr('add', '.bzr', retcode=3)[1]
199
190
        self.assertContainsRe(err, r'ERROR:.*\.bzr.*control file')
200
 
        err = self.run_bzr('add .bzr/README', retcode=3)[1]
 
191
        err = self.run_bzr('add', '.bzr/README', retcode=3)[1]
201
192
        self.assertContainsRe(err, r'ERROR:.*\.bzr.*control file')
202
193
        self.build_tree(['.bzr/crescent'])
203
 
        err = self.run_bzr('add .bzr/crescent', retcode=3)[1]
 
194
        err = self.run_bzr('add', '.bzr/crescent', retcode=3)[1]
204
195
        self.assertContainsRe(err, r'ERROR:.*\.bzr.*control file')
205
 
 
206
 
    def test_add_via_symlink(self):
207
 
        self.requireFeature(tests.SymlinkFeature)
208
 
        self.make_branch_and_tree('source')
209
 
        self.build_tree(['source/top.txt'])
210
 
        os.symlink('source', 'link')
211
 
        out = self.run_bzr(['add', 'link/top.txt'])[0]
212
 
        self.assertEquals(out, 'adding top.txt\n')
213
 
 
214
 
    def test_add_symlink_to_abspath(self):
215
 
        self.requireFeature(tests.SymlinkFeature)
216
 
        self.make_branch_and_tree('tree')
217
 
        os.symlink(osutils.abspath('target'), 'tree/link')
218
 
        out = self.run_bzr(['add', 'tree/link'])[0]
219
 
        self.assertEquals(out, 'adding link\n')