/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_script.py

  • Committer: John Arbash Meinel
  • Date: 2009-12-22 16:28:47 UTC
  • mto: This revision was merged to the branch mainline in revision 4922.
  • Revision ID: john@arbash-meinel.com-20091222162847-tvnsc69to4l4uf5r
Implement a permute_for_extension helper.

Use it for all of the 'simple' extension permutations.
It basically permutes all tests in the current module, by setting TestCase.module.
Which works well for most of our extension tests. Some had more advanced
handling of permutations (extra permutations, custom vars, etc.)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_script.py
 
1
# Copyright (C) 2009 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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
 
16
 
 
17
 
 
18
from bzrlib import (
 
19
    osutils,
 
20
    tests,
 
21
    )
 
22
from bzrlib.tests import script
 
23
 
 
24
 
 
25
class TestSyntax(tests.TestCase):
 
26
 
 
27
    def test_comment_is_ignored(self):
 
28
        self.assertEquals([], script._script_to_commands('#comment\n'))
 
29
 
 
30
    def test_empty_line_is_ignored(self):
 
31
        self.assertEquals([], script._script_to_commands('\n'))
 
32
 
 
33
    def test_simple_command(self):
 
34
        self.assertEquals([(['cd', 'trunk'], None, None, None)],
 
35
                           script._script_to_commands('$ cd trunk'))
 
36
 
 
37
    def test_command_with_single_quoted_param(self):
 
38
        story = """$ bzr commit -m 'two words'"""
 
39
        self.assertEquals([(['bzr', 'commit', '-m', "'two words'"],
 
40
                            None, None, None)],
 
41
                           script._script_to_commands(story))
 
42
 
 
43
    def test_command_with_double_quoted_param(self):
 
44
        story = """$ bzr commit -m "two words" """
 
45
        self.assertEquals([(['bzr', 'commit', '-m', '"two words"'],
 
46
                            None, None, None)],
 
47
                           script._script_to_commands(story))
 
48
 
 
49
    def test_command_with_input(self):
 
50
        self.assertEquals(
 
51
            [(['cat', '>file'], 'content\n', None, None)],
 
52
            script._script_to_commands('$ cat >file\n<content\n'))
 
53
 
 
54
    def test_command_with_output(self):
 
55
        story = """
 
56
$ bzr add
 
57
adding file
 
58
adding file2
 
59
"""
 
60
        self.assertEquals([(['bzr', 'add'], None,
 
61
                            'adding file\nadding file2\n', None)],
 
62
                          script._script_to_commands(story))
 
63
 
 
64
    def test_command_with_error(self):
 
65
        story = """
 
66
$ bzr branch foo
 
67
2>bzr: ERROR: Not a branch: "foo"
 
68
"""
 
69
        self.assertEquals([(['bzr', 'branch', 'foo'],
 
70
                            None, None, 'bzr: ERROR: Not a branch: "foo"\n')],
 
71
                          script._script_to_commands(story))
 
72
 
 
73
    def test_input_without_command(self):
 
74
        self.assertRaises(SyntaxError, script._script_to_commands, '<input')
 
75
 
 
76
    def test_output_without_command(self):
 
77
        self.assertRaises(SyntaxError, script._script_to_commands, '>input')
 
78
 
 
79
    def test_command_with_backquotes(self):
 
80
        story = """
 
81
$ foo = `bzr file-id toto`
 
82
"""
 
83
        self.assertEquals([(['foo', '=', '`bzr file-id toto`'],
 
84
                            None, None, None)],
 
85
                          script._script_to_commands(story))
 
86
 
 
87
 
 
88
class TestRedirections(tests.TestCase):
 
89
 
 
90
    def _check(self, in_name, out_name, out_mode, remaining, args):
 
91
        self.assertEqual(script._scan_redirection_options(args),
 
92
                         (in_name, out_name, out_mode, remaining))
 
93
 
 
94
    def test_no_redirection(self):
 
95
        self._check(None, None, None, [], [])
 
96
        self._check(None, None, None, ['foo', 'bar'], ['foo', 'bar'])
 
97
 
 
98
    def test_input_redirection(self):
 
99
        self._check('foo', None, None, [], ['<foo'])
 
100
        self._check('foo', None, None, ['bar'], ['bar', '<foo'])
 
