← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-03-25 18:43:31 UTC
  • mfrom: (4147.1.3 bzr.bug-338261)
  • Revision ID: pqm@pqm.ubuntu.com-20090325184331-1up3t0gh14ttr5zm
(James Henstridge) Insure that byte strings are passed to SMTP.login()

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Testing framework extensions"""
18
17
 
19
18
# TODO: Perhaps there should be an API to find out if bzr running under the
20
19
# test suite -- some plugins might want to avoid making intrusive changes if
29
28
 
30
29
import atexit
31
30
import codecs
32
 
from copy import copy
33
31
from cStringIO import StringIO
34
32
import difflib
35
33
import doctest
36
34
import errno
37
35
import logging
38
 
import math
39
36
import os
40
37
from pprint import pformat
41
38
import random
42
39
import re
43
40
import shlex
44
41
import stat
45
 
from subprocess import Popen, PIPE, STDOUT
 
42
from subprocess import Popen, PIPE
46
43
import sys
47
44
import tempfile
48
45
import threading
49
46
import time
50
 
import traceback
51
47
import unittest
52
48
import warnings
53
49
 
54
 
import testtools
55
 
# nb: check this before importing anything else from within it
56
 
_testtools_version = getattr(testtools, '__version__', ())
57
 
if _testtools_version < (0, 9, 2):
58
 
    raise ImportError("need at least testtools 0.9.2: %s is %r"
59
 
        % (testtools.__file__, _testtools_version))
60
 
from testtools import content
61
50
 
62
51
from bzrlib import (
63
52
    branchbuilder,
64
53
    bzrdir,
65
 
    chk_map,
66
 
    config,
67
54
    debug,
68
55
    errors,
69
56
    hooks,
70
 
    lock as _mod_lock,
71
57
    memorytree,
72
58
    osutils,
73
59
    progress,
97
83
from bzrlib.symbol_versioning import (
98
84
    DEPRECATED_PARAMETER,
99
85
    deprecated_function,
100
 
    deprecated_in,
101
86
    deprecated_method,
102
87
    deprecated_passed,
103
88
    )
104
89
import bzrlib.trace
105
 
from bzrlib.transport import (
106
 
    get_transport,
107
 
    memory,
108
 
    pathfilter,
109
 
    )
 
90
from bzrlib.transport import get_transport
110
91
import bzrlib.transport
 
92
from bzrlib.transport.local import LocalURLServer
 
93
from bzrlib.transport.memory import MemoryServer
 
94
from bzrlib.transport.readonly import ReadonlyServer
111
95
from bzrlib.trace import mutter, note
112
 
from bzrlib.tests import (
113
 
    test_server,
114
 
    TestUtil,
115
 
    treeshape,
116
 
    )
 
96
from bzrlib.tests import TestUtil
117
97
from bzrlib.tests.http_server import HttpServer
118
98
from bzrlib.tests.TestUtil import (
119
99
                          TestSuite,
120
100
                          TestLoader,
121
101
                          )
122
 
from bzrlib.ui import NullProgressView
123
 
from bzrlib.ui.text import TextUIFactory
 
102
from bzrlib.tests.treeshape import build_tree_contents
124
103
import bzrlib.version_info_formats.format_custom
125
104
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
126
105
 
129
108
# shown frame is the test code, not our assertXYZ.
130
109
__unittest = 1
131
110
 
132
 
default_transport = test_server.LocalURLServer
133
 
 
134
 
 
135
 
_unitialized_attr = object()
136
 
"""A sentinel needed to act as a default value in a method signature."""
137
 
 
138
 
 
139
 
# Subunit result codes, defined here to prevent a hard dependency on subunit.
140
 
SUBUNIT_SEEK_SET = 0
141
 
SUBUNIT_SEEK_CUR = 1
 
111
default_transport = LocalURLServer
142
112
 
143
113
 
144
114
class ExtendedTestResult(unittest._TextTestResult):
161
131
 
162
132
    def __init__(self, stream, descriptions, verbosity,
163
133
                 bench_history=None,
164
 
                 strict=False,
 
134
                 num_tests=None,
165
135
                 ):
166
136
        """Construct new TestResult.
167
137
 
185
155
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
186
156
        self._bench_history = bench_history
187
157
        self.ui = ui.ui_factory
188
 
        self.num_tests = 0
 
158
        self.num_tests = num_tests
189
159
        self.error_count = 0
190
160
        self.failure_count = 0
191
161
        self.known_failure_count = 0
194
164
        self.unsupported = {}
195
165
        self.count = 0
196
166
        self._overall_start_time = time.time()
197
 
        self._strict = strict
198
 
 
199
 
    def stopTestRun(self):
200
 
        run = self.testsRun
201
 
        actionTaken = "Ran"
202
 
        stopTime = time.time()
203
 
        timeTaken = stopTime - self.startTime
204
 
        self.printErrors()
205
 
        self.stream.writeln(self.separator2)
206
 
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
207
 
                            run, run != 1 and "s" or "", timeTaken))
208
 
        self.stream.writeln()
209
 
        if not self.wasSuccessful():
210
 
            self.stream.write("FAILED (")
211
 
            failed, errored = map(len, (self.failures, self.errors))
212
 
            if failed:
213
 
                self.stream.write("failures=%d" % failed)
214
 
            if errored:
215
 
                if failed: self.stream.write(", ")
216
 
                self.stream.write("errors=%d" % errored)
217
 
            if self.known_failure_count:
218
 
                if failed or errored: self.stream.write(", ")
219
 
                self.stream.write("known_failure_count=%d" %
220
 
                    self.known_failure_count)
221
 
            self.stream.writeln(")")
222
 
        else:
223
 
            if self.known_failure_count:
224
 
                self.stream.writeln("OK (known_failures=%d)" %
225
 
                    self.known_failure_count)
226
 
            else:
227
 
                self.stream.writeln("OK")
228
 
        if self.skip_count > 0:
229
 
            skipped = self.skip_count
230
 
            self.stream.writeln('%d test%s skipped' %
231
 
                                (skipped, skipped != 1 and "s" or ""))
232
 
        if self.unsupported:
233
 
            for feature, count in sorted(self.unsupported.items()):
234
 
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
235
 
                    (feature, count))
236
 
        if self._strict:
237
 
            ok = self.wasStrictlySuccessful()
238
 
        else:
239
 
            ok = self.wasSuccessful()
240
 
        if TestCase._first_thread_leaker_id:
241
 
            self.stream.write(
242
 
                '%s is leaking threads among %d leaking tests.\n' % (
243
 
                TestCase._first_thread_leaker_id,
244
 
                TestCase._leaking_threads_tests))
245
 
            # We don't report the main thread as an active one.
246
 
            self.stream.write(
247
 
                '%d non-main threads were left active in the end.\n'
248
 
                % (TestCase._active_threads - 1))
249
 
 
250
 
    def getDescription(self, test):
251
 
        return test.id()
252
 
 
253
 
    def _extractBenchmarkTime(self, testCase, details=None):
 
167
 
 
168
    def _extractBenchmarkTime(self, testCase):
254
169
        """Add a benchmark time for the current test case."""
255
 
        if details and 'benchtime' in details:
256
 
            return float(''.join(details['benchtime'].iter_bytes()))
257
170
        return getattr(testCase, "_benchtime", None)
258
171
 
259
172
    def _elapsedTestTimeString(self):
263
176
    def _testTimeString(self, testCase):
264
177
        benchmark_time = self._extractBenchmarkTime(testCase)
265
178
        if benchmark_time is not None:
266
 
            return self._formatTime(benchmark_time) + "*"
 
179
            return "%s/%s" % (
 
180
                self._formatTime(benchmark_time),
 
181
                self._elapsedTestTimeString())
267
182
        else:
268
 
            return self._elapsedTestTimeString()
 
183
            return "           %s" % self._elapsedTestTimeString()
269
184
 
270
185
    def _formatTime(self, seconds):
271
186
        """Format seconds as milliseconds with leading spaces."""
280
195
 
281
196
    def startTest(self, test):
282
197
        unittest.TestResult.startTest(self, test)
283
 
        if self.count == 0:
284
 
            self.startTests()
285
198
        self.report_test_start(test)
286
199
        test.number = self.count
287
200
        self._recordTestStartTime()
288
201
 
289
 
    def startTests(self):
290
 
        import platform
291
 
        if getattr(sys, 'frozen', None) is None:
292
 
            bzr_path = osutils.realpath(sys.argv[0])
293
 
        else:
294
 
            bzr_path = sys.executable
295
 
        self.stream.write(
296
 
            'bzr selftest: %s\n' % (bzr_path,))
297
 
        self.stream.write(
298
 
            '   %s\n' % (
299
 
                    bzrlib.__path__[0],))
300
 
        self.stream.write(
301
 
            '   bzr-%s python-%s %s\n' % (
302
 
                    bzrlib.version_string,
303
 
                    bzrlib._format_version_tuple(sys.version_info),
304
 
                    platform.platform(aliased=1),
305
 
                    ))
306
 
        self.stream.write('\n')
307
 
 
308
202
    def _recordTestStartTime(self):
309
203
        """Record that a test has started."""
310
204
        self._start_time = time.time()
322
216
        Called from the TestCase run() method when the test
323
217
        fails with an unexpected error.
324
218
        """
325
 
        self._post_mortem()
326
 
        unittest.TestResult.addError(self, test, err)
327
 
        self.error_count += 1
328
 
        self.report_error(test, err)
329
 
        if self.stop_early:
330
 
            self.stop()
331
 
        self._cleanupLogFile(test)
 
219
        self._testConcluded(test)
 
220
        if isinstance(err[1], TestNotApplicable):
 
221
            return self._addNotApplicable(test, err)
 
222
        elif isinstance(err[1], UnavailableFeature):
 
223
            return self.addNotSupported(test, err[1].args[0])
 
224
        else:
 
225
            unittest.TestResult.addError(self, test, err)
 
226
            self.error_count += 1
 
227
            self.report_error(test, err)
 
228
            if self.stop_early:
 
229
                self.stop()
 
230
            self._cleanupLogFile(test)
332
231
 
333
232
    def addFailure(self, test, err):
334
233
        """Tell result that test failed.
336
235
        Called from the TestCase run() method when the test
337
236
        fails because e.g. an assert() method failed.
338
237
        """
339
 
        self._post_mortem()
340
 
        unittest.TestResult.addFailure(self, test, err)
341
 
        self.failure_count += 1
342
 
        self.report_failure(test, err)
343
 
        if self.stop_early:
344
 
            self.stop()
345
 
        self._cleanupLogFile(test)
 
238
        self._testConcluded(test)
 
239
        if isinstance(err[1], KnownFailure):
 
240
            return self._addKnownFailure(test, err)
 
241
        else:
 
242
            unittest.TestResult.addFailure(self, test, err)
 
243
            self.failure_count += 1
 
244
            self.report_failure(test, err)
 
245
            if self.stop_early:
 
246
                self.stop()
 
247
            self._cleanupLogFile(test)
346
248
 
347
 
    def addSuccess(self, test, details=None):
 
249
    def addSuccess(self, test):
348
250
        """Tell result that test completed successfully.
349
251
 
350
252
        Called from the TestCase run()
351
253
        """
 
254
        self._testConcluded(test)
352
255
        if self._bench_history is not None:
353
 
            benchmark_time = self._extractBenchmarkTime(test, details)
 
256
            benchmark_time = self._extractBenchmarkTime(test)
354
257
            if benchmark_time is not None:
355
258
                self._bench_history.write("%s %s\n" % (
356
259
                    self._formatTime(benchmark_time),
360
263
        unittest.TestResult.addSuccess(self, test)
361
264
        test._log_contents = ''
362
265
 
363
 
    def addExpectedFailure(self, test, err):
 
266
    def _testConcluded(self, test):
 
267
        """Common code when a test has finished.
 
268
 
 
269
        Called regardless of whether it succeded, failed, etc.
 
270
        """
 
271
        pass
 
272
 
 
273
    def _addKnownFailure(self, test, err):
364
274
        self.known_failure_count += 1
365
275
        self.report_known_failure(test, err)
366
276
 
368
278
        """The test will not be run because of a missing feature.
369
279
        """
370
280
        # this can be called in two different ways: it may be that the
371
 
        # test started running, and then raised (through requireFeature)
 
281
        # test started running, and then raised (through addError)
372
282
        # UnavailableFeature.  Alternatively this method can be called
373
 
        # while probing for features before running the test code proper; in
374
 
        # that case we will see startTest and stopTest, but the test will
375
 
        # never actually run.
 
283
        # while probing for features before running the tests; in that
 
284
        # case we will see startTest and stopTest, but the test will never
 
285
        # actually run.
376
286
        self.unsupported.setdefault(str(feature), 0)
377
287
        self.unsupported[str(feature)] += 1
378
288
        self.report_unsupported(test, feature)
382
292
        self.skip_count += 1
383
293
        self.report_skip(test, reason)
384
294
 
385
 
    def addNotApplicable(self, test, reason):
386
 
        self.not_applicable_count += 1
387
 
        self.report_not_applicable(test, reason)
388
 
 
389
 
    def _post_mortem(self):
390
 
        """Start a PDB post mortem session."""
391
 
        if os.environ.get('BZR_TEST_PDB', None):
392
 
            import pdb;pdb.post_mortem()
393
 
 
394
 
    def progress(self, offset, whence):
395
 
        """The test is adjusting the count of tests to run."""
396
 
        if whence == SUBUNIT_SEEK_SET:
397
 
            self.num_tests = offset
398
 
        elif whence == SUBUNIT_SEEK_CUR:
399
 
            self.num_tests += offset
 
295
    def _addNotApplicable(self, test, skip_excinfo):
 
296
        if isinstance(skip_excinfo[1], TestNotApplicable):
 
297
            self.not_applicable_count += 1
 
298
            self.report_not_applicable(test, skip_excinfo)
 
299
        try:
 
300
            test.tearDown()
 
301
        except KeyboardInterrupt:
 
302
            raise
 
303
        except:
 
304
            self.addError(test, test.exc_info())
400
305
        else:
401
 
            raise errors.BzrError("Unknown whence %r" % whence)
 
306
            # seems best to treat this as success from point-of-view of unittest
 
307
            # -- it actually does nothing so it barely matters :)
 
308
            unittest.TestResult.addSuccess(self, test)
 
309
            test._log_contents = ''
 
310
 
 
311
    def printErrorList(self, flavour, errors):
 
312
        for test, err in errors:
 
313
            self.stream.writeln(self.separator1)
 
314
            self.stream.write("%s: " % flavour)
 
315
            self.stream.writeln(self.getDescription(test))
 
316
            if getattr(test, '_get_log', None) is not None:
 
317
                self.stream.write('\n')
 
318
                self.stream.write(
 
319
                        ('vvvv[log from %s]' % test.id()).ljust(78,'-'))
 
320
                self.stream.write('\n')
 
321
                self.stream.write(test._get_log())
 
322
                self.stream.write('\n')
 
323
                self.stream.write(
 
324
                        ('^^^^[log from %s]' % test.id()).ljust(78,'-'))
 
325
                self.stream.write('\n')
 
326
            self.stream.writeln(self.separator2)
 
327
            self.stream.writeln("%s" % err)
 
328
 
 
329
    def finished(self):
 
330
        pass
402
331
 
403
332
    def report_cleaning_up(self):
404
333
        pass
405
334
 
406
 
    def startTestRun(self):
407
 
        self.startTime = time.time()
408
 
 
409
335
    def report_success(self, test):
410
336
        pass
411
337
 
420
346
 
421
347
    def __init__(self, stream, descriptions, verbosity,
422
348
                 bench_history=None,
 
349
                 num_tests=None,
423
350
                 pb=None,
424
 
                 strict=None,
425
351
                 ):
426
352
        ExtendedTestResult.__init__(self, stream, descriptions, verbosity,
427
 
            bench_history, strict)
428
 
        # We no longer pass them around, but just rely on the UIFactory stack
429
 
        # for state
430
 
        if pb is not None:
431
 
            warnings.warn("Passing pb to TextTestResult is deprecated")
432
 
        self.pb = self.ui.nested_progress_bar()
 
353
            bench_history, num_tests)
 
354
        if pb is None:
 
355
            self.pb = self.ui.nested_progress_bar()
 
356
            self._supplied_pb = False
 
357
        else:
 
358
            self.pb = pb
 
359
            self._supplied_pb = True
433
360
        self.pb.show_pct = False
434
361
        self.pb.show_spinner = False
435
362
        self.pb.show_eta = False,
436
363
        self.pb.show_count = False
437
364
        self.pb.show_bar = False
438
 
        self.pb.update_latency = 0
439
 
        self.pb.show_transport_activity = False
440
 
 
441
 
    def stopTestRun(self):
442
 
        # called when the tests that are going to run have run
443
 
        self.pb.clear()
444
 
        self.pb.finished()
445
 
        super(TextTestResult, self).stopTestRun()
446
 
 
447
 
    def startTestRun(self):
448
 
        super(TextTestResult, self).startTestRun()
 
365
 
 
366
    def report_starting(self):
449
367
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
450
368
 
451
 
    def printErrors(self):
452
 
        # clear the pb to make room for the error listing
453
 
        self.pb.clear()
454
 
        super(TextTestResult, self).printErrors()
455
 
 
456
369
    def _progress_prefix_text(self):
457
370
        # the longer this text, the less space we have to show the test
458
371
        # name...
463
376
        ##     a += ', %d skip' % self.skip_count
464
377
        ## if self.known_failure_count:
465
378
        ##     a += '+%dX' % self.known_failure_count
466
 
        if self.num_tests:
 
379
        if self.num_tests is not None:
467
380
            a +='/%d' % self.num_tests
468
381
        a += ' in '
469
382
        runtime = time.time() - self._overall_start_time
471
384
            a += '%dm%ds' % (runtime / 60, runtime % 60)
472
385
        else:
473
386
            a += '%ds' % runtime
474
 
        total_fail_count = self.error_count + self.failure_count
475
 
        if total_fail_count:
476
 
            a += ', %d failed' % total_fail_count
477
 
        # if self.unsupported:
478
 
        #     a += ', %d missing' % len(self.unsupported)
 
387
        if self.error_count:
 
388
            a += ', %d err' % self.error_count
 
389
        if self.failure_count:
 
390
            a += ', %d fail' % self.failure_count
 
391
        if self.unsupported:
 
392
            a += ', %d missing' % len(self.unsupported)
479
393
        a += ']'
480
394
        return a
481
395
 
490
404
        return self._shortened_test_description(test)
491
405
 
492
406
    def report_error(self, test, err):
493
 
        self.stream.write('ERROR: %s\n    %s\n' % (
 
407
        self.pb.note('ERROR: %s\n    %s\n',
494
408
            self._test_description(test),
495
409
            err[1],
496
 
            ))
 
410
            )
497
411
 
498
412
    def report_failure(self, test, err):
499
 
        self.stream.write('FAIL: %s\n    %s\n' % (
 
413
        self.pb.note('FAIL: %s\n    %s\n',
500
414
            self._test_description(test),
501
415
            err[1],
502
 
            ))
 
416
            )
503
417
 
504
418
    def report_known_failure(self, test, err):
505
 
        pass
 
419
        self.pb.note('XFAIL: %s\n%s\n',
 
420
            self._test_description(test), err[1])
506
421
 
507
422
    def report_skip(self, test, reason):
508
423
        pass
509
424
 
510
 
    def report_not_applicable(self, test, reason):
 
425
    def report_not_applicable(self, test, skip_excinfo):
511
426
        pass
512
427
 
513
428
    def report_unsupported(self, test, feature):
516
431
    def report_cleaning_up(self):
517
432
        self.pb.update('Cleaning up')
518
433
 
 
434
    def finished(self):
 
435
        if not self._supplied_pb:
 
436
            self.pb.finished()
 
437
 
519
438
 
520
439
class VerboseTestResult(ExtendedTestResult):
521
440
    """Produce long output, with one line per test run plus times"""
528
447
            result = a_string
529
448
        return result.ljust(final_width)
530
449
 
531
 
    def startTestRun(self):
532
 
        super(VerboseTestResult, self).startTestRun()
 
450
    def report_starting(self):
533
451
        self.stream.write('running %d tests...\n' % self.num_tests)
534
452
 
535
453
    def report_test_start(self, test):
536
454
        self.count += 1
537
455
        name = self._shortened_test_description(test)
538
 
        width = osutils.terminal_width()
539
 
        if width is not None:
540
 
            # width needs space for 6 char status, plus 1 for slash, plus an
541
 
            # 11-char time string, plus a trailing blank
542
 
            # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on
543
 
            # space
544
 
            self.stream.write(self._ellipsize_to_right(name, width-18))
545
 
        else:
546
 
            self.stream.write(name)
 
456
        # width needs space for 6 char status, plus 1 for slash, plus 2 10-char
 
457
        # numbers, plus a trailing blank
 
458
        # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on space
 
459
        self.stream.write(self._ellipsize_to_right(name,
 
460
                          osutils.terminal_width()-30))
547
461
        self.stream.flush()
548
462
 
549
463
    def _error_summary(self, err):
578
492
        self.stream.writeln(' SKIP %s\n%s'
579
493
                % (self._testTimeString(test), reason))
580
494
 
581
 
    def report_not_applicable(self, test, reason):
582
 
        self.stream.writeln('  N/A %s\n    %s'
583
 
                % (self._testTimeString(test), reason))
 
495
    def report_not_applicable(self, test, skip_excinfo):
 
496
        self.stream.writeln('  N/A %s\n%s'
 
497
                % (self._testTimeString(test),
 
498
                   self._error_summary(skip_excinfo)))
584
499
 
585
500
    def report_unsupported(self, test, feature):
586
501
        """test cannot be run because feature is missing."""
596
511
                 descriptions=0,
597
512
                 verbosity=1,
598
513
                 bench_history=None,
599
 
                 strict=False,
600
 
                 result_decorators=None,
 
514
                 list_only=False
601
515
                 ):
602
 
        """Create a TextTestRunner.
