/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: Robert Collins
  • Date: 2010-05-05 00:05:29 UTC
  • mto: This revision was merged to the branch mainline in revision 5206.
  • Revision ID: robertc@robertcollins.net-20100505000529-ltmllyms5watqj5u
Make 'pydoc bzrlib.tests.build_tree_shape' useful.

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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
 
from breezy import (
19
 
    commands,
 
18
from bzrlib import (
20
19
    osutils,
21
20
    tests,
22
 
    trace,
23
 
    ui,
24
21
    )
25
 
from breezy.tests import script
 
22
from bzrlib.tests import script
26
23
 
27
24
 
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)],
63
 
                         script._script_to_commands('$ cd trunk'))
 
34
        self.assertEquals([(['cd', 'trunk'], None, None, None)],
 
35
                           script._script_to_commands('$ cd trunk'))
64
36
 
65
37
    def test_command_with_single_quoted_param(self):
66
 
        story = """$ brz commit -m 'two words'"""
67
 
        self.assertEqual([(['brz', 'commit', '-m', "'two words'"],
68
 
                           None, None, None)],
69
 
                         script._script_to_commands(story))
 
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))
70
42
 
71
43
    def test_command_with_double_quoted_param(self):
72
 
        story = """$ brz commit -m "two words" """
73
 
        self.assertEqual([(['brz', 'commit', '-m', '"two words"'],
74
 
                           None, None, None)],
75
 
                         script._script_to_commands(story))
 
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))
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
 
82
 
    def test_indented(self):
83
 
        # scripts are commonly given indented within the test source code, and
84
 
        # common indentation is stripped off
85
 
        story = """
86
 
            $ brz add
87
 
            adding file
88
 
            adding file2
89
 
            """
90
 
        self.assertEqual([(['brz', 'add'], None,
91
 
                           'adding file\nadding file2\n', None)],
92
 
                         script._script_to_commands(story))
93
 
 
94
54
    def test_command_with_output(self):
95
55
        story = """
96
 
$ brz add
 
56
$ bzr add
97
57
adding file
98
58
adding file2
99
59
"""
100
 
        self.assertEqual([(['brz', 'add'], None,
101
 
                           'adding file\nadding file2\n', None)],
102
 
                         script._script_to_commands(story))
 
60
        self.assertEquals([(['bzr', 'add'], None,
 
61
                            'adding file\nadding file2\n', None)],
 
62
                          script._script_to_commands(story))
103
63
 
104
64
    def test_command_with_error(self):
105
65
        story = """
106
 
$ brz branch foo
107
 
2>brz: ERROR: Not a branch: "foo"
 
66
$ bzr branch foo
 
67
2>bzr: ERROR: Not a branch: "foo"
108
68
"""
109
 
        self.assertEqual([(['brz', 'branch', 'foo'],
110
 
                           None, None, 'brz: ERROR: Not a branch: "foo"\n')],
111
 
                         script._script_to_commands(story))
 
69
        self.assertEquals([(['bzr', 'branch', 'foo'],
 
70
                            None, None, 'bzr: ERROR: Not a branch: "foo"\n')],
 
71
                          script._script_to_commands(story))
112
72
 
113
73
    def test_input_without_command(self):
114
74
        self.assertRaises(SyntaxError, script._script_to_commands, '<input')
118
78
 
119
79
    def test_command_with_backquotes(self):
120
80
        story = """
121
 
$ foo = `brz file-id toto`
 
81
$ foo = `bzr file-id toto`
122
82
"""
123
 
        self.assertEqual([(['foo', '=', '`brz file-id toto`'],
124
 
                           None, None, None)],
125
 
                         script._script_to_commands(story))
 
83
        self.assertEquals([(['foo', '=', '`bzr file-id toto`'],
 
84
                            None, None, None)],
 
85
                          script._script_to_commands(story))
126
86
 
127
87
 
128
88
class TestRedirections(tests.TestCase):
143
103
        self._check('foo', None, None, ['bar', 'baz'], ['bar', '<foo', 'baz'])
144
104
 
145
105
    def test_output_redirection(self):
146
 
        self._check(None, 'foo', 'w+', [], ['>foo'])
147
 
        self._check(None, 'foo', 'w+', ['bar'], ['bar', '>foo'])
148
 
        self._check(None, 'foo', 'w+', ['bar'], ['bar', '>', 'foo'])
149
 
        self._check(None, 'foo', 'a+', [], ['>>foo'])
150
 
        self._check(None, 'foo', 'a+', ['bar'], ['bar', '>>foo'])
