← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_script.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-08-24 23:20:14 UTC
  • mfrom: (5365.5.29 2.3-btree-chk-leaf)
  • Revision ID: pqm@pqm.ubuntu.com-20100824232014-nu9owzel2zym2jk2
(jam) Use a custom C type for CHK index entries, saves memory

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_script.py
1
 
# Copyright (C) 2009, 2010, 2011, 2016 Canonical Ltd
 
1
# Copyright (C) 2009, 2010 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
16
16
 
17
17
 
18
18
from bzrlib import (
19
 
    commands,
20
19
    osutils,
21
20
    tests,
22
 
    trace,
23
 
    ui,
24
21
    )
25
22
from bzrlib.tests import script
26
23
 
28
25
class TestSyntax(tests.TestCase):
29
26
 
30
27
    def test_comment_is_ignored(self):
31
 
        self.assertEqual([], script._script_to_commands('#comment\n'))
32
 
 
33
 
    def test_comment_multiple_lines(self):
34
 
        self.assertEqual([
35
 
            (['bar'], None, None, None),
36
 
            ],
37
 
            script._script_to_commands("""
38
 
            # this comment is ignored
39
 
            # so is this
40
 
            # no we run bar
41
 
            $ bar
42
 
            """))
43
 
 
44
 
    def test_trim_blank_lines(self):
45
 
        """Blank lines are respected, but trimmed at the start and end.
46
 
 
47
 
        Python triple-quoted syntax is going to give stubby/empty blank lines 
48
 
        right at the start and the end.  These are cut off so that callers don't 
49
 
        need special syntax to avoid them.
50
 
 
51
 
        However we do want to be able to match commands that emit blank lines.
52
 
        """
53
 
        self.assertEqual([
54
 
            (['bar'], None, '\n', None),
55
 
            ],
56
 
            script._script_to_commands("""
57
 
            $bar
58
 
 
59
 
            """))
 
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'))
60
32
 
61
33
    def test_simple_command(self):