101
        self._check('foo', None, None, ['bar'], ['bar', '<', 'foo'])
 
102
        self._check('foo', None, None, ['bar'], ['<foo', 'bar'])
 
103
        self._check('foo', None, None, ['bar', 'baz'], ['bar', '<foo', 'baz'])
 
104
 
 
105
    def test_output_redirection(self):
 
106
        self._check(None, 'foo', 'wb+', [], ['>foo'])
 
107
        self._check(None, 'foo', 'wb+', ['bar'], ['bar', '>foo'])
 
108
        self._check(None, 'foo', 'wb+', ['bar'], ['bar', '>', 'foo'])
 
109
        self._check(None, 'foo', 'ab+', [], ['>>foo'])
 
110
        self._check(None, 'foo', 'ab+', ['bar'], ['bar', '>>foo'])
 
111
        self._check(None, 'foo', 'ab+', ['bar'], ['bar', '>>', 'foo'])
 
112
 
 
113
    def test_redirection_syntax_errors(self):
 
114
        self._check('', None, None, [], ['<'])
 
115
        self._check(None, '', 'wb+', [], ['>'])
 
116
        self._check(None, '', 'ab+', [], ['>>'])
 
117
        self._check('>', '', 'ab+', [], ['<', '>', '>>'])
 
118
 
 
119
 
 
120
 
 
121
class TestExecution(script.TestCaseWithTransportAndScript):
 
122
 
 
123
    def test_unknown_command(self):
 
124
        self.assertRaises(SyntaxError, self.run_script, 'foo')
 
125
 
 
126
    def test_stops_on_unexpected_output(self):
 
127
        story = """
 
128
$ mkdir dir
 
129
$ cd dir
 
130
The cd command ouputs nothing
 
131
"""
 
132
        self.assertRaises(AssertionError, self.run_script, story)
 
133
 
 
134
 
 
135
    def test_stops_on_unexpected_error(self):
 
136
        story = """
 
137
$ cat
 
138
<Hello
 
139
$ bzr not-a-command
 
140
"""
 
141
        self.assertRaises(AssertionError, self.run_script, story)
 
142
 
 
143
    def test_continue_on_expected_error(self):
 
144
        story = """
 
145
$ bzr not-a-command
 
146
2>..."not-a-command"
 
147
"""
 
148
        self.run_script(story)
 
149
 
 
150
    def test_continue_on_error_output(self):
 
151
        # The status matters, not the output
 
152
        story = """
 
153
$ bzr init
 
154
$ cat >file
 
155
<Hello
 
156
$ bzr add file
 
157
$ bzr commit -m 'adding file'
 
158
"""
 
159
        self.run_script(story)
 
160
 
 
161
    def test_ellipsis_output(self):
 
162
        story = """
 
163
$ cat
 
164
<first line
 
165
<second line
 
166
<last line
 
167
first line
 
168
...
 
169
last line
 
170
"""
 
171
        self.run_script(story)
 
172
        story = """
 
173
$ bzr not-a-command
 
174
2>..."not-a-command"
 
175
"""
 
176
        self.run_script(story)
 
177
 
 
178
        story = """
 
179
$ bzr branch not-a-branch
 
180
2>bzr: ERROR: Not a branch...not-a-branch/".
 
181
"""
 
182
        self.run_script(story)
 
183
 
 
184
 
 
185
class TestArgumentProcessing(script.TestCaseWithTransportAndScript):
 
186
 
 
187
    def test_globing(self):
 
188
        self.run_script("""
 
189
$ echo cat >cat
 
190
$ echo dog >dog
 
191
$ cat *
 
192
cat
 
193
dog
 
194
""")
 
195
 
 
196
    def test_quoted_globbing(self):
 
197
        self.run_script("""
 
198
$ echo cat >cat
 
199
$ cat '*'
 
200
2>*: No such file or directory
 
201
""")
 
202
 
 
203
    def test_quotes_removal(self):
 
204
        self.run_script("""
 
205
$ echo 'cat' "dog" '"chicken"' "'dragon'"
 
206
cat dog "chicken" 'dragon'
 
207
""")
 
208
 
 
209
 
 
210
class TestCat(script.TestCaseWithTransportAndScript):
 
211
 
 
212
    def test_cat_usage(self):
 
