← 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: Jelmer Vernooij
  • Date: 2011-01-11 04:33:12 UTC
  • mto: (5582.12.2 weave-plugin)
  • mto: This revision was merged to the branch mainline in revision 5718.
  • Revision ID: jelmer@samba.org-20110111043312-g4wx6iuf9662f36d
Move weave formats into bzrlib.plugins.weave_fmt.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_script.py
16
16
 
17
17
 
18
18
from bzrlib import (
 
19
    commands,
19
20
    osutils,
20
21
    tests,
 
22
    trace,
 
23
    ui,
21
24
    )
22
25
from bzrlib.tests import script
23
26
 
27
30
    def test_comment_is_ignored(self):
28
31
        self.assertEquals([], script._script_to_commands('#comment\n'))
29
32
 
30
 
    def test_empty_line_is_ignored(self):
31
 
        self.assertEquals([], script._script_to_commands('\n'))
 
33
    def test_comment_multiple_lines(self):
 
34
        self.assertEquals([
 
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.assertEquals([
 
54
            (['bar'], None, '\n', None),
 
55
            ],
 
56
            script._script_to_commands("""
 
57
            $bar
 
58
 
 
59
            """))
32
60
 
33
61
    def test_simple_command(self):
34
62
        self.assertEquals([(['cd', 'trunk'], None, None, None)],
133
161
class TestExecution(script.TestCaseWithTransportAndScript):
134
162
 
135
163
    def test_unknown_command(self):
136
 
        self.assertRaises(SyntaxError, self.run_script, 'foo')
 
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.assertEquals(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
        """)
137
209
 
138
210
    def test_stops_on_unexpected_output(self):
139
211
        story = """
143
215
"""
144
216
        self.assertRaises(AssertionError, self.run_script, story)
145
217
 
146
 
 
147
218
    def test_stops_on_unexpected_error(self):
148
219
        story = """
149
220
$ cat
163
234
        # The status matters, not the output
164
235
        story = """
165
236
$ bzr init
 
237
...
166
238
$ cat >file
167
239
<Hello
168
240
$ bzr add file
 
241
...
169
242
$ bzr commit -m 'adding file'
 
243
2>...
170
244
"""
171
245
        self.run_script(story)
172
246
 
218
292
cat dog "chicken" 'dragon'
219
293
""")
220
294
 
 
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.assertEquals(trace.is_quiet(), False)
 
303
 
221
304
 
222
305
class TestCat(script.TestCaseWithTransportAndScript):
223
306
 
329
412
class TestBzr(script.TestCaseWithTransportAndScript):
330
413
 
331
414
    def test_bzr_smoke(self):
332
 
        self.run_script('$ bzr init branch')
 
415
        self.run_script("""
 
416
            $ bzr init branch
 
417
            Created a standalone tree (format: ...)
 
418
            """)
333
419
        self.failUnlessExists('branch')
334
420
 
335
421
 
377
463
        self.assertEquals(None, err)
378
464
        self.assertFileEqual('hello\nhappy\n', 'file')
379
465
 
 
466
    def test_empty_line_in_output_is_respected(self):
 
467
        self.run_script("""
 
468
            $ echo
 
469
 
 
470
            $ echo bar
 
471
            bar
 
472
            """)
 
473
 
380
474
 
381
475
class TestRm(script.TestCaseWithTransportAndScript):
382
476
 
459
553
        self.failIfExists('file')
460
554
        self.failUnlessExists('dir/file')
461
555
 
 
556
 
 
557
class cmd_test_confirm(commands.Command):
 
558
 
 
559
    def run(self):
 
560
        if ui.ui_factory.get_boolean(
 
561
            '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 prompt
 
576
        isn't terminated by a newline from the program; it's implicitly terminated 
 
577
        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/n]: 
 
584
            <yes
 
585
            Do it!
 
586
            $ bzr test-confirm
 
587
            2>Really do it? [y/n]: 
 
588
            <no
 
589
            ok, no
 
590
            """)
 
591