151
 
        self._check(None, 'foo', 'a+', ['bar'], ['bar', '>>', 'foo'])
 
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'])
152
112
 
153
113
    def test_redirection_syntax_errors(self):
154
114
        self._check('', None, None, [], ['<'])
155
 
        self._check(None, '', 'w+', [], ['>'])
156
 
        self._check(None, '', 'a+', [], ['>>'])
157
 
        self._check('>', '', 'a+', [], ['<', '>', '>>'])
 
115
        self._check(None, '', 'wb+', [], ['>'])
 
116
        self._check(None, '', 'ab+', [], ['>>'])
 
117
        self._check('>', '', 'ab+', [], ['<', '>', '>>'])
 
118
 
158
119
 
159
120
 
160
121
class TestExecution(script.TestCaseWithTransportAndScript):
161
122
 
162
123
    def test_unknown_command(self):
163
 
        """A clear error is reported for commands that aren't recognised
164
 
 
165
 
        Testing the attributes of the SyntaxError instance is equivalent to
166
 
        using traceback.format_exception_only and comparing with:
167
 
          File "<string>", line 1
168
 
            foo --frob
169
 
            ^
170
 
        SyntaxError: Command not found "foo"
171
 
        """
172
 
        e = self.assertRaises(SyntaxError, self.run_script, "$ foo --frob")
173
 
        self.assertContainsRe(e.msg, "not found.*foo")
174
 
        self.assertEqual(e.text, "foo --frob")
175
 
 
176
 
    def test_blank_output_mismatches_output(self):
177
 
        """If you give output, the output must actually be blank.
178
 
 
179
 
        See <https://bugs.launchpad.net/bzr/+bug/637830>: previously blank
180
 
        output was a wildcard.  Now you must say ... if you want that.
181
 
        """
182
 
        self.assertRaises(AssertionError,
183
 
                          self.run_script,
184
 
                          """
185
 
            $ echo foo
186
 
            """)
187
 
 
188
 
    def test_null_output_matches_option(self):
189
 
        """If you want null output to be a wild card, you can pass
190
 
        null_output_matches_anything to run_script"""
191
 
        self.run_script(
192
 
            """
193
 
            $ echo foo
194
 
            """, null_output_matches_anything=True)
195
 
 
196
 
    def test_ellipsis_everything(self):
197
 
        """A simple ellipsis matches everything."""
198
 
        self.run_script("""
199
 
        $ echo foo
200
 
        ...
201
 
        """)
202
 
 
203
 
    def test_ellipsis_matches_empty(self):
204
 
        self.run_script("""
205
 
        $ cd .
206
 
        ...
207
 
        """)
 
124
        self.assertRaises(SyntaxError, self.run_script, 'foo')
208
125
 
209
126
    def test_stops_on_unexpected_output(self):
210
127
        story = """
214
131
"""
215
132
        self.assertRaises(AssertionError, self.run_script, story)
216
133
 
 
134
 
217
135
    def test_stops_on_unexpected_error(self):
218
136
        story = """
219
137
$ cat
220
138
<Hello
221
 
$ brz not-a-command
 
139
$ bzr not-a-command
222
140
"""
223
141
        self.assertRaises(AssertionError, self.run_script, story)
224
142
 
225
143
    def test_continue_on_expected_error(self):
226
144
        story = """
227
 
$ brz not-a-command
 
145
$ bzr not-a-command
228
146
2>..."not-a-command"
229
147
"""
230
148
        self.run_script(story)
232
150
    def test_continue_on_error_output(self):
233
151
        # The status matters, not the output
234
152
        story = """
235
 
$ brz init
236
 
...
 
153
$ bzr init
237
154
$ cat >file
238
155
<Hello
239
 
$ brz add file
240
 
...
241
 
$ brz commit -m 'adding file'
242
 
2>...
 
156
$ bzr add file
 
157
$ bzr commit -m 'adding file'
243
158
"""
244
159
        self.run_script(story)
245
160
 
255
170
"""
256
171
        self.run_script(story)
257
172
        story = """
258
 
$ brz not-a-command
 
173
$ bzr not-a-command
259
174
2>..."not-a-command"
260
175
"""
261
176
        self.run_script(story)
262
177
 
263
178
        story = """
264
 
$ brz branch not-a-branch
265
 
2>brz: ERROR: Not a branch...not-a-branch/".
 
179
$ bzr branch not-a-branch
 
