~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_script.py

  • Committer: Alexander Belchenko
  • Date: 2006-07-30 16:43:12 UTC
  • mto: (1711.2.111 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060730164312-b025fd3ff0cee59e
rename  gpl.txt => COPYING.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
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')
410
 
 
411
 
 
412
 
class TestMv(script.TestCaseWithTransportAndScript):
413
 
 
414
 
    def test_usage(self):
415
 
        self.assertRaises(SyntaxError, self.run_script, '$ mv')
416
 
        self.assertRaises(SyntaxError, self.run_script, '$ mv f')
417
 
        self.assertRaises(SyntaxError, self.run_script, '$ mv f1 f2 f3')
418
 
 
419
 
    def test_move_file(self):
420
 
        self.run_script('$ echo content >file')
421
 
        self.failUnlessExists('file')
422
 
        self.run_script('$ mv file new_name')
423
 
        self.failIfExists('file')
424
 
        self.failUnlessExists('new_name')
425
 
 
426
 
    def test_move_unknown_file(self):
427
 
        self.assertRaises(AssertionError,
428
 
                          self.run_script, '$ mv unknown does-not-exist')
429
 
 
430
 
    def test_move_dir(self):
431
 
        self.run_script("""
432
 
$ mkdir dir
433
 
$ echo content >dir/file
434
 
""")
435
 
        self.run_script('$ mv dir new_name')
436
 
        self.failIfExists('dir')
437
 
        self.failUnlessExists('new_name')
438
 
        self.failUnlessExists('new_name/file')
439
 
 
440
 
    def test_move_file_into_dir(self):
441
 
        self.run_script("""
442
 
$ mkdir dir
443
 
$ echo content > file
444
 
""")
445
 
        self.run_script('$ mv file dir')
446
 
        self.failUnlessExists('dir')
447
 
        self.failIfExists('file')
448
 
        self.failUnlessExists('dir/file')
449