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

  • Committer: Jelmer Vernooij
  • Date: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_add.py
1
 
# Copyright (C) 2006, 2007, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2009-2012, 2016 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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
#
17
17
 
18
 
"""Tests of the 'bzr add' command."""
 
18
"""Tests of the 'brz add' command."""
19
19
 
20
20
import os
21
21
 
22
 
from bzrlib import (
 
22
from breezy import (
23
23
    osutils,
24
24
    tests,
25
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))
 
26
from breezy.tests import (
 
27
    features,
 
28
    script,
 
29
    )
 
30
from breezy.tests.scenarios import load_tests_apply_scenarios
 
31
 
 
32
 
 
33
load_tests = load_tests_apply_scenarios
 
34
 
 
35
 
 
36
class TestAdd(tests.TestCaseWithTransport):
 
37
 
32
38
    scenarios = [
33
39
        ('pre-views', {'branch_tree_format': 'pack-0.92'}),
34
 
        ('view-aware', {'branch_tree_format': 'development6-rich-root'}),
 
40
        ('view-aware', {'branch_tree_format': '2a'}),
35
41
        ]
36
 
    return tests.multiply_tests(to_adapt, scenarios, result)
37
 
 
38
 
 
39
 
class TestAdd(tests.TestCaseWithTransport):
40
42
 
41
43
    def make_branch_and_tree(self, dir):