603
 
 
604
 
        :param result_decorators: An optional list of decorators to apply
605
 
            to the result object being used by the runner. Decorators are
606
 
            applied left to right - the first element in the list is the 
607
 
            innermost decorator.
608
 
        """
609
 
        # stream may know claim to know to write unicode strings, but in older
610
 
        # pythons this goes sufficiently wrong that it is a bad idea. (
611
 
        # specifically a built in file with encoding 'UTF-8' will still try
612
 
        # to encode using ascii.
613
 
        new_encoding = osutils.get_terminal_encoding()
614
 
        codec = codecs.lookup(new_encoding)
615
 
        if type(codec) is tuple:
616
 
            # Python 2.4
617
 
            encode = codec[0]
618
 
        else:
619
 
            encode = codec.encode
620
 
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
621
 
        stream.encoding = new_encoding
622
516
        self.stream = unittest._WritelnDecorator(stream)
623
517
        self.descriptions = descriptions
624
518
        self.verbosity = verbosity
625
519
        self._bench_history = bench_history
626
 
        self._strict = strict
627
 
        self._result_decorators = result_decorators or []
 
520
        self.list_only = list_only
628
521
 
629
522
    def run(self, test):
630
523
        "Run the given test case or test suite."
 
524
        startTime = time.time()
631
525
        if self.verbosity == 1:
632
526
            result_class = TextTestResult
633
527
        elif self.verbosity >= 2:
634
528
            result_class = VerboseTestResult
635
 
        original_result = result_class(self.stream,
 
529
        result = result_class(self.stream,
636
530
                              self.descriptions,
637
531
                              self.verbosity,
638
532
                              bench_history=self._bench_history,
639
 
                              strict=self._strict,
 
533
                              num_tests=test.countTestCases(),
640
534
                              )
641
 
        # Signal to result objects that look at stop early policy to stop,
642
 
        original_result.stop_early = self.stop_on_failure
643
 
        result = original_result
644
 
        for decorator in self._result_decorators:
645
 
            result = decorator(result)
646
 
            result.stop_early = self.stop_on_failure
647
 
        result.startTestRun()
648
 
        try:
 
535
        result.stop_early = self.stop_on_failure
 
536
        result.report_starting()
 
537
        if self.list_only:
 
538
            if self.verbosity >= 2:
 
539
                self.stream.writeln("Listing tests only ...\n")
 
540
            run = 0
 
541
            for t in iter_suite_tests(test):
 
542
                self.stream.writeln("%s" % (t.id()))
 
543
                run += 1
 
544
            actionTaken = "Listed"
 
545
        else:
649
546
            test.run(result)
650
 
        finally:
651
 
            result.stopTestRun()
652
 
        # higher level code uses our extended protocol to determine
653
 
        # what exit code to give.
654
 
        return original_result
 
547
            run = result.testsRun
 
548
            actionTaken = "Ran"
 
549
        stopTime = time.time()
 
550
        timeTaken = stopTime - startTime
 
551
        result.printErrors()
 
552
        self.stream.writeln(result.separator2)
 
553
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
 
554
                            run, run != 1 and "s" or "", timeTaken))
 
555
        self.stream.writeln()
 
556
        if not result.wasSuccessful():
 
557
            self.stream.write("FAILED (")
 
558
            failed, errored = map(len, (result.failures, result.errors))
 
559
            if failed:
 
560
                self.stream.write("failures=%d" % failed)
 
561
            if errored:
 
562
                if failed: self.stream.write(", ")
 
563
                self.stream.write("errors=%d" % errored)
 
564
            if result.known_failure_count:
 
565
                if failed or errored: self.stream.write(", ")
 
566
                self.stream.write("known_failure_count=%d" %
 
567
                    result.known_failure_count)
 
568
            self.stream.writeln(")")
 
569
        else:
 
570
            if result.known_failure_count:
 
571
                self.stream.writeln("OK (known_failures=%d)" %
 
572
                    result.known_failure_count)
 
573
            else:
 
574
                self.stream.writeln("OK")
 
575
        if result.skip_count > 0:
 
576
            skipped = result.skip_count
 
577
            self.stream.writeln('%d test%s skipped' %
 
578
                                (skipped, skipped != 1 and "s" or ""))
 
579
        if result.unsupported:
 
580
            for feature, count in sorted(result.unsupported.items()):
 
581
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
 
582
                    (feature, count))
 
583
        result.finished()
 
584
        return result
655
585
 
656
586
 
657
587
def iter_suite_tests(suite):
659
589
    if isinstance(suite, unittest.TestCase):
660
590
        yield suite
661
591
    elif isinstance(suite, unittest.TestSuite):
662
 
        for item in suite:
 
592
        for item in suite._tests:
663
593
            for r in iter_suite_tests(item):
664
594
                yield r
665
595
    else:
667
597
                        % (type(suite), suite))
668
598
 
669
599
 
670
 
TestSkipped = testtools.testcase.TestSkipped
 
600
class TestSkipped(Exception):
 
601
    """Indicates that a test was intentionally skipped, rather than failing."""
671
602
 
672
603
 
673
604
class TestNotApplicable(TestSkipped):
679
610
    """
680
611
 
681
612
 
682
 
# traceback._some_str fails to format exceptions that have the default
683
 
# __str__ which does an implicit ascii conversion. However, repr() on those
684
 
# objects works, for all that its not quite what the doctor may have ordered.
685
 
def _clever_some_str(value):
686
 
    try:
687
 
        return str(value)
688
 
    except:
689
 
        try:
690
 
            return repr(value).replace('\\n', '\n')
691
 
        except:
692
 
            return '<unprintable %s object>' % type(value).__name__
693
 
 
694
 
traceback._some_str = _clever_some_str
695
 
 
696
 
 
697
 
# deprecated - use self.knownFailure(), or self.expectFailure.
698
 
KnownFailure = testtools.testcase._ExpectedFailure
 
613
class KnownFailure(AssertionError):
 
614
    """Indicates that a test failed in a precisely expected manner.
 
615
 
 
616
    Such failures dont block the whole test suite from passing because they are
 
617
    indicators of partially completed code or of future work. We have an
 
618
    explicit error for them so that we can ensure that they are always visible:
 
619
    KnownFailures are always shown in the output of bzr selftest.
 
620
    """
699
621
 
700
622
 
701
623
class UnavailableFeature(Exception):
702
624
    """A feature required for this test was not available.
703
625
 
704
 
    This can be considered a specialised form of SkippedTest.
705
 
 
706
626
    The feature should be used to construct the exception.
707
627
    """
708
628
 
709
629
 
 
630
class CommandFailed(Exception):
 
631
    pass
 
632
 
 
633
 
710
634
class StringIOWrapper(object):
711
635
    """A wrapper around cStringIO which just adds an encoding attribute.
712
636
 
733
657
            return setattr(self._cstring, name, val)
734
658
 
735
659
 
736
 
class TestUIFactory(TextUIFactory):
 
660
class TestUIFactory(ui.CLIUIFactory):
737
661
    """A UI Factory for testing.
738
662
 
739
663
    Hide the progress bar but emit note()s.
740
664
    Redirect stdin.
741
665
    Allows get_password to be tested without real tty attached.
742
 
 
743
 
    See also CannedInputUIFactory which lets you provide programmatic input in
744
 
    a structured way.
745
666
    """
746
 
    # TODO: Capture progress events at the model level and allow them to be
747
 
    # observed by tests that care.
748
 
    #
749
 
    # XXX: Should probably unify more with CannedInputUIFactory or a
750
 
    # particular configuration of TextUIFactory, or otherwise have a clearer
751
 
    # idea of how they're supposed to be different.
752
 
    # See https://bugs.edge.launchpad.net/bzr/+bug/408213
753
667
 
754
 
    def __init__(self, stdout=None, stderr=None, stdin=None):
 
668
    def __init__(self,
 
669
                 stdout=None,
 
670
                 stderr=None,
 
671
                 stdin=None):
 
672
        super(TestUIFactory, self).__init__()
755
673
        if stdin is not None:
756
674
            # We use a StringIOWrapper to be able to test various
757
675
            # encodings, but the user is still responsible to
758
676
            # encode the string and to set the encoding attribute
759
677
            # of StringIOWrapper.
760
 
            stdin = StringIOWrapper(stdin)
761
 
        super(TestUIFactory, self).__init__(stdin, stdout, stderr)
762
 
 
763
 
    def get_non_echoed_password(self):
 
678
            self.stdin = StringIOWrapper(stdin)
 
679
        if stdout is None:
 
680
            self.stdout = sys.stdout
 
681
        else:
 
682
            self.stdout = stdout
 
683
        if stderr is None:
 
684
            self.stderr = sys.stderr
 
685
        else:
 
686
            self.stderr = stderr
 
687
 
 
688
    def clear(self):
 
689
        """See progress.ProgressBar.clear()."""
 
690
 
 
691
    def clear_term(self):
 
692
        """See progress.ProgressBar.clear_term()."""
 
693
 
 
694
    def clear_term(self):
 
695
        """See progress.ProgressBar.clear_term()."""
 
696
 
 
697
    def finished(self):
 
698
        """See progress.ProgressBar.finished()."""
 
699
 
 
700
    def note(self, fmt_string, *args, **kwargs):
 
701
        """See progress.ProgressBar.note()."""
 
702
        self.stdout.write((fmt_string + "\n") % args)
 
703
 
 
704
    def progress_bar(self):
 
705
        return self
 
706
 
 
707
    def nested_progress_bar(self):
 
708
        return self
 
709
 
 
710
    def update(self, message, count=None, total=None):
 
711
        """See progress.ProgressBar.update()."""
 
712
 
 
713
    def get_non_echoed_password(self, prompt):
764
714
        """Get password from stdin without trying to handle the echo mode"""
 
715
        if prompt:
 
716
            self.stdout.write(prompt.encode(self.stdout.encoding, 'replace'))
765
717
        password = self.stdin.readline()
766
718
        if not password:
767
719
            raise EOFError
769
721
            password = password[:-1]
770
722
        return password
771
723
 
772
 
    def make_progress_view(self):
773
 
        return NullProgressView()
774
 
 
775
 
 
776
 
class TestCase(testtools.TestCase):
 
724
 
 
725
def _report_leaked_threads():
 
726
    bzrlib.trace.warning('%s is leaking threads among %d leaking tests',
 
727
                         TestCase._first_thread_leaker_id,
 
728
                         TestCase._leaking_threads_tests)
 
729
 
 
730
 
 
731
class TestCase(unittest.TestCase):
777
732
    """Base class for bzr unit tests.
778
733
 
779
734
    Tests that need access to disk resources should subclass
798
753
    _leaking_threads_tests = 0
799
754
    _first_thread_leaker_id = None
800
755
    _log_file_name = None
 
756
    _log_contents = ''
 
757
    _keep_log_file = False
801
758
    # record lsprof data when performing benchmark calls.
802
759
    _gather_lsprof_in_benchmarks = False
 
760
    attrs_to_keep = ('id', '_testMethodName', '_testMethodDoc',
 
761
                     '_log_contents', '_log_file_name', '_benchtime',
 
762
                     '_TestCase__testMethodName')
803
763
 
804
764
    def __init__(self, methodName='testMethod'):
805
765
        super(TestCase, self).__init__(methodName)
806
766
        self._cleanups = []
807
 
        self._directory_isolation = True
808
 
        self.exception_handlers.insert(0,
809
 
            (UnavailableFeature, self._do_unsupported_or_skip))
810
 
        self.exception_handlers.insert(0,
811
 
            (TestNotApplicable, self._do_not_applicable))
 
767
        self._bzr_test_setUp_run = False
 
768
        self._bzr_test_tearDown_run = False
812
769
 
813
770
    def setUp(self):
814
 
        super(TestCase, self).setUp()
815
 
        for feature in getattr(self, '_test_needs_features', []):
816
 
            self.requireFeature(feature)
817
 
        self._log_contents = None
818
 
        self.addDetail("log", content.Content(content.ContentType("text",
819
 
            "plain", {"charset": "utf8"}),
820
 
            lambda:[self._get_log(keep_log_file=True)]))
 
771
        unittest.TestCase.setUp(self)
 
772
        self._bzr_test_setUp_run = True
821
773
        self._cleanEnvironment()
822
774
        self._silenceUI()
823
775
        self._startLogFile()
824
776
        self._benchcalls = []
825
777
        self._benchtime = None
826
778
        self._clear_hooks()
827
 
        self._track_transports()
828
 
        self._track_locks()
829
779
        self._clear_debug_flags()
830
780
        TestCase._active_threads = threading.activeCount()
831
781
        self.addCleanup(self._check_leaked_threads)
835
785
        import pdb
836
786
        pdb.Pdb().set_trace(sys._getframe().f_back)
837
787
 
 
788
    def exc_info(self):
 
789
        absent_attr = object()
 
790
        exc_info = getattr(self, '_exc_info', absent_attr)
 
791
        if exc_info is absent_attr:
 
792
            exc_info = getattr(self, '_TestCase__exc_info')
 
793
        return exc_info()
 
794
 
838
795
    def _check_leaked_threads(self):
839
796
        active = threading.activeCount()
840
797
        leaked_threads = active - TestCase._active_threads
841
798
        TestCase._active_threads = active
842
 
        # If some tests make the number of threads *decrease*, we'll consider
843
 
        # that they are just observing old threads dieing, not agressively kill
844
 
        # random threads. So we don't report these tests as leaking. The risk
845
 
        # is that we have false positives that way (the test see 2 threads
846
 
        # going away but leak one) but it seems less likely than the actual
847
 
        # false positives (the test see threads going away and does not leak).
848
 
        if leaked_threads > 0:
 
799
        if leaked_threads:
849
800
            TestCase._leaking_threads_tests += 1
850
801
            if TestCase._first_thread_leaker_id is None:
851
802
                TestCase._first_thread_leaker_id = self.id()
 
803
                # we're not specifically told when all tests are finished.
 
804
                # This will do. We use a function to avoid keeping a reference
 
805
                # to a TestCase object.
 
806
                atexit.register(_report_leaked_threads)
852
807
 
853
808
    def _clear_debug_flags(self):
854
809
        """Prevent externally set debug flags affecting tests.
856
811
        Tests that want to use debug flags can just set them in the
857
812
        debug_flags set during setup/teardown.
858
813
        """