213
        self.assertRaises(SyntaxError, self.run_script, 'cat foo <bar')
 
214
 
 
215
    def test_cat_input_to_output(self):
 
216
        retcode, out, err = self.run_command(['cat'],
 
217
                                             'content\n', 'content\n', None)
 
218
        self.assertEquals('content\n', out)
 
219
        self.assertEquals(None, err)
 
220
 
 
221
    def test_cat_file_to_output(self):
 
222
        self.build_tree_contents([('file', 'content\n')])
 
223
        retcode, out, err = self.run_command(['cat', 'file'],
 
224
                                             None, 'content\n', None)
 
225
        self.assertEquals('content\n', out)
 
226
        self.assertEquals(None, err)
 
227
 
 
228
    def test_cat_input_to_file(self):
 
229
        retcode, out, err = self.run_command(['cat', '>file'],
 
230
                                             'content\n', None, None)
 
231
        self.assertFileEqual('content\n', 'file')
 
232
        self.assertEquals(None, out)
 
233
        self.assertEquals(None, err)
 
234
        retcode, out, err = self.run_command(['cat', '>>file'],
 
235
                                             'more\n', None, None)
 
236
        self.assertFileEqual('content\nmore\n', 'file')
 
237
        self.assertEquals(None, out)
 
238
        self.assertEquals(None, err)
 
239
 
 
240
    def test_cat_file_to_file(self):
 
241
        self.build_tree_contents([('file', 'content\n')])
 
242
        retcode, out, err = self.run_command(['cat', 'file', '>file2'],
 
243
                                             None, None, None)
 
244
        self.assertFileEqual('content\n', 'file2')
 
245
 
 
246
    def test_cat_files_to_file(self):
 
247
        self.build_tree_contents([('cat', 'cat\n')])
 
248
        self.build_tree_contents([('dog', 'dog\n')])
 
249
        retcode, out, err = self.run_command(['cat', 'cat', 'dog', '>file'],
 
250
                                             None, None, None)
 
251
        self.assertFileEqual('cat\ndog\n', 'file')
 
252
 
 
253
    def test_cat_bogus_input_file(self):
 
254
        self.run_script("""
 
255
$ cat <file
 
256
2>file: No such file or directory
 
257
""")
 
258
 
 
259
    def test_cat_bogus_output_file(self):
 
260
        self.run_script("""
 
261
$ cat >
 
262
2>: No such file or directory
 
263
""")
 
264
 
 
265
    def test_echo_bogus_output_file(self):
 
266
        # We need a backing file sysytem for that test so it can't be in
 
267
        # TestEcho
 
268
        self.run_script("""
 
269
$ echo >
 
270
2>: No such file or directory
 
271
""")
 
272
 
 
273
 
 
274
class TestMkdir(script.TestCaseWithTransportAndScript):
 
275
 
 
276
    def test_mkdir_usage(self):
 
277
        self.assertRaises(SyntaxError, self.run_script, '$ mkdir')
 
278
        self.assertRaises(SyntaxError, self.run_script, '$ mkdir foo bar')
 
279
 
 
280
    def test_mkdir_jailed(self):
 
281
        self.assertRaises(ValueError, self.run_script, '$ mkdir /out-of-jail')
 
282
        self.assertRaises(ValueError, self.run_script, '$ mkdir ../out-of-jail')
 
283
 
 
284
    def test_mkdir_in_jail(self):
 
285
        self.run_script("""
 
286
$ mkdir dir
 
287
$ cd dir
 
288
$ mkdir ../dir2
 
289
$ cd ..
 
290
""")
 
291
        self.failUnlessExists('dir')
 
292
        self.failUnlessExists('dir2')
 
293
 
 
294
 
 
295
class TestCd(script.TestCaseWithTransportAndScript):
 
296
 
 
297
    def test_cd_usage(self):
 
298
        self.assertRaises(SyntaxError, self.run_script, '$ cd foo bar')
 
299
 
 
300
    def test_cd_out_of_jail(self):
 
301
        self.assertRaises(ValueError, self.run_script, '$ cd /out-of-jail')
 
302
        self.assertRaises(ValueError, self.run_script, '$ cd ..')
 
303
 
 
304
    def test_cd_dir_and_back_home(self):
 
305
        self.assertEquals(self.test_dir, osutils.getcwd())
 
