← 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: John Arbash Meinel
  • Date: 2007-05-04 18:59:36 UTC
  • mto: This revision was merged to the branch mainline in revision 2643.
  • Revision ID: john@arbash-meinel.com-20070504185936-1mjdoqmtz74xe5mg
A C implementation of _fields_to_entry_0_parents drops the time from 400ms to 330ms for a 21k-entry tree

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_selftest.py
1
 
# Copyright (C) 2005, 2007 Canonical Ltd
 
1
# Copyright (C) 2005 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
34
34
                          TestUIFactory,
35
35
                          TestSkipped,
36
36
                          )
37
 
from bzrlib.symbol_versioning import (
38
 
    zero_eighteen,
39
 
    )
40
37
from bzrlib.tests.blackbox import ExternalBase
41
38
 
42
39
 
76
73
        TestCaseWithMemoryTransport.TEST_ROOT = None
77
74
        try:
78
75
            TestOptions.current_test = "test_transport_set_to_sftp"
79
 
            stdout = self.run_bzr(
80
 
                'selftest --transport=sftp test_transport_set_to_sftp')[0]
 
76
            stdout = self.capture('selftest --transport=sftp test_transport_set_to_sftp')
 
77
            
81
78
            self.assertContainsRe(stdout, 'Ran 1 test')
82
79
            self.assertEqual(old_transport, bzrlib.tests.default_transport)
83
80
 
84
81
            TestOptions.current_test = "test_transport_set_to_memory"
85
 
            stdout = self.run_bzr(
86
 
                'selftest --transport=memory test_transport_set_to_memory')[0]
 
82
            stdout = self.capture('selftest --transport=memory test_transport_set_to_memory')
87
83
            self.assertContainsRe(stdout, 'Ran 1 test')
88
84
            self.assertEqual(old_transport, bzrlib.tests.default_transport)
89
85
        finally:
94
90
 
95
91
class TestRunBzr(ExternalBase):
96
92
 
97
 
    def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
 
93
    def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None,
98
94
                         working_dir=None):
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.
 
95
        """Override run_bzr_captured to test how it is invoked by run_bzr.
 
96
 
 
97
        We test how run_bzr_captured actually invokes bzr in another location.
104
98
        Here we only need to test that it is run_bzr passes the right
105
 
        parameters to run_bzr.
 
99
        parameters to run_bzr_captured.
106
100
        """
107
 
        self.argv = list(argv)
 
101
        self.argv = argv
108
102
        self.retcode = retcode
109
103
        self.encoding = encoding
110
104
        self.stdin = stdin
111
105
        self.working_dir = working_dir
112
106
        return '', ''
113
107
 
 
108
    def test_args(self):
 
109
        """Test that run_bzr passes args correctly to run_bzr_captured"""
 
110
        self.run_bzr('arg1', 'arg2', 'arg3', retcode=1)
 
111
        self.assertEqual(('arg1', 'arg2', 'arg3'), self.argv)
 
112
 
114
113
    def test_encoding(self):
115
 
        """Test that run_bzr passes encoding to _run_bzr_core"""
116
 
        self.run_bzr('foo bar')
 
114
        """Test that run_bzr passes encoding to run_bzr_captured"""
 
115
        self.run_bzr('foo', 'bar')
117
116
        self.assertEqual(None, self.encoding)
118
 
        self.assertEqual(['foo', 'bar'], self.argv)
 
117
        self.assertEqual(('foo', 'bar'), self.argv)
119
118
 
120
 
        self.run_bzr('foo bar', encoding='baz')
 
119
        self.run_bzr('foo', 'bar', encoding='baz')
121
120
        self.assertEqual('baz', self.encoding)
122
 
        self.assertEqual(['foo', 'bar'], self.argv)
 
121
        self.assertEqual(('foo', 'bar'), self.argv)
123
122
 
124
123
    def test_retcode(self):
125
 
        """Test that run_bzr passes retcode to _run_bzr_core"""
 
124
        """Test that run_bzr passes retcode to run_bzr_captured"""
126
125
        # Default is retcode == 0
127
 
        self.run_bzr('foo bar')
 
126
        self.run_bzr('foo', 'bar')
128
127
        self.assertEqual(0, self.retcode)
129
 
        self.assertEqual(['foo', 'bar'], self.argv)
 
128
        self.assertEqual(('foo', 'bar'), self.argv)
130
129
 
131
 
        self.run_bzr('foo bar', retcode=1)
 
130
        self.run_bzr('foo', 'bar', retcode=1)
132
131
        self.assertEqual(1, self.retcode)
133
 
        self.assertEqual(['foo', 'bar'], self.argv)
 
132
        self.assertEqual(('foo', 'bar'), self.argv)
134
133
 
135
 
        self.run_bzr('foo bar', retcode=None)
 
134
        self.run_bzr('foo', 'bar', retcode=None)
136
135
        self.assertEqual(None, self.retcode)
137
 
        self.assertEqual(['foo', 'bar'], self.argv)
 
136
        self.assertEqual(('foo', 'bar'), self.argv)
138
137
 
139
 
        self.run_bzr(['foo', 'bar'], retcode=3)
 
138
        self.run_bzr('foo', 'bar', retcode=3)
140
139
        self.assertEqual(3, self.retcode)
141
 
        self.assertEqual(['foo', 'bar'], self.argv)
 
140
        self.assertEqual(('foo', 'bar'), self.argv)
142
141
 
143
142
    def test_stdin(self):
144
143
        # test that the stdin keyword to run_bzr is passed through to
145
 
        # _run_bzr_core as-is. We do this by overriding
146
 
        # _run_bzr_core in this class, and then calling run_bzr,
147
 
        # which is a convenience function for _run_bzr_core, so 
 
144
        # run_bzr_captured as-is. We do this by overriding
 
145
        # run_bzr_captured in this class, and then calling run_bzr,
 
146
        # which is a convenience function for run_bzr_captured, so 
148
147
        # should invoke it.
149
 
        self.run_bzr('foo bar', stdin='gam')
 
148
        self.run_bzr('foo', 'bar', stdin='gam')
150
149
        self.assertEqual('gam', self.stdin)
151
 
        self.assertEqual(['foo', 'bar'], self.argv)
 
150
        self.assertEqual(('foo', 'bar'), self.argv)
152
151
 
153
 
        self.run_bzr('foo bar', stdin='zippy')
 
152
        self.run_bzr('foo', 'bar', stdin='zippy')
154
153
        self.assertEqual('zippy', self.stdin)
155
 
        self.assertEqual(['foo', 'bar'], self.argv)
 
154
        self.assertEqual(('foo', 'bar'), self.argv)
156
155
 
157
156
    def test_working_dir(self):
158
 
        """Test that run_bzr passes working_dir to _run_bzr_core"""
159
 
        self.run_bzr('foo bar')
 
157
        """Test that run_bzr passes working_dir to run_bzr_captured"""
 
158
        self.run_bzr('foo', 'bar')
160
159
        self.assertEqual(None, self.working_dir)
161
 
        self.assertEqual(['foo', 'bar'], self.argv)
 
160
        self.assertEqual(('foo', 'bar'), self.argv)
162
161
 
163
 
        self.run_bzr('foo bar', working_dir='baz')
 
162
        self.run_bzr('foo', 'bar', working_dir='baz')
164
163
        self.assertEqual('baz', self.working_dir)
165
 
        self.assertEqual(['foo', 'bar'], self.argv)
166
 
 
167
 
    def test_reject_extra_keyword_arguments(self):
168
 
        self.assertRaises(TypeError, self.run_bzr, "foo bar",
169
 
                          error_regex=['error message'])
 
164
        self.assertEqual(('foo', 'bar'), self.argv)
170
165
 
171
166
 
172
167
class TestBenchmarkTests(TestCaseWithTransport):
174
169
    def test_benchmark_runs_benchmark_tests(self):
175
170
        """bzr selftest --benchmark should not run the default test suite."""
176
171
        # We test this by passing a regression test name to --benchmark, which
177
 
        # should result in 0 tests run.
 
172
        # should result in 0 rests run.
178
173
        old_root = TestCaseWithMemoryTransport.TEST_ROOT
179
174
        try:
180
175
            TestCaseWithMemoryTransport.TEST_ROOT = None
181
 
            out, err = self.run_bzr('selftest --benchmark'
182
 
                                    ' workingtree_implementations')
 
176
            out, err = self.run_bzr('selftest', '--benchmark', 'workingtree_implementations')
183
177
        finally:
184
178
            TestCaseWithMemoryTransport.TEST_ROOT = old_root
185
179
        self.assertContainsRe(out, 'Ran 0 tests.*\n\nOK')
208
202
        return 0
209
203
 
210
204
    def test_stdin(self):
211
 
        # test that the stdin keyword to _run_bzr_core is passed through to
 
205
        # test that the stdin keyword to run_bzr_captured is passed through to
212
206
        # apply_redirected as a StringIO. We do this by overriding
213
 
        # apply_redirected in this class, and then calling _run_bzr_core,
 
207
        # apply_redirected in this class, and then calling run_bzr_captured,
214
208
        # which calls apply_redirected. 
215
 
        self.run_bzr(['foo', 'bar'], stdin='gam')
 
209
        self.run_bzr_captured(['foo', 'bar'], stdin='gam')
216
210
        self.assertEqual('gam', self.stdin.read())
217
211
        self.assertTrue(self.stdin is self.factory_stdin)
218
 
        self.run_bzr(['foo', 'bar'], stdin='zippy')
 
212
        self.run_bzr_captured(['foo', 'bar'], stdin='zippy')
219
213
        self.assertEqual('zippy', self.stdin.read())
220
214
        self.assertTrue(self.stdin is self.factory_stdin)
221
215
 
222
216
    def test_ui_factory(self):
223
 
        # each invocation of self.run_bzr should get its
 
217
        # each invocation of self.run_bzr_captured should get its
224
218
        # own UI factory, which is an instance of TestUIFactory,
225
219
        # with stdin, stdout and stderr attached to the stdin,
226
 
        # stdout and stderr of the invoked run_bzr
 
220
        # stdout and stderr of the invoked run_bzr_captured
227
221
        current_factory = bzrlib.ui.ui_factory
228
 
        self.run_bzr(['foo'])
 
222
        self.run_bzr_captured(['foo'])
229
223
        self.failIf(current_factory is self.factory)
230
224
        self.assertNotEqual(sys.stdout, self.factory.stdout)
231
225
        self.assertNotEqual(sys.stderr, self.factory.stderr)
238
232
        cwd = osutils.getcwd()
239
233
 
240
234
        # Default is to work in the current directory
241
 
        self.run_bzr(['foo', 'bar'])
 
235
        self.run_bzr_captured(['foo', 'bar'])
242
236
        self.assertEqual(cwd, self.working_dir)
243
237
 
244
 
        self.run_bzr(['foo', 'bar'], working_dir=None)
 
238
        self.run_bzr_captured(['foo', 'bar'], working_dir=None)
245
239
        self.assertEqual(cwd, self.working_dir)
246
240
 
247
241
        # The function should be run in the alternative directory
248
242
        # but afterwards the current working dir shouldn't be changed
249
 
        self.run_bzr(['foo', 'bar'], working_dir='one')
 
243
        self.run_bzr_captured(['foo', 'bar'], working_dir='one')
250
244
        self.assertNotEqual(cwd, self.working_dir)
251
245
        self.assertEndsWith(self.working_dir, 'one')
252
246
        self.assertEqual(cwd, osutils.getcwd())
253
247
 
254
 
        self.run_bzr(['foo', 'bar'], working_dir='two')
 
248
        self.run_bzr_captured(['foo', 'bar'], working_dir='two')
255
249
        self.assertNotEqual(cwd, self.working_dir)
256
250
        self.assertEndsWith(self.working_dir, 'two')
257
251
        self.assertEqual(cwd, osutils.getcwd())
262
256
    def test_run_bzr_subprocess(self):
263
257
        """The run_bzr_helper_external comand behaves nicely."""
264
258
        result = self.run_bzr_subprocess('--version')
265
 
        result = self.run_bzr_subprocess(['--version'])
266
259
        result = self.run_bzr_subprocess('--version', retcode=None)
267
260
        self.assertContainsRe(result[0], 'is free software')
268
261
        self.assertRaises(AssertionError, self.run_bzr_subprocess, 
270
263
        result = self.run_bzr_subprocess('--versionn', retcode=3)
271
264
        result = self.run_bzr_subprocess('--versionn', retcode=None)
272
265
        self.assertContainsRe(result[1], 'unknown command')
273
 
        err = self.run_bzr_subprocess(['merge', '--merge-type',
274
 
                                      'magic merge'], retcode=3)[1]
 
266
        err = self.run_bzr_subprocess('merge', '--merge-type', 'magic merge', 
 
267
                                      retcode=3)[1]
275
268
        self.assertContainsRe(err, 'Bad value "magic merge" for option'
276
269
                              ' "merge-type"')
277
 
        self.callDeprecated(['passing varargs to run_bzr_subprocess was'
278
 
                             ' deprecated in version 0.91.'],
279
 
                            self.run_bzr_subprocess,
280
 
                            'arg1', 'arg2', 'arg3', retcode=3)
281
270
 
282
271
    def test_run_bzr_subprocess_env(self):
283
272
        """run_bzr_subprocess can set environment variables in the child only.
389
378
        raise _DontSpawnProcess()
390
379
 
391
380
    def test_run_bzr_subprocess_no_plugins(self):
392
 
        self.assertRaises(_DontSpawnProcess, self.run_bzr_subprocess, '')
 
381
        self.assertRaises(_DontSpawnProcess, self.run_bzr_subprocess)
393
382
        command = self._popen_args[0]
394
383
        self.assertEqual(sys.executable, command[0])
395
384
        self.assertEqual(self.get_bzr_path(), command[1])
397
386
 
398
387
    def test_allow_plugins(self):
399
388
        self.assertRaises(_DontSpawnProcess,
400
 
                          self.run_bzr_subprocess, '', allow_plugins=True)
 
389
                          self.run_bzr_subprocess, allow_plugins=True)
401
390
        command = self._popen_args[0]
402
391
        self.assertEqual([], command[2:])
403
392
 
434
423
        """
435
424
        process = self.start_bzr_subprocess(['--versionn'])
436
425
        self.assertRaises(self.failureException, self.finish_bzr_subprocess,
437
 
                          process)
 
426
                          process, retcode=0)
438
427
        
439
428
    def test_start_and_stop_bzr_subprocess_send_signal(self):
440
429
        """finish_bzr_subprocess raises self.failureException if the retcode is
462
451
class TestRunBzrError(ExternalBase):
463
452
 
464
453
    def test_run_bzr_error(self):
465
 
        # retcode=0 is specially needed here because run_bzr_error expects
466
 
        # an error (oddly enough) but we want to test the case of not
467
 
        # actually getting one
468
 
        out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=0)
 
454
        out, err = self.run_bzr_error(['^$'], 'rocks', retcode=0)
469
455
        self.assertEqual(out, 'It sure does!\n')
470
 
        # now test actually getting an error
471
 
        out, err = self.run_bzr_error(
472
 
                ["bzr: ERROR: foobarbaz is not versioned"],
473
 
                ['file-id', 'foobarbaz'])
 
456
 
 
457
        out, err = self.run_bzr_error(["bzr: ERROR: foobarbaz is not versioned"],
 
458
                                      'file-id', 'foobarbaz')
 
459
 
 
460
 
 
461
class TestSelftestCleanOutput(TestCaseInTempDir):
 
462
 
 
463
    def test_clean_output(self):
 
464
        # check that 'bzr selftest --clean-output' works correct
 
465
        dirs = ('test0000.tmp', 'test0001.tmp', 'bzrlib', 'tests')
 
466
        files = ('bzr', 'setup.py', 'test9999.tmp')
 
467
        for i in dirs:
 
468
            os.mkdir(i)
 
469
        for i in files:
 
470
            f = file(i, 'wb')
 
471
            f.write('content of ')
 
472
            f.write(i)
 
473
            f.close()
 
474
 
 
475
        root = os.getcwdu()
 
476
        before = os.listdir(root)
 
477
        before.sort()
 
478
        self.assertEquals(['bzr','bzrlib','setup.py',
 
479
                           'test0000.tmp','test0001.tmp',
 
480
                           'test9999.tmp','tests'],
 
481
                           before)
 
482
 
 
483
        out,err = self.run_bzr_captured(['selftest','--clean-output'],
 
484
                                        working_dir=root)
 
485
 
 
486
        self.assertEquals(['delete directory: test0000.tmp',
 
487
                          'delete directory: test0001.tmp'],
 
488
                          sorted(out.splitlines()))
 
489
        self.assertEquals('', err)
 
490
 
 
491
        after = os.listdir(root)
 
492
        after.sort()
 
493
        self.assertEquals(['bzr','bzrlib','setup.py',
 
494
                           'test9999.tmp','tests'],
 
495
                           after)
474
496
 
475
497
 
476
498
class TestSelftestListOnly(TestCase):
478
500
    @staticmethod
479
501
    def _parse_test_list(lines, newlines_in_header=1):
480
502
        "Parse a list of lines into a tuple of 3 lists (header,body,footer)."
 
503
 
481
504
        in_header = True
482
505
        in_footer = False
483
506
        header = []
484
507
        body = []
485
508
        footer = []
486
 
        header_newlines_found = 0
 
509
        header_newlines_found = 0 
487
510
        for line in lines:
488
511
            if in_header:
489
512
                if line == '':
501
524
                footer.append(line)
502
525
        # If the last body line is blank, drop it off the list
503
526
        if len(body) > 0 and body[-1] == '':
504
 
            body.pop()
 
527
            body.pop()                
505
528
        return (header,body,footer)
506
529
 
507
530
    def test_list_only(self):
508
531
        # check that bzr selftest --list-only works correctly
509
 
        out,err = self.run_bzr('selftest selftest --list-only')
 
532
        out,err = self.run_bzr_captured(['selftest', 'selftest',
 
533
            '--list-only'])
510
534
        self.assertEndsWith(err, 'tests passed\n')
511
535
        (header,body,footer) = self._parse_test_list(out.splitlines())
512
536
        num_tests = len(body)
514
538
 
515
539
    def test_list_only_filtered(self):
516
540
        # check that a filtered --list-only works, both include and exclude
517
 
        out_all,err_all = self.run_bzr('selftest --list-only')
 
541
        out_all,err_all = self.run_bzr_captured(['selftest', '--list-only'])
518
542
        tests_all = self._parse_test_list(out_all.splitlines())[1]
519
 
        out_incl,err_incl = self.run_bzr('selftest --list-only selftest')
 
543
        out_incl,err_incl = self.run_bzr_captured(['selftest', '--list-only',
 
544
          'selftest'])
520
545
        tests_incl = self._parse_test_list(out_incl.splitlines())[1]
521
546
        self.assertSubset(tests_incl, tests_all)
522
 
        out_excl,err_excl = self.run_bzr(['selftest', '--list-only',
523
 
                                          '--exclude', 'selftest'])
 
547
        out_excl,err_excl = self.run_bzr_captured(['selftest', '--list-only',
 
548
          '--exclude', 'selftest'])
524
549
        tests_excl = self._parse_test_list(out_excl.splitlines())[1]
525
550
        self.assertSubset(tests_excl, tests_all)
526
551
        set_incl = set(tests_incl)
531
556
 
532
557
    def test_list_only_random(self):
533
558
        # check that --randomize works correctly
534
 
        out_all,err_all = self.run_bzr('selftest --list-only selftest')
 
559
        out_all,err_all = self.run_bzr_captured(['selftest', '--list-only',
 
560
            'selftest'])
535
561
        tests_all = self._parse_test_list(out_all.splitlines())[1]
536
 
        # XXX: It looks like there are some orders for generating tests that
537
 
        # fail as of 20070504 - maybe because of import order dependencies.
538
 
        # So unfortunately this will rarely intermittently fail at the moment.
539
 
        # -- mbp 20070504
540
 
        out_rand,err_rand = self.run_bzr(['selftest', '--list-only',
541
 
                                          'selftest', '--randomize', 'now'])
 
562
        out_rand,err_rand = self.run_bzr_captured(['selftest', '--list-only',
 
563
            'selftest', '--randomize', 'now'])
542
564
        (header_rand,tests_rand,dummy) = self._parse_test_list(
543
565
            out_rand.splitlines(), 2)
544
 
        # XXX: The following line asserts that the randomized order is not the
545
 
        # same as the default order.  It is just possible that they'll get
546
 
        # randomized into the same order and this will falsely fail, but
547
 
        # that's very unlikely in practice because there are thousands of
548
 
        # tests.
549
566
        self.assertNotEqual(tests_all, tests_rand)
550
567
        self.assertEqual(sorted(tests_all), sorted(tests_rand))
551
568
        # Check that the seed can be reused to get the exact same order
552
569
        seed_re = re.compile('Randomizing test order using seed (\w+)')
553
570
        match_obj = seed_re.search(header_rand[-1])
554
571
        seed = match_obj.group(1)
555
 
        out_rand2,err_rand2 = self.run_bzr(['selftest', '--list-only',
556
 
                                            'selftest', '--randomize', seed])
 
572
        out_rand2,err_rand2 = self.run_bzr_captured(['selftest', '--list-only',
 
573
            'selftest', '--randomize', seed])
557
574
        (header_rand2,tests_rand2,dummy) = self._parse_test_list(
558
575
            out_rand2.splitlines(), 2)
559
576
        self.assertEqual(tests_rand, tests_rand2)
560
577
 
561
 
 
562
 
class TestSelftestWithIdList(TestCaseInTempDir):
563
 
 
564
 
    def test_load_list(self):
565
 
        # We don't want to call selftest for the whole suite, so we start with
566
 
        # a reduced list.
567
 
        test_list_fname = 'test.list'
568
 
        fl = open(test_list_fname, 'wt')
569
 
        fl.write('%s\n' % self.id())
570
 
        fl.close()
571
 
        out, err = self.run_bzr(
572
 
            ['selftest', '--load-list', test_list_fname, '--list'])
573
 
        self.assertContainsRe(out, "Listed 1 test in")
574
 
 
575
 
    def test_load_unknown(self):
576
 
        out, err = self.run_bzr('selftest --load-list I_do_not_exist ',
577
 
                                retcode=3)