/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 breezy/tests/test_script.py

  • Committer: Jelmer Vernooij
  • Date: 2020-05-06 02:13:25 UTC
  • mfrom: (7490.7.21 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200506021325-awbmmqu1zyorz7sj
Merge 3.1 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_script.py
44
44
    def test_trim_blank_lines(self):
45
45
        """Blank lines are respected, but trimmed at the start and end.
46
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 
 
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
49
        need special syntax to avoid them.
50
50
 
51
51
        However we do want to be able to match commands that emit blank lines.
60
60
 
61
61
    def test_simple_command(self):
62
62
        self.assertEqual([(['cd', 'trunk'], None, None, None)],
63
 
                           script._script_to_commands('$ cd trunk'))
 
63
                         script._script_to_commands('$ cd trunk'))
64
64
 
65
65
    def test_command_with_single_quoted_param(self):
66
66
        story = """$ brz commit -m 'two words'"""
67
67
        self.assertEqual([(['brz', 'commit', '-m', "'two words'"],
68
 
                            None, None, None)],
69
 
                           script._script_to_commands(story))
 
68
                           None, None, None)],
 
69
                         script._script_to_commands(story))
70
70
 
71
71
    def test_command_with_double_quoted_param(self):
72
72
        story = """$ brz commit -m "two words" """
73
73
        self.assertEqual([(['brz', 'commit', '-m', '"two words"'],
74
 
                            None, None, None)],
75
 
                           script._script_to_commands(story))
 
74
                           None, None, None)],
 
75
                         script._script_to_commands(story))
76
76
 
77
77
    def test_command_with_input(self):
78
78
        self.assertEqual(
88
88
            adding file2
89
89
            """
90
90
        self.assertEqual([(['brz', 'add'], None,
91
 
                            'adding file\nadding file2\n', None)],
92
 
                          script._script_to_commands(story))
 
91
                           'adding file\nadding file2\n', None)],
 
92
                         script._script_to_commands(story))
93
93
 
94
94
    def test_command_with_output(self):
95
95
        story = """
98
98
adding file2
99
99
"""
100
100
        self.assertEqual([(['brz', 'add'], None,
101
 
                            'adding file\nadding file2\n', None)],
102
 
                          script._script_to_commands(story))
 
101
                           'adding file\nadding file2\n', None)],
 
102
                         script._script_to_commands(story))
103
103
 
104
104
    def test_command_with_error(self):
105
105
        story = """
107
107
2>brz: ERROR: Not a branch: "foo"
108
108
"""
109
109
        self.assertEqual([(['brz', 'branch', 'foo'],
110
 
                            None, None, 'brz: ERROR: Not a branch: "foo"\n')],
111
 
                          script._script_to_commands(story))
 
110
                           None, None, 'brz: ERROR: Not a branch: "foo"\n')],
 
111
                         script._script_to_commands(story))
112
112
 
113
113
    def test_input_without_command(self):
114
114
        self.assertRaises(SyntaxError, script._script_to_commands, '<input')
121
121
$ foo = `brz file-id toto`
122
122
"""
123
123
        self.assertEqual([(['foo', '=', '`brz file-id toto`'],
124
 
                            None, None, None)],
125
 
                          script._script_to_commands(story))
 
124
                           None, None, None)],
 
125
                         script._script_to_commands(story))
126
126
 
127
127
 
128
128
class TestRedirections(tests.TestCase):
143
143
        self._check('foo', None, None, ['bar', 'baz'], ['bar', '<foo', 'baz'])
144
144
 
145
145
    def test_output_redirection(self):
146
 
        self._check(None, 'foo', 'wb+', [], ['>foo'])
147
 
        self._check(None, 'foo', 'wb+', ['bar'], ['bar', '>foo'])
148
 
        self._check(None, 'foo', 'wb+', ['bar'], ['bar', '>', 'foo'])
149
 
        self._check(None, 'foo', 'ab+', [], ['>>foo'])
150
 
        self._check(None, 'foo', 'ab+', ['bar'], ['bar', '>>foo'])
151
 
        self._check(None, 'foo', 'ab+', ['bar'], ['bar', '>>', 'foo'])
 
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'])
152
152
 
153
153
    def test_redirection_syntax_errors(self):
154
154
        self._check('', None, None, [], ['<'])
155
 
        self._check(None, '', 'wb+', [], ['>'])
156
 
        self._check(None, '', 'ab+', [], ['>>'])
157
 
        self._check('>', '', 'ab+', [], ['<', '>', '>>'])
158
 
 
 
155
        self._check(None, '', 'w+', [], ['>'])
 
156
        self._check(None, '', 'a+', [], ['>>'])
 
157
        self._check('>', '', 'a+', [], ['<', '>', '>>'])
159
158
 
160
159
 
161
160
class TestExecution(script.TestCaseWithTransportAndScript):
176
175
 
177
176
    def test_blank_output_mismatches_output(self):
178
177
        """If you give output, the output must actually be blank.
179
 
        
 
178
 
180
179
        See <https://bugs.launchpad.net/bzr/+bug/637830>: previously blank
181
180
        output was a wildcard.  Now you must say ... if you want that.
182
181
        """
183
182
        self.assertRaises(AssertionError,
184
 
            self.run_script,
185
 
            """
 