859
 
        # Start with a copy of the current debug flags we can safely modify.
860
 
        self.overrideAttr(debug, 'debug_flags', set(debug.debug_flags))
 
814
        self._preserved_debug_flags = set(debug.debug_flags)
861
815
        if 'allow_debug' not in selftest_debug_flags:
862
816
            debug.debug_flags.clear()
863
 
        if 'disable_lock_checks' not in selftest_debug_flags:
864
 
            debug.debug_flags.add('strict_locks')
 
817
        self.addCleanup(self._restore_debug_flags)
865
818
 
866
819
    def _clear_hooks(self):
867
820
        # prevent hooks affecting tests
877
830
        # this hook should always be installed
878
831
        request._install_hook()
879
832
 
880
 
    def disable_directory_isolation(self):
881
 
        """Turn off directory isolation checks."""
882
 
        self._directory_isolation = False
883
 
 
884
 
    def enable_directory_isolation(self):
885
 
        """Enable directory isolation checks."""
886
 
        self._directory_isolation = True
887
 
 
888
833
    def _silenceUI(self):
889
834
        """Turn off UI for duration of test"""
890
835
        # by default the UI is off; tests can turn it on if they want it.
891
 
        self.overrideAttr(ui, 'ui_factory', ui.SilentUIFactory())
892
 
 
893
 
    def _check_locks(self):
894
 
        """Check that all lock take/release actions have been paired."""
895
 
        # We always check for mismatched locks. If a mismatch is found, we
896
 
        # fail unless -Edisable_lock_checks is supplied to selftest, in which
897
 
        # case we just print a warning.
898
 
        # unhook:
899
 
        acquired_locks = [lock for action, lock in self._lock_actions
900
 
                          if action == 'acquired']
901
 
        released_locks = [lock for action, lock in self._lock_actions
902
 
                          if action == 'released']
903
 
        broken_locks = [lock for action, lock in self._lock_actions
904
 
                        if action == 'broken']
905
 
        # trivially, given the tests for lock acquistion and release, if we
906
 
        # have as many in each list, it should be ok. Some lock tests also
907
 
        # break some locks on purpose and should be taken into account by
908
 
        # considering that breaking a lock is just a dirty way of releasing it.
909
 
        if len(acquired_locks) != (len(released_locks) + len(broken_locks)):
910
 
            message = ('Different number of acquired and '
911
 
                       'released or broken locks. (%s, %s + %s)' %
912
 
                       (acquired_locks, released_locks, broken_locks))
913
 
            if not self._lock_check_thorough:
914
 
                # Rather than fail, just warn
915
 
                print "Broken test %s: %s" % (self, message)
916
 
                return
917
 
            self.fail(message)
918
 
 
919
 
    def _track_locks(self):
920
 
        """Track lock activity during tests."""
921
 
        self._lock_actions = []
922
 
        if 'disable_lock_checks' in selftest_debug_flags:
923
 
            self._lock_check_thorough = False
924
 
        else:
925
 
            self._lock_check_thorough = True
926
 
 
927
 
        self.addCleanup(self._check_locks)
928
 
        _mod_lock.Lock.hooks.install_named_hook('lock_acquired',
929
 
                                                self._lock_acquired, None)
930
 
        _mod_lock.Lock.hooks.install_named_hook('lock_released',
931
 
                                                self._lock_released, None)
932
 
        _mod_lock.Lock.hooks.install_named_hook('lock_broken',
933
 
                                                self._lock_broken, None)
934
 
 
935
 
    def _lock_acquired(self, result):
936
 
        self._lock_actions.append(('acquired', result))
937
 
 
938
 
    def _lock_released(self, result):
939
 
        self._lock_actions.append(('released', result))
940
 
 
941
 
    def _lock_broken(self, result):
942
 
        self._lock_actions.append(('broken', result))
943
 
 
944
 
    def permit_dir(self, name):
945
 
        """Permit a directory to be used by this test. See permit_url."""
946
 
        name_transport = get_transport(name)
947
 
        self.permit_url(name)
948
 
        self.permit_url(name_transport.base)
949
 
 
950
 
    def permit_url(self, url):
951
 
        """Declare that url is an ok url to use in this test.
952
 
        
953
 
        Do this for memory transports, temporary test directory etc.
954
 
        
955
 
        Do not do this for the current working directory, /tmp, or any other
956
 
        preexisting non isolated url.
957
 
        """
958
 
        if not url.endswith('/'):
959
 
            url += '/'
960
 
        self._bzr_selftest_roots.append(url)
961
 
 
962
 
    def permit_source_tree_branch_repo(self):
963
 
        """Permit the source tree bzr is running from to be opened.
964
 
 
965
 
        Some code such as bzrlib.version attempts to read from the bzr branch
966
 
        that bzr is executing from (if any). This method permits that directory
967
 
        to be used in the test suite.
968
 
        """
969
 
        path = self.get_source_path()
970
 
        self.record_directory_isolation()
971
 
        try:
972
 
            try:
973
 
                workingtree.WorkingTree.open(path)
974
 
            except (errors.NotBranchError, errors.NoWorkingTree):
975
 
                return
976
 
        finally:
977
 
            self.enable_directory_isolation()
978
 
 
979
 
    def _preopen_isolate_transport(self, transport):
980
 
        """Check that all transport openings are done in the test work area."""
981
 
        while isinstance(transport, pathfilter.PathFilteringTransport):
982
 
            # Unwrap pathfiltered transports
983
 
            transport = transport.server.backing_transport.clone(
984
 
                transport._filter('.'))
985
 
        url = transport.base
986
 
        # ReadonlySmartTCPServer_for_testing decorates the backing transport
987
 
        # urls it is given by prepending readonly+. This is appropriate as the
988
 
        # client shouldn't know that the server is readonly (or not readonly).
989
 
        # We could register all servers twice, with readonly+ prepending, but
990
 
        # that makes for a long list; this is about the same but easier to
991
 
        # read.
992
 
        if url.startswith('readonly+'):
993
 
            url = url[len('readonly+'):]
994
 
        self._preopen_isolate_url(url)
995
 
 
996
 
    def _preopen_isolate_url(self, url):
997
 
        if not self._directory_isolation:
998
 
            return
999
 
        if self._directory_isolation == 'record':
1000
 
            self._bzr_selftest_roots.append(url)
1001
 
            return
1002
 
        # This prevents all transports, including e.g. sftp ones backed on disk
1003
 
        # from working unless they are explicitly granted permission. We then
1004
 
        # depend on the code that sets up test transports to check that they are
1005
 
        # appropriately isolated and enable their use by calling
1006
 
        # self.permit_transport()
1007
 
        if not osutils.is_inside_any(self._bzr_selftest_roots, url):
1008
 
            raise errors.BzrError("Attempt to escape test isolation: %r %r"
1009
 
                % (url, self._bzr_selftest_roots))
1010
 
 
1011
 
    def record_directory_isolation(self):
1012
 
        """Gather accessed directories to permit later access.
1013
 
        
1014
 
        This is used for tests that access the branch bzr is running from.
1015
 
        """
1016
 
        self._directory_isolation = "record"
1017
 
 
1018
 
    def start_server(self, transport_server, backing_server=None):
1019
 
        """Start transport_server for this test.
1020
 
 
1021
 
        This starts the server, registers a cleanup for it and permits the
1022
 
        server's urls to be used.
1023
 
        """
1024
 
        if backing_server is None:
1025
 
            transport_server.start_server()
1026
 
        else:
1027
 
            transport_server.start_server(backing_server)
1028
 
        self.addCleanup(transport_server.stop_server)
1029
 
        # Obtain a real transport because if the server supplies a password, it
1030
 
        # will be hidden from the base on the client side.
1031
 
        t = get_transport(transport_server.get_url())
1032
 
        # Some transport servers effectively chroot the backing transport;
1033
 
        # others like SFTPServer don't - users of the transport can walk up the
1034
 
        # transport to read the entire backing transport. This wouldn't matter
1035
 
        # except that the workdir tests are given - and that they expect the
1036
 
        # server's url to point at - is one directory under the safety net. So
1037
 
        # Branch operations into the transport will attempt to walk up one
1038
 
        # directory. Chrooting all servers would avoid this but also mean that
1039
 
        # we wouldn't be testing directly against non-root urls. Alternatively
1040
 
        # getting the test framework to start the server with a backing server
1041
 
        # at the actual safety net directory would work too, but this then
1042
 
        # means that the self.get_url/self.get_transport methods would need
1043
 
        # to transform all their results. On balance its cleaner to handle it
1044
 
        # here, and permit a higher url when we have one of these transports.
1045
 
        if t.base.endswith('/work/'):
1046
 
            # we have safety net/test root/work
1047
 
            t = t.clone('../..')
1048
 
        elif isinstance(transport_server,
1049
 
                        test_server.SmartTCPServer_for_testing):
1050
 
            # The smart server adds a path similar to work, which is traversed
1051
 
            # up from by the client. But the server is chrooted - the actual
1052
 
            # backing transport is not escaped from, and VFS requests to the
1053
 
            # root will error (because they try to escape the chroot).
1054
 
            t2 = t.clone('..')
1055
 
            while t2.base != t.base:
1056
 
                t = t2
1057
 
                t2 = t.clone('..')
1058
 
        self.permit_url(t.base)
1059
 
 
1060
 
    def _track_transports(self):
1061
 
        """Install checks for transport usage."""
1062
 
        # TestCase has no safe place it can write to.
1063
 
        self._bzr_selftest_roots = []
1064
 
        # Currently the easiest way to be sure that nothing is going on is to
1065
 
        # hook into bzr dir opening. This leaves a small window of error for
1066
 
        # transport tests, but they are well known, and we can improve on this
1067
 
        # step.
1068
 
        bzrdir.BzrDir.hooks.install_named_hook("pre_open",
1069
 
            self._preopen_isolate_transport, "Check bzr directories are safe.")
 
836
        saved = ui.ui_factory
 
837
        def _restore():
 
838
            ui.ui_factory = saved
 
839
        ui.ui_factory = ui.SilentUIFactory()
 
840
        self.addCleanup(_restore)
1070
841
 
1071
842
    def _ndiff_strings(self, a, b):
1072
843
        """Return ndiff between two strings containing lines.
1110
881
            return
1111
882
        if message is None:
1112
883
            message = "texts not equal:\n"
 
884
        if a == b + '\n':
 
885
            message = 'first string is missing a final newline.\n'
1113
886
        if a + '\n' == b:
1114
 
            message = 'first string is missing a final newline.\n'
1115
 
        if a == b + '\n':
1116
887
            message = 'second string is missing a final newline.\n'
1117
888
        raise AssertionError(message +
1118
889
                             self._ndiff_strings(a, b))
1129
900
        :raises AssertionError: If the expected and actual stat values differ
1130
901
            other than by atime.
1131
902
        """
1132
 
        self.assertEqual(expected.st_size, actual.st_size,
1133
 
                         'st_size did not match')
1134
 
        self.assertEqual(expected.st_mtime, actual.st_mtime,
1135
 
                         'st_mtime did not match')
1136
 
        self.assertEqual(expected.st_ctime, actual.st_ctime,
1137
 
                         'st_ctime did not match')
1138
 
        if sys.platform != 'win32':
1139
 
            # On Win32 both 'dev' and 'ino' cannot be trusted. In python2.4 it
1140
 
            # is 'dev' that varies, in python 2.5 (6?) it is st_ino that is
1141
 
            # odd. Regardless we shouldn't actually try to assert anything
1142
 
            # about their values
1143
 
            self.assertEqual(expected.st_dev, actual.st_dev,
1144
 
                             'st_dev did not match')
1145
 
            self.assertEqual(expected.st_ino, actual.st_ino,
1146
 
                             'st_ino did not match')
1147
 
        self.assertEqual(expected.st_mode, actual.st_mode,
1148
 
                         'st_mode did not match')
 
903
        self.assertEqual(expected.st_size, actual.st_size)
 
904
        self.assertEqual(expected.st_mtime, actual.st_mtime)
 
905
        self.assertEqual(expected.st_ctime, actual.st_ctime)
 
906
        self.assertEqual(expected.st_dev, actual.st_dev)
 
907
        self.assertEqual(expected.st_ino, actual.st_ino)
 
908
        self.assertEqual(expected.st_mode, actual.st_mode)
1149
909
 
1150
910
    def assertLength(self, length, obj_with_len):
1151
911
        """Assert that obj_with_len is of length length."""
1153
913
            self.fail("Incorrect length: wanted %d, got %d for %r" % (
1154
914
                length, len(obj_with_len), obj_with_len))
1155
915
 
1156
 
    def assertLogsError(self, exception_class, func, *args, **kwargs):
1157
 
        """Assert that func(*args, **kwargs) quietly logs a specific exception.
1158
 
        """
1159
 
        from bzrlib import trace
1160
 
        captured = []
1161
 
        orig_log_exception_quietly = trace.log_exception_quietly
1162
 
        try:
1163
 
            def capture():
1164
 
                orig_log_exception_quietly()
1165
 
                captured.append(sys.exc_info())
1166
 
            trace.log_exception_quietly = capture
1167
 
            func(*args, **kwargs)
1168
 
        finally:
1169
 
            trace.log_exception_quietly = orig_log_exception_quietly
1170
 
        self.assertLength(1, captured)
1171
 
        err = captured[0][1]
1172
 
        self.assertIsInstance(err, exception_class)
1173
 
        return err
1174
 
 
1175
916
    def assertPositive(self, val):
1176
917
        """Assert that val is greater than 0."""
1177
918
        self.assertTrue(val > 0, 'expected a positive value, but got %s' % val)
1207
948
            raise AssertionError('pattern "%s" found in "%s"'
1208
949
                    % (needle_re, haystack))
1209
950
 
1210
 
    def assertContainsString(self, haystack, needle):
1211
 
        if haystack.find(needle) == -1:
1212
 
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
1213
 
 
1214
951
    def assertSubset(self, sublist, superlist):
1215
952
        """Assert that every entry in sublist is present in superlist."""
1216
953
        missing = set(sublist) - set(superlist)
1273
1010
                raise AssertionError("%r is %r." % (left, right))
1274
1011
 
1275
1012
    def assertTransportMode(self, transport, path, mode):
1276
 
        """Fail if a path does not have mode "mode".
 
1013
        """Fail if a path does not have mode mode.
1277
1014
 
1278
1015
        If modes are not supported on this transport, the assertion is ignored.
1279
1016
        """
1291
1028
                         osutils.realpath(path2),
1292
1029
                         "apparent paths:\na = %s\nb = %s\n," % (path1, path2))
1293
1030
 
1294
 
    def assertIsInstance(self, obj, kls, msg=None):
1295
 
        """Fail if obj is not an instance of kls
1296
 
        
1297
 
        :param msg: Supplementary message to show if the assertion fails.
1298
 
        """
 
1031
    def assertIsInstance(self, obj, kls):
 
1032
        """Fail if obj is not an instance of kls"""
1299
1033
        if not isinstance(obj, kls):
1300
 
            m = "%r is an instance of %s rather than %s" % (
1301
 
                obj, obj.__class__, kls)
1302
 
            if msg:
1303
 
                m += ": " + msg
1304
 
            self.fail(m)
 
1034
            self.fail("%r is an instance of %s rather than %s" % (
 
1035
                obj, obj.__class__, kls))
 
1036
 
 
1037
    def expectFailure(self, reason, assertion, *args, **kwargs):
 
1038
        """Invoke a test, expecting it to fail for the given reason.
 
1039
 
 
1040
        This is for assertions that ought to succeed, but currently fail.
 
1041
        (The failure is *expected* but not *wanted*.)  Please be very precise
 
1042
        about the failure you're expecting.  If a new bug is introduced,
 
1043
        AssertionError should be raised, not KnownFailure.
 
1044
 
 
1045
        Frequently, expectFailure should be followed by an opposite assertion.
 
1046
        See example below.
 
1047
 
 
1048
        Intended to be used with a callable that raises AssertionError as the
 
1049
        'assertion' parameter.  args and kwargs are passed to the 'assertion'.
 
1050
 
 
1051
        Raises KnownFailure if the test fails.  Raises AssertionError if the
 
1052
        test succeeds.
 
1053
 
 
1054
        example usage::
 
1055
 
 
1056
          self.expectFailure('Math is broken', self.assertNotEqual, 54,
 
1057
                             dynamic_val)
 
1058
          self.assertEqual(42, dynamic_val)
 
1059
 
 
1060
          This means that a dynamic_val of 54 will cause the test to raise
 
1061
          a KnownFailure.  Once math is fixed and the expectFailure is removed,
 
1062
          only a dynamic_val of 42 will allow the test to pass.  Anything other
 
1063
          than 54 or 42 will cause an AssertionError.
 
1064
        """
 
1065
        try:
 
1066
            assertion(*args, **kwargs)
 
1067
        except AssertionError:
 
1068
            raise KnownFailure(reason)
 
1069
        else:
 
1070
            self.fail('Unexpected success.  Should have failed: %s' % reason)
1305
1071
 
1306
1072
    def assertFileEqual(self, content, path):
1307
1073
        """Fail if path does not contain 'content'."""
1313
1079
            f.close()
1314
1080
        self.assertEqualDiff(content, s)
1315
1081
 
1316
 
    def assertDocstring(self, expected_docstring, obj):
1317
 
        """Fail if obj does not have expected_docstring"""
1318
 
        if __doc__ is None:
1319
 
            # With -OO the docstring should be None instead
1320
 
            self.assertIs(obj.__doc__, None)
1321
 
        else:
1322
 
            self.assertEqual(expected_docstring, obj.__doc__)
1323
 
 
1324
1082
    def failUnlessExists(self, path):
1325
1083
        """Fail unless path or paths, which may be abs or relative, exist."""
1326
1084
        if not isinstance(path, basestring):
1466
1224
 
1467
1225
        Close the file and delete it, unless setKeepLogfile was called.
1468
1226
        """
1469
 
        if bzrlib.trace._trace_file:
1470
 
            # flush the log file, to get all content
1471
 
            bzrlib.trace._trace_file.flush()
 
1227
        if self._log_file is None:
 
