/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/blackbox/test_selftest.py

  • Committer: John Arbash Meinel
  • Date: 2006-09-25 20:48:24 UTC
  • mfrom: (2041 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2050.
  • Revision ID: john@arbash-meinel.com-20060925204824-f4fff4858fa59b0c
[merge] bzr.dev 2041

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_selftest.py
16
16
"""UI tests for the test framework."""
17
17
 
18
18
import os
 
19
import signal
19
20
import sys
20
21
 
21
22
import bzrlib
85
86
 
86
87
class TestRunBzr(ExternalBase):
87
88
 
88
 
    def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None):
 
89
    def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None,
 
90
                         working_dir=None):
 
91
        """Override run_bzr_captured to test how it is invoked by run_bzr.
 
92
 
 
93
        We test how run_bzr_captured actually invokes bzr in another location.
 
94
        Here we only need to test that it is run_bzr passes the right
 
95
        parameters to run_bzr_captured.
 
96
        """
 
97
        self.argv = argv
 
98
        self.retcode = retcode
 
99
        self.encoding = encoding
89
100
        self.stdin = stdin
 
101
        self.working_dir = working_dir
 
102
 
 
103
    def test_args(self):
 
104
        """Test that run_bzr passes args correctly to run_bzr_captured"""
 
105
        self.run_bzr('arg1', 'arg2', 'arg3', retcode=1)
 
106
        self.assertEqual(('arg1', 'arg2', 'arg3'), self.argv)
 
107
 
 
108
    def test_encoding(self):
 
109
        """Test that run_bzr passes encoding to run_bzr_captured"""
 
110
        self.run_bzr('foo', 'bar')
 
111
        self.assertEqual(None, self.encoding)
 
112
        self.assertEqual(('foo', 'bar'), self.argv)
 
113
 
 
114
        self.run_bzr('foo', 'bar', encoding='baz')
 
115
        self.assertEqual('baz', self.encoding)
 
116
        self.assertEqual(('foo', 'bar'), self.argv)
 
117
 
 
118
    def test_retcode(self):
 
119
        """Test that run_bzr passes retcode to run_bzr_captured"""
 
120
        # Default is retcode == 0
 
121
        self.run_bzr('foo', 'bar')
 
122
        self.assertEqual(0, self.retcode)
 
123
        self.assertEqual(('foo', 'bar'), self.argv)
 
124
 
 
125
        self.run_bzr('foo', 'bar', retcode=1)
 
126
        self.assertEqual(1, self.retcode)
 
127
        self.assertEqual(('foo', 'bar'), self.argv)
 
128
 
 
129
        self.run_bzr('foo', 'bar', retcode=None)
 
130
        self.assertEqual(None, self.retcode)
 
131
        self.assertEqual(('foo', 'bar'), self.argv)
 
132
 
 
133
        self.run_bzr('foo', 'bar', retcode=3)
 
134
        self.assertEqual(3, self.retcode)
 
135
        self.assertEqual(('foo', 'bar'), self.argv)
90
136
 
91
137
    def test_stdin(self):
92
138
        # test that the stdin keyword to run_bzr is passed through to
96
142
        # should invoke it.
97
143
        self.run_bzr('foo', 'bar', stdin='gam')
98
144
        self.assertEqual('gam', self.stdin)
 
145
        self.assertEqual(('foo', 'bar'), self.argv)
 
146
 
99
147
        self.run_bzr('foo', 'bar', stdin='zippy')
100
148
        self.assertEqual('zippy', self.stdin)
 
149
        self.assertEqual(('foo', 'bar'), self.argv)
 
150
 
 
151
    def test_working_dir(self):
 
152
        """Test that run_bzr passes working_dir to run_bzr_captured"""
 
153
        self.run_bzr('foo', 'bar')
 
154
        self.assertEqual(None, self.working_dir)
 
155
        self.assertEqual(('foo', 'bar'), self.argv)
 
156
 
 
157
        self.run_bzr('foo', 'bar', working_dir='baz')
 
158
        self.assertEqual('baz', self.working_dir)
 
159
        self.assertEqual(('foo', 'bar'), self.argv)
101
160
 
102
161
 
103
162
class TestBenchmarkTests(TestCaseWithTransport):
132
191
        self.stdin = stdin
133
192
        self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
134
193
        self.factory = bzrlib.ui.ui_factory
 
194
        self.working_dir = osutils.getcwd()
135
195
        stdout.write('foo\n')
136
196
        stderr.write('bar\n')
137
197
        return 0
162
222
        self.assertEqual('bar\n', self.factory.stderr.getvalue())
163
223
        self.assertIsInstance(self.factory, bzrlib.tests.blackbox.TestUIFactory)
164
224
 
 
225
    def test_working_dir(self):
 
226
        self.build_tree(['one/', 'two/'])
 
227
        cwd = osutils.getcwd()
 
228
 
 
229
        # Default is to work in the current directory
 
230
        self.run_bzr_captured(['foo', 'bar'])
 
231
        self.assertEqual(cwd, self.working_dir)
 
232
 
 
233
        self.run_bzr_captured(['foo', 'bar'], working_dir=None)
 
234
        self.assertEqual(cwd, self.working_dir)
 
235
 
 
236
        # The function should be run in the alternative directory
 
237
        # but afterwards the current working dir shouldn't be changed
 
238
        self.run_bzr_captured(['foo', 'bar'], working_dir='one')
 
239
        self.assertNotEqual(cwd, self.working_dir)
 
240
        self.assertEndsWith(self.working_dir, 'one')
 
241
        self.assertEqual(cwd, osutils.getcwd())
 
242
 
 
243
        self.run_bzr_captured(['foo', 'bar'], working_dir='two')
 
244
        self.assertNotEqual(cwd, self.working_dir)
 
245
        self.assertEndsWith(self.working_dir, 'two')
 
246
        self.assertEqual(cwd, osutils.getcwd())
 
247
 
 
248
 
 
249
class TestRunBzrSubprocess(TestCaseWithTransport):
 
250
 
165
251
    def test_run_bzr_subprocess(self):
166
252
        """The run_bzr_helper_external comand behaves nicely."""
167
253
        result = self.run_bzr_subprocess('--version')
243
329
        self.assertEqual('it sure does!\n', out)
244
330
        self.assertEqual('', err)
245
331
 
 
332
    def test_run_bzr_subprocess_working_dir(self):
 
333
        """Test that we can specify the working dir for the child"""
 
334
        cwd = osutils.getcwd()
 
335
 
 
336
        self.make_branch_and_tree('.')
 
337
        self.make_branch_and_tree('one')
 
338
        self.make_branch_and_tree('two')
 
339
 
 
340
        def get_root(**kwargs):
 
341
            """Spawn a process to get the 'root' of the tree.
 
342
 
 
343
            You can pass in arbitrary new arguments. This just makes
 
344
            sure that the returned path doesn't have trailing whitespace.
 
345
            """
 
346
            return self.run_bzr_subprocess('root', **kwargs)[0].rstrip()
 
347
 
 
348
        self.assertEqual(cwd, get_root())
 
349
        self.assertEqual(cwd, get_root(working_dir=None))
 
350
        # Has our path changed?
 
351
        self.assertEqual(cwd, osutils.getcwd())
 
352
 
 
353
        dir1 = get_root(working_dir='one')
 
354
        self.assertEndsWith(dir1, 'one')
 
355
        self.assertEqual(cwd, osutils.getcwd())
 
356
 
 
357
        dir2 = get_root(working_dir='two')
 
358
        self.assertEndsWith(dir2, 'two')
 
359
        self.assertEqual(cwd, osutils.getcwd())
 
360
 
 
361
 
 
362
class TestBzrSubprocess(TestCaseWithTransport):
 
363
 
 
364
    def test_start_and_stop_bzr_subprocess(self):
 
365
        """We can start and perform other test actions while that process is
 
366
        still alive.
 
367
        """
 
368
        process = self.start_bzr_subprocess(['--version'])
 
369
        result = self.finish_bzr_subprocess(process)
 
370
        self.assertContainsRe(result[0], 'is free software')
 
371
        self.assertEqual('', result[1])
 
372
 
 
373
    def test_start_and_stop_bzr_subprocess_with_error(self):
 
374
        """finish_bzr_subprocess allows specification of the desired exit code.
 
375
        """
 
376
        process = self.start_bzr_subprocess(['--versionn'])
 
377
        result = self.finish_bzr_subprocess(process, retcode=3)
 
378
        self.assertEqual('', result[0])
 
379
        self.assertContainsRe(result[1], 'unknown command')
 
380
 
 
381
    def test_start_and_stop_bzr_subprocess_ignoring_retcode(self):
 
382
        """finish_bzr_subprocess allows the exit code to be ignored."""
 
383
        process = self.start_bzr_subprocess(['--versionn'])
 
384
        result = self.finish_bzr_subprocess(process, retcode=None)
 
385
        self.assertEqual('', result[0])
 
386
        self.assertContainsRe(result[1], 'unknown command')
 
387
 
 
388
    def test_start_and_stop_bzr_subprocess_with_unexpected_retcode(self):
 
389
        """finish_bzr_subprocess raises self.failureException if the retcode is
 
390
        not the expected one.
 
391
        """
 
392
        process = self.start_bzr_subprocess(['--versionn'])
 
393
        self.assertRaises(self.failureException, self.finish_bzr_subprocess,
 
394
                          process, retcode=0)
 
395
        
 
396
    def test_start_and_stop_bzr_subprocess_send_signal(self):
 
397
        """finish_bzr_subprocess raises self.failureException if the retcode is
 
398
        not the expected one.
 
399
        """
 
400
        process = self.start_bzr_subprocess(['wait-until-signalled'],
 
401
                                            skip_if_plan_to_signal=True)
 
402
        self.assertEqual('running\n', process.stdout.readline())
 
403
        result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
 
404
                                            retcode=3)
 
405
        self.assertEqual('', result[0])
 
406
        self.assertEqual('bzr: interrupted\n', result[1])
 
407
 
 
408
    def test_start_and_stop_working_dir(self):
 
409
        cwd = osutils.getcwd()
 
410
 
 
411
        self.make_branch_and_tree('one')
 
412
 
 
413
        process = self.start_bzr_subprocess(['root'], working_dir='one')
 
414
        result = self.finish_bzr_subprocess(process)
 
415
        self.assertEndsWith(result[0], 'one\n')
 
416
        self.assertEqual('', result[1])
 
417
        
246
418
 
247
419
class TestRunBzrError(ExternalBase):
248
420