← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_selftest.py

  • Committer: Robert Collins
  • Date: 2007-07-04 08:08:13 UTC
  • mfrom: (2572 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2587.
  • Revision ID: robertc@robertcollins.net-20070704080813-wzebx0r88fvwj5rq
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_selftest.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License version 2 as published by
5
 
# the Free Software Foundation.
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
6
7
#
7
8
# This program is distributed in the hope that it will be useful,
8
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
16
17
"""UI tests for the test framework."""
17
18
 
18
19
import os
 
20
import re
19
21
import signal
20
22
import sys
21
23
 
27
29
from bzrlib.tests import (
28
30
                          TestCase,
29
31
                          TestCaseInTempDir,
 
32
                          TestCaseWithMemoryTransport,
30
33
                          TestCaseWithTransport,
 
34
                          TestUIFactory,
31
35
                          TestSkipped,
32
36
                          )
 
37
from bzrlib.symbol_versioning import (
 
38
    zero_eighteen,
 
39
    )
33
40
from bzrlib.tests.blackbox import ExternalBase
34
41
 
35
42
 
65
72
        except ParamikoNotPresent:
66
73
            raise TestSkipped("Paramiko not present")
67
74
        old_transport = bzrlib.tests.default_transport
68
 
        old_root = TestCaseInTempDir.TEST_ROOT
69
 
        TestCaseInTempDir.TEST_ROOT = None
 
75
        old_root = TestCaseWithMemoryTransport.TEST_ROOT
 
76
        TestCaseWithMemoryTransport.TEST_ROOT = None
70
77
        try:
71
78
            TestOptions.current_test = "test_transport_set_to_sftp"
72
 
            stdout = self.capture('selftest --transport=sftp test_transport_set_to_sftp')
73
 
            
 
79
            stdout = self.run_bzr(
 
80
                'selftest --transport=sftp test_transport_set_to_sftp')[0]
74
81
            self.assertContainsRe(stdout, 'Ran 1 test')
75
82
            self.assertEqual(old_transport, bzrlib.tests.default_transport)
76
83
 
77
84
            TestOptions.current_test = "test_transport_set_to_memory"
78
 
            stdout = self.capture('selftest --transport=memory test_transport_set_to_memory')
 
85
            stdout = self.run_bzr(
 
86
                'selftest --transport=memory test_transport_set_to_memory')[0]
79
87
            self.assertContainsRe(stdout, 'Ran 1 test')
80
88
            self.assertEqual(old_transport, bzrlib.tests.default_transport)
81
89
        finally:
82
90
            bzrlib.tests.default_transport = old_transport
83
91
            TestOptions.current_test = None
84
 
            TestCaseInTempDir.TEST_ROOT = old_root
 
92
            TestCaseWithMemoryTransport.TEST_ROOT = old_root
85
93
 
86
94
 
87
95
class TestRunBzr(ExternalBase):
88
96
 
89
 
    def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None,
 
97
    def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
90
98
                         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.
 
99
        """Override _run_bzr_core to test how it is invoked by run_bzr.
 
100
 
 
101
        Attempts to run bzr from inside this class don't actually run it.
 
102
 
 
103
        We test how run_bzr actually invokes bzr in another location.
94
104
        Here we only need to test that it is run_bzr passes the right
95
 
        parameters to run_bzr_captured.
 
105
        parameters to run_bzr.
96
106
        """
97
 
        self.argv = argv
 
107
        self.argv = list(argv)
98
108
        self.retcode = retcode
99
109
        self.encoding = encoding
100
110
        self.stdin = stdin
101
111
        self.working_dir = working_dir
 
112
        return '', ''
102
113
 
103
114
    def test_args(self):
104
 
        """Test that run_bzr passes args correctly to run_bzr_captured"""
 
115
        """Test that run_bzr passes args correctly to _run_bzr_core"""
 
116
        ## self.callDeprecated(
 
117
        ##         ['passing varargs to run_bzr was deprecated in version 0.18.'],
 
118
        ##         self.run_bzr,
 
119
        ##         'arg1', 'arg2', 'arg3', retcode=1)
105
120
        self.run_bzr('arg1', 'arg2', 'arg3', retcode=1)
106
 
        self.assertEqual(('arg1', 'arg2', 'arg3'), self.argv)
 
121
        self.assertEqual(['arg1', 'arg2', 'arg3'], self.argv)
107
122
 
108
123
    def test_encoding(self):
109
 
        """Test that run_bzr passes encoding to run_bzr_captured"""
110
 
        self.run_bzr('foo', 'bar')
 
124
        """Test that run_bzr passes encoding to _run_bzr_core"""
 
125
        self.run_bzr('foo bar')
111
126
        self.assertEqual(None, self.encoding)
112
 
        self.assertEqual(('foo', 'bar'), self.argv)
 
127
        self.assertEqual(['foo', 'bar'], self.argv)
113
128
 
114
 
        self.run_bzr('foo', 'bar', encoding='baz')
 
129
        self.run_bzr('foo bar', encoding='baz')
115
130
        self.assertEqual('baz', self.encoding)
116
 
        self.assertEqual(('foo', 'bar'), self.argv)
 
131
        self.assertEqual(['foo', 'bar'], self.argv)
117
132
 
118
133
    def test_retcode(self):
119
 
        """Test that run_bzr passes retcode to run_bzr_captured"""
 
134
        """Test that run_bzr passes retcode to _run_bzr_core"""
120
135
        # Default is retcode == 0
121
 
        self.run_bzr('foo', 'bar')
 
136
        self.run_bzr('foo bar')
122
137
        self.assertEqual(0, self.retcode)
123
 
        self.assertEqual(('foo', 'bar'), self.argv)
 
138
        self.assertEqual(['foo', 'bar'], self.argv)
124
139
 
125
 
        self.run_bzr('foo', 'bar', retcode=1)
 
140
        self.run_bzr('foo bar', retcode=1)
126
141
        self.assertEqual(1, self.retcode)
127
 
        self.assertEqual(('foo', 'bar'), self.argv)
 
142
        self.assertEqual(['foo', 'bar'], self.argv)
128
143
 
129
 
        self.run_bzr('foo', 'bar', retcode=None)
 
144
        self.run_bzr('foo bar', retcode=None)
130
145
        self.assertEqual(None, self.retcode)
131
 
        self.assertEqual(('foo', 'bar'), self.argv)
 
146
        self.assertEqual(['foo', 'bar'], self.argv)
132
147
 
133
 
        self.run_bzr('foo', 'bar', retcode=3)
 
148
        self.run_bzr(['foo', 'bar'], retcode=3)
134
149
        self.assertEqual(3, self.retcode)
135
 
        self.assertEqual(('foo', 'bar'), self.argv)
 
150
        self.assertEqual(['foo', 'bar'], self.argv)
136
151
 
137
152
    def test_stdin(self):
138
153
        # test that the stdin keyword to run_bzr is passed through to
139
 
        # run_bzr_captured as-is. We do this by overriding
140
 
        # run_bzr_captured in this class, and then calling run_bzr,
141
 
        # which is a convenience function for run_bzr_captured, so 
 
154
        # _run_bzr_core as-is. We do this by overriding
 
155
        # _run_bzr_core in this class, and then calling run_bzr,
 
156
        # which is a convenience function for _run_bzr_core, so 
142
157
        # should invoke it.
143
 
        self.run_bzr('foo', 'bar', stdin='gam')
 
158
        self.run_bzr('foo bar', stdin='gam')
144
159
        self.assertEqual('gam', self.stdin)
145
 
        self.assertEqual(('foo', 'bar'), self.argv)
 
160
        self.assertEqual(['foo', 'bar'], self.argv)
146
161
 
147
 
        self.run_bzr('foo', 'bar', stdin='zippy')
 
162
        self.run_bzr('foo bar', stdin='zippy')
148
163
        self.assertEqual('zippy', self.stdin)
149
 
        self.assertEqual(('foo', 'bar'), self.argv)
 
164
        self.assertEqual(['foo', 'bar'], self.argv)
150
165
 
151
166
    def test_working_dir(self):
152
 
        """Test that run_bzr passes working_dir to run_bzr_captured"""
153
 
        self.run_bzr('foo', 'bar')
 
167
        """Test that run_bzr passes working_dir to _run_bzr_core"""
 
168
        self.run_bzr('foo bar')
154
169
        self.assertEqual(None, self.working_dir)
155
 
        self.assertEqual(('foo', 'bar'), self.argv)
 
170
        self.assertEqual(['foo', 'bar'], self.argv)
156
171
 
157
 
        self.run_bzr('foo', 'bar', working_dir='baz')
 
172
        self.run_bzr('foo bar', working_dir='baz')
158
173
        self.assertEqual('baz', self.working_dir)
159
 
        self.assertEqual(('foo', 'bar'), self.argv)
 
174
        self.assertEqual(['foo', 'bar'], self.argv)
160
175
 
161
176
 
162
177
class TestBenchmarkTests(TestCaseWithTransport):
165
180
        """bzr selftest --benchmark should not run the default test suite."""
166
181
        # We test this by passing a regression test name to --benchmark, which
167
182
        # should result in 0 rests run.
168
 
        old_root = TestCaseInTempDir.TEST_ROOT
 
183
        old_root = TestCaseWithMemoryTransport.TEST_ROOT
169
184
        try:
170
 
            TestCaseInTempDir.TEST_ROOT = None
171
 
            out, err = self.run_bzr('selftest', '--benchmark', 'workingtree_implementations')
 
185
            TestCaseWithMemoryTransport.TEST_ROOT = None
 
186
            out, err = self.run_bzr(['selftest', '--benchmark',
 
187
                'workingtree_implementations'])
172
188
        finally:
173
 
            TestCaseInTempDir.TEST_ROOT = old_root
 
189
            TestCaseWithMemoryTransport.TEST_ROOT = old_root
174
190
        self.assertContainsRe(out, 'Ran 0 tests.*\n\nOK')
175
191
        self.assertEqual(
176
 
            'running tests...\ntests passed\n',
 
192
            'tests passed\n',
177
193
            err)
178
194
        benchfile = open(".perf_history", "rt")
179
195
        try:
197
213
        return 0
198
214
 
199
215
    def test_stdin(self):
200
 
        # test that the stdin keyword to run_bzr_captured is passed through to
 
216
        # test that the stdin keyword to _run_bzr_core is passed through to
201
217
        # apply_redirected as a StringIO. We do this by overriding
202
 
        # apply_redirected in this class, and then calling run_bzr_captured,
 
218
        # apply_redirected in this class, and then calling _run_bzr_core,
203
219
        # which calls apply_redirected. 
204
 
        self.run_bzr_captured(['foo', 'bar'], stdin='gam')
 
220
        self.run_bzr(['foo', 'bar'], stdin='gam')
205
221
        self.assertEqual('gam', self.stdin.read())
206
222
        self.assertTrue(self.stdin is self.factory_stdin)
207
 
        self.run_bzr_captured(['foo', 'bar'], stdin='zippy')
 
223
        self.run_bzr(['foo', 'bar'], stdin='zippy')
208
224
        self.assertEqual('zippy', self.stdin.read())
209
225
        self.assertTrue(self.stdin is self.factory_stdin)
210
226
 
211
227
    def test_ui_factory(self):
212
 
        # each invocation of self.run_bzr_captured should get its own UI
213
 
        # factory, which is an instance of TestUIFactory, with stdout and
214
 
        # stderr attached to the stdout and stderr of the invoked
215
 
        # run_bzr_captured
 
228
        # each invocation of self.run_bzr should get its
 
229
        # own UI factory, which is an instance of TestUIFactory,
 
230
        # with stdin, stdout and stderr attached to the stdin,
 
231
        # stdout and stderr of the invoked run_bzr
216
232
        current_factory = bzrlib.ui.ui_factory
217
 
        self.run_bzr_captured(['foo'])
 
233
        self.run_bzr(['foo'])
218
234
        self.failIf(current_factory is self.factory)
219
235
        self.assertNotEqual(sys.stdout, self.factory.stdout)
220
236
        self.assertNotEqual(sys.stderr, self.factory.stderr)
221
237
        self.assertEqual('foo\n', self.factory.stdout.getvalue())
222
238
        self.assertEqual('bar\n', self.factory.stderr.getvalue())
223
 
        self.assertIsInstance(self.factory, bzrlib.tests.blackbox.TestUIFactory)
 
239
        self.assertIsInstance(self.factory, TestUIFactory)
224
240
 
225
241
    def test_working_dir(self):
226
242
        self.build_tree(['one/', 'two/'])
227
243
        cwd = osutils.getcwd()
228
244
 
229
245
        # Default is to work in the current directory
230
 
        self.run_bzr_captured(['foo', 'bar'])
 
246
        self.run_bzr(['foo', 'bar'])
231
247
        self.assertEqual(cwd, self.working_dir)
232
248
 
233
 
        self.run_bzr_captured(['foo', 'bar'], working_dir=None)
 
249
        self.run_bzr(['foo', 'bar'], working_dir=None)
234
250
        self.assertEqual(cwd, self.working_dir)
235
251
 
236
252
        # The function should be run in the alternative directory
237
253
        # but afterwards the current working dir shouldn't be changed
238
 
        self.run_bzr_captured(['foo', 'bar'], working_dir='one')
 
254
        self.run_bzr(['foo', 'bar'], working_dir='one')
239
255
        self.assertNotEqual(cwd, self.working_dir)
240
256
        self.assertEndsWith(self.working_dir, 'one')
241
257
        self.assertEqual(cwd, osutils.getcwd())
242
258
 
243
 
        self.run_bzr_captured(['foo', 'bar'], working_dir='two')
 
259
        self.run_bzr(['foo', 'bar'], working_dir='two')
244
260
        self.assertNotEqual(cwd, self.working_dir)
245
261
        self.assertEndsWith(self.working_dir, 'two')
246
262
        self.assertEqual(cwd, osutils.getcwd())
260
276
        self.assertContainsRe(result[1], 'unknown command')
261
277
        err = self.run_bzr_subprocess('merge', '--merge-type', 'magic merge', 
262
278
                                      retcode=3)[1]
263
 
        self.assertContainsRe(err, 'No known merge type magic merge')
 
279
        self.assertContainsRe(err, 'Bad value "magic merge" for option'
 
280
                              ' "merge-type"')
264
281
 
265
282
    def test_run_bzr_subprocess_env(self):
266
283
        """run_bzr_subprocess can set environment variables in the child only.
326
343
        out, err = self.run_bzr_subprocess('rocks',
327
344
                        env_changes={'NON_EXISTANT_ENV_VAR':None},
328
345
                        universal_newlines=True)
329
 
        self.assertEqual('it sure does!\n', out)
 
346
        self.assertEqual('It sure does!\n', out)
330
347
        self.assertEqual('', err)
331
348
 
332
349
    def test_run_bzr_subprocess_working_dir(self):
359
376
        self.assertEqual(cwd, osutils.getcwd())
360
377
 
361
378
 
 
379
class _DontSpawnProcess(Exception):
 
380
    """A simple exception which just allows us to skip unnecessary steps"""
 
381
 
 
382
 
 
383
class TestRunBzrSubprocessCommands(TestCaseWithTransport):
 
384
 
 
385
    def _popen(self, *args, **kwargs):
 
386
        """Record the command that is run, so that we can ensure it is correct"""
 
387
        self._popen_args = args
 
388
        self._popen_kwargs = kwargs
 
389
        raise _DontSpawnProcess()
 
390
 
 
391
    def test_run_bzr_subprocess_no_plugins(self):
 
392
        self.assertRaises(_DontSpawnProcess, self.run_bzr_subprocess)
 
393
        command = self._popen_args[0]
 
394
        self.assertEqual(sys.executable, command[0])
 
395
        self.assertEqual(self.get_bzr_path(), command[1])
 
396
        self.assertEqual(['--no-plugins'], command[2:])
 
397
 
 
398
    def test_allow_plugins(self):
 
399
        self.assertRaises(_DontSpawnProcess,
 
400
                          self.run_bzr_subprocess, allow_plugins=True)
 
401
        command = self._popen_args[0]
 
402
        self.assertEqual([], command[2:])
 
403
 
 
404
 
362
405
class TestBzrSubprocess(TestCaseWithTransport):
363
406
 
364
407
    def test_start_and_stop_bzr_subprocess(self):
411
454
        self.make_branch_and_tree('one')
412
455
 
413
456
        process = self.start_bzr_subprocess(['root'], working_dir='one')
414
 
        result = self.finish_bzr_subprocess(process)
 
457
        result = self.finish_bzr_subprocess(process, universal_newlines=True)
415
458
        self.assertEndsWith(result[0], 'one\n')
416
459
        self.assertEqual('', result[1])
417
 
        
 
460
 
418
461
 
419
462
class TestRunBzrError(ExternalBase):
420
463
 
421
464
    def test_run_bzr_error(self):
422
 
        out, err = self.run_bzr_error(['^$'], 'rocks', retcode=0)
423
 
        self.assertEqual(out, 'it sure does!\n')
424
 
 
425
 
        out, err = self.run_bzr_error(["'foobarbaz' is not a versioned file"],
426
 
                                      'file-id', 'foobarbaz')
 
465
        out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=0)
 
466
        self.assertEqual(out, 'It sure does!\n')
 
467
 
 
468
        out, err = self.run_bzr_error(["bzr: ERROR: foobarbaz is not versioned"],
 
469
                                      ['file-id', 'foobarbaz'])
 
470
 
 
471
 
 
472
class TestSelftestCleanOutput(TestCaseInTempDir):
 
473
 
 
474
    def test_clean_output(self):
 
475
        # check that 'bzr selftest --clean-output' works correct
 
476
        dirs = ('test0000.tmp', 'test0001.tmp', 'bzrlib', 'tests')
 
477
        files = ('bzr', 'setup.py', 'test9999.tmp')
 
478
        for i in dirs:
 
479
            os.mkdir(i)
 
480
        for i in files:
 
481
            f = file(i, 'wb')
 
482
            f.write('content of ')
 
483
            f.write(i)
 
484
            f.close()
 
485
 
 
486
        root = os.getcwdu()
 
487
        before = os.listdir(root)
 
488
        before.sort()
 
489
        self.assertEquals(['bzr','bzrlib','setup.py',
 
490
                           'test0000.tmp','test0001.tmp',
 
491
                           'test9999.tmp','tests'],
 
492
                           before)
 
493
 
 
494
        out, err = self.run_bzr(['selftest','--clean-output'],
 
495
                                        working_dir=root)
 
496
 
 
497
        self.assertEquals(['delete directory: test0000.tmp',
 
498
                          'delete directory: test0001.tmp'],
 
499
                          sorted(out.splitlines()))
 
500
        self.assertEquals('', err)
 
501
 
 
502
        after = os.listdir(root)
 
503
        after.sort()
 
504
        self.assertEquals(['bzr','bzrlib','setup.py',
 
505
                           'test9999.tmp','tests'],
 
506
                           after)
 
507
 
 
508
 
 
509
class TestSelftestListOnly(TestCase):
 
510
 
 
511
    @staticmethod
 
512
    def _parse_test_list(lines, newlines_in_header=1):
 
513
        "Parse a list of lines into a tuple of 3 lists (header,body,footer)."
 
514
 
 
515
        in_header = True
 
516
        in_footer = False
 
517
        header = []
 
518
        body = []
 
519
        footer = []
 
520
        header_newlines_found = 0 
 
521
        for line in lines:
 
522
            if in_header:
 
523
                if line == '':
 
524
                    header_newlines_found += 1
 
525
                    if header_newlines_found >= newlines_in_header:
 
526
                        in_header = False
 
527
                        continue
 
528
                header.append(line)
 
529
            elif not in_footer:
 
530
                if line.startswith('-------'):
 
531
                    in_footer = True
 
532
                else:
 
533
                    body.append(line)
 
534
            else:
 
535
                footer.append(line)
 
536
        # If the last body line is blank, drop it off the list
 
537
        if len(body) > 0 and body[-1] == '':
 
538
            body.pop()                
 
539
        return (header,body,footer)
 
540
 
 
541
    def test_list_only(self):
 
542
        # check that bzr selftest --list-only works correctly
 
543
        out,err = self.run_bzr(['selftest', 'selftest',
 
544
            '--list-only'])
 
545
        self.assertEndsWith(err, 'tests passed\n')
 
546
        (header,body,footer) = self._parse_test_list(out.splitlines())
 
547
        num_tests = len(body)
 
548
        self.assertContainsRe(footer[0], 'Listed %s tests in' % num_tests)
 
549
 
 
550
    def test_list_only_filtered(self):
 
551
        # check that a filtered --list-only works, both include and exclude
 
552
        out_all,err_all = self.run_bzr(['selftest', '--list-only'])
 
553
        tests_all = self._parse_test_list(out_all.splitlines())[1]
 
554
        out_incl,err_incl = self.run_bzr(['selftest', '--list-only',
 
555
          'selftest'])
 
556
        tests_incl = self._parse_test_list(out_incl.splitlines())[1]
 
557
        self.assertSubset(tests_incl, tests_all)
 
558
        out_excl,err_excl = self.run_bzr(['selftest', '--list-only',
 
559
          '--exclude', 'selftest'])
 
560
        tests_excl = self._parse_test_list(out_excl.splitlines())[1]
 
561
        self.assertSubset(tests_excl, tests_all)
 
562
        set_incl = set(tests_incl)
 
563
        set_excl = set(tests_excl)
 
564
        intersection = set_incl.intersection(set_excl)
 
565
        self.assertEquals(0, len(intersection))
 
566
        self.assertEquals(len(tests_all), len(tests_incl) + len(tests_excl))
 
567
 
 
568
    def test_list_only_random(self):
 
569
        # check that --randomize works correctly
 
570
        out_all,err_all = self.run_bzr(['selftest', '--list-only',
 
571
            'selftest'])
 
572
        tests_all = self._parse_test_list(out_all.splitlines())[1]
 
573
        # XXX: It looks like there are some orders for generating tests that
 
574
        # fail as of 20070504 - maybe because of import order dependencies.
 
575
        # So unfortunately this will rarely intermittently fail at the moment.
 
576
        # -- mbp 20070504
 
577
        out_rand,err_rand = self.run_bzr(['selftest', '--list-only',
 
578
            'selftest', '--randomize', 'now'])
 
579
        (header_rand,tests_rand,dummy) = self._parse_test_list(
 
580
            out_rand.splitlines(), 2)
 
581
        self.assertNotEqual(tests_all, tests_rand)
 
582
        self.assertEqual(sorted(tests_all), sorted(tests_rand))
 
583
        # Check that the seed can be reused to get the exact same order
 
584
        seed_re = re.compile('Randomizing test order using seed (\w+)')
 
585
        match_obj = seed_re.search(header_rand[-1])
 
586
        seed = match_obj.group(1)
 
587
        out_rand2,err_rand2 = self.run_bzr(['selftest', '--list-only',
 
588
            'selftest', '--randomize', seed])
 
589
        (header_rand2,tests_rand2,dummy) = self._parse_test_list(
 
590
            out_rand2.splitlines(), 2)
 
591
        self.assertEqual(tests_rand, tests_rand2)
 
592