1228
            return
1472
1229
        bzrlib.trace.pop_log_file(self._log_memento)
1473
 
        # Cache the log result and delete the file on disk
1474
 
        self._get_log(False)
1475
 
 
1476
 
    def thisFailsStrictLockCheck(self):
1477
 
        """It is known that this test would fail with -Dstrict_locks.
1478
 
 
1479
 
        By default, all tests are run with strict lock checking unless
1480
 
        -Edisable_lock_checks is supplied. However there are some tests which
1481
 
        we know fail strict locks at this point that have not been fixed.
1482
 
        They should call this function to disable the strict checking.
1483
 
 
1484
 
        This should be used sparingly, it is much better to fix the locking
1485
 
        issues rather than papering over the problem by calling this function.
1486
 
        """
1487
 
        debug.debug_flags.discard('strict_locks')
 
1230
        self._log_file.close()
 
1231
        self._log_file = None
 
1232
        if not self._keep_log_file:
 
1233
            os.remove(self._log_file_name)
 
1234
            self._log_file_name = None
 
1235
 
 
1236
    def setKeepLogfile(self):
 
1237
        """Make the logfile not be deleted when _finishLogFile is called."""
 
1238
        self._keep_log_file = True
1488
1239
 
1489
1240
    def addCleanup(self, callable, *args, **kwargs):
1490
1241
        """Arrange to run a callable when this case is torn down.
1494
1245
        """
1495
1246
        self._cleanups.append((callable, args, kwargs))
1496
1247
 
1497
 
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
1498
 
        """Overrides an object attribute restoring it after the test.
1499
 
 
1500
 
        :param obj: The object that will be mutated.
1501
 
 
1502
 
        :param attr_name: The attribute name we want to preserve/override in
1503
 
            the object.
1504
 
 
1505
 
        :param new: The optional value we want to set the attribute to.
1506
 
 
1507
 
        :returns: The actual attr value.
1508
 
        """
1509
 
        value = getattr(obj, attr_name)
1510
 
        # The actual value is captured by the call below
1511
 
        self.addCleanup(setattr, obj, attr_name, value)
1512
 
        if new is not _unitialized_attr:
1513
 
            setattr(obj, attr_name, new)
1514
 
        return value
1515
 
 
1516
1248
    def _cleanEnvironment(self):
1517
1249
        new_env = {
1518
1250
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
1528
1260
            'BZR_PROGRESS_BAR': None,
1529
1261
            'BZR_LOG': None,
1530
1262
            'BZR_PLUGIN_PATH': None,
1531
 
            'BZR_DISABLE_PLUGINS': None,
1532
 
            'BZR_PLUGINS_AT': None,
1533
 
            'BZR_CONCURRENCY': None,
1534
 
            # Make sure that any text ui tests are consistent regardless of
1535
 
            # the environment the test case is run in; you may want tests that
1536
 
            # test other combinations.  'dumb' is a reasonable guess for tests
1537
 
            # going to a pipe or a StringIO.
1538
 
            'TERM': 'dumb',
1539
 
            'LINES': '25',
1540
 
            'COLUMNS': '80',
1541
 
            'BZR_COLUMNS': '80',
1542
1263
            # SSH Agent
1543
1264
            'SSH_AUTH_SOCK': None,
1544
1265
            # Proxies
1550
1271
            'NO_PROXY': None,
1551
1272
            'all_proxy': None,
1552
1273
            'ALL_PROXY': None,
1553
 
            # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
 
1274
            # Nobody cares about these ones AFAIK. So far at
1554
1275
            # least. If you do (care), please update this comment
1555
 
            # -- vila 20080401
 
1276
            # -- vila 20061212
1556
1277
            'ftp_proxy': None,
1557
1278
            'FTP_PROXY': None,
1558
1279
            'BZR_REMOTE_PATH': None,
1559
 
            # Generally speaking, we don't want apport reporting on crashes in
1560
 
            # the test envirnoment unless we're specifically testing apport,
1561
 
            # so that it doesn't leak into the real system environment.  We
1562
 
            # use an env var so it propagates to subprocesses.
1563
 
            'APPORT_DISABLE': '1',
1564
1280
        }
1565
 
        self._old_env = {}
 
1281
        self.__old_env = {}
1566
1282
        self.addCleanup(self._restoreEnvironment)
1567
1283
        for name, value in new_env.iteritems():
1568
1284
            self._captureVar(name, value)
1569
1285
 
1570
1286
    def _captureVar(self, name, newvalue):
1571
1287
        """Set an environment variable, and reset it when finished."""
1572
 
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1288
        self.__old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1289
 
 
1290
    def _restore_debug_flags(self):
 
1291
        debug.debug_flags.clear()
 
1292
        debug.debug_flags.update(self._preserved_debug_flags)
1573
1293
 
1574
1294
    def _restoreEnvironment(self):
1575
 
        for name, value in self._old_env.iteritems():
 
1295
        for name, value in self.__old_env.iteritems():
1576
1296
            osutils.set_or_unset_env(name, value)
1577
1297
 
1578
1298
    def _restoreHooks(self):
1586
1306
    def _do_skip(self, result, reason):
1587
1307
        addSkip = getattr(result, 'addSkip', None)
1588
1308
        if not callable(addSkip):
1589
 
            result.addSuccess(result)
 
1309
            result.addError(self, self.exc_info())
1590
1310
        else:
1591
1311
            addSkip(self, reason)
1592
1312
 
1593
 
    @staticmethod
1594
 
    def _do_known_failure(self, result, e):
1595
 
        err = sys.exc_info()
1596
 
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
1597
 
        if addExpectedFailure is not None:
1598
 
            addExpectedFailure(self, err)
1599
 
        else:
1600
 
            result.addSuccess(self)
1601
 
 
1602
 
    @staticmethod
1603
 
    def _do_not_applicable(self, result, e):
1604
 
        if not e.args:
1605
 
            reason = 'No reason given'
1606
 
        else:
1607
 
            reason = e.args[0]
1608
 
        addNotApplicable = getattr(result, 'addNotApplicable', None)
1609
 
        if addNotApplicable is not None:
1610
 
            result.addNotApplicable(self, reason)
1611
 
        else:
1612
 
            self._do_skip(result, reason)
1613
 
 
1614
 
    @staticmethod
1615
 
    def _do_unsupported_or_skip(self, result, e):
1616
 
        reason = e.args[0]
1617
 
        addNotSupported = getattr(result, 'addNotSupported', None)
1618
 
        if addNotSupported is not None:
1619
 
            result.addNotSupported(self, reason)
1620
 
        else:
1621
 
            self._do_skip(result, reason)
 
1313
    def run(self, result=None):
 
1314
        if result is None: result = self.defaultTestResult()
 
1315
        for feature in getattr(self, '_test_needs_features', []):
 
1316
            if not feature.available():
 
1317
                result.startTest(self)
 
1318
                if getattr(result, 'addNotSupported', None):
 
1319
                    result.addNotSupported(self, feature)
 
1320
                else:
 
1321
                    result.addSuccess(self)
 
1322
                result.stopTest(self)
 
1323
                return
 
1324
        try:
 
1325
            try:
 
1326
                result.startTest(self)
 
1327
                absent_attr = object()
 
1328
                # Python 2.5
 
1329
                method_name = getattr(self, '_testMethodName', absent_attr)
 
1330
                if method_name is absent_attr:
 
1331
                    # Python 2.4
 
1332
                    method_name = getattr(self, '_TestCase__testMethodName')
 
1333
                testMethod = getattr(self, method_name)
 
1334
                try:
 
1335
                    try:
 
1336
                        self.setUp()
 
1337
                        if not self._bzr_test_setUp_run:
 
1338
                            self.fail(
 
1339
                                "test setUp did not invoke "
 
1340
                                "bzrlib.tests.TestCase's setUp")
 
1341
                    except KeyboardInterrupt:
 
1342
                        raise
 
1343
                    except TestSkipped, e:
 
1344
                        self._do_skip(result, e.args[0])
 
1345
                        self.tearDown()
 
1346
                        return
 
1347
                    except:
 
1348
                        result.addError(self, self.exc_info())
 
1349
                        return
 
1350
 
 
1351
                    ok = False
 
1352
                    try:
 
1353
                        testMethod()
 
1354
                        ok = True
 
1355
                    except self.failureException:
 
1356
                        result.addFailure(self, self.exc_info())
 
1357
                    except TestSkipped, e:
 
1358
                        if not e.args:
 
1359
                            reason = "No reason given."
 
1360
                        else:
 
1361
                            reason = e.args[0]
 
1362
                        self._do_skip(result, reason)
 
1363
                    except KeyboardInterrupt:
 
1364
                        raise
 
1365
                    except:
 
1366
                        result.addError(self, self.exc_info())
 
1367
 
 
1368
                    try:
 
1369
                        self.tearDown()
 
1370
                        if not self._bzr_test_tearDown_run:
 
1371
                            self.fail(
 
1372
                                "test tearDown did not invoke "
 
1373
                                "bzrlib.tests.TestCase's tearDown")
 
1374
                    except KeyboardInterrupt:
 
1375
                        raise
 
1376
                    except:
 
1377
                        result.addError(self, self.exc_info())
 
1378
                        ok = False
 
1379
                    if ok: result.addSuccess(self)
 
1380
                finally:
 
1381
                    result.stopTest(self)
 
1382
                return
 
1383
            except TestNotApplicable:
 
1384
                # Not moved from the result [yet].
 
1385
                raise
 
1386
            except KeyboardInterrupt:
 
1387
                raise
 
1388
        finally:
 
1389
            saved_attrs = {}
 
1390
            absent_attr = object()
 
1391
            for attr_name in self.attrs_to_keep:
 
1392
                attr = getattr(self, attr_name, absent_attr)
 
1393
                if attr is not absent_attr:
 
1394
                    saved_attrs[attr_name] = attr
 
1395
            self.__dict__ = saved_attrs
 
1396
 
 
1397
    def tearDown(self):
 
1398
        self._bzr_test_tearDown_run = True
 
1399
        self._runCleanups()
 
1400
        self._log_contents = ''
 
1401
        unittest.TestCase.tearDown(self)
1622
1402
 
1623
1403
    def time(self, callable, *args, **kwargs):
1624
1404
        """Run callable and accrue the time it takes to the benchmark time.
1628
1408
        self._benchcalls.
1629
1409
        """
1630
1410
        if self._benchtime is None:
1631
 
            self.addDetail('benchtime', content.Content(content.ContentType(
1632
 
                "text", "plain"), lambda:[str(self._benchtime)]))
1633
1411
            self._benchtime = 0
1634
1412
        start = time.time()
1635
1413
        try:
1644
1422
        finally:
1645
1423
            self._benchtime += time.time() - start
1646
1424
 
 
1425
    def _runCleanups(self):
 
1426
        """Run registered cleanup functions.
 
1427
 
 
1428
        This should only be called from TestCase.tearDown.
 
1429
        """
 
1430
        # TODO: Perhaps this should keep running cleanups even if
 
1431
        # one of them fails?
 
1432
 
 
1433
        # Actually pop the cleanups from the list so tearDown running
 
1434
        # twice is safe (this happens for skipped tests).
 
1435
        while self._cleanups:
 
1436
            cleanup, args, kwargs = self._cleanups.pop()
 
1437
            cleanup(*args, **kwargs)
 
1438
 
1647
1439
    def log(self, *args):
1648
1440
        mutter(*args)
1649
1441
 
1650
1442
    def _get_log(self, keep_log_file=False):
1651
 
        """Internal helper to get the log from bzrlib.trace for this test.
1652
 
 
1653
 
        Please use self.getDetails, or self.get_log to access this in test case
1654
 
        code.
 
1443
        """Get the log from bzrlib.trace calls from this test.
1655
1444
 
1656
1445
        :param keep_log_file: When True, if the log is still a file on disk
1657
1446
            leave it as a file on disk. When False, if the log is still a file
1659
1448
            self._log_contents.
1660
1449
        :return: A string containing the log.
1661
1450
        """
1662
 
        if self._log_contents is not None:
1663
 
            try:
1664
 
                self._log_contents.decode('utf8')
1665
 
            except UnicodeDecodeError:
1666
 
                unicodestr = self._log_contents.decode('utf8', 'replace')
1667
 
                self._log_contents = unicodestr.encode('utf8')
 
1451
        # flush the log file, to get all content
 
1452
        import bzrlib.trace
 
1453
        if bzrlib.trace._trace_file:
 
1454
            bzrlib.trace._trace_file.flush()
 
1455
        if self._log_contents:
 
1456
            # XXX: this can hardly contain the content flushed above --vila
 
1457
            # 20080128
1668
1458
            return self._log_contents
1669
 
        import bzrlib.trace
1670
 
        if bzrlib.trace._trace_file:
1671
 
            # flush the log file, to get all content
1672
 
            bzrlib.trace._trace_file.flush()
1673
1459
        if self._log_file_name is not None:
1674
1460
            logfile = open(self._log_file_name)
1675
1461
            try:
1676
1462
                log_contents = logfile.read()
1677
1463
            finally:
1678
1464
                logfile.close()
1679
 
            try:
1680
 
                log_contents.decode('utf8')
1681
 
            except UnicodeDecodeError:
1682
 
                unicodestr = log_contents.decode('utf8', 'replace')
1683
 
                log_contents = unicodestr.encode('utf8')
1684
1465
            if not keep_log_file:
1685
 
                close_attempts = 0
1686
 
                max_close_attempts = 100
1687
 
                first_close_error = None
1688
 
                while close_attempts < max_close_attempts:
1689
 
                    close_attempts += 1
1690
 
                    try:
1691
 
                        self._log_file.close()
1692
 
                    except IOError, ioe:
1693
 
                        if ioe.errno is None:
1694
 
                            # No errno implies 'close() called during
1695
 
                            # concurrent operation on the same file object', so
1696
 
                            # retry.  Probably a thread is trying to write to
1697
 
                            # the log file.
1698
 
                            if first_close_error is None:
1699
 
                                first_close_error = ioe
1700
 
                            continue
1701
 
                        raise
1702
 
                    else:
1703
 
                        break
1704
 
                if close_attempts > 1:
1705
 
                    sys.stderr.write(
1706
 
                        'Unable to close log file on first attempt, '
1707
 
                        'will retry: %s\n' % (first_close_error,))
1708
 
                    if close_attempts == max_close_attempts:
1709
 
                        sys.stderr.write(
1710
 
                            'Unable to close log file after %d attempts.\n'
1711
 
                            % (max_close_attempts,))
1712
 
                self._log_file = None
1713
 
                # Permit multiple calls to get_log until we clean it up in
1714
 
                # finishLogFile
1715
1466
                self._log_contents = log_contents
1716
1467
                try:
1717
1468
                    os.remove(self._log_file_name)
1721
1472
                                             ' %r\n' % self._log_file_name))
1722
1473
                    else:
1723
1474
                        raise
1724
 
                self._log_file_name = None
1725
1475
            return log_contents
1726
1476
        else:
1727
 
            return "No log file content and no log file name."
1728
 
 
1729
 
    def get_log(self):
1730
 
        """Get a unicode string containing the log from bzrlib.trace.
1731
 
 
1732
 
        Undecodable characters are replaced.
1733
 
        """
1734
 
        return u"".join(self.getDetails()['log'].iter_text())
 
1477
            return "DELETED log file to reduce memory footprint"
1735
1478
 
1736
1479
    def requireFeature(self, feature):
1737
1480
        """This test requires a specific feature is available.
1754
1497
 
1755
1498
    def _run_bzr_core(self, args, retcode, encoding, stdin,
1756
1499
            working_dir):
1757
 
        # Clear chk_map page cache, because the contents are likely to mask
1758
 
        # locking errors.
1759
 
        chk_map.clear_cache()
1760
1500
        if encoding is None:
1761
1501
            encoding = osutils.get_user_encoding()
1762
1502
        stdout = StringIOWrapper()
1779
1519
            os.chdir(working_dir)
1780
1520
 
1781
1521
        try:
1782
 
            try:
1783
 
                result = self.apply_redirected(ui.ui_factory.stdin,
1784
 
                    stdout, stderr,
1785
 
                    bzrlib.commands.run_bzr_catch_user_errors,
1786
 
                    args)
1787
 
            except KeyboardInterrupt:
1788
 
                # Reraise KeyboardInterrupt with contents of redirected stdout
1789
 
                # and stderr as arguments, for tests which are interested in
1790
 
                # stdout and stderr and are expecting the exception.
1791
 
                out = stdout.getvalue()
1792
 
                err = stderr.getvalue()
1793
 
                if out:
1794
 
                    self.log('output:\n%r', out)
1795
 
                if err:
1796
 
                    self.log('errors:\n%r', err)
1797
 
                raise KeyboardInterrupt(out, err)
 
1522
            result = self.apply_redirected(ui.ui_factory.stdin,
 
1523
                stdout, stderr,
 
1524
                bzrlib.commands.run_bzr_catch_user_errors,
 
1525
                args)
1798
1526
        finally:
1799
1527
            logger.removeHandler(handler)
1800
1528
            ui.ui_factory = old_ui_factory
1810
1538
        if retcode is not None:
1811
1539
            self.assertEquals(retcode, result,
1812
1540
                              message='Unexpected return code')
1813
 
        return result, out, err
 
1541
        return out, err
1814
1542
 
1815
1543
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
1816
1544
                working_dir=None, error_regexes=[], output_encoding=None):
1845
1573
        :keyword error_regexes: A list of expected error messages.  If
1846
1574
            specified they must be seen in the error output of the command.
1847
1575
        """
1848
 
        retcode, out, err = self._run_bzr_autosplit(
 
1576
        out, err = self._run_bzr_autosplit(
1849
1577
            args=args,
1850
1578
            retcode=retcode,
1851
1579
            encoding=encoding,
1852
1580
            stdin=stdin,
1853
1581
            working_dir=working_dir,
1854
1582
            )
1855
 
        self.assertIsInstance(error_regexes, (list, tuple))
1856
1583
        for regex in error_regexes:
1857
1584
            self.assertContainsRe(err, regex)
1858
1585
        return out, err
2002
1729
        """