183
                          self.run_script,
 
184
                          """
186
185
            $ echo foo
187
186
            """)
188
187
 
189
188
    def test_null_output_matches_option(self):
190
 
        """If you want null output to be a wild card, you can pass 
 
189
        """If you want null output to be a wild card, you can pass
191
190
        null_output_matches_anything to run_script"""
192
191
        self.run_script(
193
192
            """
314
313
        self.assertEqual(None, err)
315
314
 
316
315
    def test_cat_file_to_output(self):
317
 
        self.build_tree_contents([('file', 'content\n')])
 
316
        self.build_tree_contents([('file', b'content\n')])
318
317
        retcode, out, err = self.run_command(['cat', 'file'],
319
318
                                             None, 'content\n', None)
320
319
        self.assertEqual('content\n', out)
333
332
        self.assertEqual(None, err)
334
333
 
335
334
    def test_cat_file_to_file(self):
336
 
        self.build_tree_contents([('file', 'content\n')])
 
335
        self.build_tree_contents([('file', b'content\n')])
337
336
        retcode, out, err = self.run_command(['cat', 'file', '>file2'],
338
337
                                             None, None, None)
339
 
        self.assertFileEqual('content\n', 'file2')
 
338
        self.assertFileEqual(b'content\n', 'file2')
340
339
 
341
340
    def test_cat_files_to_file(self):
342
 
        self.build_tree_contents([('cat', 'cat\n')])
343
 
        self.build_tree_contents([('dog', 'dog\n')])
 
341
        self.build_tree_contents([('cat', b'cat\n')])
 
342
        self.build_tree_contents([('dog', b'dog\n')])
344
343
        retcode, out, err = self.run_command(['cat', 'cat', 'dog', '>file'],
345
344
                                             None, None, None)
346
 
        self.assertFileEqual('cat\ndog\n', 'file')
 
345
        self.assertFileEqual(b'cat\ndog\n', 'file')
347
346
 
348
347
    def test_cat_bogus_input_file(self):
349
348
        self.run_script("""
374
373
 
375
374
    def test_mkdir_jailed(self):
376
375
        self.assertRaises(ValueError, self.run_script, '$ mkdir /out-of-jail')
377
 
        self.assertRaises(ValueError, self.run_script, '$ mkdir ../out-of-jail')
 
376
        self.assertRaises(ValueError, self.run_script,
 
377
                          '$ mkdir ../out-of-jail')
378
378
 
379
379
    def test_mkdir_in_jail(self):
380
380
        self.run_script("""
403
403
$ cd dir
404
404
""")
405
405
        self.assertEqual(osutils.pathjoin(self.test_dir, 'dir'),
406
 
                          osutils.getcwd())
 
406
                         osutils.getcwd())
407
407
 
408
408
        self.run_script('$ cd')
409
409
        self.assertEqual(self.test_dir, osutils.getcwd())
456
456
                                             None, None, None)
457
457
        self.assertEqual(None, out)
458
458
        self.assertEqual(None, err)
459
 
        self.assertFileEqual('hello\n', 'file')
 
459
        self.assertFileEqual(b'hello\n', 'file')
460
460
        retcode, out, err = self.run_command(['echo', 'happy', '>>file'],
461
461
                                             None, None, None)
462
462
        self.assertEqual(None, out)
463
463
        self.assertEqual(None, err)
464
 
        self.assertFileEqual('hello\nhappy\n', 'file')
 
464
        self.assertFileEqual(b'hello\nhappy\n', 'file')
465
465
 
466
466
    def test_empty_line_in_output_is_respected(self):
467
467
        self.run_script("""
558
558
 
559
559
    def run(self):
560
560
        if ui.ui_factory.get_boolean(
561
 
            u'Really do it',
562
 
            # 'breezy.tests.test_script.confirm',
563
 
            # {}
564
 
            ):
 
561
                u'Really do it',
 
562
                # 'breezy.tests.test_script.confirm',
 
563
                # {}
 
564
                ):
565
565
            self.outf.write('Do it!\n')
566
566
        else:
567
567
            print('ok, no')
571
571
 
572
572
    def test_confirm_action(self):
573
573
        """You can write tests that demonstrate user confirmation.
574
 
        
 
574
 
575
575
        Specifically, ScriptRunner does't care if the output line for the
576
576
        prompt isn't terminated by a newline from the program; it's implicitly
577
577
        terminated by the input.
578
578
        """
579
579
        commands.builtin_command_registry.register(cmd_test_confirm)
580
 
        self.addCleanup(commands.builtin_command_registry.remove, 'test-confirm')
 
580
        self.addCleanup(
 
581
            commands.builtin_command_registry.remove, 'test-confirm')
581
582
        self.run_script("""
582
583
            $ brz test-confirm
583
584
            2>Really do it? ([y]es, [n]o): yes
589
590
            ok, no
590
591
            """)
591
592
 
 
593
 
592
594
class TestShelve(script.TestCaseWithTransportAndScript):
593
595
 
594
596
    def setUp(self):
626
628
 
627
629
    def test_dont_shelve(self):
628
630
        # We intentionally provide no input here to test EOF
629
 
        self.run_script("""
630
 
            $ brz 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)
 
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)
635
636
        self.run_script("""
636
637
            $ brz st
637
638
            modified: