~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

Don't encode unicode messages to UTF-8 in mutter() (the stream writer does it).

Use a codec wrapped log file in tests to match the real environment.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 by Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
# TODO: Perhaps there should be an API to find out if bzr running under the
19
 
# test suite -- some plugins might want to avoid making intrusive changes if
20
 
# this is the case.  However, we want behaviour under to test to diverge as
21
 
# little as possible, so this should be used rarely if it's added at all.
22
 
# (Suggestion from j-a-meinel, 2005-11-24)
23
 
 
24
 
# NOTE: Some classes in here use camelCaseNaming() rather than
25
 
# underscore_naming().  That's for consistency with unittest; it's not the
26
 
# general style of bzrlib.  Please continue that consistency when adding e.g.
27
 
# new assertFoo() methods.
28
 
 
29
 
import codecs
30
18
from cStringIO import StringIO
31
19
import difflib
32
 
import doctest
33
20
import errno
34
21
import logging
35
22
import os
36
 
from pprint import pformat
37
 
import random
38
23
import re
39
 
import stat
40
 
from subprocess import Popen, PIPE
 
24
import shutil
41
25
import sys
42
26
import tempfile
43
27
import unittest
44
28
import time
45
 
 
46
 
 
47
 
from bzrlib import (
48
 
    bzrdir,
49
 
    debug,
50
 
    errors,
51
 
    memorytree,
52
 
    osutils,
53
 
    progress,
54
 
    ui,
55
 
    urlutils,
56
 
    workingtree,
57
 
    )
 
29
import codecs
 
30
 
58
31
import bzrlib.branch
59
32
import bzrlib.commands
60
 
import bzrlib.timestamp
61
 
import bzrlib.export
 
33
from bzrlib.errors import BzrError
62
34
import bzrlib.inventory
63
 
import bzrlib.iterablefile
64
 
import bzrlib.lockdir
65
 
try:
66
 
    import bzrlib.lsprof
67
 
except ImportError:
68
 
    # lsprof not available
69
 
    pass
70
 
from bzrlib.merge import merge_inner
71
35
import bzrlib.merge3
72
36
import bzrlib.osutils
 
37
import bzrlib.osutils as osutils
73
38
import bzrlib.plugin
74
 
from bzrlib.revision import common_ancestor
75
39
import bzrlib.store
76
 
from bzrlib import symbol_versioning
77
40
import bzrlib.trace
78
 
from bzrlib.transport import get_transport
79
 
import bzrlib.transport
80
 
from bzrlib.transport.local import LocalURLServer
81
 
from bzrlib.transport.memory import MemoryServer
82
 
from bzrlib.transport.readonly import ReadonlyServer
83
 
from bzrlib.trace import mutter, note
84
 
from bzrlib.tests import TestUtil
85
 
from bzrlib.tests.HttpServer import HttpServer
86
 
from bzrlib.tests.TestUtil import (
87
 
                          TestSuite,
88
 
                          TestLoader,
89
 
                          )
 
41
from bzrlib.trace import mutter
 
42
from bzrlib.tests.TestUtil import TestLoader, TestSuite
90
43
from bzrlib.tests.treeshape import build_tree_contents
91
 
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
92
 
 
93
 
# Mark this python module as being part of the implementation
94
 
# of unittest: this gives us better tracebacks where the last
95
 
# shown frame is the test code, not our assertXYZ.
96
 
__unittest = 1
97
 
 
98
 
default_transport = LocalURLServer
99
44
 
100
45
MODULES_TO_TEST = []
101
46
MODULES_TO_DOCTEST = [
102
 
                      bzrlib.timestamp,
 
47
                      bzrlib.branch,
 
48
                      bzrlib.commands,
103
49
                      bzrlib.errors,
104
 
                      bzrlib.export,
105
50
                      bzrlib.inventory,
106
 
                      bzrlib.iterablefile,
107
 
                      bzrlib.lockdir,
108
51
                      bzrlib.merge3,
109
 
                      bzrlib.option,
 
52
                      bzrlib.osutils,
110
53
                      bzrlib.store,
111
54
                      ]
112
 
 
113
 
 
114
55
def packages_to_test():
115
 
    """Return a list of packages to test.
116
 
 
117
 
    The packages are not globally imported so that import failures are
118
 
    triggered when running selftest, not when importing the command.
119
 
    """
120
 
    import bzrlib.doc
121
56
    import bzrlib.tests.blackbox
122
 
    import bzrlib.tests.branch_implementations
123
 
    import bzrlib.tests.bzrdir_implementations
124
 
    import bzrlib.tests.interrepository_implementations
125
 
    import bzrlib.tests.interversionedfile_implementations
126
 
    import bzrlib.tests.intertree_implementations
127
 
    import bzrlib.tests.per_lock
128
 
    import bzrlib.tests.repository_implementations
129
 
    import bzrlib.tests.revisionstore_implementations
130
 
    import bzrlib.tests.tree_implementations
131
 
    import bzrlib.tests.workingtree_implementations
132
57
    return [
133
 
            bzrlib.doc,
134
 
            bzrlib.tests.blackbox,
135
 
            bzrlib.tests.branch_implementations,
136
 
            bzrlib.tests.bzrdir_implementations,
137
 
            bzrlib.tests.interrepository_implementations,
138
 
            bzrlib.tests.interversionedfile_implementations,
139
 
            bzrlib.tests.intertree_implementations,
140
 
            bzrlib.tests.per_lock,
141
 
            bzrlib.tests.repository_implementations,
142
 
            bzrlib.tests.revisionstore_implementations,
143
 
            bzrlib.tests.tree_implementations,
144
 
            bzrlib.tests.workingtree_implementations,
 
58
            bzrlib.tests.blackbox
145
59
            ]
146
60
 
147
61
 
148
 
class ExtendedTestResult(unittest._TextTestResult):
149
 
    """Accepts, reports and accumulates the results of running tests.
150
 
 
151
 
    Compared to this unittest version this class adds support for profiling,
152
 
    benchmarking, stopping as soon as a test fails,  and skipping tests.
153
 
    There are further-specialized subclasses for different types of display.
 
62
class EarlyStoppingTestResultAdapter(object):
 
63
    """An adapter for TestResult to stop at the first first failure or error"""
 
64
 
 
65
    def __init__(self, result):
 
66
        self._result = result
 
67
 
 
68
    def addError(self, test, err):
 
69
        self._result.addError(test, err)
 
70
        self._result.stop()
 
71
 
 
72
    def addFailure(self, test, err):
 
73
        self._result.addFailure(test, err)
 
74
        self._result.stop()
 
75
 
 
76
    def __getattr__(self, name):
 
77
        return getattr(self._result, name)
 
78
 
 
79
    def __setattr__(self, name, value):
 
80
        if name == '_result':
 
81
            object.__setattr__(self, name, value)
 
82
        return setattr(self._result, name, value)
 
83
 
 
84
 
 
85
class _MyResult(unittest._TextTestResult):
 
86
    """Custom TestResult.
 
87
 
 
88
    Shows output in a different format, including displaying runtime for tests.
154
89
    """
155
90
 
156
 
    stop_early = False
157
 
    
158
 
    def __init__(self, stream, descriptions, verbosity,
159
 
                 bench_history=None,
160
 
                 num_tests=None,
161
 
                 use_numbered_dirs=False,
162
 
                 ):
163
 
        """Construct new TestResult.
164
 
 
165
 
        :param bench_history: Optionally, a writable file object to accumulate
166
 
            benchmark results.
167
 
        """
168
 
        unittest._TextTestResult.__init__(self, stream, descriptions, verbosity)
169
 
        if bench_history is not None:
170
 
            from bzrlib.version import _get_bzr_source_tree
171
 
            src_tree = _get_bzr_source_tree()
172
 
            if src_tree:
173
 
                try:
174
 
                    revision_id = src_tree.get_parent_ids()[0]
175
 
                except IndexError:
176
 
                    # XXX: if this is a brand new tree, do the same as if there
177
 
                    # is no branch.
178
 
                    revision_id = ''
179
 
            else:
180
 
                # XXX: If there's no branch, what should we do?
181
 
                revision_id = ''
182
 
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
183
 
        self._bench_history = bench_history
184
 
        self.ui = ui.ui_factory
185
 
        self.num_tests = num_tests
186
 
        self.error_count = 0
187
 
        self.failure_count = 0
188
 
        self.known_failure_count = 0
189
 
        self.skip_count = 0
190
 
        self.unsupported = {}
191
 
        self.count = 0
192
 
        self.use_numbered_dirs = use_numbered_dirs
193
 
        self._overall_start_time = time.time()
194
 
    
195
 
    def extractBenchmarkTime(self, testCase):
196
 
        """Add a benchmark time for the current test case."""
197
 
        self._benchmarkTime = getattr(testCase, "_benchtime", None)
198
 
    
199
 
    def _elapsedTestTimeString(self):
200
 
        """Return a time string for the overall time the current test has taken."""
201
 
        return self._formatTime(time.time() - self._start_time)
202
 
 
203
 
    def _testTimeString(self):
204
 
        if self._benchmarkTime is not None:
205
 
            return "%s/%s" % (
206
 
                self._formatTime(self._benchmarkTime),
207
 
                self._elapsedTestTimeString())
208
 
        else:
209
 
            return "           %s" % self._elapsedTestTimeString()
210
 
 
211
 
    def _formatTime(self, seconds):
212
 
        """Format seconds as milliseconds with leading spaces."""
213
 
        # some benchmarks can take thousands of seconds to run, so we need 8
214
 
        # places
215
 
        return "%8dms" % (1000 * seconds)
216
 
 
217
 
    def _shortened_test_description(self, test):
218
 
        what = test.id()
219
 
        what = re.sub(r'^bzrlib\.(tests|benchmarks)\.', '', what)
220
 
        return what
 
91
    def _elapsedTime(self):
 
92
        return "%5dms" % (1000 * (time.time() - self._start_time))
221
93
 
222
94
    def startTest(self, test):
223
95
        unittest.TestResult.startTest(self, test)
224
 
        self.report_test_start(test)
225
 
        test.number = self.count
226
 
        self._recordTestStartTime()
227
 
 
228
 
    def _recordTestStartTime(self):
229
 
        """Record that a test has started."""
 
96
        # In a short description, the important words are in
 
97
        # the beginning, but in an id, the important words are
 
98
        # at the end
 
99
        SHOW_DESCRIPTIONS = False
 
100
        if self.showAll:
 
101
            width = osutils.terminal_width()
 
102
            name_width = width - 15
 
103
            what = None
 
104
            if SHOW_DESCRIPTIONS:
 
105
                what = test.shortDescription()
 
106
                if what:
 
107
                    if len(what) > name_width:
 
108
                        what = what[:name_width-3] + '...'
 
109
            if what is None:
 
110
                what = test.id()
 
111
                if what.startswith('bzrlib.tests.'):
 
112
                    what = what[13:]
 
113
                if len(what) > name_width:
 
114
                    what = '...' + what[3-name_width:]
 
115
            what = what.ljust(name_width)
 
116
            self.stream.write(what)
 
117
        self.stream.flush()
230
118
        self._start_time = time.time()
231
119
 
232
 
    def _cleanupLogFile(self, test):
233
 
        # We can only do this if we have one of our TestCases, not if
234
 
        # we have a doctest.
235
 
        setKeepLogfile = getattr(test, 'setKeepLogfile', None)
236
 
        if setKeepLogfile is not None:
237
 
            setKeepLogfile()
238
 
 
239
120
    def addError(self, test, err):
240
 
        self.extractBenchmarkTime(test)
241
 
        self._cleanupLogFile(test)
242
 
        if isinstance(err[1], TestSkipped):
243
 
            return self.addSkipped(test, err)
244
 
        elif isinstance(err[1], UnavailableFeature):
245
 
            return self.addNotSupported(test, err[1].args[0])
246
121
        unittest.TestResult.addError(self, test, err)
247
 
        self.error_count += 1
248
 
        self.report_error(test, err)
249
 
        if self.stop_early:
250
 
            self.stop()
 
122
        if self.showAll:
 
123
            self.stream.writeln("ERROR %s" % self._elapsedTime())
 
124
        elif self.dots:
 
125
            self.stream.write('E')
 
126
        self.stream.flush()
251
127
 
252
128
    def addFailure(self, test, err):
253
 
        self._cleanupLogFile(test)
254
 
        self.extractBenchmarkTime(test)
255
 
        if isinstance(err[1], KnownFailure):
256
 
            return self.addKnownFailure(test, err)
257
129
        unittest.TestResult.addFailure(self, test, err)
258
 
        self.failure_count += 1
259
 
        self.report_failure(test, err)
260
 
        if self.stop_early:
261
 
            self.stop()
262
 
 
263
 
    def addKnownFailure(self, test, err):
264
 
        self.known_failure_count += 1
265
 
        self.report_known_failure(test, err)
266
 
 
267
 
    def addNotSupported(self, test, feature):
268
 
        self.unsupported.setdefault(str(feature), 0)
269
 
        self.unsupported[str(feature)] += 1
270
 
        self.report_unsupported(test, feature)
 
130
        if self.showAll:
 
131
            self.stream.writeln(" FAIL %s" % self._elapsedTime())
 
132
        elif self.dots:
 
133
            self.stream.write('F')
 
134
        self.stream.flush()
271
135
 
272
136
    def addSuccess(self, test):
273
 
        self.extractBenchmarkTime(test)
274
 
        if self._bench_history is not None:
275
 
            if self._benchmarkTime is not None:
276
 
                self._bench_history.write("%s %s\n" % (
277
 
                    self._formatTime(self._benchmarkTime),
278
 
                    test.id()))
279
 
        self.report_success(test)
 
137
        if self.showAll:
 
138
            self.stream.writeln('   OK %s' % self._elapsedTime())
 
139
        elif self.dots:
 
140
            self.stream.write('~')
 
141
        self.stream.flush()
280
142
        unittest.TestResult.addSuccess(self, test)
281
143
 
282
 
    def addSkipped(self, test, skip_excinfo):
283
 
        self.report_skip(test, skip_excinfo)
284
 
        # seems best to treat this as success from point-of-view of unittest
285
 
        # -- it actually does nothing so it barely matters :)
286
 
        try:
287
 
            test.tearDown()
288
 
        except KeyboardInterrupt:
289
 
            raise
290
 
        except:
291
 
            self.addError(test, test.__exc_info())
292
 
        else:
293
 
            unittest.TestResult.addSuccess(self, test)
294
 
 
295
144
    def printErrorList(self, flavour, errors):
296
145
        for test, err in errors:
297
146
            self.stream.writeln(self.separator1)
298
 
            self.stream.write("%s: " % flavour)
299
 
            if self.use_numbered_dirs:
300
 
                self.stream.write('#%d ' % test.number)
301
 
            self.stream.writeln(self.getDescription(test))
302
 
            if getattr(test, '_get_log', None) is not None:
303
 
                print >>self.stream
304
 
                print >>self.stream, \
305
 
                        ('vvvv[log from %s]' % test.id()).ljust(78,'-')
 
147
            self.stream.writeln("%s: %s" % (flavour,self.getDescription(test)))
 
148
            if hasattr(test, '_get_log'):
 
149
                self.stream.writeln()
 
150
                self.stream.writeln('log from this test:')
306
151
                print >>self.stream, test._get_log()
307
 
                print >>self.stream, \
308
 
                        ('^^^^[log from %s]' % test.id()).ljust(78,'-')
309
152
            self.stream.writeln(self.separator2)
310
153
            self.stream.writeln("%s" % err)
311
154
 
312
 
    def finished(self):
313
 
        pass
314
 
 
315
 
    def report_cleaning_up(self):
316
 
        pass
317
 
 
318
 
    def report_success(self, test):
319
 
        pass
320
 
 
321
 
 
322
 
class TextTestResult(ExtendedTestResult):
323
 
    """Displays progress and results of tests in text form"""
324
 
 
325
 
    def __init__(self, stream, descriptions, verbosity,
326
 
                 bench_history=None,
327
 
                 num_tests=None,
328
 
                 pb=None,
329
 
                 use_numbered_dirs=False,
330
 
                 ):
331
 
        ExtendedTestResult.__init__(self, stream, descriptions, verbosity,
332
 
            bench_history, num_tests, use_numbered_dirs)
333
 
        if pb is None:
334
 
            self.pb = self.ui.nested_progress_bar()
335
 
            self._supplied_pb = False
336
 
        else:
337
 
            self.pb = pb
338
 
            self._supplied_pb = True
339
 
        self.pb.show_pct = False
340
 
        self.pb.show_spinner = False
341
 
        self.pb.show_eta = False,
342
 
        self.pb.show_count = False
343
 
        self.pb.show_bar = False
344
 
 
345
 
    def report_starting(self):
346
 
        self.pb.update('[test 0/%d] starting...' % (self.num_tests))
347
 
 
348
 
    def _progress_prefix_text(self):
349
 
        a = '[%d' % self.count
350
 
        if self.num_tests is not None:
351
 
            a +='/%d' % self.num_tests
352
 
        a += ' in %ds' % (time.time() - self._overall_start_time)
353
 
        if self.error_count:
354
 
            a += ', %d errors' % self.error_count
355
 
        if self.failure_count:
356
 
            a += ', %d failed' % self.failure_count
357
 
        if self.known_failure_count:
358
 
            a += ', %d known failures' % self.known_failure_count
359
 
        if self.skip_count:
360
 
            a += ', %d skipped' % self.skip_count
361
 
        if self.unsupported:
362
 
            a += ', %d missing features' % len(self.unsupported)
363
 
        a += ']'
364
 
        return a
365
 
 
366
 
    def report_test_start(self, test):
367
 
        self.count += 1
368
 
        self.pb.update(
369
 
                self._progress_prefix_text()
370
 
                + ' ' 
371
 
                + self._shortened_test_description(test))
372
 
 
373
 
    def _test_description(self, test):
374
 
        if self.use_numbered_dirs:
375
 
            return '#%d %s' % (self.count,
376
 
                               self._shortened_test_description(test))
377
 
        else:
378
 
            return self._shortened_test_description(test)
379
 
 
380
 
    def report_error(self, test, err):
381
 
        self.pb.note('ERROR: %s\n    %s\n', 
382
 
            self._test_description(test),
383
 
            err[1],
384
 
            )
385
 
 
386
 
    def report_failure(self, test, err):
387
 
        self.pb.note('FAIL: %s\n    %s\n', 
388
 
            self._test_description(test),
389
 
            err[1],
390
 
            )
391
 
 
392
 
    def report_known_failure(self, test, err):
393
 
        self.pb.note('XFAIL: %s\n%s\n',
394
 
            self._test_description(test), err[1])
395
 
 
396
 
    def report_skip(self, test, skip_excinfo):
397
 
        self.skip_count += 1
398
 
        if False:
399
 
            # at the moment these are mostly not things we can fix
400
 
            # and so they just produce stipple; use the verbose reporter
401
 
            # to see them.
402
 
            if False:
403
 
                # show test and reason for skip
404
 
                self.pb.note('SKIP: %s\n    %s\n', 
405
 
                    self._shortened_test_description(test),
406
 
                    skip_excinfo[1])
407
 
            else:
408
 
                # since the class name was left behind in the still-visible
409
 
                # progress bar...
410
 
                self.pb.note('SKIP: %s', skip_excinfo[1])
411
 
 
412
 
    def report_unsupported(self, test, feature):
413
 
        """test cannot be run because feature is missing."""
414
 
                  
415
 
    def report_cleaning_up(self):
416
 
        self.pb.update('cleaning up...')
417
 
 
418
 
    def finished(self):
419
 
        if not self._supplied_pb:
420
 
            self.pb.finished()
421
 
 
422
 
 
423
 
class VerboseTestResult(ExtendedTestResult):
424
 
    """Produce long output, with one line per test run plus times"""
425
 
 
426
 
    def _ellipsize_to_right(self, a_string, final_width):
427
 
        """Truncate and pad a string, keeping the right hand side"""
428
 
        if len(a_string) > final_width:
429
 
            result = '...' + a_string[3-final_width:]
430
 
        else:
431
 
            result = a_string
432
 
        return result.ljust(final_width)
433
 
 
434
 
    def report_starting(self):
435
 
        self.stream.write('running %d tests...\n' % self.num_tests)
436
 
 
437
 
    def report_test_start(self, test):
438
 
        self.count += 1
439
 
        name = self._shortened_test_description(test)
440
 
        # width needs space for 6 char status, plus 1 for slash, plus 2 10-char
441
 
        # numbers, plus a trailing blank
442
 
        # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on space
443
 
        if self.use_numbered_dirs:
444
 
            self.stream.write('%5d ' % self.count)
445
 
            self.stream.write(self._ellipsize_to_right(name,
446
 
                                osutils.terminal_width()-36))
447
 
        else:
448
 
            self.stream.write(self._ellipsize_to_right(name,
449
 
                                osutils.terminal_width()-30))
450
 
        self.stream.flush()
451
 
 
452
 
    def _error_summary(self, err):
453
 
        indent = ' ' * 4
454
 
        if self.use_numbered_dirs:
455
 
            indent += ' ' * 6
456
 
        return '%s%s' % (indent, err[1])
457
 
 
458
 
    def report_error(self, test, err):
459
 
        self.stream.writeln('ERROR %s\n%s'
460
 
                % (self._testTimeString(),
461
 
                   self._error_summary(err)))
462
 
 
463
 
    def report_failure(self, test, err):
464
 
        self.stream.writeln(' FAIL %s\n%s'
465
 
                % (self._testTimeString(),
466
 
                   self._error_summary(err)))
467
 
 
468
 
    def report_known_failure(self, test, err):
469
 
        self.stream.writeln('XFAIL %s\n%s'
470
 
                % (self._testTimeString(),
471
 
                   self._error_summary(err)))
472
 
 
473
 
    def report_success(self, test):
474
 
        self.stream.writeln('   OK %s' % self._testTimeString())
475
 
        for bench_called, stats in getattr(test, '_benchcalls', []):
476
 
            self.stream.writeln('LSProf output for %s(%s, %s)' % bench_called)
477
 
            stats.pprint(file=self.stream)
478
 
        # flush the stream so that we get smooth output. This verbose mode is
479
 
        # used to show the output in PQM.
480
 
        self.stream.flush()
481
 
 
482
 
    def report_skip(self, test, skip_excinfo):
483
 
        self.skip_count += 1
484
 
        self.stream.writeln(' SKIP %s\n%s'
485
 
                % (self._testTimeString(),
486
 
                   self._error_summary(skip_excinfo)))
487
 
 
488
 
    def report_unsupported(self, test, feature):
489
 
        """test cannot be run because feature is missing."""
490
 
        self.stream.writeln("NODEP %s\n    The feature '%s' is not available."
491
 
                %(self._testTimeString(), feature))
492
 
                  
493
 
 
494
 
 
495
 
class TextTestRunner(object):
 
155
 
 
156
class TextTestRunner(unittest.TextTestRunner):
496
157
    stop_on_failure = False
497
158
 
498
 
    def __init__(self,
499
 
                 stream=sys.stderr,
500
 
                 descriptions=0,
501
 
                 verbosity=1,
502
 
                 keep_output=False,
503
 
                 bench_history=None,
504
 
                 use_numbered_dirs=False,
505
 
                 list_only=False
506
 
                 ):
507
 
        self.stream = unittest._WritelnDecorator(stream)
508
 
        self.descriptions = descriptions
509
 
        self.verbosity = verbosity
510
 
        self.keep_output = keep_output
511
 
        self._bench_history = bench_history
512
 
        self.use_numbered_dirs = use_numbered_dirs
513
 
        self.list_only = list_only
514
 
 
515
 
    def run(self, test):
516
 
        "Run the given test case or test suite."
517
 
        startTime = time.time()
518
 
        if self.verbosity == 1:
519
 
            result_class = TextTestResult
520
 
        elif self.verbosity >= 2:
521
 
            result_class = VerboseTestResult
522
 
        result = result_class(self.stream,
523
 
                              self.descriptions,
524
 
                              self.verbosity,
525
 
                              bench_history=self._bench_history,
526
 
                              num_tests=test.countTestCases(),
527
 
                              use_numbered_dirs=self.use_numbered_dirs,
528
 
                              )
529
 
        result.stop_early = self.stop_on_failure
530
 
        result.report_starting()
531
 
        if self.list_only:
532
 
            if self.verbosity >= 2:
533
 
                self.stream.writeln("Listing tests only ...\n")
534
 
            run = 0
535
 
            for t in iter_suite_tests(test):
536
 
                self.stream.writeln("%s" % (t.id()))
537
 
                run += 1
538
 
            actionTaken = "Listed"
539
 
        else: 
540
 
            test.run(result)
541
 
            run = result.testsRun
542
 
            actionTaken = "Ran"
543
 
        stopTime = time.time()
544
 
        timeTaken = stopTime - startTime
545
 
        result.printErrors()
546
 
        self.stream.writeln(result.separator2)
547
 
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
548
 
                            run, run != 1 and "s" or "", timeTaken))
549
 
        self.stream.writeln()
550
 
        if not result.wasSuccessful():
551
 
            self.stream.write("FAILED (")
552
 
            failed, errored = map(len, (result.failures, result.errors))
553
 
            if failed:
554
 
                self.stream.write("failures=%d" % failed)
555
 
            if errored:
556
 
                if failed: self.stream.write(", ")
557
 
                self.stream.write("errors=%d" % errored)
558
 
            if result.known_failure_count:
559
 
                if failed or errored: self.stream.write(", ")
560
 
                self.stream.write("known_failure_count=%d" %
561
 
                    result.known_failure_count)
562
 
            self.stream.writeln(")")
563
 
        else:
564
 
            if result.known_failure_count:
565
 
                self.stream.writeln("OK (known_failures=%d)" %
566
 
                    result.known_failure_count)
567
 
            else:
568
 
                self.stream.writeln("OK")
569
 
        if result.skip_count > 0:
570
 
            skipped = result.skip_count
571
 
            self.stream.writeln('%d test%s skipped' %
572
 
                                (skipped, skipped != 1 and "s" or ""))
573
 
        if result.unsupported:
574
 
            for feature, count in sorted(result.unsupported.items()):
575
 
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
576
 
                    (feature, count))
577
 
        result.report_cleaning_up()
578
 
        # This is still a little bogus, 
579
 
        # but only a little. Folk not using our testrunner will
580
 
        # have to delete their temp directories themselves.
581
 
        test_root = TestCaseWithMemoryTransport.TEST_ROOT
582
 
        if result.wasSuccessful() or not self.keep_output:
583
 
            if test_root is not None:
584
 
                # If LANG=C we probably have created some bogus paths
585
 
                # which rmtree(unicode) will fail to delete
586
 
                # so make sure we are using rmtree(str) to delete everything
587
 
                # except on win32, where rmtree(str) will fail
588
 
                # since it doesn't have the property of byte-stream paths
589
 
                # (they are either ascii or mbcs)
590
 
                if sys.platform == 'win32':
591
 
                    # make sure we are using the unicode win32 api
592
 
                    test_root = unicode(test_root)
593
 
                else:
594
 
                    test_root = test_root.encode(
595
 
                        sys.getfilesystemencoding())
596
 
                _rmtree_temp_dir(test_root)
597
 
        else:
598
 
            note("Failed tests working directories are in '%s'\n", test_root)
599
 
        TestCaseWithMemoryTransport.TEST_ROOT = None
600
 
        result.finished()
 
159
    def _makeResult(self):
 
160
        result = _MyResult(self.stream, self.descriptions, self.verbosity)
 
161
        if self.stop_on_failure:
 
162
            result = EarlyStoppingTestResultAdapter(result)
601
163
        return result
602
164
 
603
165
 
616
178
 
617
179
class TestSkipped(Exception):
618
180
    """Indicates that a test was intentionally skipped, rather than failing."""
619
 
 
620
 
 
621
 
class KnownFailure(AssertionError):
622
 
    """Indicates that a test failed in a precisely expected manner.
623
 
 
624
 
    Such failures dont block the whole test suite from passing because they are
625
 
    indicators of partially completed code or of future work. We have an
626
 
    explicit error for them so that we can ensure that they are always visible:
627
 
    KnownFailures are always shown in the output of bzr selftest.
628
 
    """
629
 
 
630
 
 
631
 
class UnavailableFeature(Exception):
632
 
    """A feature required for this test was not available.
633
 
 
634
 
    The feature should be used to construct the exception.
635
 
    """
 
181
    # XXX: Not used yet
636
182
 
637
183
 
638
184
class CommandFailed(Exception):
639
185
    pass
640
186
 
641
 
 
642
 
class StringIOWrapper(object):
643
 
    """A wrapper around cStringIO which just adds an encoding attribute.
644
 
    
645
 
    Internally we can check sys.stdout to see what the output encoding
646
 
    should be. However, cStringIO has no encoding attribute that we can
647
 
    set. So we wrap it instead.
648
 
    """
649
 
    encoding='ascii'
650
 
    _cstring = None
651
 
 
652
 
    def __init__(self, s=None):
653
 
        if s is not None:
654
 
            self.__dict__['_cstring'] = StringIO(s)
655
 
        else:
656
 
            self.__dict__['_cstring'] = StringIO()
657
 
 
658
 
    def __getattr__(self, name, getattr=getattr):
659
 
        return getattr(self.__dict__['_cstring'], name)
660
 
 
661
 
    def __setattr__(self, name, val):
662
 
        if name == 'encoding':
663
 
            self.__dict__['encoding'] = val
664
 
        else:
665
 
            return setattr(self._cstring, name, val)
666
 
 
667
 
 
668
 
class TestUIFactory(ui.CLIUIFactory):
669
 
    """A UI Factory for testing.
670
 
 
671
 
    Hide the progress bar but emit note()s.
672
 
    Redirect stdin.
673
 
    Allows get_password to be tested without real tty attached.
674
 
    """
675
 
 
676
 
    def __init__(self,
677
 
                 stdout=None,
678
 
                 stderr=None,
679
 
                 stdin=None):
680
 
        super(TestUIFactory, self).__init__()
681
 
        if stdin is not None:
682
 
            # We use a StringIOWrapper to be able to test various
683
 
            # encodings, but the user is still responsible to
684
 
            # encode the string and to set the encoding attribute
685
 
            # of StringIOWrapper.
686
 
            self.stdin = StringIOWrapper(stdin)
687
 
        if stdout is None:
688
 
            self.stdout = sys.stdout
689
 
        else:
690
 
            self.stdout = stdout
691
 
        if stderr is None:
692
 
            self.stderr = sys.stderr
693
 
        else:
694
 
            self.stderr = stderr
695
 
 
696
 
    def clear(self):
697
 
        """See progress.ProgressBar.clear()."""
698
 
 
699
 
    def clear_term(self):
700
 
        """See progress.ProgressBar.clear_term()."""
701
 
 
702
 
    def clear_term(self):
703
 
        """See progress.ProgressBar.clear_term()."""
704
 
 
705
 
    def finished(self):
706
 
        """See progress.ProgressBar.finished()."""
707
 
 
708
 
    def note(self, fmt_string, *args, **kwargs):
709
 
        """See progress.ProgressBar.note()."""
710
 
        self.stdout.write((fmt_string + "\n") % args)
711
 
 
712
 
    def progress_bar(self):
713
 
        return self
714
 
 
715
 
    def nested_progress_bar(self):
716
 
        return self
717
 
 
718
 
    def update(self, message, count=None, total=None):
719
 
        """See progress.ProgressBar.update()."""
720
 
 
721
 
    def get_non_echoed_password(self, prompt):
722
 
        """Get password from stdin without trying to handle the echo mode"""
723
 
        if prompt:
724
 
            self.stdout.write(prompt.encode(self.stdout.encoding, 'replace'))
725
 
        password = self.stdin.readline()
726
 
        if not password:
727
 
            raise EOFError
728
 
        if password[-1] == '\n':
729
 
            password = password[:-1]
730
 
        return password
731
 
 
732
 
 
733
187
class TestCase(unittest.TestCase):
734
188
    """Base class for bzr unit tests.
735
189
    
751
205
    accidentally overlooked.
752
206
    """
753
207
 
 
208
    BZRPATH = 'bzr'
754
209
    _log_file_name = None
755
210
    _log_contents = ''
756
 
    _keep_log_file = False
757
 
    # record lsprof data when performing benchmark calls.
758
 
    _gather_lsprof_in_benchmarks = False
759
211
 
760
 
    def __init__(self, methodName='testMethod'):
761
 
        super(TestCase, self).__init__(methodName)
 
212
    def setUp(self):
 
213
        unittest.TestCase.setUp(self)
762
214
        self._cleanups = []
763
 
 
764
 
    def setUp(self):
765
 
        unittest.TestCase.setUp(self)
766
215
        self._cleanEnvironment()
767
216
        bzrlib.trace.disable_default_logging()
768
 
        self._silenceUI()
769
217
        self._startLogFile()
770
 
        self._benchcalls = []
771
 
        self._benchtime = None
772
 
        self._clear_hooks()
773
 
 
774
 
    def _clear_hooks(self):
775
 
        # prevent hooks affecting tests
776
 
        import bzrlib.branch
777
 
        import bzrlib.smart.server
778
 
        self._preserved_hooks = {
779
 
            bzrlib.branch.Branch: bzrlib.branch.Branch.hooks,
780
 
            bzrlib.smart.server.SmartTCPServer: bzrlib.smart.server.SmartTCPServer.hooks,
781
 
            }
782
 
        self.addCleanup(self._restoreHooks)
783
 
        # reset all hooks to an empty instance of the appropriate type
784
 
        bzrlib.branch.Branch.hooks = bzrlib.branch.BranchHooks()
785
 
        bzrlib.smart.server.SmartTCPServer.hooks = bzrlib.smart.server.SmartServerHooks()
786
 
        # FIXME: Rather than constructing new objects like this, how about
787
 
        # having save() and clear() methods on the base Hook class? mbp
788
 
        # 20070416
789
 
 
790
 
    def _silenceUI(self):
791
 
        """Turn off UI for duration of test"""
792
 
        # by default the UI is off; tests can turn it on if they want it.
793
 
        saved = ui.ui_factory
794
 
        def _restore():
795
 
            ui.ui_factory = saved
796
 
        ui.ui_factory = ui.SilentUIFactory()
797
 
        self.addCleanup(_restore)
798
218
 
799
219
    def _ndiff_strings(self, a, b):
800
220
        """Return ndiff between two strings containing lines.
811
231
                                  charjunk=lambda x: False)
812
232
        return ''.join(difflines)
813
233
 
814
 
    def assertEqual(self, a, b, message=''):
815
 
        try:
816
 
            if a == b:
817
 
                return
818
 
        except UnicodeError, e:
819
 
            # If we can't compare without getting a UnicodeError, then
820
 
            # obviously they are different
821
 
            mutter('UnicodeError: %s', e)
822
 
        if message:
823
 
            message += '\n'
824
 
        raise AssertionError("%snot equal:\na = %s\nb = %s\n"
825
 
            % (message,
826
 
               pformat(a), pformat(b)))
827
 
 
828
 
    assertEquals = assertEqual
829
 
 
830
 
    def assertEqualDiff(self, a, b, message=None):
 
234
    def assertEqualDiff(self, a, b):
831
235
        """Assert two texts are equal, if not raise an exception.
832
236
        
833
237
        This is intended for use with multi-line strings where it can 
836
240
        # TODO: perhaps override assertEquals to call this for strings?
837
241
        if a == b:
838
242
            return
839
 
        if message is None:
840
 
            message = "texts not equal:\n"
841
 
        raise AssertionError(message + 
 
243
        raise AssertionError("texts not equal:\n" + 
842
244
                             self._ndiff_strings(a, b))      
843
 
        
844
 
    def assertEqualMode(self, mode, mode_test):
845
 
        self.assertEqual(mode, mode_test,
846
 
                         'mode mismatch %o != %o' % (mode, mode_test))
847
 
 
848
 
    def assertStartsWith(self, s, prefix):
849
 
        if not s.startswith(prefix):
850
 
            raise AssertionError('string %r does not start with %r' % (s, prefix))
851
 
 
852
 
    def assertEndsWith(self, s, suffix):
853
 
        """Asserts that s ends with suffix."""
854
 
        if not s.endswith(suffix):
855
 
            raise AssertionError('string %r does not end with %r' % (s, suffix))
856
245
 
857
246
    def assertContainsRe(self, haystack, needle_re):
858
247
        """Assert that a contains something matching a regular expression."""
859
248
        if not re.search(needle_re, haystack):
860
 
            raise AssertionError('pattern "%r" not found in "%r"'
861
 
                    % (needle_re, haystack))
862
 
 
863
 
    def assertNotContainsRe(self, haystack, needle_re):
864
 
        """Assert that a does not match a regular expression"""
865
 
        if re.search(needle_re, haystack):
866
 
            raise AssertionError('pattern "%s" found in "%s"'
867
 
                    % (needle_re, haystack))
868
 
 
869
 
    def assertSubset(self, sublist, superlist):
870
 
        """Assert that every entry in sublist is present in superlist."""
871
 
        missing = []
872
 
        for entry in sublist:
873
 
            if entry not in superlist:
874
 
                missing.append(entry)
875
 
        if len(missing) > 0:
876
 
            raise AssertionError("value(s) %r not present in container %r" % 
877
 
                                 (missing, superlist))
878
 
 
879
 
    def assertListRaises(self, excClass, func, *args, **kwargs):
880
 
        """Fail unless excClass is raised when the iterator from func is used.
881
 
        
882
 
        Many functions can return generators this makes sure
883
 
        to wrap them in a list() call to make sure the whole generator
884
 
        is run, and that the proper exception is raised.
885
 
        """
886
 
        try:
887
 
            list(func(*args, **kwargs))
888
 
        except excClass:
889
 
            return
890
 
        else:
891
 
            if getattr(excClass,'__name__', None) is not None:
892
 
                excName = excClass.__name__
893
 
            else:
894
 
                excName = str(excClass)
895
 
            raise self.failureException, "%s not raised" % excName
896
 
 
897
 
    def assertRaises(self, excClass, func, *args, **kwargs):
898
 
        """Assert that a callable raises a particular exception.
899
 
 
900
 
        :param excClass: As for the except statement, this may be either an
901
 
        exception class, or a tuple of classes.
902
 
 
903
 
        Returns the exception so that you can examine it.
904
 
        """
905
 
        try:
906
 
            func(*args, **kwargs)
907
 
        except excClass, e:
908
 
            return e
909
 
        else:
910
 
            if getattr(excClass,'__name__', None) is not None:
911
 
                excName = excClass.__name__
912
 
            else:
913
 
                # probably a tuple
914
 
                excName = str(excClass)
915
 
            raise self.failureException, "%s not raised" % excName
916
 
 
917
 
    def assertIs(self, left, right, message=None):
918
 
        if not (left is right):
919
 
            if message is not None:
920
 
                raise AssertionError(message)
921
 
            else:
922
 
                raise AssertionError("%r is not %r." % (left, right))
923
 
 
924
 
    def assertIsNot(self, left, right, message=None):
925
 
        if (left is right):
926
 
            if message is not None:
927
 
                raise AssertionError(message)
928
 
            else:
929
 
                raise AssertionError("%r is %r." % (left, right))
930
 
 
931
 
    def assertTransportMode(self, transport, path, mode):
932
 
        """Fail if a path does not have mode mode.
933
 
        
934
 
        If modes are not supported on this transport, the assertion is ignored.
935
 
        """
936
 
        if not transport._can_roundtrip_unix_modebits():
937
 
            return
938
 
        path_stat = transport.stat(path)
939
 
        actual_mode = stat.S_IMODE(path_stat.st_mode)
940
 
        self.assertEqual(mode, actual_mode,
941
 
            'mode of %r incorrect (%o != %o)' % (path, mode, actual_mode))
942
 
 
943
 
    def assertIsInstance(self, obj, kls):
944
 
        """Fail if obj is not an instance of kls"""
945
 
        if not isinstance(obj, kls):
946
 
            self.fail("%r is an instance of %s rather than %s" % (
947
 
                obj, obj.__class__, kls))
948
 
 
949
 
    def expectFailure(self, reason, assertion, *args, **kwargs):
950
 
        """Invoke a test, expecting it to fail for the given reason.
951
 
 
952
 
        This is for assertions that ought to succeed, but currently fail.
953
 
        (The failure is *expected* but not *wanted*.)  Please be very precise
954
 
        about the failure you're expecting.  If a new bug is introduced,
955
 
        AssertionError should be raised, not KnownFailure.
956
 
 
957
 
        Frequently, expectFailure should be followed by an opposite assertion.
958
 
        See example below.
959
 
 
960
 
        Intended to be used with a callable that raises AssertionError as the
961
 
        'assertion' parameter.  args and kwargs are passed to the 'assertion'.
962
 
 
963
 
        Raises KnownFailure if the test fails.  Raises AssertionError if the
964
 
        test succeeds.
965
 
 
966
 
        example usage::
967
 
 
968
 
          self.expectFailure('Math is broken', self.assertNotEqual, 54,
969
 
                             dynamic_val)
970
 
          self.assertEqual(42, dynamic_val)
971
 
 
972
 
          This means that a dynamic_val of 54 will cause the test to raise
973
 
          a KnownFailure.  Once math is fixed and the expectFailure is removed,
974
 
          only a dynamic_val of 42 will allow the test to pass.  Anything other
975
 
          than 54 or 42 will cause an AssertionError.
976
 
        """
977
 
        try:
978
 
            assertion(*args, **kwargs)
979
 
        except AssertionError:
980
 
            raise KnownFailure(reason)
981
 
        else:
982
 
            self.fail('Unexpected success.  Should have failed: %s' % reason)
983
 
 
984
 
    def _capture_warnings(self, a_callable, *args, **kwargs):
985
 
        """A helper for callDeprecated and applyDeprecated.
986
 
 
987
 
        :param a_callable: A callable to call.
988
 
        :param args: The positional arguments for the callable
989
 
        :param kwargs: The keyword arguments for the callable
990
 
        :return: A tuple (warnings, result). result is the result of calling
991
 
            a_callable(*args, **kwargs).
992
 
        """
993
 
        local_warnings = []
994
 
        def capture_warnings(msg, cls=None, stacklevel=None):
995
 
            # we've hooked into a deprecation specific callpath,
996
 
            # only deprecations should getting sent via it.
997
 
            self.assertEqual(cls, DeprecationWarning)
998
 
            local_warnings.append(msg)
999
 
        original_warning_method = symbol_versioning.warn
1000
 
        symbol_versioning.set_warning_method(capture_warnings)
1001
 
        try:
1002
 
            result = a_callable(*args, **kwargs)
1003
 
        finally:
1004
 
            symbol_versioning.set_warning_method(original_warning_method)
1005
 
        return (local_warnings, result)
1006
 
 
1007
 
    def applyDeprecated(self, deprecation_format, a_callable, *args, **kwargs):
1008
 
        """Call a deprecated callable without warning the user.
1009
 
 
1010
 
        :param deprecation_format: The deprecation format that the callable
1011
 
            should have been deprecated with. This is the same type as the 
1012
 
            parameter to deprecated_method/deprecated_function. If the 
1013
 
            callable is not deprecated with this format, an assertion error
1014
 
            will be raised.
1015
 
        :param a_callable: A callable to call. This may be a bound method or
1016
 
            a regular function. It will be called with *args and **kwargs.
1017
 
        :param args: The positional arguments for the callable
1018
 
        :param kwargs: The keyword arguments for the callable
1019
 
        :return: The result of a_callable(*args, **kwargs)
1020
 
        """
1021
 
        call_warnings, result = self._capture_warnings(a_callable,
1022
 
            *args, **kwargs)
1023
 
        expected_first_warning = symbol_versioning.deprecation_string(
1024
 
            a_callable, deprecation_format)
1025
 
        if len(call_warnings) == 0:
1026
 
            self.fail("No deprecation warning generated by call to %s" %
1027
 
                a_callable)
1028
 
        self.assertEqual(expected_first_warning, call_warnings[0])
1029
 
        return result
1030
 
 
1031
 
    def callDeprecated(self, expected, callable, *args, **kwargs):
1032
 
        """Assert that a callable is deprecated in a particular way.
1033
 
 
1034
 
        This is a very precise test for unusual requirements. The 
1035
 
        applyDeprecated helper function is probably more suited for most tests
1036
 
        as it allows you to simply specify the deprecation format being used
1037
 
        and will ensure that that is issued for the function being called.
1038
 
 
1039
 
        :param expected: a list of the deprecation warnings expected, in order
1040
 
        :param callable: The callable to call
1041
 
        :param args: The positional arguments for the callable
1042
 
        :param kwargs: The keyword arguments for the callable
1043
 
        """
1044
 
        call_warnings, result = self._capture_warnings(callable,
1045
 
            *args, **kwargs)
1046
 
        self.assertEqual(expected, call_warnings)
1047
 
        return result
 
249
            raise AssertionError('pattern "%s" not found in "%s"'
 
250
                    % (needle_re, haystack))
1048
251
 
1049
252
    def _startLogFile(self):
1050
253
        """Send bzr and test log messages to a temporary file.
1052
255
        The file is removed as the test is torn down.
1053
256
        """
1054
257
        fileno, name = tempfile.mkstemp(suffix='.log', prefix='testbzr')
1055
 
        self._log_file = os.fdopen(fileno, 'w+')
1056
 
        self._log_nonce = bzrlib.trace.enable_test_log(self._log_file)
 
258
        encoder, decoder, stream_reader, stream_writer = codecs.lookup('UTF-8')
 
259
        self._log_file = stream_writer(os.fdopen(fileno, 'w+'))
 
260
        bzrlib.trace.enable_test_log(self._log_file)
1057
261
        self._log_file_name = name
1058
262
        self.addCleanup(self._finishLogFile)
1059
263
 
1060
264
    def _finishLogFile(self):
1061
265
        """Finished with the log file.
1062
266
 
1063
 
        Close the file and delete it, unless setKeepLogfile was called.
 
267
        Read contents into memory, close, and delete.
1064
268
        """
1065
 
        if self._log_file is None:
1066
 
            return
1067
 
        bzrlib.trace.disable_test_log(self._log_nonce)
 
269
        bzrlib.trace.disable_test_log()
 
270
        self._log_file.seek(0)
 
271
        self._log_contents = self._log_file.read()
1068
272
        self._log_file.close()
1069
 
        self._log_file = None
1070
 
        if not self._keep_log_file:
1071
 
            os.remove(self._log_file_name)
1072
 
            self._log_file_name = None
1073
 
 
1074
 
    def setKeepLogfile(self):
1075
 
        """Make the logfile not be deleted when _finishLogFile is called."""
1076
 
        self._keep_log_file = True
 
273
        os.remove(self._log_file_name)
 
274
        self._log_file = self._log_file_name = None
1077
275
 
1078
276
    def addCleanup(self, callable):
1079
277
        """Arrange to run a callable when this case is torn down.
1088
286
 
1089
287
    def _cleanEnvironment(self):
1090
288
        new_env = {
1091
 
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
1092
289
            'HOME': os.getcwd(),
1093
 
            'APPDATA': None,  # bzr now use Win32 API and don't rely on APPDATA
1094
 
            'BZR_EMAIL': None,
1095
 
            'BZREMAIL': None, # may still be present in the environment
 
290
            'APPDATA': os.getcwd(),
 
291
            'BZREMAIL': None,
1096
292
            'EMAIL': None,
1097
 
            'BZR_PROGRESS_BAR': None,
1098
 
            # Proxies
1099
 
            'http_proxy': None,
1100
 
            'HTTP_PROXY': None,
1101
 
            'https_proxy': None,
1102
 
            'HTTPS_PROXY': None,
1103
 
            'no_proxy': None,
1104
 
            'NO_PROXY': None,
1105
 
            'all_proxy': None,
1106
 
            'ALL_PROXY': None,
1107
 
            # Nobody cares about these ones AFAIK. So far at
1108
 
            # least. If you do (care), please update this comment
1109
 
            # -- vila 20061212
1110
 
            'ftp_proxy': None,
1111
 
            'FTP_PROXY': None,
1112
 
            'BZR_REMOTE_PATH': None,
1113
293
        }
1114
294
        self.__old_env = {}
1115
295
        self.addCleanup(self._restoreEnvironment)
1116
296
        for name, value in new_env.iteritems():
1117
297
            self._captureVar(name, value)
1118
298
 
 
299
 
1119
300
    def _captureVar(self, name, newvalue):
1120
 
        """Set an environment variable, and reset it when finished."""
1121
 
        self.__old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
301
        """Set an environment variable, preparing it to be reset when finished."""
 
302
        self.__old_env[name] = os.environ.get(name, None)
 
303
        if newvalue is None:
 
304
            if name in os.environ:
 
305
                del os.environ[name]
 
306
        else:
 
307
            os.environ[name] = newvalue
 
308
 
 
309
    @staticmethod
 
310
    def _restoreVar(name, value):
 
311
        if value is None:
 
312
            if name in os.environ:
 
313
                del os.environ[name]
 
314
        else:
 
315
            os.environ[name] = value
1122
316
 
1123
317
    def _restoreEnvironment(self):
1124
318
        for name, value in self.__old_env.iteritems():
1125
 
            osutils.set_or_unset_env(name, value)
1126
 
 
1127
 
    def _restoreHooks(self):
1128
 
        for klass, hooks in self._preserved_hooks.items():
1129
 
            setattr(klass, 'hooks', hooks)
1130
 
 
1131
 
    def knownFailure(self, reason):
1132
 
        """This test has failed for some known reason."""
1133
 
        raise KnownFailure(reason)
1134
 
 
1135
 
    def run(self, result=None):
1136
 
        if result is None: result = self.defaultTestResult()
1137
 
        for feature in getattr(self, '_test_needs_features', []):
1138
 
            if not feature.available():
1139
 
                result.startTest(self)
1140
 
                if getattr(result, 'addNotSupported', None):
1141
 
                    result.addNotSupported(self, feature)
1142
 
                else:
1143
 
                    result.addSuccess(self)
1144
 
                result.stopTest(self)
1145
 
                return
1146
 
        return unittest.TestCase.run(self, result)
 
319
            self._restoreVar(name, value)
1147
320
 
1148
321
    def tearDown(self):
1149
322
        self._runCleanups()
1150
323
        unittest.TestCase.tearDown(self)
1151
324
 
1152
 
    def time(self, callable, *args, **kwargs):
1153
 
        """Run callable and accrue the time it takes to the benchmark time.
1154
 
        
1155
 
        If lsprofiling is enabled (i.e. by --lsprof-time to bzr selftest) then
1156
 
        this will cause lsprofile statistics to be gathered and stored in
1157
 
        self._benchcalls.
1158
 
        """
1159
 
        if self._benchtime is None:
1160
 
            self._benchtime = 0
1161
 
        start = time.time()
1162
 
        try:
1163
 
            if not self._gather_lsprof_in_benchmarks:
1164
 
                return callable(*args, **kwargs)
1165
 
            else:
1166
 
                # record this benchmark
1167
 
                ret, stats = bzrlib.lsprof.profile(callable, *args, **kwargs)
1168
 
                stats.sort()
1169
 
                self._benchcalls.append(((callable, args, kwargs), stats))
1170
 
                return ret
1171
 
        finally:
1172
 
            self._benchtime += time.time() - start
1173
 
 
1174
325
    def _runCleanups(self):
1175
326
        """Run registered cleanup functions. 
1176
327
 
1177
328
        This should only be called from TestCase.tearDown.
1178
329
        """
1179
 
        # TODO: Perhaps this should keep running cleanups even if 
1180
 
        # one of them fails?
1181
 
 
1182
 
        # Actually pop the cleanups from the list so tearDown running
1183
 
        # twice is safe (this happens for skipped tests).
1184
 
        while self._cleanups:
1185
 
            self._cleanups.pop()()
 
330
        for callable in reversed(self._cleanups):
 
331
            callable()
1186
332
 
1187
333
    def log(self, *args):
1188
334
        mutter(*args)
1189
335
 
1190
 
    def _get_log(self, keep_log_file=False):
1191
 
        """Return as a string the log for this test. If the file is still
1192
 
        on disk and keep_log_file=False, delete the log file and store the
1193
 
        content in self._log_contents."""
1194
 
        # flush the log file, to get all content
1195
 
        import bzrlib.trace
1196
 
        bzrlib.trace._trace_file.flush()
1197
 
        if self._log_contents:
 
336
    def _get_log(self):
 
337
        """Return as a string the log for this test"""
 
338
        if self._log_file_name:
 
339
            return open(self._log_file_name).read()
 
340
        else:
1198
341
            return self._log_contents
1199
 
        if self._log_file_name is not None:
1200
 
            logfile = open(self._log_file_name)
1201
 
            try:
1202
 
                log_contents = logfile.read()
1203
 
            finally:
1204
 
                logfile.close()
1205
 
            if not keep_log_file:
1206
 
                self._log_contents = log_contents
1207
 
                try:
1208
 
                    os.remove(self._log_file_name)
1209
 
                except OSError, e:
1210
 
                    if sys.platform == 'win32' and e.errno == errno.EACCES:
1211
 
                        print >>sys.stderr, ('Unable to delete log file '
1212
 
                                             ' %r' % self._log_file_name)
1213
 
                    else:
1214
 
                        raise
1215
 
            return log_contents
1216
 
        else:
1217
 
            return "DELETED log file to reduce memory footprint"
 
342
        # TODO: Delete the log after it's been read in
1218
343
 
1219
344
    def capture(self, cmd, retcode=0):
1220
345
        """Shortcut that splits cmd into words, runs, and returns stdout"""
1221
346
        return self.run_bzr_captured(cmd.split(), retcode=retcode)[0]
1222
347
 
1223
 
    def requireFeature(self, feature):
1224
 
        """This test requires a specific feature is available.
1225
 
 
1226
 
        :raises UnavailableFeature: When feature is not available.
1227
 
        """
1228
 
        if not feature.available():
1229
 
            raise UnavailableFeature(feature)
1230
 
 
1231
 
    def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None,
1232
 
                         working_dir=None):
 
348
    def run_bzr_captured(self, argv, retcode=0):
1233
349
        """Invoke bzr and return (stdout, stderr).
1234
350
 
1235
351
        Useful for code that wants to check the contents of the
1246
362
        errors, and with logging set to something approximating the
1247
363
        default, so that error reporting can be checked.
1248
364
 
1249
 
        :param argv: arguments to invoke bzr
1250
 
        :param retcode: expected return code, or None for don't-care.
1251
 
        :param encoding: encoding for sys.stdout and sys.stderr
1252
 
        :param stdin: A string to be used as stdin for the command.
1253
 
        :param working_dir: Change to this directory before running
 
365
        argv -- arguments to invoke bzr
 
366
        retcode -- expected return code, or None for don't-care.
1254
367
        """
1255
 
        if encoding is None:
1256
 
            encoding = bzrlib.user_encoding
1257
 
        stdout = StringIOWrapper()
1258
 
        stderr = StringIOWrapper()
1259
 
        stdout.encoding = encoding
1260
 
        stderr.encoding = encoding
1261
 
 
1262
 
        self.log('run bzr: %r', argv)
 
368
        stdout = StringIO()
 
369
        stderr = StringIO()
 
370
        self.log('run bzr: %s', ' '.join(argv))
1263
371
        # FIXME: don't call into logging here
1264
372
        handler = logging.StreamHandler(stderr)
 
373
        handler.setFormatter(bzrlib.trace.QuietFormatter())
1265
374
        handler.setLevel(logging.INFO)
1266
375
        logger = logging.getLogger('')
1267
376
        logger.addHandler(handler)
1268
 
        old_ui_factory = ui.ui_factory
1269
 
        ui.ui_factory = TestUIFactory(stdin=stdin, stdout=stdout, stderr=stderr)
1270
 
 
1271
 
        cwd = None
1272
 
        if working_dir is not None:
1273
 
            cwd = osutils.getcwd()
1274
 
            os.chdir(working_dir)
1275
 
 
1276
377
        try:
1277
 
            saved_debug_flags = frozenset(debug.debug_flags)
1278
 
            debug.debug_flags.clear()
1279
 
            try:
1280
 
                result = self.apply_redirected(ui.ui_factory.stdin,
1281
 
                                               stdout, stderr,
1282
 
                                               bzrlib.commands.run_bzr_catch_errors,
1283
 
                                               argv)
1284
 
            finally:
1285
 
                debug.debug_flags.update(saved_debug_flags)
 
378
            result = self.apply_redirected(None, stdout, stderr,
 
379
                                           bzrlib.commands.run_bzr_catch_errors,
 
380
                                           argv)
1286
381
        finally:
1287
382
            logger.removeHandler(handler)
1288
 
            ui.ui_factory = old_ui_factory
1289
 
            if cwd is not None:
1290
 
                os.chdir(cwd)
1291
 
 
1292
383
        out = stdout.getvalue()
1293
384
        err = stderr.getvalue()
1294
385
        if out:
1295
 
            self.log('output:\n%r', out)
 
386
            self.log('output:\n%s', out)
1296
387
        if err:
1297
 
            self.log('errors:\n%r', err)
 
388
            self.log('errors:\n%s', err)
1298
389
        if retcode is not None:
1299
 
            self.assertEquals(retcode, result,
1300
 
                              message='Unexpected return code')
 
390
            self.assertEquals(result, retcode)
1301
391
        return out, err
1302
392
 
1303
393
    def run_bzr(self, *args, **kwargs):
1309
399
 
1310
400
        This sends the stdout/stderr results into the test's log,
1311
401
        where it may be useful for debugging.  See also run_captured.
1312
 
 
1313
 
        :param stdin: A string to be used as stdin for the command.
1314
 
        :param retcode: The status code the command should return
1315
 
        :param working_dir: The directory to run the command in
1316
402
        """
1317
403
        retcode = kwargs.pop('retcode', 0)
1318
 
        encoding = kwargs.pop('encoding', None)
1319
 
        stdin = kwargs.pop('stdin', None)
1320
 
        working_dir = kwargs.pop('working_dir', None)
1321
 
        error_regexes = kwargs.pop('error_regexes', [])
1322
 
 
1323
 
        out, err = self.run_bzr_captured(args, retcode=retcode,
1324
 
            encoding=encoding, stdin=stdin, working_dir=working_dir)
1325
 
 
1326
 
        for regex in error_regexes:
1327
 
            self.assertContainsRe(err, regex)
1328
 
        return out, err
1329
 
 
1330
 
 
1331
 
    def run_bzr_decode(self, *args, **kwargs):
1332
 
        if 'encoding' in kwargs:
1333
 
            encoding = kwargs['encoding']
1334
 
        else:
1335
 
            encoding = bzrlib.user_encoding
1336
 
        return self.run_bzr(*args, **kwargs)[0].decode(encoding)
1337
 
 
1338
 
    def run_bzr_error(self, error_regexes, *args, **kwargs):
1339
 
        """Run bzr, and check that stderr contains the supplied regexes
1340
 
        
1341
 
        :param error_regexes: Sequence of regular expressions which 
1342
 
            must each be found in the error output. The relative ordering
1343
 
            is not enforced.
1344
 
        :param args: command-line arguments for bzr
1345
 
        :param kwargs: Keyword arguments which are interpreted by run_bzr
1346
 
            This function changes the default value of retcode to be 3,
1347
 
            since in most cases this is run when you expect bzr to fail.
1348
 
        :return: (out, err) The actual output of running the command (in case you
1349
 
                 want to do more inspection)
1350
 
 
1351
 
        Examples of use:
1352
 
            # Make sure that commit is failing because there is nothing to do
1353
 
            self.run_bzr_error(['no changes to commit'],
1354
 
                               'commit', '-m', 'my commit comment')
1355
 
            # Make sure --strict is handling an unknown file, rather than
1356
 
            # giving us the 'nothing to do' error
1357
 
            self.build_tree(['unknown'])
1358
 
            self.run_bzr_error(['Commit refused because there are unknown files'],
1359
 
                               'commit', '--strict', '-m', 'my commit comment')
1360
 
        """
1361
 
        kwargs.setdefault('retcode', 3)
1362
 
        out, err = self.run_bzr(error_regexes=error_regexes, *args, **kwargs)
1363
 
        return out, err
1364
 
 
1365
 
    def run_bzr_subprocess(self, *args, **kwargs):
1366
 
        """Run bzr in a subprocess for testing.
1367
 
 
1368
 
        This starts a new Python interpreter and runs bzr in there. 
1369
 
        This should only be used for tests that have a justifiable need for
1370
 
        this isolation: e.g. they are testing startup time, or signal
1371
 
        handling, or early startup code, etc.  Subprocess code can't be 
1372
 
        profiled or debugged so easily.
1373
 
 
1374
 
        :param retcode: The status code that is expected.  Defaults to 0.  If
1375
 
            None is supplied, the status code is not checked.
1376
 
        :param env_changes: A dictionary which lists changes to environment
1377
 
            variables. A value of None will unset the env variable.
1378
 
            The values must be strings. The change will only occur in the
1379
 
            child, so you don't need to fix the environment after running.
1380
 
        :param universal_newlines: Convert CRLF => LF
1381
 
        :param allow_plugins: By default the subprocess is run with
1382
 
            --no-plugins to ensure test reproducibility. Also, it is possible
1383
 
            for system-wide plugins to create unexpected output on stderr,
1384
 
            which can cause unnecessary test failures.
1385
 
        """
1386
 
        env_changes = kwargs.get('env_changes', {})
1387
 
        working_dir = kwargs.get('working_dir', None)
1388
 
        allow_plugins = kwargs.get('allow_plugins', False)
1389
 
        process = self.start_bzr_subprocess(args, env_changes=env_changes,
1390
 
                                            working_dir=working_dir,
1391
 
                                            allow_plugins=allow_plugins)
1392
 
        # We distinguish between retcode=None and retcode not passed.
1393
 
        supplied_retcode = kwargs.get('retcode', 0)
1394
 
        return self.finish_bzr_subprocess(process, retcode=supplied_retcode,
1395
 
            universal_newlines=kwargs.get('universal_newlines', False),
1396
 
            process_args=args)
1397
 
 
1398
 
    def start_bzr_subprocess(self, process_args, env_changes=None,
1399
 
                             skip_if_plan_to_signal=False,
1400
 
                             working_dir=None,
1401
 
                             allow_plugins=False):
1402
 
        """Start bzr in a subprocess for testing.
1403
 
 
1404
 
        This starts a new Python interpreter and runs bzr in there.
1405
 
        This should only be used for tests that have a justifiable need for
1406
 
        this isolation: e.g. they are testing startup time, or signal
1407
 
        handling, or early startup code, etc.  Subprocess code can't be
1408
 
        profiled or debugged so easily.
1409
 
 
1410
 
        :param process_args: a list of arguments to pass to the bzr executable,
1411
 
            for example `['--version']`.
1412
 
        :param env_changes: A dictionary which lists changes to environment
1413
 
            variables. A value of None will unset the env variable.
1414
 
            The values must be strings. The change will only occur in the
1415
 
            child, so you don't need to fix the environment after running.
1416
 
        :param skip_if_plan_to_signal: raise TestSkipped when true and os.kill
1417
 
            is not available.
1418
 
        :param allow_plugins: If False (default) pass --no-plugins to bzr.
1419
 
 
1420
 
        :returns: Popen object for the started process.
1421
 
        """
1422
 
        if skip_if_plan_to_signal:
1423
 
            if not getattr(os, 'kill', None):
1424
 
                raise TestSkipped("os.kill not available.")
1425
 
 
1426
 
        if env_changes is None:
1427
 
            env_changes = {}
1428
 
        old_env = {}
1429
 
 
1430
 
        def cleanup_environment():
1431
 
            for env_var, value in env_changes.iteritems():
1432
 
                old_env[env_var] = osutils.set_or_unset_env(env_var, value)
1433
 
 
1434
 
        def restore_environment():
1435
 
            for env_var, value in old_env.iteritems():
1436
 
                osutils.set_or_unset_env(env_var, value)
1437
 
 
1438
 
        bzr_path = self.get_bzr_path()
1439
 
 
1440
 
        cwd = None
1441
 
        if working_dir is not None:
1442
 
            cwd = osutils.getcwd()
1443
 
            os.chdir(working_dir)
1444
 
 
1445
 
        try:
1446
 
            # win32 subprocess doesn't support preexec_fn
1447
 
            # so we will avoid using it on all platforms, just to
1448
 
            # make sure the code path is used, and we don't break on win32
1449
 
            cleanup_environment()
1450
 
            command = [sys.executable, bzr_path]
1451
 
            if not allow_plugins:
1452
 
                command.append('--no-plugins')
1453
 
            command.extend(process_args)
1454
 
            process = self._popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
1455
 
        finally:
1456
 
            restore_environment()
1457
 
            if cwd is not None:
1458
 
                os.chdir(cwd)
1459
 
 
1460
 
        return process
1461
 
 
1462
 
    def _popen(self, *args, **kwargs):
1463
 
        """Place a call to Popen.
1464
 
 
1465
 
        Allows tests to override this method to intercept the calls made to
1466
 
        Popen for introspection.
1467
 
        """
1468
 
        return Popen(*args, **kwargs)
1469
 
 
1470
 
    def get_bzr_path(self):
1471
 
        """Return the path of the 'bzr' executable for this test suite."""
1472
 
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
1473
 
        if not os.path.isfile(bzr_path):
1474
 
            # We are probably installed. Assume sys.argv is the right file
1475
 
            bzr_path = sys.argv[0]
1476
 
        return bzr_path
1477
 
 
1478
 
    def finish_bzr_subprocess(self, process, retcode=0, send_signal=None,
1479
 
                              universal_newlines=False, process_args=None):
1480
 
        """Finish the execution of process.
1481
 
 
1482
 
        :param process: the Popen object returned from start_bzr_subprocess.
1483
 
        :param retcode: The status code that is expected.  Defaults to 0.  If
1484
 
            None is supplied, the status code is not checked.
1485
 
        :param send_signal: an optional signal to send to the process.
1486
 
        :param universal_newlines: Convert CRLF => LF
1487
 
        :returns: (stdout, stderr)
1488
 
        """
1489
 
        if send_signal is not None:
1490
 
            os.kill(process.pid, send_signal)
1491
 
        out, err = process.communicate()
1492
 
 
1493
 
        if universal_newlines:
1494
 
            out = out.replace('\r\n', '\n')
1495
 
            err = err.replace('\r\n', '\n')
1496
 
 
1497
 
        if retcode is not None and retcode != process.returncode:
1498
 
            if process_args is None:
1499
 
                process_args = "(unknown args)"
1500
 
            mutter('Output of bzr %s:\n%s', process_args, out)
1501
 
            mutter('Error for bzr %s:\n%s', process_args, err)
1502
 
            self.fail('Command bzr %s failed with retcode %s != %s'
1503
 
                      % (process_args, retcode, process.returncode))
1504
 
        return [out, err]
 
404
        return self.run_bzr_captured(args, retcode)
1505
405
 
1506
406
    def check_inventory_shape(self, inv, shape):
1507
407
        """Compare an inventory to a list of expected names.
1533
433
        if stdin is None:
1534
434
            stdin = StringIO("")
1535
435
        if stdout is None:
1536
 
            if getattr(self, "_log_file", None) is not None:
 
436
            if hasattr(self, "_log_file"):
1537
437
                stdout = self._log_file
1538
438
            else:
1539
439
                stdout = StringIO()
1540
440
        if stderr is None:
1541
 
            if getattr(self, "_log_file", None is not None):
 
441
            if hasattr(self, "_log_file"):
1542
442
                stderr = self._log_file
1543
443
            else:
1544
444
                stderr = StringIO()
1555
455
            sys.stderr = real_stderr
1556
456
            sys.stdin = real_stdin
1557
457
 
1558
 
    @symbol_versioning.deprecated_method(symbol_versioning.zero_eleven)
1559
 
    def merge(self, branch_from, wt_to):
1560
 
        """A helper for tests to do a ui-less merge.
1561
 
 
1562
 
        This should move to the main library when someone has time to integrate
1563
 
        it in.
1564
 
        """
1565
 
        # minimal ui-less merge.
1566
 
        wt_to.branch.fetch(branch_from)
1567
 
        base_rev = common_ancestor(branch_from.last_revision(),
1568
 
                                   wt_to.branch.last_revision(),
1569
 
                                   wt_to.branch.repository)
1570
 
        merge_inner(wt_to.branch, branch_from.basis_tree(),
1571
 
                    wt_to.branch.repository.revision_tree(base_rev),
1572
 
                    this_tree=wt_to)
1573
 
        wt_to.add_parent_tree_id(branch_from.last_revision())
1574
 
 
1575
 
    def reduceLockdirTimeout(self):
1576
 
        """Reduce the default lock timeout for the duration of the test, so that
1577
 
        if LockContention occurs during a test, it does so quickly.
1578
 
 
1579
 
        Tests that expect to provoke LockContention errors should call this.
1580
 
        """
1581
 
        orig_timeout = bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS
1582
 
        def resetTimeout():
1583
 
            bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = orig_timeout
1584
 
        self.addCleanup(resetTimeout)
1585
 
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 0
1586
458
 
1587
459
BzrTestBase = TestCase
1588
460
 
1589
 
 
1590
 
class TestCaseWithMemoryTransport(TestCase):
1591
 
    """Common test class for tests that do not need disk resources.
1592
 
 
1593
 
    Tests that need disk resources should derive from TestCaseWithTransport.
1594
 
 
1595
 
    TestCaseWithMemoryTransport sets the TEST_ROOT variable for all bzr tests.
1596
 
 
1597
 
    For TestCaseWithMemoryTransport the test_home_dir is set to the name of
1598
 
    a directory which does not exist. This serves to help ensure test isolation
1599
 
    is preserved. test_dir is set to the TEST_ROOT, as is cwd, because they
1600
 
    must exist. However, TestCaseWithMemoryTransport does not offer local
1601
 
    file defaults for the transport in tests, nor does it obey the command line
1602
 
    override, so tests that accidentally write to the common directory should
1603
 
    be rare.
 
461
     
 
462
class TestCaseInTempDir(TestCase):
 
463
    """Derived class that runs a test within a temporary directory.
 
464
 
 
465
    This is useful for tests that need to create a branch, etc.
 
466
 
 
467
    The directory is created in a slightly complex way: for each
 
468
    Python invocation, a new temporary top-level directory is created.
 
469
    All test cases create their own directory within that.  If the
 
470
    tests complete successfully, the directory is removed.
 
471
 
 
472
    InTempDir is an old alias for FunctionalTestCase.
1604
473
    """
1605
474
 
1606
475
    TEST_ROOT = None
1607
476
    _TEST_NAME = 'test'
1608
 
 
1609
 
 
1610
 
    def __init__(self, methodName='runTest'):
1611
 
        # allow test parameterisation after test construction and before test
1612
 
        # execution. Variables that the parameteriser sets need to be 
1613
 
        # ones that are not set by setUp, or setUp will trash them.
1614
 
        super(TestCaseWithMemoryTransport, self).__init__(methodName)
1615
 
        self.vfs_transport_factory = default_transport
1616
 
        self.transport_server = None
1617
 
        self.transport_readonly_server = None
1618
 
        self.__vfs_server = None
1619
 
 
1620
 
    def get_transport(self):
1621
 
        """Return a writeable transport for the test scratch space"""
1622
 
        t = get_transport(self.get_url())
1623
 
        self.assertFalse(t.is_readonly())
1624
 
        return t
1625
 
 
1626
 
    def get_readonly_transport(self):
1627
 
        """Return a readonly transport for the test scratch space
1628
 
        
1629
 
        This can be used to test that operations which should only need
1630
 
        readonly access in fact do not try to write.
1631
 
        """
1632
 
        t = get_transport(self.get_readonly_url())
1633
 
        self.assertTrue(t.is_readonly())
1634
 
        return t
1635
 
 
1636
 
    def create_transport_readonly_server(self):
1637
 
        """Create a transport server from class defined at init.
1638
 
 
1639
 
        This is mostly a hook for daughter classes.
1640
 
        """
1641
 
        return self.transport_readonly_server()
1642
 
 
1643
 
    def get_readonly_server(self):
1644
 
        """Get the server instance for the readonly transport
1645
 
 
1646
 
        This is useful for some tests with specific servers to do diagnostics.
1647
 
        """
1648
 
        if self.__readonly_server is None:
1649
 
            if self.transport_readonly_server is None:
1650
 
                # readonly decorator requested
1651
 
                # bring up the server
1652
 
                self.__readonly_server = ReadonlyServer()
1653
 
                self.__readonly_server.setUp(self.get_vfs_only_server())
1654
 
            else:
1655
 
                self.__readonly_server = self.create_transport_readonly_server()
1656
 
                self.__readonly_server.setUp(self.get_vfs_only_server())
1657
 
            self.addCleanup(self.__readonly_server.tearDown)
1658
 
        return self.__readonly_server
1659
 
 
1660
 
    def get_readonly_url(self, relpath=None):
1661
 
        """Get a URL for the readonly transport.
1662
 
 
1663
 
        This will either be backed by '.' or a decorator to the transport 
1664
 
        used by self.get_url()
1665
 
        relpath provides for clients to get a path relative to the base url.
1666
 
        These should only be downwards relative, not upwards.
1667
 
        """
1668
 
        base = self.get_readonly_server().get_url()
1669
 
        if relpath is not None:
1670
 
            if not base.endswith('/'):
1671
 
                base = base + '/'
1672
 
            base = base + relpath
1673
 
        return base
1674
 
 
1675
 
    def get_vfs_only_server(self):
1676
 
        """Get the vfs only read/write server instance.
1677
 
 
1678
 
        This is useful for some tests with specific servers that need
1679
 
        diagnostics.
1680
 
 
1681
 
        For TestCaseWithMemoryTransport this is always a MemoryServer, and there
1682
 
        is no means to override it.
1683
 
        """
1684
 
        if self.__vfs_server is None:
1685
 
            self.__vfs_server = MemoryServer()
1686
 
            self.__vfs_server.setUp()
1687
 
            self.addCleanup(self.__vfs_server.tearDown)
1688
 
        return self.__vfs_server
1689
 
 
1690
 
    def get_server(self):
1691
 
        """Get the read/write server instance.
1692
 
 
1693
 
        This is useful for some tests with specific servers that need
1694
 
        diagnostics.
1695
 
 
1696
 
        This is built from the self.transport_server factory. If that is None,
1697
 
        then the self.get_vfs_server is returned.
1698
 
        """
1699
 
        if self.__server is None:
1700
 
            if self.transport_server is None or self.transport_server is self.vfs_transport_factory:
1701
 
                return self.get_vfs_only_server()
1702
 
            else:
1703
 
                # bring up a decorated means of access to the vfs only server.
1704
 
                self.__server = self.transport_server()
1705
 
                try:
1706
 
                    self.__server.setUp(self.get_vfs_only_server())
1707
 
                except TypeError, e:
1708
 
                    # This should never happen; the try:Except here is to assist
1709
 
                    # developers having to update code rather than seeing an
1710
 
                    # uninformative TypeError.
1711
 
                    raise Exception, "Old server API in use: %s, %s" % (self.__server, e)
1712
 
            self.addCleanup(self.__server.tearDown)
1713
 
        return self.__server
1714
 
 
1715
 
    def _adjust_url(self, base, relpath):
1716
 
        """Get a URL (or maybe a path) for the readwrite transport.
1717
 
 
1718
 
        This will either be backed by '.' or to an equivalent non-file based
1719
 
        facility.
1720
 
        relpath provides for clients to get a path relative to the base url.
1721
 
        These should only be downwards relative, not upwards.
1722
 
        """
1723
 
        if relpath is not None and relpath != '.':
1724
 
            if not base.endswith('/'):
1725
 
                base = base + '/'
1726
 
            # XXX: Really base should be a url; we did after all call
1727
 
            # get_url()!  But sometimes it's just a path (from
1728
 
            # LocalAbspathServer), and it'd be wrong to append urlescaped data
1729
 
            # to a non-escaped local path.
1730
 
            if base.startswith('./') or base.startswith('/'):
1731
 
                base += relpath
1732
 
            else:
1733
 
                base += urlutils.escape(relpath)
1734
 
        return base
1735
 
 
1736
 
    def get_url(self, relpath=None):
1737
 
        """Get a URL (or maybe a path) for the readwrite transport.
1738
 
 
1739
 
        This will either be backed by '.' or to an equivalent non-file based
1740
 
        facility.
1741
 
        relpath provides for clients to get a path relative to the base url.
1742
 
        These should only be downwards relative, not upwards.