2003
1730
        return Popen(*args, **kwargs)
2004
1731
 
2005
 
    def get_source_path(self):
2006
 
        """Return the path of the directory containing bzrlib."""
2007
 
        return os.path.dirname(os.path.dirname(bzrlib.__file__))
2008
 
 
2009
1732
    def get_bzr_path(self):
2010
1733
        """Return the path of the 'bzr' executable for this test suite."""
2011
 
        bzr_path = self.get_source_path()+'/bzr'
 
1734
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
2012
1735
        if not os.path.isfile(bzr_path):
2013
1736
            # We are probably installed. Assume sys.argv is the right file
2014
1737
            bzr_path = sys.argv[0]
2100
1823
 
2101
1824
        Tests that expect to provoke LockContention errors should call this.
2102
1825
        """
2103
 
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
 
1826
        orig_timeout = bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS
 
1827
        def resetTimeout():
 
1828
            bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = orig_timeout
 
1829
        self.addCleanup(resetTimeout)
 
1830
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 0
2104
1831
 
2105
1832
    def make_utf8_encoded_stringio(self, encoding_type=None):
2106
1833
        """Return a StringIOWrapper instance, that will encode Unicode
2114
1841
        sio.encoding = output_encoding
2115
1842
        return sio
2116
1843
 
2117
 
    def disable_verb(self, verb):
2118
 
        """Disable a smart server verb for one test."""
2119
 
        from bzrlib.smart import request
2120
 
        request_handlers = request.request_handlers
2121
 
        orig_method = request_handlers.get(verb)
2122
 
        request_handlers.remove(verb)
2123
 
        self.addCleanup(request_handlers.register, verb, orig_method)
2124
 
 
2125
1844
 
2126
1845
class CapturedCall(object):
2127
1846
    """A helper for capturing smart server calls for easy debug analysis."""
2217
1936
        if self.__readonly_server is None:
2218
1937
            if self.transport_readonly_server is None:
2219
1938
                # readonly decorator requested
2220
 
                self.__readonly_server = test_server.ReadonlyServer()
 
1939
                # bring up the server
 
1940
                self.__readonly_server = ReadonlyServer()
 
1941
                self.__readonly_server.setUp(self.get_vfs_only_server())
2221
1942
            else:
2222
 
                # explicit readonly transport.
2223
1943
                self.__readonly_server = self.create_transport_readonly_server()
2224
 
            self.start_server(self.__readonly_server,
2225
 
                self.get_vfs_only_server())
 
1944
                self.__readonly_server.setUp(self.get_vfs_only_server())
 
1945
            self.addCleanup(self.__readonly_server.tearDown)
2226
1946
        return self.__readonly_server
2227
1947
 
2228
1948
    def get_readonly_url(self, relpath=None):
2246
1966
        is no means to override it.
2247
1967
        """
2248
1968
        if self.__vfs_server is None:
2249
 
            self.__vfs_server = memory.MemoryServer()
2250
 
            self.start_server(self.__vfs_server)
 
1969
            self.__vfs_server = MemoryServer()
 
1970
            self.__vfs_server.setUp()
 
1971
            self.addCleanup(self.__vfs_server.tearDown)
2251
1972
        return self.__vfs_server
2252
1973
 
2253
1974
    def get_server(self):
2260
1981
        then the self.get_vfs_server is returned.
2261
1982
        """
2262
1983
        if self.__server is None:
2263
 
            if (self.transport_server is None or self.transport_server is
2264
 
                self.vfs_transport_factory):
2265
 
                self.__server = self.get_vfs_only_server()
 
1984
            if self.transport_server is None or self.transport_server is self.vfs_transport_factory:
 
1985
                return self.get_vfs_only_server()
2266
1986
            else:
2267
1987
                # bring up a decorated means of access to the vfs only server.
2268
1988
                self.__server = self.transport_server()
2269
 
                self.start_server(self.__server, self.get_vfs_only_server())
 
1989
                try:
 
1990
                    self.__server.setUp(self.get_vfs_only_server())
 
1991
                except TypeError, e:
 
1992
                    # This should never happen; the try:Except here is to assist
 
1993
                    # developers having to update code rather than seeing an
 
1994
                    # uninformative TypeError.
 
1995
                    raise Exception, "Old server API in use: %s, %s" % (self.__server, e)
 
1996
            self.addCleanup(self.__server.tearDown)
2270
1997
        return self.__server
2271
1998
 
2272
1999
    def _adjust_url(self, base, relpath):
2334
2061
        propagating. This method ensures than a test did not leaked.
2335
2062
        """
2336
2063
        root = TestCaseWithMemoryTransport.TEST_ROOT
2337
 
        self.permit_url(get_transport(root).base)
2338
2064
        wt = workingtree.WorkingTree.open(root)
2339
2065
        last_rev = wt.last_revision()
2340
2066
        if last_rev != 'null:':
2342
2068
            # recreate a new one or all the followng tests will fail.
2343
2069
            # If you need to inspect its content uncomment the following line
2344
2070
            # import pdb; pdb.set_trace()
2345
 
            _rmtree_temp_dir(root + '/.bzr', test_id=self.id())
 
2071
            _rmtree_temp_dir(root + '/.bzr')
2346
2072
            self._create_safety_net()
2347
2073
            raise AssertionError('%s/.bzr should not be modified' % root)
2348
2074
 
2349
2075
    def _make_test_root(self):
2350
2076
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
2351
 
            # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
2352
 
            root = osutils.realpath(osutils.mkdtemp(prefix='testbzr-',
2353
 
                                                    suffix='.tmp'))
 
2077
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
2354
2078
            TestCaseWithMemoryTransport.TEST_ROOT = root
2355
2079
 
2356
2080
            self._create_safety_net()
2359
2083
            # specifically told when all tests are finished.  This will do.
2360
2084
            atexit.register(_rmtree_temp_dir, root)
2361
2085
 
2362
 
        self.permit_dir(TestCaseWithMemoryTransport.TEST_ROOT)
2363
2086
        self.addCleanup(self._check_safety_net)
2364
2087
 
2365
2088
    def makeAndChdirToTestDir(self):
2373
2096
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2374
2097
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2375
2098
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
2376
 
        self.permit_dir(self.test_dir)
2377
2099
 
2378
2100
    def make_branch(self, relpath, format=None):
2379
2101
        """Create a branch on the transport at relpath."""
2409
2131
        return made_control.create_repository(shared=shared)
2410
2132
 
2411
2133
    def make_smart_server(self, path):
2412
 
        smart_server = test_server.SmartTCPServer_for_testing()
2413
 
        self.start_server(smart_server, self.get_server())
 
2134
        smart_server = server.SmartTCPServer_for_testing()
 
2135
        smart_server.setUp(self.get_server())
2414
2136
        remote_transport = get_transport(smart_server.get_url()).clone(path)
 
2137
        self.addCleanup(smart_server.tearDown)
2415
2138
        return remote_transport
2416
2139
 
2417
2140
    def make_branch_and_memory_tree(self, relpath, format=None):
2420
2143
        return memorytree.MemoryTree.create_on_branch(b)
2421
2144
 
2422
2145
    def make_branch_builder(self, relpath, format=None):
2423
 
        branch = self.make_branch(relpath, format=format)
2424
 
        return branchbuilder.BranchBuilder(branch=branch)
 
2146
        return branchbuilder.BranchBuilder(self.get_transport(relpath),
 
2147
            format=format)
2425
2148
 
2426
2149
    def overrideEnvironmentForTesting(self):
2427
 
        test_home_dir = self.test_home_dir
2428
 
        if isinstance(test_home_dir, unicode):
2429
 
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
2430
 
        os.environ['HOME'] = test_home_dir
2431
 
        os.environ['BZR_HOME'] = test_home_dir
 
2150
        os.environ['HOME'] = self.test_home_dir
 
2151
        os.environ['BZR_HOME'] = self.test_home_dir
2432
2152
 
2433
2153
    def setUp(self):
2434
2154
        super(TestCaseWithMemoryTransport, self).setUp()
2435
2155
        self._make_test_root()
2436
 
        self.addCleanup(os.chdir, os.getcwdu())
 
2156
        _currentdir = os.getcwdu()
 
2157
        def _leaveDirectory():
 
2158
            os.chdir(_currentdir)
 
2159
        self.addCleanup(_leaveDirectory)
2437
2160
        self.makeAndChdirToTestDir()
2438
2161
        self.overrideEnvironmentForTesting()
2439
2162
        self.__readonly_server = None
2442
2165
 
2443
2166
    def setup_smart_server_with_call_log(self):
2444
2167
        """Sets up a smart server as the transport server with a call log."""
2445
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
2168
        self.transport_server = server.SmartTCPServer_for_testing
2446
2169
        self.hpss_calls = []
2447
2170
        import traceback
2448
2171
        # Skip the current stack down to the caller of
2490
2213
 
2491
2214
    def _getTestDirPrefix(self):
2492
2215
        # create a directory within the top level test directory
2493
 
        if sys.platform in ('win32', 'cygwin'):
 
2216
        if sys.platform == 'win32':
2494
2217
            name_prefix = re.sub('[<>*=+",:;_/\\-]', '_', self.id())
2495
2218
            # windows is likely to have path-length limits so use a short name
2496
2219
            name_prefix = name_prefix[-30:]
2504
2227
        For TestCaseInTempDir we create a temporary directory based on the test
2505
2228
        name and then create two subdirs - test and home under it.
2506
2229
        """
2507
 
        name_prefix = osutils.pathjoin(TestCaseWithMemoryTransport.TEST_ROOT,
2508
 
            self._getTestDirPrefix())
 
2230
        name_prefix = osutils.pathjoin(self.TEST_ROOT, self._getTestDirPrefix())
2509
2231
        name = name_prefix
2510
2232
        for i in range(100):
2511
2233
            if os.path.exists(name):
2512
2234
                name = name_prefix + '_' + str(i)
2513
2235
            else:
2514
 
                # now create test and home directories within this dir
2515
 
                self.test_base_dir = name
2516
 
                self.addCleanup(self.deleteTestDir)
2517
 
                os.mkdir(self.test_base_dir)
 
2236
                os.mkdir(name)
2518
2237
                break
2519
 
        self.permit_dir(self.test_base_dir)
2520
 
        # 'sprouting' and 'init' of a branch both walk up the tree to find
2521
 
        # stacking policy to honour; create a bzr dir with an unshared
2522
 
        # repository (but not a branch - our code would be trying to escape
2523
 
        # then!) to stop them, and permit it to be read.
2524
 
        # control = bzrdir.BzrDir.create(self.test_base_dir)
2525
 
        # control.create_repository()
 
2238
        # now create test and home directories within this dir
 
2239
        self.test_base_dir = name
2526
2240
        self.test_home_dir = self.test_base_dir + '/home'
2527
2241
        os.mkdir(self.test_home_dir)
2528
2242
        self.test_dir = self.test_base_dir + '/work'
2534
2248
            f.write(self.id())
2535
2249
        finally:
2536
2250
            f.close()
 
2251
        self.addCleanup(self.deleteTestDir)
2537
2252
 
2538
2253
    def deleteTestDir(self):
2539
 
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2540
 
        _rmtree_temp_dir(self.test_base_dir, test_id=self.id())
 
2254
        os.chdir(self.TEST_ROOT)
 
2255
        _rmtree_temp_dir(self.test_base_dir)
2541
2256
 
2542
2257
    def build_tree(self, shape, line_endings='binary', transport=None):
2543
2258
        """Build a test tree according to a pattern.
2578
2293
                content = "contents of %s%s" % (name.encode('utf-8'), end)
2579
2294
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
2580
2295
 
2581
 
    build_tree_contents = staticmethod(treeshape.build_tree_contents)
 
2296
    def build_tree_contents(self, shape):
 
2297
        build_tree_contents(shape)
2582
2298
 
2583
2299
    def assertInWorkingTree(self, path, root_path='.', tree=None):
2584
2300
        """Assert whether path or paths are in the WorkingTree"""
2624
2340
        """
2625
2341
        if self.__vfs_server is None:
2626
2342
            self.__vfs_server = self.vfs_transport_factory()
2627
 
            self.start_server(self.__vfs_server)
 
2343
            self.__vfs_server.setUp()
 
2344
            self.addCleanup(self.__vfs_server.tearDown)
2628
2345
        return self.__vfs_server
2629
2346
 
2630
2347
    def make_branch_and_tree(self, relpath, format=None):
2637
2354
        repository will also be accessed locally. Otherwise a lightweight
2638
2355
        checkout is created and returned.
2639
2356
 
2640
 
        We do this because we can't physically create a tree in the local
2641
 
        path, with a branch reference to the transport_factory url, and
2642
 
        a branch + repository in the vfs_transport, unless the vfs_transport
2643
 
        namespace is distinct from the local disk - the two branch objects
2644
 
        would collide. While we could construct a tree with its branch object
2645
 
        pointing at the transport_factory transport in memory, reopening it
2646
 
        would behaving unexpectedly, and has in the past caused testing bugs
2647
 
        when we tried to do it that way.
2648
 
 
2649
2357
        :param format: The BzrDirFormat.
2650
2358
        :returns: the WorkingTree.
2651
2359
        """
2660
2368
            # We can only make working trees locally at the moment.  If the
2661
2369
            # transport can't support them, then we keep the non-disk-backed
2662
2370
            # branch and create a local checkout.
2663
 
            if self.vfs_transport_factory is test_server.LocalURLServer:
 
2371
            if self.vfs_transport_factory is LocalURLServer:
2664
2372
                # the branch is colocated on disk, we cannot create a checkout.
2665
2373
                # hopefully callers will expect this.
2666
2374
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
2703
2411
        super(TestCaseWithTransport, self).setUp()
2704
2412
        self.__vfs_server = None
2705
2413
 
2706
 
    def disable_missing_extensions_warning(self):
2707
 
        """Some tests expect a precise stderr content.
2708
 
 
2709
 
        There is no point in forcing them to duplicate the extension related
2710
 
        warning.
2711
 
        """
2712
 
        config.GlobalConfig().set_user_option('ignore_missing_extensions', True)
2713
 
 
2714
2414
 
2715
2415
class ChrootedTestCase(TestCaseWithTransport):
2716
2416
    """A support class that provides readonly urls outside the local namespace.
2726
2426
 
2727
2427
    def setUp(self):
2728
2428
        super(ChrootedTestCase, self).setUp()
2729
 
        if not self.vfs_transport_factory == memory.MemoryServer:
 
2429
        if not self.vfs_transport_factory == MemoryServer:
2730
2430
            self.transport_readonly_server = HttpServer
2731
2431
 
2732
2432
 
2928
2628
              random_seed=None,
2929
2629
              exclude_pattern=None,
2930
2630
              strict=False,
2931
 
              runner_class=None,
2932
 
              suite_decorators=None,
2933
 
              stream=None,
2934
 
              result_decorators=None,
2935
 
              ):
 
2631
              runner_class=None):
2936
2632
    """Run a test suite for bzr selftest.
2937
2633
 
2938
2634
    :param runner_class: The class of runner to use. Must support the
2947
2643
        verbosity = 1
2948
2644
    if runner_class is None:
2949
2645
        runner_class = TextTestRunner
2950
 
    if stream is None:
2951
 
        stream = sys.stdout
2952
 
    runner = runner_class(stream=stream,
 
2646
    runner = runner_class(stream=sys.stdout,
2953
2647
                            descriptions=0,
2954
2648
                            verbosity=verbosity,
2955
2649
                            bench_history=bench_history,
2956
 
                            strict=strict,
2957
 
                            result_decorators=result_decorators,
 
2650
                            list_only=list_only,
2958
2651
                            )
2959
2652
    runner.stop_on_failure=stop_on_failure
2960
 
    # built in decorator factories:
2961
 
    decorators = [
2962
 
        random_order(random_seed, runner),
2963
 
        exclude_tests(exclude_pattern),
2964
 
        ]
2965
 
    if matching_tests_first:
2966
 
        decorators.append(tests_first(pattern))
 
2653
    # Initialise the random number generator and display the seed used.
 
2654
    # We convert the seed to a long to make it reuseable across invocations.
 
2655
    random_order = False
 
2656
    if random_seed is not None:
 
2657
        random_order = True
 
2658
        if random_seed == "now":
 
2659
            random_seed = long(time.time())
 
2660
        else:
 
2661
            # Convert the seed to a long if we can
 
2662
            try:
 
2663
                random_seed = long(random_seed)
 
2664
            except:
 
2665
                pass
 
2666
        runner.stream.writeln("Randomizing test order using seed %s\n" %
 
2667
            (random_seed))
 
2668
        random.seed(random_seed)
 
2669
    # Customise the list of tests if requested
 
2670
    if exclude_pattern is not None:
 
2671
        suite = exclude_tests_by_re(suite, exclude_pattern)
 
2672
    if random_order:
 
2673
        order_changer = randomize_suite
2967
2674
    else:
2968
 
        decorators.append(filter_tests(pattern))
2969
 
    if suite_decorators:
2970
 
        decorators.extend(suite_decorators)
2971
 
    # tell the result object how many tests will be running: (except if
2972
 
    # --parallel=fork is being used. Robert said he will provide a better
2973
 
    # progress design later -- vila 20090817)
2974
 
    if fork_decorator not in decorators:
2975
 
        decorators.append(CountingDecorator)
2976
 
    for decorator in decorators:
2977
 
        suite = decorator(suite)
2978
 
    if list_only:
2979
 
        # Done after test suite decoration to allow randomisation etc
2980
 
        # to take effect, though that is of marginal benefit.
2981
 
        if verbosity >= 2:
2982
 
            stream.write("Listing tests only ...\n")
2983
 
        for t in iter_suite_tests(suite):
2984
 
            stream.write("%s\n" % (t.id()))
2985
 
        return True
 
2675
        order_changer = preserve_input
 
2676
    if pattern != '.*' or random_order:
 
2677
        if matching_tests_first:
 
2678
            suites = map(order_changer, split_suite_by_re(suite, pattern))
 
2679
            suite = TestUtil.TestSuite(suites)
 
2680
        else:
 
2681
            suite = order_changer(filter_suite_by_re(suite, pattern))
 
2682
 
2986
2683
    result = runner.run(suite)
 
2684
 
2987
2685
    if strict:
2988
2686
        return result.wasStrictlySuccessful()
2989
 
    else:
2990
 
        return result.wasSuccessful()
2991
 
 
2992
 
 
2993
 
# A registry where get() returns a suite decorator.
2994
 
parallel_registry = registry.Registry()
2995
 
 
2996
 
 
2997
 
def fork_decorator(suite):
2998
 
    concurrency = osutils.local_concurrency()
2999
 
    if concurrency == 1:
3000
 
        return suite
3001
 
    from testtools import ConcurrentTestSuite
3002
 
    return ConcurrentTestSuite(suite, fork_for_tests)
3003
 
parallel_registry.register('fork', fork_decorator)
3004
 
 
3005
 
 
3006
 
def subprocess_decorator(suite):
3007
 
    concurrency = osutils.local_concurrency()
3008
 
    if concurrency == 1:
3009
 
        return suite
3010
 
    from testtools import ConcurrentTestSuite
3011
 
    return ConcurrentTestSuite(suite, reinvoke_for_tests)
3012
 
parallel_registry.register('subprocess', subprocess_decorator)
3013
 
 
3014
 
 
3015
 
def exclude_tests(exclude_pattern):
3016
 
    """Return a test suite decorator that excludes tests."""
3017
 
    if exclude_pattern is None:
3018
 
        return identity_decorator
3019
 
    def decorator(suite):
3020
 
        return ExcludeDecorator(suite, exclude_pattern)
3021
 
    return decorator
3022
 
 
3023
 
 
3024
 
def filter_tests(pattern):
3025
 
    if pattern == '.*':
3026
 
        return identity_decorator
3027
 
    def decorator(suite):
3028
 
        return FilterTestsDecorator(suite, pattern)
3029
 
    return decorator
3030
 
 
3031
 
 
3032
 
def random_order(random_seed, runner):
3033
 
    """Return a test suite decorator factory for randomising tests order.
3034
 
    
3035
 
    :param random_seed: now, a string which casts to a long, or a long.
3036
 
    :param runner: A test runner with a stream attribute to report on.
3037
 
    """
3038
 
    if random_seed is None:
3039
 
        return identity_decorator
3040
 
    def decorator(suite):
3041
 
        return RandomDecorator(suite, random_seed, runner.stream)
3042
 
    return decorator
3043
 
 
3044
 
 
3045
 
def tests_first(pattern):
3046
 
    if pattern == '.*':
3047
 
        return identity_decorator
3048
 
    def decorator(suite):
3049
 
        return TestFirstDecorator(suite, pattern)
3050
 
    return decorator
3051
 
 
3052
 
 
3053
 
def identity_decorator(suite):
3054
 
    """Return suite."""
3055
 
    return suite
3056
 
 
3057
 
 
3058
 
class TestDecorator(TestSuite):
3059
 
    """A decorator for TestCase/TestSuite objects.
3060
 
    
3061
 
    Usually, subclasses should override __iter__(used when flattening test
3062
 
    suites), which we do to filter, reorder, parallelise and so on, run() and
3063
 
    debug().
3064
 
    """
3065
 
 
3066
 
    def __init__(self, suite):
3067
 
        TestSuite.__init__(self)
3068
 
        self.addTest(suite)
3069
 
 
3070
 
    def countTestCases(self):
3071
 
        cases = 0
3072
 
        for test in self:
3073
 
            cases += test.countTestCases()
3074
 
        return cases
3075
 
 
3076
 
    def debug(self):
3077
 
        for test in self:
3078
 
            test.debug()
3079
 
 
3080
 
    def run(self, result):
3081
 
        # Use iteration on self, not self._tests, to allow subclasses to hook
3082
 
        # into __iter__.
3083
 
        for test in self:
3084
 
            if result.shouldStop:
3085
 
                break
3086
 
            test.run(result)
3087
 
        return result
3088
 
 
3089
 
 
3090
 
class CountingDecorator(TestDecorator):
3091
 
    """A decorator which calls result.progress(self.countTestCases)."""
3092
 
 
3093
 
    def run(self, result):
3094
 
        progress_method = getattr(result, 'progress', None)
3095
 
        if callable(progress_method):
3096
 
            progress_method(self.countTestCases(), SUBUNIT_SEEK_SET)
3097
 
        return super(CountingDecorator, self).run(result)
3098
 
 
3099
 
 
3100
 
class ExcludeDecorator(TestDecorator):
3101
 
    """A decorator which excludes test matching an exclude pattern."""
3102
 
 
3103
 
    def __init__(self, suite, exclude_pattern):
3104
 
        TestDecorator.__init__(self, suite)
3105
 
        self.exclude_pattern = exclude_pattern
3106
 
        self.excluded = False
3107
 
 
3108
 
    def __iter__(self):
3109
 
        if self.excluded:
3110
 
            return iter(self._tests)
3111
 
        self.excluded = True
3112
 
        suite = exclude_tests_by_re(self, self.exclude_pattern)
3113
 
        del self._tests[:]
3114
 
        self.addTests(suite)
3115
 
        return iter(self._tests)
3116
 
 
3117
 
 
3118
 
class FilterTestsDecorator(TestDecorator):
3119
 
    """A decorator which filters tests to those matching a pattern."""
3120
 
 
3121
 
    def __init__(self, suite, pattern):
3122
 
        TestDecorator.__init__(self, suite)
3123
 
        self.pattern = pattern
3124
 
        self.filtered = False
3125
 
 
3126
 
    def __iter__(self):
3127
 
        if self.filtered:
3128
 
            return iter(self._tests)
3129
 
        self.filtered = True
3130
 
        suite = filter_suite_by_re(self, self.pattern)
3131
 
        del self._tests[:]
3132
 
        self.addTests(suite)
3133
 
        return iter(self._tests)
3134
 
 
3135
 
 
3136
 
class RandomDecorator(TestDecorator):
3137
 
    """A decorator which randomises the order of its tests."""
3138
 
 
3139
 
    def __init__(self, suite, random_seed, stream):
3140
 
        TestDecorator.__init__(self, suite)
3141
 
        self.random_seed = random_seed
3142
 
        self.randomised = False
3143
 
        self.stream = stream
3144
 
 
3145
 
    def __iter__(self):
3146
 
        if self.randomised:
3147
 
            return iter(self._tests)
3148
 
        self.randomised = True
3149
 
        self.stream.write("Randomizing test order using seed %s\n\n" %
3150
 
            (self.actual_seed()))
3151
 
        # Initialise the random number generator.
3152
 
        random.seed(self.actual_seed())
3153
 
        suite = randomize_suite(self)
3154
 
        del self._tests[:]
3155
 
        self.addTests(suite)
3156
 
        return iter(self._tests)
3157
 
 
3158
 
    def actual_seed(self):
3159
 
        if self.random_seed == "now":
3160
 
            # We convert the seed to a long to make it reuseable across
3161
 
            # invocations (because the user can reenter it).
3162
 
            self.random_seed = long(time.time())
3163
 
        else:
3164
 
            # Convert the seed to a long if we can
3165
 
            try:
3166
 
                self.random_seed = long(self.random_seed)
3167
 
            except:
3168
 
                pass
3169
 
        return self.random_seed
3170
 
 
3171
 
 
3172
 
class TestFirstDecorator(TestDecorator):
3173
 
    """A decorator which moves named tests to the front."""
3174
 
 
3175
 
    def __init__(self, suite, pattern):
3176
 
        TestDecorator.__init__(self, suite)
3177
 
        self.pattern = pattern
3178
 
        self.filtered = False
3179
 
 
3180
 
    def __iter__(self):
3181
 
        if self.filtered:
3182
 
            return iter(self._tests)
3183
 
        self.filtered = True
3184
 
        suites = split_suite_by_re(self, self.pattern)
3185
 
        del self._tests[:]
3186
 
        self.addTests(suites)
3187
 
        return iter(self._tests)
3188
 
 
3189
 
 
3190
 
def partition_tests(suite, count):
3191
 
    """Partition suite into count lists of tests."""
3192
 
    result = []
3193
 
    tests = list(iter_suite_tests(suite))
3194
 
    tests_per_process = int(math.ceil(float(len(tests)) / count))
3195
 
    for block in range(count):
3196
 
        low_test = block * tests_per_process
3197
 
        high_test = low_test + tests_per_process
3198
 
        process_tests = tests[low_test:high_test]
3199
 
        result.append(process_tests)
3200
 
    return result
3201
 
 
3202
 
 
3203
 
def workaround_zealous_crypto_random():
3204
 
    """Crypto.Random want to help us being secure, but we don't care here.
3205
 
 
3206
 
    This workaround some test failure related to the sftp server. Once paramiko
3207
 
    stop using the controversial API in Crypto.Random, we may get rid of it.
3208
 
    """
3209
 
    try:
3210
 
        from Crypto.Random import atfork
3211
 
        atfork()
3212
 
    except ImportError:
3213
 
        pass
3214
 
 
3215
 
 
3216
 
def fork_for_tests(suite):
3217
 
    """Take suite and start up one runner per CPU by forking()
3218
 
 
3219
 
    :return: An iterable of TestCase-like objects which can each have
3220
 
        run(result) called on them to feed tests to result.
3221
 
    """
3222
 
    concurrency = osutils.local_concurrency()
3223
 
    result = []
3224
 
    from subunit import TestProtocolClient, ProtocolTestCase
3225
 
    from subunit.test_results import AutoTimingTestResultDecorator
3226
 
    class TestInOtherProcess(ProtocolTestCase):
3227
 
        # Should be in subunit, I think. RBC.
3228
 
        def __init__(self, stream, pid):
3229
 
            ProtocolTestCase.__init__(self, stream)
3230
 
            self.pid = pid
3231
 
 
3232
 
        def run(self, result):
3233
 
            try:
3234
 
                ProtocolTestCase.run(self, result)
3235
 
            finally:
3236
 
                os.waitpid(self.pid, 0)
3237
 
 
3238
 
    test_blocks = partition_tests(suite, concurrency)
3239
 
    for process_tests in test_blocks:
3240
 
        process_suite = TestSuite()
3241
 
        process_suite.addTests(process_tests)
3242
 
        c2pread, c2pwrite = os.pipe()
3243
 
        pid = os.fork()
3244
 
        if pid == 0:
3245
 
            workaround_zealous_crypto_random()
3246
 
            try:
3247
 
                os.close(c2pread)
3248
 
                # Leave stderr and stdout open so we can see test noise
3249
 
                # Close stdin so that the child goes away if it decides to
3250
 
                # read from stdin (otherwise its a roulette to see what
3251
 
                # child actually gets keystrokes for pdb etc).
3252
 
                sys.stdin.close()
3253
 
                sys.stdin = None
3254
 
                stream = os.fdopen(c2pwrite, 'wb', 1)
3255
 
                subunit_result = AutoTimingTestResultDecorator(
3256
 
                    TestProtocolClient(stream))
3257
 
                process_suite.run(subunit_result)
3258
 
            finally:
3259
 
                os._exit(0)
3260
 
        else:
3261
 
            os.close(c2pwrite)
3262
 
            stream = os.fdopen(c2pread, 'rb', 1)
3263
 
            test = TestInOtherProcess(stream, pid)
3264
 
            result.append(test)
3265
 
    return result
3266
 
 
3267
 
 
3268
 
def reinvoke_for_tests(suite):
3269
 
    """Take suite and start up one runner per CPU using subprocess().
3270
 
 
3271
 
    :return: An iterable of TestCase-like objects which can each have
3272
 
        run(result) called on them to feed tests to result.
3273
 
    """
3274
 
    concurrency = osutils.local_concurrency()
3275
 
    result = []
3276
 
    from subunit import ProtocolTestCase
3277
 
    class TestInSubprocess(ProtocolTestCase):
3278
 
        def __init__(self, process, name):
3279
 
            ProtocolTestCase.__init__(self, process.stdout)
3280
 
            self.process = process
3281
 
            self.process.stdin.close()
3282
 
            self.name = name
3283
 
 
3284
 
        def run(self, result):
3285
 
            try:
3286
 
                ProtocolTestCase.run(self, result)
3287
 
            finally:
3288
 
                self.process.wait()
3289
 
                os.unlink(self.name)
3290
 
            # print "pid %d finished" % finished_process
3291
 
    test_blocks = partition_tests(suite, concurrency)
3292
 
    for process_tests in test_blocks:
3293
 
        # ugly; currently reimplement rather than reuses TestCase methods.
3294
 
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
3295
 
        if not os.path.isfile(bzr_path):
3296
 
            # We are probably installed. Assume sys.argv is the right file
3297
 
            bzr_path = sys.argv[0]
3298
 
        bzr_path = [bzr_path]
3299
 
        if sys.platform == "win32":
3300
 
            # if we're on windows, we can't execute the bzr script directly
3301
 
            bzr_path = [sys.executable] + bzr_path
3302
 
        fd, test_list_file_name = tempfile.mkstemp()
3303
 
        test_list_file = os.fdopen(fd, 'wb', 1)
3304
 
        for test in process_tests:
3305
 
            test_list_file.write(test.id() + '\n')
3306
 
        test_list_file.close()
3307
 
        try:
3308
 
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
3309
 
                '--subunit']
3310
 
            if '--no-plugins' in sys.argv:
3311
 
                argv.append('--no-plugins')
3312
 
            # stderr=STDOUT would be ideal, but until we prevent noise on
3313
 
            # stderr it can interrupt the subunit protocol.
3314
 
            process = Popen(argv, stdin=PIPE, stdout=PIPE, stderr=PIPE,
3315
 
                bufsize=1)
3316
 
            test = TestInSubprocess(process, test_list_file_name)
3317
 
            result.append(test)
3318
 
        except:
3319
 
            os.unlink(test_list_file_name)
3320
 
            raise
3321
 
    return result
3322
 
 
3323
 
 
3324
 
class ForwardingResult(unittest.TestResult):
3325
 
 
3326
 
    def __init__(self, target):
3327
 
        unittest.TestResult.__init__(self)
3328
 
        self.result = target
3329
 
 
3330
 
    def startTest(self, test):
3331
 
        self.result.startTest(test)
3332
 
 
3333
 
    def stopTest(self, test):
3334
 
        self.result.stopTest(test)
3335
 
 
3336
 
    def startTestRun(self):
3337
 
        self.result.startTestRun()
3338
 
 
3339
 
    def stopTestRun(self):
3340
 
        self.result.stopTestRun()
3341
 
 
3342
 
    def addSkip(self, test, reason):
3343
 
        self.result.addSkip(test, reason)
3344
 
 
3345
 
    def addSuccess(self, test):
3346
 
        self.result.addSuccess(test)
3347
 
 
3348
 
    def addError(self, test, err):
3349
 
        self.result.addError(test, err)
3350
 
 
3351
 
    def addFailure(self, test, err):
3352
 
        self.result.addFailure(test, err)
3353
 
ForwardingResult = testtools.ExtendedToOriginalDecorator
3354
 
 
3355
 
 
3356
 
class ProfileResult(ForwardingResult):
3357
 
    """Generate profiling data for all activity between start and success.
3358
 
    
3359
 
    The profile data is appended to the test's _benchcalls attribute and can
3360
 
    be accessed by the forwarded-to TestResult.
3361
 
 
3362
 
    While it might be cleaner do accumulate this in stopTest, addSuccess is
3363
 
    where our existing output support for lsprof is, and this class aims to
3364
 
    fit in with that: while it could be moved it's not necessary to accomplish
3365
 
    test profiling, nor would it be dramatically cleaner.
3366
 
    """
3367
 
 
3368
 
    def startTest(self, test):
3369
 
        self.profiler = bzrlib.lsprof.BzrProfiler()
3370
 
        self.profiler.start()
3371
 
        ForwardingResult.startTest(self, test)
3372
 
 
3373
 
    def addSuccess(self, test):
3374
 
        stats = self.profiler.stop()
3375
 
        try:
3376
 
            calls = test._benchcalls
3377
 
        except AttributeError:
3378
 
            test._benchcalls = []
3379
 
            calls = test._benchcalls
3380
 
        calls.append(((test.id(), "", ""), stats))
3381
 
        ForwardingResult.addSuccess(self, test)
3382
 
 
3383
 
    def stopTest(self, test):
3384
 
        ForwardingResult.stopTest(self, test)
3385
 
        self.profiler = None
 
2687
 
 
2688
    return result.wasSuccessful()
3386
2689
 
3387
2690
 
3388
2691
# Controlled by "bzr selftest -E=..." option
3389
 
# Currently supported:
3390
 
#   -Eallow_debug           Will no longer clear debug.debug_flags() so it
3391
 
#                           preserves any flags supplied at the command line.
3392
 
#   -Edisable_lock_checks   Turns errors in mismatched locks into simple prints
3393
 
#                           rather than failing tests. And no longer raise
3394
 
#                           LockContention when fctnl locks are not being used
3395
 
#                           with proper exclusion rules.
3396
2692
selftest_debug_flags = set()
3397
2693
 
3398
2694
 
3410
2706
             debug_flags=None,
3411
2707
             starting_with=None,
3412
2708
             runner_class=None,
3413
 
             suite_decorators=None,
3414
 
             stream=None,
3415
 
             lsprof_tests=False,
3416
2709
             ):
3417
2710
    """Run the whole test suite under the enhanced runner"""
3418
2711
    # XXX: Very ugly way to do this...
3435
2728
            keep_only = None
3436
2729
        else:
3437
2730
            keep_only = load_test_id_list(load_list)
3438
 
        if starting_with:
3439
 
            starting_with = [test_prefix_alias_registry.resolve_alias(start)
3440
 
                             for start in starting_with]
3441
2731
        if test_suite_factory is None:
3442
 
            # Reduce loading time by loading modules based on the starting_with
3443
 
            # patterns.
3444
2732
            suite = test_suite(keep_only, starting_with)
3445
2733
        else:
3446
2734
            suite = test_suite_factory()
3447
 
        if starting_with:
3448
 
            # But always filter as requested.
3449
 
            suite = filter_suite_by_id_startswith(suite, starting_with)
3450
 
        result_decorators = []
3451
 
        if lsprof_tests:
3452
 
            result_decorators.append(ProfileResult)
3453
2735
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
3454
2736
                     stop_on_failure=stop_on_failure,
3455
2737
                     transport=transport,
3461
2743
                     exclude_pattern=exclude_pattern,
3462
2744
                     strict=strict,
3463
2745
                     runner_class=runner_class,
3464
 
                     suite_decorators=suite_decorators,
3465
 
                     stream=stream,
3466
 
                     result_decorators=result_decorators,
3467
2746
                     )
3468
2747
    finally:
3469
2748
        default_transport = old_transport
3617
2896
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
3618
2897
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3619
2898
 
3620
 
# Obvious highest levels prefixes, feel free to add your own via a plugin
 
2899
# Obvious higest levels prefixes, feel free to add your own via a plugin
3621
2900
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
3622
2901
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
3623
2902
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
3625
2904
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3626
2905
 
3627
2906
 
3628
 
def _test_suite_testmod_names():
3629
 
    """Return the standard list of test module names to test."""
3630
 
    return [
3631
 
        'bzrlib.doc',
3632
 
        'bzrlib.tests.blackbox',
3633
 
        'bzrlib.tests.commands',
3634
 
        'bzrlib.tests.per_branch',
3635
 
        'bzrlib.tests.per_bzrdir',
3636
 
        'bzrlib.tests.per_bzrdir_colo',
3637
 
        'bzrlib.tests.per_foreign_vcs',
3638
 
        'bzrlib.tests.per_interrepository',
3639
 
        'bzrlib.tests.per_intertree',
3640
 
        'bzrlib.tests.per_inventory',
3641
 
        'bzrlib.tests.per_interbranch',
3642
 
        'bzrlib.tests.per_lock',
3643
 
        'bzrlib.tests.per_merger',
3644
 
        'bzrlib.tests.per_transport',
3645
 
        'bzrlib.tests.per_tree',
3646
 
        'bzrlib.tests.per_pack_repository',
3647
 
        'bzrlib.tests.per_repository',
3648
 
        'bzrlib.tests.per_repository_chk',
3649
 
        'bzrlib.tests.per_repository_reference',
3650
 
        'bzrlib.tests.per_uifactory',
3651
 
        'bzrlib.tests.per_versionedfile',
3652
 
        'bzrlib.tests.per_workingtree',
3653
 
        'bzrlib.tests.test__annotator',
3654
 
        'bzrlib.tests.test__bencode',
3655
 
        'bzrlib.tests.test__chk_map',
3656
 
        'bzrlib.tests.test__dirstate_helpers',
3657
 
        'bzrlib.tests.test__groupcompress',
3658
 
        'bzrlib.tests.test__known_graph',
3659
 
        'bzrlib.tests.test__rio',
3660
 
        'bzrlib.tests.test__simple_set',
3661
 
        'bzrlib.tests.test__static_tuple',
3662
 
        'bzrlib.tests.test__walkdirs_win32',
3663
 
        'bzrlib.tests.test_ancestry',
3664
 
        'bzrlib.tests.test_annotate',
3665
 
        'bzrlib.tests.test_api',
3666
 
        'bzrlib.tests.test_atomicfile',
3667
 
        'bzrlib.tests.test_bad_files',
3668
 
        'bzrlib.tests.test_bisect_multi',
3669
 
        'bzrlib.tests.test_branch',
3670
 
        'bzrlib.tests.test_branchbuilder',
3671
 
        'bzrlib.tests.test_btree_index',
3672
 
        'bzrlib.tests.test_bugtracker',
3673
 
        'bzrlib.tests.test_bundle',
3674
 
        'bzrlib.tests.test_bzrdir',
3675
 
        'bzrlib.tests.test__chunks_to_lines',
3676
 
        'bzrlib.tests.test_cache_utf8',
3677
 
        'bzrlib.tests.test_chk_map',
3678
 
        'bzrlib.tests.test_chk_serializer',
3679
 
        'bzrlib.tests.test_chunk_writer',
3680
 
        'bzrlib.tests.test_clean_tree',
3681
 
        'bzrlib.tests.test_cleanup',
3682
 
        'bzrlib.tests.test_cmdline',
3683
 
        'bzrlib.tests.test_commands',
3684
 
        'bzrlib.tests.test_commit',
3685
 
        'bzrlib.tests.test_commit_merge',
3686
 
        'bzrlib.tests.test_config',
3687
 
        'bzrlib.tests.test_conflicts',
3688
 
        'bzrlib.tests.test_counted_lock',
3689
 
        'bzrlib.tests.test_crash',
3690
 
        'bzrlib.tests.test_decorators',
3691
 
        'bzrlib.tests.test_delta',
3692
 
        'bzrlib.tests.test_debug',
3693
 
        'bzrlib.tests.test_deprecated_graph',
3694
 
        'bzrlib.tests.test_diff',
3695
 
        'bzrlib.tests.test_directory_service',
3696
 
        'bzrlib.tests.test_dirstate',
3697
 
        'bzrlib.tests.test_email_message',
3698
 
        'bzrlib.tests.test_eol_filters',
3699
 
        'bzrlib.tests.test_errors',
3700
 
        'bzrlib.tests.test_export',
3701
 
        'bzrlib.tests.test_extract',
3702
 
        'bzrlib.tests.test_fetch',
3703
 
        'bzrlib.tests.test_fifo_cache',
3704
 
        'bzrlib.tests.test_filters',
3705
 
        'bzrlib.tests.test_ftp_transport',
3706
 
        'bzrlib.tests.test_foreign',
3707
 
        'bzrlib.tests.test_generate_docs',
3708
 
        'bzrlib.tests.test_generate_ids',
3709
 
        'bzrlib.tests.test_globbing',
3710
 
        'bzrlib.tests.test_gpg',
3711
 
        'bzrlib.tests.test_graph',
3712
 
        'bzrlib.tests.test_groupcompress',
3713
 
        'bzrlib.tests.test_hashcache',
3714
 
        'bzrlib.tests.test_help',
3715
 
        'bzrlib.tests.test_hooks',
3716
 
        'bzrlib.tests.test_http',
3717
 
        'bzrlib.tests.test_http_response',
3718
 
        'bzrlib.tests.test_https_ca_bundle',
3719
 
        'bzrlib.tests.test_identitymap',
3720
 
        'bzrlib.tests.test_ignores',
3721
 
        'bzrlib.tests.test_index',
3722
 
        'bzrlib.tests.test_import_tariff',
3723
 
        'bzrlib.tests.test_info',
3724
 
        'bzrlib.tests.test_inv',
3725
 
        'bzrlib.tests.test_inventory_delta',
3726
 
        'bzrlib.tests.test_knit',
3727
 
        'bzrlib.tests.test_lazy_import',
3728
 
        'bzrlib.tests.test_lazy_regex',
3729
 
        'bzrlib.tests.test_lock',
3730
 
        'bzrlib.tests.test_lockable_files',
3731
 
        'bzrlib.tests.test_lockdir',
3732
 
        'bzrlib.tests.test_log',
3733
 
        'bzrlib.tests.test_lru_cache',
3734
 
        'bzrlib.tests.test_lsprof',
3735
 
        'bzrlib.tests.test_mail_client',
3736
 
        'bzrlib.tests.test_memorytree',
3737
 
        'bzrlib.tests.test_merge',
3738
 
        'bzrlib.tests.test_merge3',
3739
 
        'bzrlib.tests.test_merge_core',
3740
 
        'bzrlib.tests.test_merge_directive',
3741
 
        'bzrlib.tests.test_missing',
3742
 
        'bzrlib.tests.test_msgeditor',
3743
 
        'bzrlib.tests.test_multiparent',
3744
 
        'bzrlib.tests.test_mutabletree',
3745
 
        'bzrlib.tests.test_nonascii',
3746
 
        'bzrlib.tests.test_options',
3747
 
        'bzrlib.tests.test_osutils',
3748
 
        'bzrlib.tests.test_osutils_encodings',
3749
 
        'bzrlib.tests.test_pack',
3750
 
        'bzrlib.tests.test_patch',
3751
 
        'bzrlib.tests.test_patches',
3752
 
        'bzrlib.tests.test_permissions',
3753
 
        'bzrlib.tests.test_plugins',
3754
 
        'bzrlib.tests.test_progress',
3755
 
        'bzrlib.tests.test_read_bundle',
3756
 
        'bzrlib.tests.test_reconcile',
3757
 
        'bzrlib.tests.test_reconfigure',
3758
 
        'bzrlib.tests.test_registry',
3759
 
        'bzrlib.tests.test_remote',
3760
 
        'bzrlib.tests.test_rename_map',
3761
 
        'bzrlib.tests.test_repository',
3762
 
        'bzrlib.tests.test_revert',
3763
 
        'bzrlib.tests.test_revision',
3764
 
        'bzrlib.tests.test_revisionspec',
3765
 
        'bzrlib.tests.test_revisiontree',
3766
 
        'bzrlib.tests.test_rio',
3767
 
        'bzrlib.tests.test_rules',
3768
 
        'bzrlib.tests.test_sampler',
3769
 
        'bzrlib.tests.test_script',
3770
 
        'bzrlib.tests.test_selftest',
3771
 
        'bzrlib.tests.test_serializer',
3772
 
        'bzrlib.tests.test_setup',
3773
 
        'bzrlib.tests.test_sftp_transport',
3774
 
        'bzrlib.tests.test_shelf',
3775
 
        'bzrlib.tests.test_shelf_ui',
3776
 
        'bzrlib.tests.test_smart',
3777
 
        'bzrlib.tests.test_smart_add',
3778
 
        'bzrlib.tests.test_smart_request',
3779
 
        'bzrlib.tests.test_smart_transport',
3780
 
        'bzrlib.tests.test_smtp_connection',
3781
 
        'bzrlib.tests.test_source',
3782
 
        'bzrlib.tests.test_ssh_transport',
3783
 
        'bzrlib.tests.test_status',
3784
 
        'bzrlib.tests.test_store',
3785
 
        'bzrlib.tests.test_strace',
3786
 
        'bzrlib.tests.test_subsume',
3787
 
        'bzrlib.tests.test_switch',
3788
 
        'bzrlib.tests.test_symbol_versioning',
3789
 
        'bzrlib.tests.test_tag',
3790
 
        'bzrlib.tests.test_testament',
3791
 
        'bzrlib.tests.test_textfile',
3792
 
        'bzrlib.tests.test_textmerge',
3793
 
        'bzrlib.tests.test_timestamp',
3794
 
        'bzrlib.tests.test_trace',
3795
 
        'bzrlib.tests.test_transactions',
3796
 
        'bzrlib.tests.test_transform',
3797
 
        'bzrlib.tests.test_transport',
3798
 
        'bzrlib.tests.test_transport_log',
3799
 
        'bzrlib.tests.test_tree',
3800
 
        'bzrlib.tests.test_treebuilder',
3801
 
        'bzrlib.tests.test_tsort',
3802
 
        'bzrlib.tests.test_tuned_gzip',
3803
 
        'bzrlib.tests.test_ui',
3804
 
        'bzrlib.tests.test_uncommit',
3805
 
        'bzrlib.tests.test_upgrade',
3806
 
        'bzrlib.tests.test_upgrade_stacked',
3807
 
        'bzrlib.tests.test_urlutils',
3808
 
        'bzrlib.tests.test_version',
3809
 
        'bzrlib.tests.test_version_info',
3810
 
        'bzrlib.tests.test_weave',
3811
 
        'bzrlib.tests.test_whitebox',
3812
 
        'bzrlib.tests.test_win32utils',
3813
 
        'bzrlib.tests.test_workingtree',
3814
 
        'bzrlib.tests.test_workingtree_4',
3815
 
        'bzrlib.tests.test_wsgi',
3816
 
        'bzrlib.tests.test_xml',
3817
 
        ]
3818
 
 
3819
 
 
3820
 
def _test_suite_modules_to_doctest():
3821
 
    """Return the list of modules to doctest."""
3822
 
    if __doc__ is None:
3823
 
        # GZ 2009-03-31: No docstrings with -OO so there's nothing to doctest
3824
 
        return []
3825
 
    return [
3826
 
        'bzrlib',
3827
 
        'bzrlib.branchbuilder',
3828
 
        'bzrlib.decorators',
3829
 
        'bzrlib.export',
3830
 
        'bzrlib.inventory',
3831
 
        'bzrlib.iterablefile',
3832
 
        'bzrlib.lockdir',
3833
 
        'bzrlib.merge3',
3834
 
        'bzrlib.option',
3835
 
        'bzrlib.symbol_versioning',
3836
 
        'bzrlib.tests',
3837
 
        'bzrlib.timestamp',
3838
 
        'bzrlib.version_info_formats.format_custom',
3839
 
        ]
3840
 
 
3841
 
 
3842
2907
def test_suite(keep_only=None, starting_with=None):
3843
2908
    """Build and return TestSuite for the whole of bzrlib.
3844
2909
 
3850
2915
    This function can be replaced if you need to change the default test
3851
2916
    suite on a global basis, but it is not encouraged.
3852
2917
    """
 
2918
    testmod_names = [
 
2919
                   'bzrlib.doc',
 
2920
                   'bzrlib.tests.blackbox',
 
2921
                   'bzrlib.tests.branch_implementations',
 
2922
                   'bzrlib.tests.bzrdir_implementations',
 
2923
                   'bzrlib.tests.commands',
 
2924
                   'bzrlib.tests.interrepository_implementations',
 
2925
                   'bzrlib.tests.intertree_implementations',
 
2926
                   'bzrlib.tests.inventory_implementations',
 
2927
                   'bzrlib.tests.per_interbranch',
 
2928
                   'bzrlib.tests.per_lock',
 
2929
                   'bzrlib.tests.per_repository',
 
2930
                   'bzrlib.tests.per_repository_reference',
 
2931
                   'bzrlib.tests.test__dirstate_helpers',
 
2932
                   'bzrlib.tests.test__walkdirs_win32',
 
2933
                   'bzrlib.tests.test_ancestry',
 
2934
                   'bzrlib.tests.test_annotate',
 
2935
                   'bzrlib.tests.test_api',
 
2936
                   'bzrlib.tests.test_atomicfile',
 
2937
                   'bzrlib.tests.test_bad_files',
 
2938
                   'bzrlib.tests.test_bisect_multi',
 
2939
                   'bzrlib.tests.test_branch',
 
2940
                   'bzrlib.tests.test_branchbuilder',
 
2941
                   'bzrlib.tests.test_btree_index',
 
2942
                   'bzrlib.tests.test_bugtracker',
 
2943
                   'bzrlib.tests.test_bundle',
 
2944
                   'bzrlib.tests.test_bzrdir',
 
2945
                   'bzrlib.tests.test_cache_utf8',
 
2946
                   'bzrlib.tests.test_clean_tree',
 
2947
                   'bzrlib.tests.test_chunk_writer',
 
2948
                   'bzrlib.tests.test__chunks_to_lines',
 
2949
                   'bzrlib.tests.test_commands',
 
2950
                   'bzrlib.tests.test_commit',
 
2951
                   'bzrlib.tests.test_commit_merge',
 
2952
                   'bzrlib.tests.test_config',
 
2953
                   'bzrlib.tests.test_conflicts',
 
2954
                   'bzrlib.tests.test_counted_lock',
 
2955
                   'bzrlib.tests.test_decorators',
 
2956
                   'bzrlib.tests.test_delta',
 
2957
                   'bzrlib.tests.test_debug',
 
2958
                   'bzrlib.tests.test_deprecated_graph',
 
2959
                   'bzrlib.tests.test_diff',
 
2960
                   'bzrlib.tests.test_directory_service',
 
2961
                   'bzrlib.tests.test_dirstate',
 
2962
                   'bzrlib.tests.test_email_message',
 
2963
                   'bzrlib.tests.test_errors',
 
2964
                   'bzrlib.tests.test_export',
 
2965
                   'bzrlib.tests.test_extract',
 
2966
                   'bzrlib.tests.test_fetch',
 
2967
                   'bzrlib.tests.test_fifo_cache',
 
2968
                   'bzrlib.tests.test_filters',
 
2969
                   'bzrlib.tests.test_ftp_transport',
 
2970
                   'bzrlib.tests.test_foreign',
 
2971
                   'bzrlib.tests.test_generate_docs',
 
2972
                   'bzrlib.tests.test_generate_ids',
 
2973
                   'bzrlib.tests.test_globbing',
 
2974
                   'bzrlib.tests.test_gpg',
 
2975
                   'bzrlib.tests.test_graph',
 
2976
                   'bzrlib.tests.test_hashcache',
 
2977
                   'bzrlib.tests.test_help',
 
2978
                   'bzrlib.tests.test_hooks',
 
2979
                   'bzrlib.tests.test_http',
 
2980
                   'bzrlib.tests.test_http_implementations',
 
2981
                   'bzrlib.tests.test_http_response',
 
2982
                   'bzrlib.tests.test_https_ca_bundle',
 
2983
                   'bzrlib.tests.test_identitymap',
 
2984
                   'bzrlib.tests.test_ignores',
 
2985
                   'bzrlib.tests.test_index',
 
2986
                   'bzrlib.tests.test_info',
 
2987
                   'bzrlib.tests.test_inv',
 
2988
                   'bzrlib.tests.test_knit',
 
2989
                   'bzrlib.tests.test_lazy_import',
 
2990
                   'bzrlib.tests.test_lazy_regex',
 
2991
                   'bzrlib.tests.test_lockable_files',
 
2992
                   'bzrlib.tests.test_lockdir',
 
2993
                   'bzrlib.tests.test_log',
 
2994
                   'bzrlib.tests.test_lru_cache',
 
2995
                   'bzrlib.tests.test_lsprof',
 
2996
                   'bzrlib.tests.test_mail_client',
 
2997
                   'bzrlib.tests.test_memorytree',
 
2998
                   'bzrlib.tests.test_merge',
 
2999
                   'bzrlib.tests.test_merge3',
 
3000
                   'bzrlib.tests.test_merge_core',
 
3001
                   'bzrlib.tests.test_merge_directive',
 
3002
                   'bzrlib.tests.test_missing',
 
3003
                   'bzrlib.tests.test_msgeditor',
 
3004
                   'bzrlib.tests.test_multiparent',
 
3005
                   'bzrlib.tests.test_mutabletree',
 
3006
                   'bzrlib.tests.test_nonascii',
 
3007
                   'bzrlib.tests.test_options',
 
3008
                   'bzrlib.tests.test_osutils',
 
3009
                   'bzrlib.tests.test_osutils_encodings',
 
3010
                   'bzrlib.tests.test_pack',
 
3011
                   'bzrlib.tests.test_pack_repository',
 
3012
                   'bzrlib.tests.test_patch',
 
3013
                   'bzrlib.tests.test_patches',
 
3014
                   'bzrlib.tests.test_permissions',
 
3015
                   'bzrlib.tests.test_plugins',
 
3016
                   'bzrlib.tests.test_progress',
 
3017
                   'bzrlib.tests.test_read_bundle',
 
3018
                   'bzrlib.tests.test_reconcile',
 
3019
                   'bzrlib.tests.test_reconfigure',
 
3020
                   'bzrlib.tests.test_registry',
 
3021
                   'bzrlib.tests.test_remote',
 
3022
                   'bzrlib.tests.test_rename_map',
 
3023
                   'bzrlib.tests.test_repository',
 
3024
                   'bzrlib.tests.test_revert',
 
3025
                   'bzrlib.tests.test_revision',
 
3026
                   'bzrlib.tests.test_revisionspec',
 
3027
                   'bzrlib.tests.test_revisiontree',
 
3028
                   'bzrlib.tests.test_rio',
 
3029
                   'bzrlib.tests.test_rules',
 
3030
                   'bzrlib.tests.test_sampler',
 
3031
                   'bzrlib.tests.test_selftest',
 
3032
                   'bzrlib.tests.test_setup',
 
3033
                   'bzrlib.tests.test_sftp_transport',
 
3034
                   'bzrlib.tests.test_shelf',
 
3035
                   'bzrlib.tests.test_shelf_ui',
 
3036
                   'bzrlib.tests.test_smart',
 
3037
                   'bzrlib.tests.test_smart_add',
 
3038
                   'bzrlib.tests.test_smart_request',
 
3039
                   'bzrlib.tests.test_smart_transport',
 
3040
                   'bzrlib.tests.test_smtp_connection',
 
3041
                   'bzrlib.tests.test_source',
 
3042
                   'bzrlib.tests.test_ssh_transport',
 
3043
                   'bzrlib.tests.test_status',
 
3044
                   'bzrlib.tests.test_store',
 
3045
                   'bzrlib.tests.test_strace',
 
3046
                   'bzrlib.tests.test_subsume',
 
3047
                   'bzrlib.tests.test_switch',
 
3048
                   'bzrlib.tests.test_symbol_versioning',
 
3049
                   'bzrlib.tests.test_tag',
 
3050
                   'bzrlib.tests.test_testament',
 
3051
                   'bzrlib.tests.test_textfile',
 
3052
                   'bzrlib.tests.test_textmerge',
 
3053
                   'bzrlib.tests.test_timestamp',
 
3054
                   'bzrlib.tests.test_trace',
 
3055
                   'bzrlib.tests.test_transactions',
 
3056
                   'bzrlib.tests.test_transform',
 
3057
                   'bzrlib.tests.test_transport',
 
3058
                   'bzrlib.tests.test_transport_implementations',
 
3059
                   'bzrlib.tests.test_transport_log',
 
3060
                   'bzrlib.tests.test_tree',
 
3061
                   'bzrlib.tests.test_treebuilder',
 
3062
                   'bzrlib.tests.test_tsort',
 
3063
                   'bzrlib.tests.test_tuned_gzip',
 
3064
                   'bzrlib.tests.test_ui',
 
3065
                   'bzrlib.tests.test_uncommit',
 
3066
                   'bzrlib.tests.test_upgrade',
 
3067
                   'bzrlib.tests.test_upgrade_stacked',
 
3068
                   'bzrlib.tests.test_urlutils',
 
3069
                   'bzrlib.tests.test_version',
 
3070
                   'bzrlib.tests.test_version_info',
 
3071
                   'bzrlib.tests.test_versionedfile',
 
3072
                   'bzrlib.tests.test_weave',
 
3073
                   'bzrlib.tests.test_whitebox',
 
3074
                   'bzrlib.tests.test_win32utils',
 
3075
                   'bzrlib.tests.test_workingtree',
 
3076
                   'bzrlib.tests.test_workingtree_4',
 
3077
                   'bzrlib.tests.test_wsgi',
 
3078
                   'bzrlib.tests.test_xml',
 
3079
                   'bzrlib.tests.tree_implementations',
 
3080
                   'bzrlib.tests.workingtree_implementations',
 
3081
                   'bzrlib.util.tests.test_bencode',
 
3082
                   ]
3853
3083
 
3854
3084
    loader = TestUtil.TestLoader()
3855
3085
 
3856
 
    if keep_only is not None:
3857
 
        id_filter = TestIdList(keep_only)
3858
3086
    if starting_with:
 
3087
        starting_with = [test_prefix_alias_registry.resolve_alias(start)
 
3088
                         for start in starting_with]
3859
3089
        # We take precedence over keep_only because *at loading time* using
3860
3090
        # both options means we will load less tests for the same final result.
3861
3091
        def interesting_module(name):
3871
3101
        loader = TestUtil.FilteredByModuleTestLoader(interesting_module)
3872
3102
 
3873
3103
    elif keep_only is not None:
 
3104
        id_filter = TestIdList(keep_only)
3874
3105
        loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
3875
3106
        def interesting_module(name):
3876
3107
            return id_filter.refers_to(name)
3884
3115
    suite = loader.suiteClass()
3885
3116
 
3886
3117
    # modules building their suite with loadTestsFromModuleNames
3887
 
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
3888
 
 
3889
 
    for mod in _test_suite_modules_to_doctest():
 
3118
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
 
3119
 
 
3120
    modules_to_doctest = [
 
3121
        'bzrlib',
 
3122
        'bzrlib.branchbuilder',
 
3123
        'bzrlib.export',
 
3124
        'bzrlib.inventory',
 
3125
        'bzrlib.iterablefile',
 
3126
        'bzrlib.lockdir',
 
3127
        'bzrlib.merge3',
 
3128
        'bzrlib.option',
 
3129
        'bzrlib.symbol_versioning',
 
3130
        'bzrlib.tests',
 
3131
        'bzrlib.timestamp',
 
3132
        'bzrlib.version_info_formats.format_custom',
 
3133
        ]
 
3134
 
 
3135
    for mod in modules_to_doctest:
3890
3136
        if not interesting_module(mod):
3891
3137
            # No tests to keep here, move along
3892
3138
            continue
3921
3167
            reload(sys)
3922
3168
            sys.setdefaultencoding(default_encoding)
3923
3169
 
 
3170
    if starting_with:
 
3171
        suite = filter_suite_by_id_startswith(suite, starting_with)
 
3172
 
3924
3173
    if keep_only is not None:
3925
3174
        # Now that the referred modules have loaded their tests, keep only the
3926
3175
        # requested ones.
3975
3224
    the scenario name at the end of its id(), and updating the test object's
3976
3225
    __dict__ with the scenario_param_dict.
3977
3226
 
3978
 
    >>> import bzrlib.tests.test_sampler
3979
3227
    >>> r = multiply_tests(
3980
3228
    ...     bzrlib.tests.test_sampler.DemoTest('test_nothing'),
3981
3229
    ...     [('one', dict(param=1)),
4033
3281
    :param new_id: The id to assign to it.
4034
3282
    :return: The new test.
4035
3283
    """
4036
 
    new_test = copy(test)
 
3284
    from copy import deepcopy
 
3285
    new_test = deepcopy(test)
4037
3286
    new_test.id = lambda: new_id
4038
3287
    return new_test
4039
3288
 
4040
3289
 
4041
 
def permute_tests_for_extension(standard_tests, loader, py_module_name,
4042
 
                                ext_module_name):
4043
 
    """Helper for permutating tests against an extension module.
4044
 
 
4045
 
    This is meant to be used inside a modules 'load_tests()' function. It will
4046
 
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
4047
 
    against both implementations. Setting 'test.module' to the appropriate
4048
 
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
4049
 
 
4050
 
    :param standard_tests: A test suite to permute
4051
 
    :param loader: A TestLoader
4052
 
    :param py_module_name: The python path to a python module that can always
4053
 
        be loaded, and will be considered the 'python' implementation. (eg
4054
 
        'bzrlib._chk_map_py')
4055
 
    :param ext_module_name: The python path to an extension module. If the
4056
 
        module cannot be loaded, a single test will be added, which notes that
4057
 
        the module is not available. If it can be loaded, all standard_tests
4058
 
        will be run against that module.
4059
 
    :return: (suite, feature) suite is a test-suite that has all the permuted
4060
 
        tests. feature is the Feature object that can be used to determine if
4061
 
        the module is available.
4062
 
    """
4063
 
 
4064
 
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
4065
 
    scenarios = [
4066
 
        ('python', {'module': py_module}),
4067
 
    ]
4068
 
    suite = loader.suiteClass()
4069
 
    feature = ModuleAvailableFeature(ext_module_name)
4070
 
    if feature.available():
4071
 
        scenarios.append(('C', {'module': feature.module}))
4072
 
    else:
4073
 
        # the compiled module isn't available, so we add a failing test
4074
 
        class FailWithoutFeature(TestCase):
4075
 
            def test_fail(self):
4076
 
                self.requireFeature(feature)
4077
 
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
4078
 
    result = multiply_tests(standard_tests, scenarios, suite)
4079
 
    return result, feature
4080
 
 
4081
 
 
4082
 
def _rmtree_temp_dir(dirname, test_id=None):
 
3290
def _rmtree_temp_dir(dirname):
4083
3291
    # If LANG=C we probably have created some bogus paths
4084
3292
    # which rmtree(unicode) will fail to delete
4085
3293
    # so make sure we are using rmtree(str) to delete everything
4094
3302
    try:
4095
3303
        osutils.rmtree(dirname)
4096
3304
    except OSError, e:
4097
 
        # We don't want to fail here because some useful display will be lost
4098
 
        # otherwise. Polluting the tmp dir is bad, but not giving all the
4099
 
        # possible info to the test runner is even worse.
4100
 
        if test_id != None:
4101
 
            ui.ui_factory.clear_term()
4102
 
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
4103
 
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4104
 
                         % (os.path.basename(dirname), e))
 
3305
        if sys.platform == 'win32' and e.errno == errno.EACCES:
 
3306
            sys.stderr.write(('Permission denied: '
 
3307
                                 'unable to remove testing dir '
 
3308
                                 '%s\n' % os.path.basename(dirname)))
 
3309
        else:
 
3310
            raise
4105
3311
 
4106
3312
 
4107
3313
class Feature(object):
4189
3395
UnicodeFilenameFeature = _UnicodeFilenameFeature()
4190
3396
 
4191
3397
 
4192
 
class _CompatabilityThunkFeature(Feature):
4193
 
    """This feature is just a thunk to another feature.
4194
 
 
4195
 
    It issues a deprecation warning if it is accessed, to let you know that you
4196
 
    should really use a different feature.
4197
 
    """
4198
 
 
4199
 
    def __init__(self, dep_version, module, name,
4200
 
                 replacement_name, replacement_module=None):
4201
 
        super(_CompatabilityThunkFeature, self).__init__()
4202
 
        self._module = module
4203
 
        if replacement_module is None:
4204
 
            replacement_module = module
4205
 
        self._replacement_module = replacement_module
4206
 
        self._name = name
4207
 
        self._replacement_name = replacement_name
4208
 
        self._dep_version = dep_version
4209
 
        self._feature = None
4210
 
 
4211
 
    def _ensure(self):
4212
 
        if self._feature is None:
4213
 
            depr_msg = self._dep_version % ('%s.%s'
4214
 
                                            % (self._module, self._name))
4215
 
            use_msg = ' Use %s.%s instead.' % (self._replacement_module,
4216
 
                                               self._replacement_name)
4217
 
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
4218
 
            # Import the new feature and use it as a replacement for the
4219
 
            # deprecated one.
4220
 
            mod = __import__(self._replacement_module, {}, {},
4221
 
                             [self._replacement_name])
4222
 
            self._feature = getattr(mod, self._replacement_name)
4223
 
 
4224
 
    def _probe(self):
4225
 
        self._ensure()
4226
 
        return self._feature._probe()
4227
 
 
4228
 
 
4229
 
class ModuleAvailableFeature(Feature):
4230
 
    """This is a feature than describes a module we want to be available.
4231
 
 
4232
 
    Declare the name of the module in __init__(), and then after probing, the
4233
 
    module will be available as 'self.module'.
4234
 
 
4235
 
    :ivar module: The module if it is available, else None.
4236
 
    """
4237
 
 
4238
 
    def __init__(self, module_name):
4239
 
        super(ModuleAvailableFeature, self).__init__()
4240
 
        self.module_name = module_name
4241
 
 
4242
 
    def _probe(self):
4243
 
        try:
4244
 
            self._module = __import__(self.module_name, {}, {}, [''])
4245
 
            return True
4246
 
        except ImportError:
4247
 
            return False
4248
 
 
4249
 
    @property
4250
 
    def module(self):
4251
 
        if self.available(): # Make sure the probe has been done
4252
 
            return self._module
4253
 
        return None
4254
 
 
4255
 
    def feature_name(self):
4256
 
        return self.module_name
4257
 
 
4258
 
 
4259
 
# This is kept here for compatibility, it is recommended to use
4260
 
# 'bzrlib.tests.feature.paramiko' instead
4261
 
ParamikoFeature = _CompatabilityThunkFeature(
4262
 
    deprecated_in((2,1,0)),
4263
 
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
4264
 
 
4265
 
 
4266
3398
def probe_unicode_in_user_encoding():
4267
3399
    """Try to encode several unicode strings to use in unicode-aware tests.
4268
3400
    Return first successfull match.
4348
3480
UTF8Filesystem = _UTF8Filesystem()
4349
3481
 
4350
3482
 
4351
 
class _BreakinFeature(Feature):
4352
 
    """Does this platform support the breakin feature?"""
4353
 
 
4354
 
    def _probe(self):
4355
 
        from bzrlib import breakin
4356
 
        if breakin.determine_signal() is None:
4357
 
            return False
4358
 
        if sys.platform == 'win32':
4359
 
            # Windows doesn't have os.kill, and we catch the SIGBREAK signal.
4360
 
            # We trigger SIGBREAK via a Console api so we need ctypes to
4361
 
            # access the function
4362
 
            try:
4363
 
                import ctypes
4364
 
            except OSError:
4365
 
                return False
4366
 
        return True
4367
 
 
4368
 
    def feature_name(self):
4369
 
        return "SIGQUIT or SIGBREAK w/ctypes on win32"
4370
 
 
4371
 
 
4372
 
BreakinFeature = _BreakinFeature()
4373
 
 
4374
 
 
4375
3483
class _CaseInsCasePresFilenameFeature(Feature):
4376
3484
    """Is the file-system case insensitive, but case-preserving?"""
4377
3485
 
4427
3535
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
4428
3536
 
4429
3537
 
4430
 
class _CaseSensitiveFilesystemFeature(Feature):
 
3538
class _SubUnitFeature(Feature):
 
3539
    """Check if subunit is available."""
4431
3540
 
4432
3541
    def _probe(self):
4433
 
        if CaseInsCasePresFilenameFeature.available():
4434
 
            return False
4435
 
        elif CaseInsensitiveFilesystemFeature.available():
4436
 
            return False
4437
 
        else:
 
3542
        try:
 
3543
            import subunit
4438
3544
            return True
 
3545
        except ImportError:
 
3546
            return False
4439
3547
 
4440
3548
    def feature_name(self):
4441
 
        return 'case-sensitive filesystem'
4442
 
 
4443
 
# new coding style is for feature instances to be lowercase
4444
 
case_sensitive_filesystem_feature = _CaseSensitiveFilesystemFeature()
4445
 
 
4446
 
 
4447
 
# Kept for compatibility, use bzrlib.tests.features.subunit instead
4448
 
SubUnitFeature = _CompatabilityThunkFeature(
4449
 
    deprecated_in((2,1,0)),
4450
 
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
 
3549
        return 'subunit'
 
3550
 
 
3551
SubUnitFeature = _SubUnitFeature()
4451
3552
# Only define SubUnitBzrRunner if subunit is available.
4452
3553
try:
4453
3554
    from subunit import TestProtocolClient
4454
 
    from subunit.test_results import AutoTimingTestResultDecorator
4455
3555
    class SubUnitBzrRunner(TextTestRunner):
4456
3556
        def run(self, test):
4457
 
            result = AutoTimingTestResultDecorator(
4458
 
                TestProtocolClient(self.stream))
 
3557
            # undo out claim for testing which looks like a test start to subunit
 
3558
            self.stream.write("success: %s\n" % (osutils.realpath(sys.argv[0]),))
 
3559
            result = TestProtocolClient(self.stream)
4459
3560
            test.run(result)
4460
3561
            return result
4461
3562
except ImportError:
4462
3563
    pass
4463
 
 
4464
 
class _PosixPermissionsFeature(Feature):
4465
 
 
4466
 
    def _probe(self):
4467
 
        def has_perms():
4468
 
            # create temporary file and check if specified perms are maintained.
4469
 
            import tempfile
4470
 
 
4471
 
            write_perms = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
4472
 
            f = tempfile.mkstemp(prefix='bzr_perms_chk_')
4473
 
            fd, name = f
4474
 
            os.close(fd)
4475
 
            os.chmod(name, write_perms)
4476
 
 
4477
 
            read_perms = os.stat(name).st_mode & 0777
4478
 
            os.unlink(name)
4479
 
            return (write_perms == read_perms)
4480
 
 
4481
 
        return (os.name == 'posix') and has_perms()
4482
 
 
4483
 
    def feature_name(self):
4484
 
        return 'POSIX permissions support'
4485
 
 
4486
 
posix_permissions_feature = _PosixPermissionsFeature()