180
2>bzr: ERROR: Not a branch...not-a-branch/".
266
181
"""
267
182
        self.run_script(story)
268
183
 
291
206
cat dog "chicken" 'dragon'
292
207
""")
293
208
 
294
 
    def test_verbosity_isolated(self):
295
 
        """Global verbosity is isolated from commands run in scripts.
296
 
        """
297
 
        # see also 656694; we should get rid of global verbosity
298
 
        self.run_script("""
299
 
        $ brz init --quiet a
300
 
        """)
301
 
        self.assertEqual(trace.is_quiet(), False)
302
 
 
303
209
 
304
210
class TestCat(script.TestCaseWithTransportAndScript):
305
211
 
309
215
    def test_cat_input_to_output(self):
310
216
        retcode, out, err = self.run_command(['cat'],
311
217
                                             'content\n', 'content\n', None)
312
 
        self.assertEqual('content\n', out)
313
 
        self.assertEqual(None, err)
 
218
        self.assertEquals('content\n', out)
 
219
        self.assertEquals(None, err)
314
220
 
315
221
    def test_cat_file_to_output(self):
316
 
        self.build_tree_contents([('file', b'content\n')])
 
222
        self.build_tree_contents([('file', 'content\n')])
317
223
        retcode, out, err = self.run_command(['cat', 'file'],
318
224
                                             None, 'content\n', None)
319
 
        self.assertEqual('content\n', out)
320
 
        self.assertEqual(None, err)
 
225
        self.assertEquals('content\n', out)
 
226
        self.assertEquals(None, err)
321
227
 
322
228
    def test_cat_input_to_file(self):
323
229
        retcode, out, err = self.run_command(['cat', '>file'],
324
230
                                             'content\n', None, None)
325
231
        self.assertFileEqual('content\n', 'file')
326
 
        self.assertEqual(None, out)
327
 
        self.assertEqual(None, err)
 
232
        self.assertEquals(None, out)
 
233
        self.assertEquals(None, err)
328
234
        retcode, out, err = self.run_command(['cat', '>>file'],
329
235
                                             'more\n', None, None)
330
236
        self.assertFileEqual('content\nmore\n', 'file')
331
 
        self.assertEqual(None, out)
332
 
        self.assertEqual(None, err)
 
237
        self.assertEquals(None, out)
 
238
        self.assertEquals(None, err)
333
239
 
334
240
    def test_cat_file_to_file(self):
335
 
        self.build_tree_contents([('file', b'content\n')])
 
241
        self.build_tree_contents([('file', 'content\n')])
336
242
        retcode, out, err = self.run_command(['cat', 'file', '>file2'],
337
243
                                             None, None, None)
338
 
        self.assertFileEqual(b'content\n', 'file2')
 
244
        self.assertFileEqual('content\n', 'file2')
339
245
 
340
246
    def test_cat_files_to_file(self):
341
 
        self.build_tree_contents([('cat', b'cat\n')])
342
 
        self.build_tree_contents([('dog', b'dog\n')])
 
247
        self.build_tree_contents([('cat', 'cat\n')])
 
248
        self.build_tree_contents([('dog', 'dog\n')])
343
249
        retcode, out, err = self.run_command(['cat', 'cat', 'dog', '>file'],
344
250
                                             None, None, None)
345
 
        self.assertFileEqual(b'cat\ndog\n', 'file')
 
251
        self.assertFileEqual('cat\ndog\n', 'file')
346
252
 
347
253
    def test_cat_bogus_input_file(self):