306
        self.run_script("""
 
307
$ mkdir dir
 
308
$ cd dir
 
309
""")
 
310
        self.assertEquals(osutils.pathjoin(self.test_dir, 'dir'),
 
311
                          osutils.getcwd())
 
312
 
 
313
        self.run_script('$ cd')
 
314
        self.assertEquals(self.test_dir, osutils.getcwd())
 
315
 
 
316
 
 
317
class TestBzr(script.TestCaseWithTransportAndScript):
 
318
 
 
319
    def test_bzr_smoke(self):
 
320
        self.run_script('$ bzr init branch')
 
321
        self.failUnlessExists('branch')
 
322
 
 
323
 
 
324
class TestEcho(script.TestCaseWithMemoryTransportAndScript):
 
325
 
 
326
    def test_echo_usage(self):
 
327
        story = """
 
328
$ echo foo
 
329
<bar
 
330
"""
 
331
        self.assertRaises(SyntaxError, self.run_script, story)
 
332
 
 
333
    def test_echo_input(self):
 
334
        self.assertRaises(SyntaxError, self.run_script, """
 
335
            $ echo <foo
 
336
            """)
 
337
 
 
338
    def test_echo_to_output(self):
 
339
        retcode, out, err = self.run_command(['echo'], None, '\n', None)
 
340
        self.assertEquals('\n', out)
 
341
        self.assertEquals(None, err)
 
342
 
 
343
    def test_echo_some_to_output(self):
 
344
        retcode, out, err = self.run_command(['echo', 'hello'],
 
345
                                             None, 'hello\n', None)
 
346
        self.assertEquals('hello\n', out)
 
347
        self.assertEquals(None, err)
 
348
 
 
349
    def test_echo_more_output(self):
 
350
        retcode, out, err = self.run_command(
 
351
            ['echo', 'hello', 'happy', 'world'],
 
352
            None, 'hello happy world\n', None)
 
353
        self.assertEquals('hello happy world\n', out)
 
354
        self.assertEquals(None, err)
 
355
 
 
356
    def test_echo_appended(self):
 
357
        retcode, out, err = self.run_command(['echo', 'hello', '>file'],
 
358
                                             None, None, None)
 
359
        self.assertEquals(None, out)
 
360
        self.assertEquals(None, err)
 
361
        self.assertFileEqual('hello\n', 'file')
 
362
        retcode, out, err = self.run_command(['echo', 'happy', '>>file'],
 
363
                                             None, None, None)
 
364
        self.assertEquals(None, out)
 
365
        self.assertEquals(None, err)
 
366
        self.assertFileEqual('hello\nhappy\n', 'file')
 
367
 
 
368
 
 
369
class TestRm(script.TestCaseWithTransportAndScript):
 
370
 
 
371
    def test_rm_usage(self):
 
372
        self.assertRaises(SyntaxError, self.run_script, '$ rm')
 
373
        self.assertRaises(SyntaxError, self.run_script, '$ rm -ff foo')
 
374
 
 
375
    def test_rm_file(self):
 
376
        self.run_script('$ echo content >file')
 
377
        self.failUnlessExists('file')
 
378
        self.run_script('$ rm file')
 
379
        self.failIfExists('file')
 
380
 
 
381
    def test_rm_file_force(self):
 
382
        self.failIfExists('file')
 
383
        self.run_script('$ rm -f file')
 
384
        self.failIfExists('file')
 
385
 
 
386
    def test_rm_files(self):
 
387
        self.run_script("""
 
388
$ echo content >file
 
389
$ echo content >file2
 
390
""")
 
391
        self.failUnlessExists('file2')
 
392
        self.run_script('$ rm file file2')
 
393
        self.failIfExists('file2')
 
394
 
 
395
    def test_rm_dir(self):
 
396
        self.run_script('$ mkdir dir')
 
397
        self.failUnlessExists('dir')
 
398
        self.run_script("""
 
399
$ rm dir
 
400
2>rm: cannot remove 'dir': Is a directory
 
401
""")
 
402
        self.failUnlessExists('dir')
 
403
 
 
404
    def test_rm_dir_recursive(self):
 
405
        self.run_script("""
 
406
$ mkdir dir
 
407
$ rm -r dir
 
408
""")
 
409
        self.failIfExists('dir')