42
44
        return super(TestAdd, self).make_branch_and_tree(
46
48
        """add command prints the names of added files."""
47
49
        tree = self.make_branch_and_tree('.')
48
50
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt', 'CVS'])
49
 
        self.build_tree_contents([('.bzrignore', 'CVS\n')])
 
51
        self.build_tree_contents([('.bzrignore', b'CVS\n')])
50
52
        out = self.run_bzr('add')[0]
51
53
        # the ordering is not defined at the moment
52
 
        results = sorted(out.rstrip('\n').split('\n'))
53
 
        self.assertEquals(['adding .bzrignore',
54
 
                           'adding dir',
55
 
                           'adding dir/sub.txt',
56
 
                           'adding top.txt'],
 
54
        results = sorted(out.rstrip(b'\n').split(b'\n'))
 
55
        self.assertEqual([b'adding .bzrignore',
 
56
                          b'adding dir',
 
57
                          b'adding dir/sub.txt',
 
58
                          b'adding top.txt'],
57
59
                          results)
58
60
        out = self.run_bzr('add -v')[0]
59
 
        results = sorted(out.rstrip('\n').split('\n'))
60
 
        self.assertEquals(['ignored CVS matching "CVS"'],
 
61
        results = sorted(out.rstrip(b'\n').split(b'\n'))
 
62
        self.assertEqual([b'ignored CVS matching "CVS"'],
61
63
                          results)
62
64
 
63
65
    def test_add_quiet_is(self):
66
68
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
67
69
        out = self.run_bzr('add -q')[0]
68
70
        # the ordering is not defined at the moment
69
 
        results = sorted(out.rstrip('\n').split('\n'))
70
 
        self.assertEquals([''], results)
 
71
        results = sorted(out.rstrip(b'\n').split(b'\n'))
 
72
        self.assertEqual([b''], results)
71
73
 
72
74
    def test_add_in_unversioned(self):
73
75
        """Try to add a file in an unversioned directory.
74
76
 
75
 
        "bzr add" should add the parent(s) as necessary.
 
77
        "brz add" should add the parent(s) as necessary.
76
78
        """
77
79
        tree = self.make_branch_and_tree('.')
78
80
        self.build_tree(['inertiatic/', 'inertiatic/esp'])
79
 
        self.assertEquals(self.run_bzr('unknowns')[0], 'inertiatic\n')
 
81
        self.assertEqual(self.run_bzr('unknowns')[0], b'inertiatic\n')
80
82
        self.run_bzr('add inertiatic/esp')
81
 
        self.assertEquals(self.run_bzr('unknowns')[0], '')
 
83
        self.assertEqual(self.run_bzr('unknowns')[0], b'')
82
84
 
83
85
        # Multiple unversioned parents
84
86
        self.build_tree(['veil/', 'veil/cerpin/', 'veil/cerpin/taxt'])
85
 
        self.assertEquals(self.run_bzr('unknowns')[0], 'veil\n')
 
87
        self.assertEqual(self.run_bzr('unknowns')[0], b'veil\n')
86
88
        self.run_bzr('add veil/cerpin/taxt')
87
 
        self.assertEquals(self.run_bzr('unknowns')[0], '')
 
89
        self.assertEqual(self.run_bzr('unknowns')[0], b'')
88
90
 
89
91
        # Check whacky paths work
90
92
        self.build_tree(['cicatriz/', 'cicatriz/esp'])
91
 
        self.assertEquals(self.run_bzr('unknowns')[0], 'cicatriz\n')
 
93
        self.assertEqual(self.run_bzr('unknowns')[0], b'cicatriz\n')
92
94
        self.run_bzr('add inertiatic/../cicatriz/esp')
93
 
        self.assertEquals(self.run_bzr('unknowns')[0], '')
 
95
        self.assertEqual(self.run_bzr('unknowns')[0], b'')
 
96
 
 
97
    def test_add_no_recurse(self):
 
98
        tree = self.make_branch_and_tree('.')
 
99
        self.build_tree(['inertiatic/', 'inertiatic/esp'])
 
100
        self.assertEqual(self.run_bzr('unknowns')[0], b'inertiatic\n')
 
101
        self.run_bzr('add -N inertiatic')
 
102
        self.assertEqual(self.run_bzr('unknowns')[0], b'inertiatic/esp\n')
94
103
 
95
104
    def test_add_in_versioned(self):
96
105
        """Try to add a file in a versioned directory.
97
106
 
98
 
        "bzr add" should do this happily.
 
107
        "brz add" should do this happily.
99
108
        """
100
109
        tree = self.make_branch_and_tree('.')
101
110
        self.build_tree(['inertiatic/', 'inertiatic/esp'])
102
 
        self.assertEquals(self.run_bzr('unknowns')[0], 'inertiatic\n')
 
111
        self.assertEqual(self.run_bzr('unknowns')[0], b'inertiatic\n')
103
112
        self.run_bzr('add --no-recurse inertiatic')
104
 
        self.assertEquals(self.run_bzr('unknowns')[0], 'inertiatic/esp\n')
 
113
        self.assertEqual(self.run_bzr('unknowns')[0], b'inertiatic/esp\n')
105
114
        self.run_bzr('add inertiatic/esp')
106
 
        self.assertEquals(self.run_bzr('unknowns')[0], '')
 
115
        self.assertEqual(self.run_bzr('unknowns')[0], b'')
107
116
 
108
117
    def test_subdir_add(self):
109
118
        """Add in subdirectory should add only things from there down"""
110
 
        from bzrlib.workingtree import WorkingTree
111
 
 
112
119
        eq = self.assertEqual
113
120
        ass = self.assertTrue
114
121
 
126
133
        # add with no arguments in a subdirectory gets only files below that
127
134
        # subdirectory
128
135
        self.run_bzr('add', working_dir='src')
129
 
        self.assertEquals('README\n',
 
136
        self.assertEqual(b'README\n',
130
137
                          self.run_bzr('unknowns', working_dir='src')[0])
131
138
        # reopen to see the new changes
132
 
        t = t.bzrdir.open_workingtree('src')
 
139
        t = t.controldir.open_workingtree('src')
133
140
        versioned = [path for path, entry in t.iter_entries_by_dir()]
134
 
        self.assertEquals(versioned, ['', 'src', 'src/foo.c'])
 
141
        self.assertEqual(versioned, ['', 'src', 'src/foo.c'])
135
142
 
136
143
        # add from the parent directory should pick up all file names
137
144
        self.run_bzr('add')
138
 
        self.assertEquals(self.run_bzr('unknowns')[0], '')
 
145
        self.assertEqual(self.run_bzr('unknowns')[0], b'')
139
146
        self.run_bzr('check')
140
147
 
141
148
    def test_add_missing(self):
142
 
        """bzr add foo where foo is missing should error."""
 
149
        """brz add foo where foo is missing should error."""
143
150
        self.make_branch_and_tree('.')
144
151
        self.run_bzr('add missing-file', retcode=3)
145
152
 
152
159
        new_tree = self.make_branch_and_tree('new')
153
160
        self.build_tree(['new/a', 'new/b/', 'new/b/c', 'd'])
154
161
 
155
 
        os.chdir('new')
156
 
        out, err = self.run_bzr('add --file-ids-from ../base')
157
 
        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',
 
162
        out, err = self.run_bzr('add --file-ids-from ../base',
 
163
                                working_dir='new')
 
164
        self.assertEqual(b'', err)
 
165
        self.assertEqualDiff(b'adding a w/ file id from a\n'
 
166
                             b'adding b w/ file id from b\n'
 
167
                             b'adding b/c w/ file id from b/c\n',
161
168
                             out)
162
 
        new_tree = new_tree.bzrdir.open_workingtree()
 
169
        new_tree = new_tree.controldir.open_workingtree()
163
170
        self.assertEqual(base_tree.path2id('a'), new_tree.path2id('a'))
164
171
        self.assertEqual(base_tree.path2id('b'), new_tree.path2id('b'))
165
172
        self.assertEqual(base_tree.path2id('b/c'), new_tree.path2id('b/c'))
173
180
        new_tree = self.make_branch_and_tree('new')
174
181
        self.build_tree(['new/c', 'new/d'])
175
182
 
176
 
        os.chdir('new')
177
 
        out, err = self.run_bzr('add --file-ids-from ../base/b')
178
 
        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',
 
183
        out, err = self.run_bzr('add --file-ids-from ../base/b',
 
184
                                working_dir='new')
 
185
        self.assertEqual(b'', err)
 
186
        self.assertEqualDiff(b'adding c w/ file id from b/c\n'
 
187
                             b'adding d w/ file id from b/d\n',
181
188
                             out)
182
189
 
183
 
        new_tree = new_tree.bzrdir.open_workingtree()
 
190
        new_tree = new_tree.controldir.open_workingtree('new')
184
191
        self.assertEqual(base_tree.path2id('b/c'), new_tree.path2id('c'))
185
192
        self.assertEqual(base_tree.path2id('b/d'), new_tree.path2id('d'))
186
193
 
196
203
        """The control dir and its content should be refused."""
197
204
        self.make_branch_and_tree('.')
198
205
        err = self.run_bzr('add .bzr', retcode=3)[1]
199
 
        self.assertContainsRe(err, r'ERROR:.*\.bzr.*control file')
 
206
        self.assertContainsRe(err, br'ERROR:.*\.bzr.*control file')
200
207
        err = self.run_bzr('add .bzr/README', retcode=3)[1]
201
 
        self.assertContainsRe(err, r'ERROR:.*\.bzr.*control file')
 
208
        self.assertContainsRe(err, br'ERROR:.*\.bzr.*control file')
202
209
        self.build_tree(['.bzr/crescent'])
203
210
        err = self.run_bzr('add .bzr/crescent', retcode=3)[1]
204
 
        self.assertContainsRe(err, r'ERROR:.*\.bzr.*control file')
 
211
        self.assertContainsRe(err, br'ERROR:.*\.bzr.*control file')
205
212
 
206
213
    def test_add_via_symlink(self):
207
 
        self.requireFeature(tests.SymlinkFeature)
 
214
        self.requireFeature(features.SymlinkFeature)
208
215
        self.make_branch_and_tree('source')
209
216
        self.build_tree(['source/top.txt'])
210
217
        os.symlink('source', 'link')
211
218
        out = self.run_bzr(['add', 'link/top.txt'])[0]
212
 
        self.assertEquals(out, 'adding top.txt\n')
 
219
        self.assertEqual(out, b'adding top.txt\n')
213
220
 
214
221
    def test_add_symlink_to_abspath(self):
215
 
        self.requireFeature(tests.SymlinkFeature)
 
222
        self.requireFeature(features.SymlinkFeature)
216
223
        self.make_branch_and_tree('tree')
217
224
        os.symlink(osutils.abspath('target'), 'tree/link')
218
225
        out = self.run_bzr(['add', 'tree/link'])[0]
219
 
        self.assertEquals(out, 'adding link\n')
 
226
        self.assertEqual(out, b'adding link\n')
 
227
 
 
228
    def test_add_not_child(self):
 
229
        # https://bugs.launchpad.net/bzr/+bug/98735
 
230
        sr = script.ScriptRunner()
 
231
        self.make_branch_and_tree('tree1')
 
232
        self.make_branch_and_tree('tree2')
 
233
        self.build_tree(['tree1/a', 'tree2/b'])
 
234
        sr.run_script(self, '''
 
235
        $ brz add tree1/a tree2/b
 
236
        2>brz: ERROR: Path "...tree2/b" is not a child of path "...tree1"
 
237
        ''')
 
238
 
 
239
    def test_add_multiple_files_in_unicode_cwd(self):
 
240
        """Adding multiple files in a non-ascii cwd, see lp:686611"""
 
241
        self.requireFeature(features.UnicodeFilenameFeature)
 
242
        self.make_branch_and_tree(u"\xA7")
 
243
        self.build_tree([u"\xA7/a", u"\xA7/b"])
 
244
        out, err = self.run_bzr(["add", "a", "b"], working_dir=u"\xA7")
 
245
        self.assertEqual(out, b"adding a\n" b"adding b\n")
 
246
        self.assertEqual(err, b"")
 
247
 
 
248
    def test_add_skip_large_files(self):
 
249
        """Test skipping files larger than add.maximum_file_size"""
 
250
        tree = self.make_branch_and_tree('.')
 
251
        self.build_tree(['small.txt', 'big.txt', 'big2.txt'])
 
252
        self.build_tree_contents([('small.txt', b'0\n')])
 
253
        self.build_tree_contents([('big.txt', b'01234567890123456789\n')])
 
254
        self.build_tree_contents([('big2.txt', b'01234567890123456789\n')])
 
255
        tree.branch.get_config_stack().set('add.maximum_file_size', 5)
 
256
        out = self.run_bzr('add')[0]
 
257
        results = sorted(out.rstrip(b'\n').split(b'\n'))
 
258
        self.assertEqual([b'adding small.txt'], results)
 
259
        # named items never skipped, even if over max
 
260
        out, err = self.run_bzr(["add", "big2.txt"])
 
261
        results = sorted(out.rstrip(b'\n').split(b'\n'))
 
262
        self.assertEqual([b'adding big2.txt'], results)
 
263
        self.assertEqual(b"", err)
 
264
        tree.branch.get_config_stack().set('add.maximum_file_size', 30)
 
265
        out = self.run_bzr('add')[0]
 
266
        results = sorted(out.rstrip(b'\n').split(b'\n'))
 
267
        self.assertEqual([b'adding big.txt'], results)