62
 
        self.assertEqual([(['cd', 'trunk'], None, None, None)],
 
34
        self.assertEquals([(['cd', 'trunk'], None, None, None)],
63
35
                           script._script_to_commands('$ cd trunk'))
64
36
 
65
37
    def test_command_with_single_quoted_param(self):
66
38
        story = """$ bzr commit -m 'two words'"""
67
 
        self.assertEqual([(['bzr', 'commit', '-m', "'two words'"],
 
39
        self.assertEquals([(['bzr', 'commit', '-m', "'two words'"],
68
40
                            None, None, None)],
69
41
                           script._script_to_commands(story))
70
42
 
71
43
    def test_command_with_double_quoted_param(self):
72
44
        story = """$ bzr commit -m "two words" """
73
 
        self.assertEqual([(['bzr', 'commit', '-m', '"two words"'],
 
45
        self.assertEquals([(['bzr', 'commit', '-m', '"two words"'],
74
46
                            None, None, None)],
75
47
                           script._script_to_commands(story))
76
48
 
77
49
    def test_command_with_input(self):
78
 
        self.assertEqual(
 
50
        self.assertEquals(
79
51
            [(['cat', '>file'], 'content\n', None, None)],
80
52
            script._script_to_commands('$ cat >file\n<content\n'))
81
53
 
87
59
            adding file
88
60
            adding file2
89
61
            """
90
 
        self.assertEqual([(['bzr', 'add'], None,
 
62
        self.assertEquals([(['bzr', 'add'], None,
91
63
                            'adding file\nadding file2\n', None)],
92
64
                          script._script_to_commands(story))
93
65
 
97
69
adding file
98
70
adding file2
99
71
"""
100
 
        self.assertEqual([(['bzr', 'add'], None,
 
72
        self.assertEquals([(['bzr', 'add'], None,
101
73
                            'adding file\nadding file2\n', None)],
102
74
                          script._script_to_commands(story))
103
75
 
106
78
$ bzr branch foo
107
79
2>bzr: ERROR: Not a branch: "foo"
108
80
"""
109
 
        self.assertEqual([(['bzr', 'branch', 'foo'],
 
81
        self.assertEquals([(['bzr', 'branch', 'foo'],
110
82
                            None, None, 'bzr: ERROR: Not a branch: "foo"\n')],
111
83
                          script._script_to_commands(story))
112
84
 
120
92
        story = """
121
93
$ foo = `bzr file-id toto`
122
94
"""
123
 
        self.assertEqual([(['foo', '=', '`bzr file-id toto`'],
 
95
        self.assertEquals([(['foo', '=', '`bzr file-id toto`'],
124
96
                            None, None, None)],
125
97
                          script._script_to_commands(story))
126
98
 
161
133
class TestExecution(script.TestCaseWithTransportAndScript):
162
134
 
163
135
    def test_unknown_command(self):
164
 
        """A clear error is reported for commands that aren't recognised
165
 
 
166
 
        Testing the attributes of the SyntaxError instance is equivalent to
167
 
        using traceback.format_exception_only and comparing with:
168
 
          File "<string>", line 1
169
 
            foo --frob
170
 
            ^
171
 
        SyntaxError: Command not found "foo"
172
 
        """
173
 
        e = self.assertRaises(SyntaxError, self.run_script, "$ foo --frob")
174
 
        self.assertContainsRe(e.msg, "not found.*foo")
175
 
        self.assertEqual(e.text, "foo --frob")
176
 
 
177
 
    def test_blank_output_mismatches_output(self):
178
 
        """If you give output, the output must actually be blank.
179
 
        
180
 
        See <https://bugs.launchpad.net/bzr/+bug/637830>: previously blank
181
 
        output was a wildcard.  Now you must say ... if you want that.
182
 
        """
183
 
        self.assertRaises(AssertionError,
184
 
            self.run_script,
185
 
            """
186
 
            $ echo foo
187
 
            """)
188
 
 
189
 
    def test_null_output_matches_option(self):
190
 
        """If you want null output to be a wild card, you can pass 
191
 
        null_output_matches_anything to run_script"""
192
 
        self.run_script(
193
 
            """
194
 
            $ echo foo
195
 
            """, null_output_matches_anything=True)
196
 
 
197
 
    def test_ellipsis_everything(self):
198
 
        """A simple ellipsis matches everything."""
199
 
        self.run_script("""
200
 
        $ echo foo
201
 
        ...
202
 
        """)
203
 
 
204
 
    def test_ellipsis_matches_empty(self):
205
 
        self.run_script("""
206
 
        $ cd .
207
 
        ...
208
 
        """)
 
136
        self.assertRaises(SyntaxError, self.run_script, 'foo')
209
137
 
210
138
    def test_stops_on_unexpected_output(self):
211
139
        story = """
215
143
"""
216
144
        self.assertRaises(AssertionError, self.run_script, story)
217
145
 
 
146
 
218
147
    def test_stops_on_unexpected_error(self):
219
148
        story = """
220
149
$ cat
234
163
        # The status matters, not the output
235
164
        story = """
236
165
$ bzr init
237
 
...
238
166
$ cat >file
239
167
<Hello
240
168
$ bzr add file
241
 
...
242
169
$ bzr commit -m 'adding file'
243
 
2>...
244
170
"""
245
171
        self.run_script(story)
246
172
 
292
218
cat dog "chicken" 'dragon'
293
219
""")
294
220
 
295
 
    def test_verbosity_isolated(self):
296
 
        """Global verbosity is isolated from commands run in scripts.
297
 
        """
298
 
        # see also 656694; we should get rid of global verbosity
299
 
        self.run_script("""
300
 
        $ bzr init --quiet a
301
 
        """)
302
 
        self.assertEqual(trace.is_quiet(), False)
303
 
 
304
221
 
305
222
class TestCat(script.TestCaseWithTransportAndScript):
306
223
 
310
227
    def test_cat_input_to_output(self):
311
228
        retcode, out, err = self.run_command(['cat'],
312
229
                                             'content\n', 'content\n', None)
313
 
        self.assertEqual('content\n', out)
314
 
        self.assertEqual(None, err)
 
230
        self.assertEquals('content\n', out)
 
231
        self.assertEquals(None, err)
315
232
 
316
233
    def test_cat_file_to_output(self):
317
234
        self.build_tree_contents([('file', 'content\n')])
318
235
        retcode, out, err = self.run_command(['cat', 'file'],
319
236
                                             None, 'content\n', None)
320
 
        self.assertEqual('content\n', out)
321
 
        self.assertEqual(None, err)
 
237
        self.assertEquals('content\n', out)
 
238
        self.assertEquals(None, err)
322
239
 
323
240
    def test_cat_input_to_file(self):
324
241
        retcode, out, err = self.run_command(['cat', '>file'],
325
242
                                             'content\n', None, None)
326
243
        self.assertFileEqual('content\n', 'file')
327
 
        self.assertEqual(None, out)
328
 
        self.assertEqual(None, err)
 
244
        self.assertEquals(None, out)
 
245
        self.assertEquals(None, err)
329
246
        retcode, out, err = self.run_command(['cat', '>>file'],
330
247
                                             'more\n', None, None)
331
248
        self.assertFileEqual('content\nmore\n', 'file')
332
 
        self.assertEqual(None, out)
333
 
        self.assertEqual(None, err)
 
249
        self.assertEquals(None, out)
 
250
        self.assertEquals(None, err)
334
251
 
335
252
    def test_cat_file_to_file(self):
336
253
        self.build_tree_contents([('file', 'content\n')])
383
300
$ mkdir ../dir2
384
301
$ cd ..
385
302
""")
386
 
        self.assertPathExists('dir')
387
 
        self.assertPathExists('dir2')
 
303
        self.failUnlessExists('dir')
 
304
        self.failUnlessExists('dir2')
388
305
 
389
306
 
390
307
class TestCd(script.TestCaseWithTransportAndScript):
397
314
        self.assertRaises(ValueError, self.run_script, '$ cd ..')
398
315
 
399
316
    def test_cd_dir_and_back_home(self):
400
 
        self.assertEqual(self.test_dir, osutils.getcwd())
 
317
        self.assertEquals(self.test_dir, osutils.getcwd())
401
318
        self.run_script("""
402
319
$ mkdir dir
403
320
$ cd dir
404
321
""")
405
 
        self.assertEqual(osutils.pathjoin(self.test_dir, 'dir'),
 
322
        self.assertEquals(osutils.pathjoin(self.test_dir, 'dir'),
406
323
                          osutils.getcwd())
407
324
 
408
325
        self.run_script('$ cd')
409
 
        self.assertEqual(self.test_dir, osutils.getcwd())
 
326
        self.assertEquals(self.test_dir, osutils.getcwd())
410
327
 
411
328
 
412
329
class TestBzr(script.TestCaseWithTransportAndScript):
413
330
 
414
331
    def test_bzr_smoke(self):
415
 
        self.run_script("""
416
 
            $ bzr init branch
417
 
            Created a standalone tree (format: ...)
418
 
            """)
419
 
        self.assertPathExists('branch')
 
332
        self.run_script('$ bzr init branch')
 
333
        self.failUnlessExists('branch')
420
334
 
421
335
 
422
336
class TestEcho(script.TestCaseWithMemoryTransportAndScript):
435
349
 
436
350
    def test_echo_to_output(self):
437
351
        retcode, out, err = self.run_command(['echo'], None, '\n', None)
438
 
        self.assertEqual('\n', out)
439
 
        self.assertEqual(None, err)
 
352
        self.assertEquals('\n', out)
 
353
        self.assertEquals(None, err)
440
354
 
441
355
    def test_echo_some_to_output(self):
442
356
        retcode, out, err = self.run_command(['echo', 'hello'],
443
357
                                             None, 'hello\n', None)
444
 
        self.assertEqual('hello\n', out)
445
 
        self.assertEqual(None, err)
 
358
        self.assertEquals('hello\n', out)
 
359
        self.assertEquals(None, err)
446
360
 
447
361
    def test_echo_more_output(self):
448
362
        retcode, out, err = self.run_command(
449
363
            ['echo', 'hello', 'happy', 'world'],
450
364
            None, 'hello happy world\n', None)
451
 
        self.assertEqual('hello happy world\n', out)
452
 
        self.assertEqual(None, err)
 
365
        self.assertEquals('hello happy world\n', out)
 
366
        self.assertEquals(None, err)
453
367
 
454
368
    def test_echo_appended(self):
455
369
        retcode, out, err = self.run_command(['echo', 'hello', '>file'],
456
370
                                             None, None, None)
457
 
        self.assertEqual(None, out)
458
 
        self.assertEqual(None, err)
 
371
        self.assertEquals(None, out)
 
372
        self.assertEquals(None, err)
459
373
        self.assertFileEqual('hello\n', 'file')
460
374
        retcode, out, err = self.run_command(['echo', 'happy', '>>file'],
461
375
                                             None, None, None)
462
 
        self.assertEqual(None, out)
463
 
        self.assertEqual(None, err)
 
376
        self.assertEquals(None, out)
 
377
        self.assertEquals(None, err)
464
378
        self.assertFileEqual('hello\nhappy\n', 'file')
465
379
 
466
 
    def test_empty_line_in_output_is_respected(self):
467
 
        self.run_script("""
468
 
            $ echo
469
 
 
470
 
            $ echo bar
471
 
            bar
472
 
            """)
473
 
 
474
380
 
475
381
class TestRm(script.TestCaseWithTransportAndScript):
476
382
 
480
386
 
481
387
    def test_rm_file(self):
482
388
        self.run_script('$ echo content >file')
483
 
        self.assertPathExists('file')
 
389
        self.failUnlessExists('file')
484
390
        self.run_script('$ rm file')
485
 
        self.assertPathDoesNotExist('file')
 
391
        self.failIfExists('file')
486
392
 
487
393
    def test_rm_file_force(self):
488
 
        self.assertPathDoesNotExist('file')
 
394
        self.failIfExists('file')
489
395
        self.run_script('$ rm -f file')
490
 
        self.assertPathDoesNotExist('file')
 
396
        self.failIfExists('file')
491
397
 
492
398
    def test_rm_files(self):
493
399
        self.run_script("""
494
400
$ echo content >file
495
401
$ echo content >file2
496
402
""")
497
 
        self.assertPathExists('file2')
 
403
        self.failUnlessExists('file2')
498
404
        self.run_script('$ rm file file2')
499
 
        self.assertPathDoesNotExist('file2')
 
405
        self.failIfExists('file2')
500
406
 
501
407
    def test_rm_dir(self):
502
408
        self.run_script('$ mkdir dir')
503
 
        self.assertPathExists('dir')
 
409
        self.failUnlessExists('dir')
504
410
        self.run_script("""
505
411
$ rm dir
506
412
2>rm: cannot remove 'dir': Is a directory
507
413
""")
508
 
        self.assertPathExists('dir')
 
414
        self.failUnlessExists('dir')
509
415
 
510
416
    def test_rm_dir_recursive(self):
511
417
        self.run_script("""
512
418
$ mkdir dir
513
419
$ rm -r dir
514
420
""")
515
 
        self.assertPathDoesNotExist('dir')
 
421
        self.failIfExists('dir')
516
422
 
517
423
 
518
424
class TestMv(script.TestCaseWithTransportAndScript):
524
430
 
525
431
    def test_move_file(self):
526
432
        self.run_script('$ echo content >file')
527
 
        self.assertPathExists('file')
 
433
        self.failUnlessExists('file')
528
434
        self.run_script('$ mv file new_name')
529
 
        self.assertPathDoesNotExist('file')
530
 
        self.assertPathExists('new_name')
 
435
        self.failIfExists('file')
 
436
        self.failUnlessExists('new_name')
531
437
 
532
438
    def test_move_unknown_file(self):
533
439
        self.assertRaises(AssertionError,
539
445
$ echo content >dir/file
540
446
""")
541
447
        self.run_script('$ mv dir new_name')
542
 
        self.assertPathDoesNotExist('dir')
543
 
        self.assertPathExists('new_name')
544
 
        self.assertPathExists('new_name/file')
 
448
        self.failIfExists('dir')
 
449
        self.failUnlessExists('new_name')
 
450
        self.failUnlessExists('new_name/file')
545
451
 
546
452
    def test_move_file_into_dir(self):
547
453
        self.run_script("""
549
455
$ echo content > file
550
456
""")
551
457
        self.run_script('$ mv file dir')
552
 
        self.assertPathExists('dir')
553
 
        self.assertPathDoesNotExist('file')
554
 
        self.assertPathExists('dir/file')
555
 
 
556
 
 
557
 
class cmd_test_confirm(commands.Command):
558
 
 
559
 
    def run(self):
560
 
        if ui.ui_factory.get_boolean(
561
 
            u'Really do it',
562
 
            # 'bzrlib.tests.test_script.confirm',
563
 
            # {}
564
 
            ):
565
 
            self.outf.write('Do it!\n')
566
 
        else:
567
 
            print 'ok, no'
568
 
 
569
 
 
570
 
class TestUserInteraction(script.TestCaseWithMemoryTransportAndScript):
571
 
 
572
 
    def test_confirm_action(self):
573
 
        """You can write tests that demonstrate user confirmation.
574
 
        
575
 
        Specifically, ScriptRunner does't care if the output line for the
576
 
        prompt isn't terminated by a newline from the program; it's implicitly
577
 
        terminated by the input.
578
 
        """
579
 
        commands.builtin_command_registry.register(cmd_test_confirm)
580
 
        self.addCleanup(commands.builtin_command_registry.remove, 'test-confirm')
581
 
        self.run_script("""
582
 
            $ bzr test-confirm
583
 
            2>Really do it? ([y]es, [n]o): yes
584
 
            <y
585
 
            Do it!
586
 
            $ bzr test-confirm
587
 
            2>Really do it? ([y]es, [n]o): no
588
 
            <n
589
 
            ok, no
590
 
            """)
591
 
 
592
 
class TestShelve(script.TestCaseWithTransportAndScript):
593
 
 
594
 
    def setUp(self):
595
 
        super(TestShelve, self).setUp()
596
 
        self.run_script("""
597
 
            $ bzr init test
598
 
            Created a standalone tree (format: 2a)
599
 
            $ cd test
600
 
            $ echo foo > file
601
 
            $ bzr add
602
 
            adding file
603
 
            $ bzr commit -m 'file added'
604
 
            2>Committing to:...test/
605
 
            2>added file
606
 
            2>Committed revision 1.
607
 
            $ echo bar > file
608
 
            """)
609
 
 
610
 
    def test_shelve(self):
611
 
        self.run_script("""
612
 
            $ bzr shelve -m 'shelve bar'
613
 
            2>Shelve? ([y]es, [N]o, [f]inish, [q]uit): yes
614
 
            <y
615
 
            2>Selected changes:
616
 
            2> M  file
617
 
            2>Shelve 1 change(s)? ([y]es, [N]o, [f]inish, [q]uit): yes
618
 
            <y
619
 
            2>Changes shelved with id "1".
620
 
            """,
621
 
                        null_output_matches_anything=True)
622
 
        self.run_script("""
623
 
            $ bzr shelve --list
624
 
              1: shelve bar
625
 
            """)
626
 
 
627
 
    def test_dont_shelve(self):
628
 
        # We intentionally provide no input here to test EOF
629
 
        self.run_script("""
630
 
            $ bzr shelve -m 'shelve bar'
631
 
            2>Shelve? ([y]es, [N]o, [f]inish, [q]uit): 
632
 
            2>No changes to shelve.
633
 
            """,
634
 
                        null_output_matches_anything=True)
635
 
        self.run_script("""
636
 
            $ bzr st
637
 
            modified:
638
 
              file
639
 
            """)
 
458
        self.failUnlessExists('dir')
 
459
        self.failIfExists('file')
 
460
        self.failUnlessExists('dir/file')
 
461