348
254
        self.run_script("""
373
279
 
374
280
    def test_mkdir_jailed(self):
375
281
        self.assertRaises(ValueError, self.run_script, '$ mkdir /out-of-jail')
376
 
        self.assertRaises(ValueError, self.run_script,
377
 
                          '$ mkdir ../out-of-jail')
 
282
        self.assertRaises(ValueError, self.run_script, '$ mkdir ../out-of-jail')
378
283
 
379
284
    def test_mkdir_in_jail(self):
380
285
        self.run_script("""
383
288
$ mkdir ../dir2
384
289
$ cd ..
385
290
""")
386
 
        self.assertPathExists('dir')
387
 
        self.assertPathExists('dir2')
 
291
        self.failUnlessExists('dir')
 
292
        self.failUnlessExists('dir2')
388
293
 
389
294
 
390
295
class TestCd(script.TestCaseWithTransportAndScript):
397
302
        self.assertRaises(ValueError, self.run_script, '$ cd ..')
398
303
 
399
304
    def test_cd_dir_and_back_home(self):
400
 
        self.assertEqual(self.test_dir, osutils.getcwd())
 
305
        self.assertEquals(self.test_dir, osutils.getcwd())
401
306
        self.run_script("""
402
307
$ mkdir dir
403
308
$ cd dir
404
309
""")
405
 
        self.assertEqual(osutils.pathjoin(self.test_dir, 'dir'),
406
 
                         osutils.getcwd())
 
310
        self.assertEquals(osutils.pathjoin(self.test_dir, 'dir'),
 
311
                          osutils.getcwd())
407
312
 
408
313
        self.run_script('$ cd')
409
 
        self.assertEqual(self.test_dir, osutils.getcwd())
410
 
 
411
 
 
412
 
class TestBrz(script.TestCaseWithTransportAndScript):
413
 
 
414
 
    def test_brz_smoke(self):
415
 
        self.run_script("""
416
 
            $ brz init branch
417
 
            Created a standalone tree (format: ...)
418
 
            """)
419
 
        self.assertPathExists('branch')
 
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')
420
322
 
421
323
 
422
324
class TestEcho(script.TestCaseWithMemoryTransportAndScript):
435
337
 
436
338
    def test_echo_to_output(self):
437
339
        retcode, out, err = self.run_command(['echo'], None, '\n', None)
438
 
        self.assertEqual('\n', out)
439
 
        self.assertEqual(None, err)
 
340
        self.assertEquals('\n', out)
 
341
        self.assertEquals(None, err)
440
342
 
441
343
    def test_echo_some_to_output(self):
442
344
        retcode, out, err = self.run_command(['echo', 'hello'],
443
345
                                             None, 'hello\n', None)
444
 
        self.assertEqual('hello\n', out)
445
 
        self.assertEqual(None, err)
 
346
        self.assertEquals('hello\n', out)
 
347
        self.assertEquals(None, err)
446
348
 
447
349
    def test_echo_more_output(self):
448
350
        retcode, out, err = self.run_command(
449
351
            ['echo', 'hello', 'happy', 'world'],
450
352
            None, 'hello happy world\n', None)
451
 
        self.assertEqual('hello happy world\n', out)
452
 
        self.assertEqual(None, err)
 
353
        self.assertEquals('hello happy world\n', out)
 
354
        self.assertEquals(None, err)
453
355
 
454
356
    def test_echo_appended(self):
455
357
        retcode, out, err = self.run_command(['echo', 'hello', '>file'],
456
358
                                             None, None, None)
457
 
        self.assertEqual(None, out)
458
 
        self.assertEqual(None, err)
459
 
        self.assertFileEqual(b'hello\n', 'file')
 
359
        self.assertEquals(None, out)
 
360
        self.assertEquals(None, err)
 
361
        self.assertFileEqual('hello\n', 'file')
460
362
        retcode, out, err = self.run_command(['echo', 'happy', '>>file'],
461
363
                                             None, None, None)
462
 
        self.assertEqual(None, out)
463
 
        self.assertEqual(None, err)
464
 
        self.assertFileEqual(b'hello\nhappy\n', 'file')
465
 
 
466
 
    def test_empty_line_in_output_is_respected(self):
467
 
        self.run_script("""
468
 
            $ echo
469
 
 
470
 
            $ echo bar
471
 
            bar
472
 
            """)
 
364
        self.assertEquals(None, out)
 
365
        self.assertEquals(None, err)
 
366
        self.assertFileEqual('hello\nhappy\n', 'file')
473
367
 
474
368
 
475
369
class TestRm(script.TestCaseWithTransportAndScript):
480
374
 
481
375
    def test_rm_file(self):
482
376
        self.run_script('$ echo content >file')
483
 
        self.assertPathExists('file')
 
377
        self.failUnlessExists('file')
484
378
        self.run_script('$ rm file')
485
 
        self.assertPathDoesNotExist('file')
 
379
        self.failIfExists('file')
486
380
 
487
381
    def test_rm_file_force(self):
488
 
        self.assertPathDoesNotExist('file')
 
382
        self.failIfExists('file')
489
383
        self.run_script('$ rm -f file')
490
 
        self.assertPathDoesNotExist('file')
 
384
        self.failIfExists('file')
491
385
 
492
386
    def test_rm_files(self):
493
387
        self.run_script("""
494
388
$ echo content >file
495
389
$ echo content >file2
496
390
""")
497
 
        self.assertPathExists('file2')
 
391
        self.failUnlessExists('file2')
498
392
        self.run_script('$ rm file file2')
499
 
        self.assertPathDoesNotExist('file2')
 
393
        self.failIfExists('file2')
500
394
 
501
395
    def test_rm_dir(self):
502
396
        self.run_script('$ mkdir dir')
503
 
        self.assertPathExists('dir')
 
397
        self.failUnlessExists('dir')
504
398
        self.run_script("""
505
399
$ rm dir
506
400
2>rm: cannot remove 'dir': Is a directory
507
401
""")
508
 
        self.assertPathExists('dir')
 
402
        self.failUnlessExists('dir')
509
403
 
510
404
    def test_rm_dir_recursive(self):
511
405
        self.run_script("""
512
406
$ mkdir dir
513
407
$ rm -r dir
514
408
""")
515
 
        self.assertPathDoesNotExist('dir')
 
409
        self.failIfExists('dir')
516
410
 
517
411
 
518
412
class TestMv(script.TestCaseWithTransportAndScript):
524
418
 
525
419
    def test_move_file(self):
526
420
        self.run_script('$ echo content >file')
527
 
        self.assertPathExists('file')
 
421
        self.failUnlessExists('file')
528
422
        self.run_script('$ mv file new_name')
529
 
        self.assertPathDoesNotExist('file')
530
 
        self.assertPathExists('new_name')
 
423
        self.failIfExists('file')
 
424
        self.failUnlessExists('new_name')
531
425
 
532
426
    def test_move_unknown_file(self):
533
427
        self.assertRaises(AssertionError,
539
433
$ echo content >dir/file
540
434
""")
541
435
        self.run_script('$ mv dir new_name')
542
 
        self.assertPathDoesNotExist('dir')
543
 
        self.assertPathExists('new_name')
544
 
        self.assertPathExists('new_name/file')
 
436
        self.failIfExists('dir')
 
437
        self.failUnlessExists('new_name')
 
438
        self.failUnlessExists('new_name/file')
545
439
 
546
440
    def test_move_file_into_dir(self):
547
441
        self.run_script("""
549
443
$ echo content > file
550
444
""")
551
445
        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
 
                # 'breezy.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(
581
 
            commands.builtin_command_registry.remove, 'test-confirm')
582
 
        self.run_script("""
583
 
            $ brz test-confirm
584
 
            2>Really do it? ([y]es, [n]o): yes
585
 
            <y
586
 
            Do it!
587
 
            $ brz test-confirm
588
 
            2>Really do it? ([y]es, [n]o): no
589
 
            <n
590
 
            ok, no
591
 
            """)
592
 
 
593
 
 
594
 
class TestShelve(script.TestCaseWithTransportAndScript):
595
 
 
596
 
    def setUp(self):
597
 
        super(TestShelve, self).setUp()
598
 
        self.run_script("""
599
 
            $ brz init test
600
 
            Created a standalone tree (format: 2a)
601
 
            $ cd test
602
 
            $ echo foo > file
603
 
            $ brz add
604
 
            adding file
605
 
            $ brz commit -m 'file added'
606
 
            2>Committing to:...test/
607
 
            2>added file
608
 
            2>Committed revision 1.
609
 
            $ echo bar > file
610
 
            """)
611
 
 
612
 
    def test_shelve(self):
613
 
        self.run_script("""
614
 
            $ brz shelve -m 'shelve bar'
615
 
            2>Shelve? ([y]es, [N]o, [f]inish, [q]uit): yes
616
 
            <y
617
 
            2>Selected changes:
618
 
            2> M  file
619
 
            2>Shelve 1 change(s)? ([y]es, [N]o, [f]inish, [q]uit): yes
620
 
            <y
621
 
            2>Changes shelved with id "1".
622
 
            """,
623
 
                        null_output_matches_anything=True)
624
 
        self.run_script("""
625
 
            $ brz shelve --list
626
 
              1: shelve bar
627
 
            """)
628
 
 
629
 
    def test_dont_shelve(self):
630
 
        # We intentionally provide no input here to test EOF
631
 
        self.run_script((
632
 
            "$ brz shelve -m 'shelve bar'\n"
633
 
            "2>Shelve? ([y]es, [N]o, [f]inish, [q]uit): \n"
634
 
            "2>No changes to shelve.\n"
635
 
            ), null_output_matches_anything=True)
636
 
        self.run_script("""
637
 
            $ brz st
638
 
            modified:
639
 
              file
640
 
            """)
 
446
        self.failUnlessExists('dir')
 
447
        self.failIfExists('file')
 
448
        self.failUnlessExists('dir/file')
 
449