1743
 
        """
1744
 
        base = self.get_server().get_url()
1745
 
        return self._adjust_url(base, relpath)
1746
 
 
1747
 
    def get_vfs_only_url(self, relpath=None):
1748
 
        """Get a URL (or maybe a path for the plain old vfs transport.
1749
 
 
1750
 
        This will never be a smart protocol.  It always has all the
1751
 
        capabilities of the local filesystem, but it might actually be a
1752
 
        MemoryTransport or some other similar virtual filesystem.
1753
 
 
1754
 
        This is the backing transport (if any) of the server returned by 
1755
 
        get_url and get_readonly_url.
1756
 
 
1757
 
        :param relpath: provides for clients to get a path relative to the base
1758
 
            url.  These should only be downwards relative, not upwards.
1759
 
        """
1760
 
        base = self.get_vfs_only_server().get_url()
1761
 
        return self._adjust_url(base, relpath)
 
477
    OVERRIDE_PYTHON = 'python'
 
478
 
 
479
    def check_file_contents(self, filename, expect):
 
480
        self.log("check contents of file %s" % filename)
 
481
        contents = file(filename, 'r').read()
 
482
        if contents != expect:
 
483
            self.log("expected: %r" % expect)
 
484
            self.log("actually: %r" % contents)
 
485
            self.fail("contents of %s not as expected" % filename)
1762
486
 
1763
487
    def _make_test_root(self):
1764
 
        if TestCaseWithMemoryTransport.TEST_ROOT is not None:
 
488
        if TestCaseInTempDir.TEST_ROOT is not None:
1765
489
            return
1766
490
        i = 0
1767
491
        while True:
1775
499
                else:
1776
500
                    raise
1777
501
            # successfully created
1778
 
            TestCaseWithMemoryTransport.TEST_ROOT = osutils.abspath(root)
 
502
            TestCaseInTempDir.TEST_ROOT = os.path.abspath(root)
1779
503
            break
1780
504
        # make a fake bzr directory there to prevent any tests propagating
1781
505
        # up onto the source directory's real branch
1782
 
        bzrdir.BzrDir.create_standalone_workingtree(
1783
 
            TestCaseWithMemoryTransport.TEST_ROOT)
1784
 
 
1785
 
    def makeAndChdirToTestDir(self):
1786
 
        """Create a temporary directories for this one test.
1787
 
        
1788
 
        This must set self.test_home_dir and self.test_dir and chdir to
1789
 
        self.test_dir.
1790
 
        
1791
 
        For TestCaseWithMemoryTransport we chdir to the TEST_ROOT for this test.
1792
 
        """
1793
 
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
1794
 
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
1795
 
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
1796
 
        
1797
 
    def make_branch(self, relpath, format=None):
1798
 
        """Create a branch on the transport at relpath."""
1799
 
        repo = self.make_repository(relpath, format=format)
1800
 
        return repo.bzrdir.create_branch()
1801
 
 
1802
 
    def make_bzrdir(self, relpath, format=None):
1803
 
        try:
1804
 
            # might be a relative or absolute path
1805
 
            maybe_a_url = self.get_url(relpath)
1806
 
            segments = maybe_a_url.rsplit('/', 1)
1807
 
            t = get_transport(maybe_a_url)
1808
 
            if len(segments) > 1 and segments[-1] not in ('', '.'):
1809
 
                t.ensure_base()
1810
 
            if format is None:
1811
 
                format = 'default'
1812
 
            if isinstance(format, basestring):
1813
 
                format = bzrdir.format_registry.make_bzrdir(format)
1814
 
            return format.initialize_on_transport(t)
1815
 
        except errors.UninitializableFormat:
1816
 
            raise TestSkipped("Format %s is not initializable." % format)
1817
 
 
1818
 
    def make_repository(self, relpath, shared=False, format=None):
1819
 
        """Create a repository on our default transport at relpath.
1820
 
        
1821
 
        Note that relpath must be a relative path, not a full url.
1822
 
        """
1823
 
        # FIXME: If you create a remoterepository this returns the underlying
1824
 
        # real format, which is incorrect.  Actually we should make sure that 
1825
 
        # RemoteBzrDir returns a RemoteRepository.
1826
 
        # maybe  mbp 20070410
1827
 
        made_control = self.make_bzrdir(relpath, format=format)
1828
 
        return made_control.create_repository(shared=shared)
1829
 
 
1830
 
    def make_branch_and_memory_tree(self, relpath, format=None):
1831
 
        """Create a branch on the default transport and a MemoryTree for it."""
1832
 
        b = self.make_branch(relpath, format=format)
1833
 
        return memorytree.MemoryTree.create_on_branch(b)
1834
 
 
1835
 
    def overrideEnvironmentForTesting(self):
1836
 
        os.environ['HOME'] = self.test_home_dir
1837
 
        os.environ['BZR_HOME'] = self.test_home_dir
1838
 
        
 
506
        os.mkdir(os.path.join(TestCaseInTempDir.TEST_ROOT, '.bzr'))
 
507
 
1839
508
    def setUp(self):
1840
 
        super(TestCaseWithMemoryTransport, self).setUp()
 
509
        super(TestCaseInTempDir, self).setUp()
1841
510
        self._make_test_root()
1842
511
        _currentdir = os.getcwdu()
 
512
        short_id = self.id().replace('bzrlib.tests.', '') \
 
513
                   .replace('__main__.', '')
 
514
        self.test_dir = os.path.join(self.TEST_ROOT, short_id)
 
515
        os.mkdir(self.test_dir)
 
516
        os.chdir(self.test_dir)
 
517
        os.environ['HOME'] = self.test_dir
1843
518
        def _leaveDirectory():
1844
519
            os.chdir(_currentdir)
1845
520
        self.addCleanup(_leaveDirectory)
1846
 
        self.makeAndChdirToTestDir()
1847
 
        self.overrideEnvironmentForTesting()
1848
 
        self.__readonly_server = None
1849
 
        self.__server = None
1850
 
        self.reduceLockdirTimeout()
1851
 
 
1852
 
     
1853
 
class TestCaseInTempDir(TestCaseWithMemoryTransport):
1854
 
    """Derived class that runs a test within a temporary directory.
1855
 
 
1856
 
    This is useful for tests that need to create a branch, etc.
1857
 
 
1858
 
    The directory is created in a slightly complex way: for each
1859
 
    Python invocation, a new temporary top-level directory is created.
1860
 
    All test cases create their own directory within that.  If the
1861
 
    tests complete successfully, the directory is removed.
1862
 
 
1863
 
    InTempDir is an old alias for FunctionalTestCase.
1864
 
    """
1865
 
 
1866
 
    OVERRIDE_PYTHON = 'python'
1867
 
    use_numbered_dirs = False
1868
 
 
1869
 
    def check_file_contents(self, filename, expect):
1870
 
        self.log("check contents of file %s" % filename)
1871
 
        contents = file(filename, 'r').read()
1872
 
        if contents != expect:
1873
 
            self.log("expected: %r" % expect)
1874
 
            self.log("actually: %r" % contents)
1875
 
            self.fail("contents of %s not as expected" % filename)
1876
 
 
1877
 
    def makeAndChdirToTestDir(self):
1878
 
        """See TestCaseWithMemoryTransport.makeAndChdirToTestDir().
1879
521
        
1880
 
        For TestCaseInTempDir we create a temporary directory based on the test
1881
 
        name and then create two subdirs - test and home under it.
1882
 
        """
1883
 
        if self.use_numbered_dirs:  # strongly recommended on Windows
1884
 
                                    # due the path length limitation (260 ch.)
1885
 
            candidate_dir = '%s/%dK/%05d' % (self.TEST_ROOT,
1886
 
                                             int(self.number/1000),
1887
 
                                             self.number)
1888
 
            os.makedirs(candidate_dir)
1889
 
            self.test_home_dir = candidate_dir + '/home'
1890
 
            os.mkdir(self.test_home_dir)
1891
 
            self.test_dir = candidate_dir + '/work'
1892
 
            os.mkdir(self.test_dir)
1893
 
            os.chdir(self.test_dir)
1894
 
            # put name of test inside
1895
 
            f = file(candidate_dir + '/name', 'w')
1896
 
            f.write(self.id())
1897
 
            f.close()
1898
 
            return
1899
 
        # Else NAMED DIRS
1900
 
        # shorten the name, to avoid test failures due to path length
1901
 
        short_id = self.id().replace('bzrlib.tests.', '') \
1902
 
                   .replace('__main__.', '')[-100:]
1903
 
        # it's possible the same test class is run several times for
1904
 
        # parameterized tests, so make sure the names don't collide.  
1905
 
        i = 0
1906
 
        while True:
1907
 
            if i > 0:
1908
 
                candidate_dir = '%s/%s.%d' % (self.TEST_ROOT, short_id, i)
1909
 
            else:
1910
 
                candidate_dir = '%s/%s' % (self.TEST_ROOT, short_id)
1911
 
            if os.path.exists(candidate_dir):
1912
 
                i = i + 1
1913
 
                continue
1914
 
            else:
1915
 
                os.mkdir(candidate_dir)
1916
 
                self.test_home_dir = candidate_dir + '/home'
1917
 
                os.mkdir(self.test_home_dir)
1918
 
                self.test_dir = candidate_dir + '/work'
1919
 
                os.mkdir(self.test_dir)
1920
 
                os.chdir(self.test_dir)
1921
 
                break
1922
 
 
1923
 
    def build_tree(self, shape, line_endings='binary', transport=None):
 
522
    def build_tree(self, shape, line_endings='native'):
1924
523
        """Build a test tree according to a pattern.
1925
524
 
1926
525
        shape is a sequence of file specifications.  If the final
1927
526
        character is '/', a directory is created.
1928
527
 
1929
 
        This assumes that all the elements in the tree being built are new.
1930
 
 
1931
528
        This doesn't add anything to a branch.
1932
529
        :param line_endings: Either 'binary' or 'native'
1933
530
                             in binary mode, exact contents are written
1934
531
                             in native mode, the line endings match the
1935
532
                             default platform endings.
1936
 
 
1937
 
        :param transport: A transport to write to, for building trees on 
1938
 
                          VFS's. If the transport is readonly or None,
1939
 
                          "." is opened automatically.
1940
533
        """
1941
 
        # It's OK to just create them using forward slashes on windows.
1942
 
        if transport is None or transport.is_readonly():
1943
 
            transport = get_transport(".")
 
534
        # XXX: It's OK to just create them using forward slashes on windows?
1944
535
        for name in shape:
1945
536
            self.assert_(isinstance(name, basestring))
1946
537
            if name[-1] == '/':
1947
 
                transport.mkdir(urlutils.escape(name[:-1]))
 
538
                os.mkdir(name[:-1])
1948
539
            else:
1949
540
                if line_endings == 'binary':
1950
 
                    end = '\n'
 
541
                    f = file(name, 'wb')
1951
542
                elif line_endings == 'native':
1952
 
                    end = os.linesep
 
543
                    f = file(name, 'wt')
1953
544
                else:
1954
 
                    raise errors.BzrError(
1955
 
                        'Invalid line ending request %r' % line_endings)
1956
 
                content = "contents of %s%s" % (name.encode('utf-8'), end)
1957
 
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
 
545
                    raise BzrError('Invalid line ending request %r' % (line_endings,))
 
546
                print >>f, "contents of", name
 
547
                f.close()
1958
548
 
1959
549
    def build_tree_contents(self, shape):
1960
550
        build_tree_contents(shape)
1961
551
 
 
552
    def failUnlessExists(self, path):
 
553
        """Fail unless path, which may be abs or relative, exists."""
 
554
        self.failUnless(osutils.lexists(path))
 
555
        
1962
556
    def assertFileEqual(self, content, path):
1963
557
        """Fail if path does not contain 'content'."""
1964
 
        self.failUnlessExists(path)
1965
 
        f = file(path, 'rb')
1966
 
        try:
1967
 
            s = f.read()
1968
 
        finally:
1969
 
            f.close()
1970
 
        self.assertEqualDiff(content, s)
1971
 
 
1972
 
    def failUnlessExists(self, path):
1973
 
        """Fail unless path or paths, which may be abs or relative, exist."""
1974
 
        if not isinstance(path, basestring):
1975
 
            for p in path:
1976
 
                self.failUnlessExists(p)
1977
 
        else:
1978
 
            self.failUnless(osutils.lexists(path),path+" does not exist")
1979
 
 
1980
 
    def failIfExists(self, path):
1981
 
        """Fail if path or paths, which may be abs or relative, exist."""
1982
 
        if not isinstance(path, basestring):
1983
 
            for p in path:
1984
 
                self.failIfExists(p)
1985
 
        else:
1986
 
            self.failIf(osutils.lexists(path),path+" exists")
1987
 
 
1988
 
    def assertInWorkingTree(self,path,root_path='.',tree=None):
1989
 
        """Assert whether path or paths are in the WorkingTree"""
1990
 
        if tree is None:
1991
 
            tree = workingtree.WorkingTree.open(root_path)
1992
 
        if not isinstance(path, basestring):
1993
 
            for p in path:
1994
 
                self.assertInWorkingTree(p,tree=tree)
1995
 
        else:
1996
 
            self.assertIsNot(tree.path2id(path), None,
1997
 
                path+' not in working tree.')
1998
 
 
1999
 
    def assertNotInWorkingTree(self,path,root_path='.',tree=None):
2000
 
        """Assert whether path or paths are not in the WorkingTree"""
2001
 
        if tree is None:
2002
 
            tree = workingtree.WorkingTree.open(root_path)
2003
 
        if not isinstance(path, basestring):
2004
 
            for p in path:
2005
 
                self.assertNotInWorkingTree(p,tree=tree)
2006
 
        else:
2007
 
            self.assertIs(tree.path2id(path), None, path+' in working tree.')
2008
 
 
2009
 
 
2010
 
class TestCaseWithTransport(TestCaseInTempDir):
2011
 
    """A test case that provides get_url and get_readonly_url facilities.
2012
 
 
2013
 
    These back onto two transport servers, one for readonly access and one for
2014
 
    read write access.
2015
 
 
2016
 
    If no explicit class is provided for readonly access, a
2017
 
    ReadonlyTransportDecorator is used instead which allows the use of non disk
2018
 
    based read write transports.
2019
 
 
2020
 
    If an explicit class is provided for readonly access, that server and the 
2021
 
    readwrite one must both define get_url() as resolving to os.getcwd().
2022
 
    """
2023
 
 
2024
 
    def get_vfs_only_server(self):
2025
 
        """See TestCaseWithMemoryTransport.
2026
 
 
2027
 
        This is useful for some tests with specific servers that need
2028
 
        diagnostics.
2029
 
        """
2030
 
        if self.__vfs_server is None:
2031
 
            self.__vfs_server = self.vfs_transport_factory()
2032
 
            self.__vfs_server.setUp()
2033
 
            self.addCleanup(self.__vfs_server.tearDown)
2034
 
        return self.__vfs_server
2035
 
 
2036
 
    def make_branch_and_tree(self, relpath, format=None):
2037
 
        """Create a branch on the transport and a tree locally.
2038
 
 
2039
 
        If the transport is not a LocalTransport, the Tree can't be created on
2040
 
        the transport.  In that case if the vfs_transport_factory is
2041
 
        LocalURLServer the working tree is created in the local
2042
 
        directory backing the transport, and the returned tree's branch and
2043
 
        repository will also be accessed locally. Otherwise a lightweight
2044
 
        checkout is created and returned.
2045
 
 
2046
 
        :param format: The BzrDirFormat.
2047
 
        :returns: the WorkingTree.
2048
 
        """
2049
 
        # TODO: always use the local disk path for the working tree,
2050
 
        # this obviously requires a format that supports branch references
2051
 
        # so check for that by checking bzrdir.BzrDirFormat.get_default_format()
2052
 
        # RBC 20060208
2053
 
        b = self.make_branch(relpath, format=format)
2054
 
        try:
2055
 
            return b.bzrdir.create_workingtree()
2056
 
        except errors.NotLocalUrl:
2057
 
            # We can only make working trees locally at the moment.  If the
2058
 
            # transport can't support them, then we keep the non-disk-backed
2059
 
            # branch and create a local checkout.
2060
 
            if self.vfs_transport_factory is LocalURLServer:
2061
 
                # the branch is colocated on disk, we cannot create a checkout.
2062
 
                # hopefully callers will expect this.
2063
 
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
2064
 
                return local_controldir.create_workingtree()
2065
 
            else:
2066
 
                return b.create_checkout(relpath, lightweight=True)
2067
 
 
2068
 
    def assertIsDirectory(self, relpath, transport):
2069
 
        """Assert that relpath within transport is a directory.
2070
 
 
2071
 
        This may not be possible on all transports; in that case it propagates
2072
 
        a TransportNotPossible.
2073
 
        """
2074
 
        try:
2075
 
            mode = transport.stat(relpath).st_mode
2076
 
        except errors.NoSuchFile:
2077
 
            self.fail("path %s is not a directory; no such file"
2078
 
                      % (relpath))
2079
 
        if not stat.S_ISDIR(mode):
2080
 
            self.fail("path %s is not a directory; has mode %#o"
2081
 
                      % (relpath, mode))
2082
 
 
2083
 
    def assertTreesEqual(self, left, right):
2084
 
        """Check that left and right have the same content and properties."""
2085
 
        # we use a tree delta to check for equality of the content, and we
2086
 
        # manually check for equality of other things such as the parents list.
2087
 
        self.assertEqual(left.get_parent_ids(), right.get_parent_ids())
2088
 
        differences = left.changes_from(right)
2089
 
        self.assertFalse(differences.has_changed(),
2090
 
            "Trees %r and %r are different: %r" % (left, right, differences))
2091
 
 
2092
 
    def setUp(self):
2093
 
        super(TestCaseWithTransport, self).setUp()
2094
 
        self.__vfs_server = None
2095
 
 
2096
 
 
2097
 
class ChrootedTestCase(TestCaseWithTransport):
2098
 
    """A support class that provides readonly urls outside the local namespace.
2099
 
 
2100
 
    This is done by checking if self.transport_server is a MemoryServer. if it
2101
 
    is then we are chrooted already, if it is not then an HttpServer is used
2102
 
    for readonly urls.
2103
 
 
2104
 
    TODO RBC 20060127: make this an option to TestCaseWithTransport so it can
2105
 
                       be used without needed to redo it when a different 
2106
 
                       subclass is in use ?
2107
 
    """
2108
 
 
2109
 
    def setUp(self):
2110
 
        super(ChrootedTestCase, self).setUp()
2111
 
        if not self.vfs_transport_factory == MemoryServer:
2112
 
            self.transport_readonly_server = HttpServer
2113
 
 
2114
 
 
2115
 
def filter_suite_by_re(suite, pattern, exclude_pattern=None,
2116
 
                       random_order=False):
2117
 
    """Create a test suite by filtering another one.
2118
 
    
2119
 
    :param suite:           the source suite
2120
 
    :param pattern:         pattern that names must match
2121
 
    :param exclude_pattern: pattern that names must not match, if any
2122
 
    :param random_order:    if True, tests in the new suite will be put in
2123
 
                            random order
2124
 
    :returns: the newly created suite
2125
 
    """ 
2126
 
    return sort_suite_by_re(suite, pattern, exclude_pattern,
2127
 
        random_order, False)
2128
 
 
2129
 
 
2130
 
def sort_suite_by_re(suite, pattern, exclude_pattern=None,
2131
 
                     random_order=False, append_rest=True):
2132
 
    """Create a test suite by sorting another one.
2133
 
    
2134
 
    :param suite:           the source suite
2135
 
    :param pattern:         pattern that names must match in order to go
2136
 
                            first in the new suite
2137
 
    :param exclude_pattern: pattern that names must not match, if any
2138
 
    :param random_order:    if True, tests in the new suite will be put in
2139
 
                            random order
2140
 
    :param append_rest:     if False, pattern is a strict filter and not
2141
 
                            just an ordering directive
2142
 
    :returns: the newly created suite
2143
 
    """ 
2144
 
    first = []
2145
 
    second = []
 
558
        self.failUnless(osutils.lexists(path))
 
559
        self.assertEqualDiff(content, open(path, 'r').read())
 
560
        
 
561
 
 
562
class MetaTestLog(TestCase):
 
563
    def test_logging(self):
 
564
        """Test logs are captured when a test fails."""
 
565
        self.log('a test message')
 
566
        self._log_file.flush()
 
567
        self.assertContainsRe(self._get_log(), 'a test message\n')
 
568
 
 
569
 
 
570
def filter_suite_by_re(suite, pattern):
 
571
    result = TestUtil.TestSuite()
2146
572
    filter_re = re.compile(pattern)
2147
 
    if exclude_pattern is not None:
2148
 
        exclude_re = re.compile(exclude_pattern)
2149
573
    for test in iter_suite_tests(suite):
2150
 
        test_id = test.id()
2151
 
        if exclude_pattern is None or not exclude_re.search(test_id):
2152
 
            if filter_re.search(test_id):
2153
 
                first.append(test)
2154
 
            elif append_rest:
2155
 
                second.append(test)
2156
 
    if random_order:
2157
 
        random.shuffle(first)
2158
 
        random.shuffle(second)
2159
 
    return TestUtil.TestSuite(first + second)
 
574
        if filter_re.search(test.id()):
 
575
            result.addTest(test)
 
576
    return result
2160
577
 
2161
578
 
2162
579
def run_suite(suite, name='test', verbose=False, pattern=".*",
2163
 
              stop_on_failure=False, keep_output=False,
2164
 
              transport=None, lsprof_timed=None, bench_history=None,
2165
 
              matching_tests_first=None,
2166
 
              numbered_dirs=None,
2167
 
              list_only=False,
2168
 
              random_seed=None,
2169
 
              exclude_pattern=None,
2170
 
              ):
2171
 
    use_numbered_dirs = bool(numbered_dirs)
2172
 
 
2173
 
    TestCase._gather_lsprof_in_benchmarks = lsprof_timed
2174
 
    if numbered_dirs is not None:
2175
 
        TestCaseInTempDir.use_numbered_dirs = use_numbered_dirs
 
580
              stop_on_failure=False, keep_output=False):
 
581
    TestCaseInTempDir._TEST_NAME = name
2176
582
    if verbose:
2177
583
        verbosity = 2
2178
584
    else:
2179
585
        verbosity = 1
2180
586
    runner = TextTestRunner(stream=sys.stdout,
2181
587
                            descriptions=0,
2182
 
                            verbosity=verbosity,
2183
 
                            keep_output=keep_output,
2184
 
                            bench_history=bench_history,
2185
 
                            use_numbered_dirs=use_numbered_dirs,
2186
 
                            list_only=list_only,
2187
 
                            )
 
588
                            verbosity=verbosity)
2188
589
    runner.stop_on_failure=stop_on_failure
2189
 
    # Initialise the random number generator and display the seed used.
2190
 
    # We convert the seed to a long to make it reuseable across invocations.
2191
 
    random_order = False
2192
 
    if random_seed is not None:
2193
 
        random_order = True
2194
 
        if random_seed == "now":
2195
 
            random_seed = long(time.time())
2196
 
        else:
2197
 
            # Convert the seed to a long if we can
2198
 
            try:
2199
 
                random_seed = long(random_seed)
2200
 
            except:
2201
 
                pass
2202
 
        runner.stream.writeln("Randomizing test order using seed %s\n" %
2203
 
            (random_seed))
2204
 
        random.seed(random_seed)
2205
 
    # Customise the list of tests if requested
2206
 
    if pattern != '.*' or exclude_pattern is not None or random_order:
2207
 
        if matching_tests_first:
2208
 
            suite = sort_suite_by_re(suite, pattern, exclude_pattern,
2209
 
                random_order)
2210
 
        else:
2211
 
            suite = filter_suite_by_re(suite, pattern, exclude_pattern,
2212
 
                random_order)
 
590
    if pattern != '.*':
 
591
        suite = filter_suite_by_re(suite, pattern)
2213
592
    result = runner.run(suite)
 
593
    # This is still a little bogus, 
 
594
    # but only a little. Folk not using our testrunner will
 
595
    # have to delete their temp directories themselves.
 
596
    if result.wasSuccessful() or not keep_output:
 
597
        if TestCaseInTempDir.TEST_ROOT is not None:
 
598
            shutil.rmtree(TestCaseInTempDir.TEST_ROOT) 
 
599
    else:
 
600
        print "Failed tests working directories are in '%s'\n" % TestCaseInTempDir.TEST_ROOT
2214
601
    return result.wasSuccessful()
2215
602
 
2216
603
 
2217
604
def selftest(verbose=False, pattern=".*", stop_on_failure=True,
2218
 
             keep_output=False,
2219
 
             transport=None,
2220
 
             test_suite_factory=None,
2221
 
             lsprof_timed=None,
2222
 
             bench_history=None,
2223
 
             matching_tests_first=None,
2224
 
             numbered_dirs=None,
2225
 
             list_only=False,
2226
 
             random_seed=None,
2227
 
             exclude_pattern=None):
 
605
             keep_output=False):
2228
606
    """Run the whole test suite under the enhanced runner"""
2229
 
    # XXX: Very ugly way to do this...
2230
 
    # Disable warning about old formats because we don't want it to disturb
2231
 
    # any blackbox tests.
2232
 
    from bzrlib import repository
2233
 
    repository._deprecation_warning_done = True
2234
 
 
2235
 
    global default_transport
2236
 
    if transport is None:
2237
 
        transport = default_transport
2238
 
    old_transport = default_transport
2239
 
    default_transport = transport
2240
 
    try:
2241
 
        if test_suite_factory is None:
2242
 
            suite = test_suite()
2243
 
        else:
2244
 
            suite = test_suite_factory()
2245
 
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
2246
 
                     stop_on_failure=stop_on_failure, keep_output=keep_output,
2247
 
                     transport=transport,
2248
 
                     lsprof_timed=lsprof_timed,
2249
 
                     bench_history=bench_history,
2250
 
                     matching_tests_first=matching_tests_first,
2251
 
                     numbered_dirs=numbered_dirs,
2252
 
                     list_only=list_only,
2253
 
                     random_seed=random_seed,
2254
 
                     exclude_pattern=exclude_pattern)
2255
 
    finally:
2256
 
        default_transport = old_transport
 
607
    return run_suite(test_suite(), 'testbzr', verbose=verbose, pattern=pattern,
 
608
                     stop_on_failure=stop_on_failure, keep_output=keep_output)
2257
609
 
2258
610
 
2259
611
def test_suite():
2260
 
    """Build and return TestSuite for the whole of bzrlib.
2261
 
    
2262
 
    This function can be replaced if you need to change the default test
2263
 
    suite on a global basis, but it is not encouraged.
2264
 
    """
2265
 
    testmod_names = [
 
612
    """Build and return TestSuite for the whole program."""
 
613
    from doctest import DocTestSuite
 
614
 
 
615
    global MODULES_TO_DOCTEST
 
616
 
 
617
    # FIXME: If these fail to load, e.g. because of a syntax error, the
 
618
    # exception is hidden by unittest.  Sucks.  Should either fix that or
 
619
    # perhaps import them and pass them to unittest as modules.
 
620
    testmod_names = \
 
621
                  ['bzrlib.tests.MetaTestLog',
 
622
                   'bzrlib.tests.test_api',
 
623
                   'bzrlib.tests.test_gpg',
 
624
                   'bzrlib.tests.test_identitymap',
 
625
                   'bzrlib.tests.test_inv',
2266
626
                   'bzrlib.tests.test_ancestry',
2267
 
                   'bzrlib.tests.test_annotate',
2268
 
                   'bzrlib.tests.test_api',
2269
 
                   'bzrlib.tests.test_atomicfile',
2270
 
                   'bzrlib.tests.test_bad_files',
2271
 
                   'bzrlib.tests.test_branch',
2272
 
                   'bzrlib.tests.test_branchbuilder',
2273
 
                   'bzrlib.tests.test_bugtracker',
2274
 
                   'bzrlib.tests.test_bundle',
2275
 
                   'bzrlib.tests.test_bzrdir',
2276
 
                   'bzrlib.tests.test_cache_utf8',
2277
 
                   'bzrlib.tests.test_commands',
2278
627
                   'bzrlib.tests.test_commit',
 
628
                   'bzrlib.tests.test_command',
2279
629
                   'bzrlib.tests.test_commit_merge',
2280
630
                   'bzrlib.tests.test_config',
2281
 
                   'bzrlib.tests.test_conflicts',
2282
 
                   'bzrlib.tests.test_counted_lock',
2283
 
                   'bzrlib.tests.test_decorators',
2284
 
                   'bzrlib.tests.test_delta',
2285
 
                   'bzrlib.tests.test_diff',
2286
 
                   'bzrlib.tests.test_dirstate',
2287
 
                   'bzrlib.tests.test_errors',
2288
 
                   'bzrlib.tests.test_escaped_store',
2289
 
                   'bzrlib.tests.test_extract',
2290
 
                   'bzrlib.tests.test_fetch',
2291
 
                   'bzrlib.tests.test_ftp_transport',
2292
 
                   'bzrlib.tests.test_generate_docs',
2293
 
                   'bzrlib.tests.test_generate_ids',
2294
 
                   'bzrlib.tests.test_globbing',
2295
 
                   'bzrlib.tests.test_gpg',
2296
 
                   'bzrlib.tests.test_graph',
 
631
                   'bzrlib.tests.test_merge3',
 
632
                   'bzrlib.tests.test_merge',
2297
633
                   'bzrlib.tests.test_hashcache',
2298
 
                   'bzrlib.tests.test_help',
2299
 
                   'bzrlib.tests.test_http',
2300
 
                   'bzrlib.tests.test_http_response',
2301
 
                   'bzrlib.tests.test_https_ca_bundle',
2302
 
                   'bzrlib.tests.test_identitymap',
2303
 
                   'bzrlib.tests.test_ignores',
2304
 
                   'bzrlib.tests.test_inv',
2305
 
                   'bzrlib.tests.test_knit',
2306
 
                   'bzrlib.tests.test_lazy_import',
2307
 
                   'bzrlib.tests.test_lazy_regex',
2308
 
                   'bzrlib.tests.test_lockdir',
2309
 
                   'bzrlib.tests.test_lockable_files',
 
634
                   'bzrlib.tests.test_status',
2310
635
                   'bzrlib.tests.test_log',
2311
 
                   'bzrlib.tests.test_memorytree',
2312
 
                   'bzrlib.tests.test_merge',
2313
 
                   'bzrlib.tests.test_merge3',
 
636
                   'bzrlib.tests.test_revisionnamespaces',
 
637
                   'bzrlib.tests.test_branch',
 
638
                   'bzrlib.tests.test_revision',
 
639
                   'bzrlib.tests.test_revision_info',
2314
640
                   'bzrlib.tests.test_merge_core',
2315
 
                   'bzrlib.tests.test_merge_directive',
2316
 
                   'bzrlib.tests.test_missing',
2317
 
                   'bzrlib.tests.test_msgeditor',
2318
 
                   'bzrlib.tests.test_multiparent',
2319
 
                   'bzrlib.tests.test_nonascii',
2320
 
                   'bzrlib.tests.test_options',
2321
 
                   'bzrlib.tests.test_osutils',
2322
 
                   'bzrlib.tests.test_osutils_encodings',
2323
 
                   'bzrlib.tests.test_patch',
2324
 
                   'bzrlib.tests.test_patches',
2325
 
                   'bzrlib.tests.test_permissions',
2326
 
                   'bzrlib.tests.test_plugins',
2327
 
                   'bzrlib.tests.test_progress',
2328
 
                   'bzrlib.tests.test_reconcile',
2329
 
                   'bzrlib.tests.test_registry',
2330
 
                   'bzrlib.tests.test_remote',
2331
 
                   'bzrlib.tests.test_repository',
2332
 
                   'bzrlib.tests.test_revert',
2333
 
                   'bzrlib.tests.test_revision',
2334
 
                   'bzrlib.tests.test_revisionnamespaces',
2335
 
                   'bzrlib.tests.test_revisiontree',
2336
 
                   'bzrlib.tests.test_rio',
2337
 
                   'bzrlib.tests.test_sampler',
2338
 
                   'bzrlib.tests.test_selftest',
2339
 
                   'bzrlib.tests.test_setup',
2340
 
                   'bzrlib.tests.test_sftp_transport',
2341
 
                   'bzrlib.tests.test_smart',
2342
641
                   'bzrlib.tests.test_smart_add',
2343
 
                   'bzrlib.tests.test_smart_transport',
2344
 
                   'bzrlib.tests.test_source',
2345
 
                   'bzrlib.tests.test_ssh_transport',
2346
 
                   'bzrlib.tests.test_status',
 
642
                   'bzrlib.tests.test_bad_files',
 
643
                   'bzrlib.tests.test_diff',
 
644
                   'bzrlib.tests.test_parent',
 
645
                   'bzrlib.tests.test_xml',
 
646
                   'bzrlib.tests.test_weave',
 
647
                   'bzrlib.tests.test_fetch',
 
648
                   'bzrlib.tests.test_whitebox',
2347
649
                   'bzrlib.tests.test_store',
2348
 
                   'bzrlib.tests.test_strace',
2349
 
                   'bzrlib.tests.test_subsume',
2350
 
                   'bzrlib.tests.test_symbol_versioning',
2351
 
                   'bzrlib.tests.test_tag',
2352
 
                   'bzrlib.tests.test_testament',
2353
 
                   'bzrlib.tests.test_textfile',
2354
 
                   'bzrlib.tests.test_textmerge',
2355
 
                   'bzrlib.tests.test_timestamp',
2356
 
                   'bzrlib.tests.test_trace',
 
650
                   'bzrlib.tests.test_sampler',
2357
651
                   'bzrlib.tests.test_transactions',
2358
 
                   'bzrlib.tests.test_transform',
2359
652
                   'bzrlib.tests.test_transport',
2360
 
                   'bzrlib.tests.test_tree',
2361
 
                   'bzrlib.tests.test_treebuilder',
 
653
                   'bzrlib.tests.test_sftp',
 
654
                   'bzrlib.tests.test_graph',
 
655
                   'bzrlib.tests.test_workingtree',
 
656
                   'bzrlib.tests.test_upgrade',
 
657
                   'bzrlib.tests.test_uncommit',
 
658
                   'bzrlib.tests.test_conflicts',
 
659
                   'bzrlib.tests.test_testament',
 
660
                   'bzrlib.tests.test_annotate',
 
661
                   'bzrlib.tests.test_revprops',
 
662
                   'bzrlib.tests.test_options',
 
663
                   'bzrlib.tests.test_http',
 
664
                   'bzrlib.tests.test_nonascii',
 
665
                   'bzrlib.tests.test_reweave',
2362
666
                   'bzrlib.tests.test_tsort',
2363
 
                   'bzrlib.tests.test_tuned_gzip',
2364
 
                   'bzrlib.tests.test_ui',
2365
 
                   'bzrlib.tests.test_upgrade',
2366
 
                   'bzrlib.tests.test_urlutils',
2367
 
                   'bzrlib.tests.test_versionedfile',
2368
 
                   'bzrlib.tests.test_version',
2369
 
                   'bzrlib.tests.test_version_info',
2370
 
                   'bzrlib.tests.test_weave',
2371
 
                   'bzrlib.tests.test_whitebox',
2372
 
                   'bzrlib.tests.test_workingtree',
2373
 
                   'bzrlib.tests.test_workingtree_4',
2374
 
                   'bzrlib.tests.test_wsgi',
2375
 
                   'bzrlib.tests.test_xml',
 
667
                   'bzrlib.tests.test_trace',
 
668
                   'bzrlib.tests.test_rio',
2376
669
                   ]
2377
 
    test_transport_implementations = [
2378
 
        'bzrlib.tests.test_transport_implementations',
2379
 
        'bzrlib.tests.test_read_bundle',
2380
 
        ]
2381
 
    suite = TestUtil.TestSuite()
2382
 
    loader = TestUtil.TestLoader()
2383
 
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
2384
 
    from bzrlib.transport import TransportTestProviderAdapter
2385
 
    adapter = TransportTestProviderAdapter()
2386
 
    adapt_modules(test_transport_implementations, adapter, loader, suite)
 
670
 
 
671
    TestCase.BZRPATH = os.path.join(os.path.realpath(os.path.dirname(bzrlib.__path__[0])), 'bzr')
 
672
    print '%-30s %s' % ('bzr binary', TestCase.BZRPATH)
 
673
    print
 
674
    suite = TestSuite()
 
675
    suite.addTest(TestLoader().loadTestsFromNames(testmod_names))
2387
676
    for package in packages_to_test():
2388
677
        suite.addTest(package.test_suite())
2389
678
    for m in MODULES_TO_TEST:
2390
 
        suite.addTest(loader.loadTestsFromModule(m))
2391
 
    for m in MODULES_TO_DOCTEST:
2392
 
        try:
2393
 
            suite.addTest(doctest.DocTestSuite(m))
2394
 
        except ValueError, e:
2395
 
            print '**failed to get doctest for: %s\n%s' %(m,e)
2396
 
            raise
2397
 
    for name, plugin in bzrlib.plugin.all_plugins().items():
2398
 
        if getattr(plugin, 'test_suite', None) is not None:
2399
 
            default_encoding = sys.getdefaultencoding()
2400
 
            try:
2401
 
                plugin_suite = plugin.test_suite()
2402
 
            except ImportError, e:
2403
 
                bzrlib.trace.warning(
2404
 
                    'Unable to test plugin "%s": %s', name, e)
2405
 
            else:
2406
 
                suite.addTest(plugin_suite)
2407
 
            if default_encoding != sys.getdefaultencoding():
2408
 
                bzrlib.trace.warning(
2409
 
                    'Plugin "%s" tried to reset default encoding to: %s', name,
2410
 
                    sys.getdefaultencoding())
2411
 
                reload(sys)
2412
 
                sys.setdefaultencoding(default_encoding)
 
679
        suite.addTest(TestLoader().loadTestsFromModule(m))
 
680
    for m in (MODULES_TO_DOCTEST):
 
681
        suite.addTest(DocTestSuite(m))
 
682
    for p in bzrlib.plugin.all_plugins:
 
683
        if hasattr(p, 'test_suite'):
 
684
            suite.addTest(p.test_suite())
2413
685
    return suite
2414
686
 
2415
 
 
2416
 
def adapt_modules(mods_list, adapter, loader, suite):
2417
 
    """Adapt the modules in mods_list using adapter and add to suite."""
2418
 
    for test in iter_suite_tests(loader.loadTestsFromModuleNames(mods_list)):
2419
 
        suite.addTests(adapter.adapt(test))
2420
 
 
2421
 
 
2422
 
def _rmtree_temp_dir(dirname):
2423
 
    try:
2424
 
        osutils.rmtree(dirname)
2425
 
    except OSError, e:
2426
 
        if sys.platform == 'win32' and e.errno == errno.EACCES:
2427
 
            print >>sys.stderr, ('Permission denied: '
2428
 
                                 'unable to remove testing dir '
2429
 
                                 '%s' % os.path.basename(dirname))
2430
 
        else:
2431
 
            raise
2432
 
 
2433
 
 
2434
 
def clean_selftest_output(root=None, quiet=False):
2435
 
    """Remove all selftest output directories from root directory.
2436
 
 
2437
 
    :param  root:   root directory for clean
2438
 
                    (if ommitted or None then clean current directory).
2439
 
    :param  quiet:  suppress report about deleting directories
2440
 
    """
2441
 
    import re
2442
 
    re_dir = re.compile(r'''test\d\d\d\d\.tmp''')
2443
 
    if root is None:
2444
 
        root = u'.'
2445
 
    for i in os.listdir(root):
2446
 
        if os.path.isdir(i) and re_dir.match(i):
2447
 
            if not quiet:
2448
 
                print 'delete directory:', i
2449
 
            _rmtree_temp_dir(i)
2450
 
 
2451
 
 
2452
 
class Feature(object):
2453
 
    """An operating system Feature."""
2454
 
 
2455
 
    def __init__(self):
2456
 
        self._available = None
2457
 
 
2458
 
    def available(self):
2459
 
        """Is the feature available?
2460
 
 
2461
 
        :return: True if the feature is available.
2462
 
        """
2463
 
        if self._available is None:
2464
 
            self._available = self._probe()
2465
 
        return self._available
2466
 
 
2467
 
    def _probe(self):
2468
 
        """Implement this method in concrete features.
2469
 
 
2470
 
        :return: True if the feature is available.
2471
 
        """
2472
 
        raise NotImplementedError
2473
 
 
2474
 
    def __str__(self):
2475
 
        if getattr(self, 'feature_name', None):
2476
 
            return self.feature_name()
2477
 
        return self.__class__.__name__