~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-09-01 17:29:56 UTC
  • mfrom: (1711.9.14 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060901172956-71246cfb9bf153f8
(vila) cleanup http changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006 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
21
21
# little as possible, so this should be used rarely if it's added at all.
22
22
# (Suggestion from j-a-meinel, 2005-11-24)
23
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
24
30
from cStringIO import StringIO
25
31
import difflib
 
32
import doctest
26
33
import errno
27
34
import logging
28
35
import os
29
36
import re
30
 
import shutil
 
37
import shlex
 
38
import stat
 
39
from subprocess import Popen, PIPE
31
40
import sys
32
41
import tempfile
33
42
import unittest
34
43
import time
35
 
import codecs
 
44
 
36
45
 
37
46
import bzrlib.branch
 
47
import bzrlib.bzrdir as bzrdir
38
48
import bzrlib.commands
39
 
from bzrlib.errors import BzrError
 
49
import bzrlib.bundle.serializer
 
50
import bzrlib.errors as errors
40
51
import bzrlib.inventory
 
52
import bzrlib.iterablefile
 
53
import bzrlib.lockdir
 
54
try:
 
55
    import bzrlib.lsprof
 
56
except ImportError:
 
57
    # lsprof not available
 
58
    pass
 
59
from bzrlib.merge import merge_inner
41
60
import bzrlib.merge3
42
61
import bzrlib.osutils
43
62
import bzrlib.osutils as osutils
44
63
import bzrlib.plugin
 
64
import bzrlib.progress as progress
 
65
from bzrlib.revision import common_ancestor
45
66
import bzrlib.store
 
67
from bzrlib import symbol_versioning
46
68
import bzrlib.trace
 
69
from bzrlib.transport import get_transport
 
70
import bzrlib.transport
 
71
from bzrlib.transport.local import LocalRelpathServer
 
72
from bzrlib.transport.readonly import ReadonlyServer
47
73
from bzrlib.trace import mutter
48
 
from bzrlib.tests.TestUtil import TestLoader, TestSuite
 
74
from bzrlib.tests import TestUtil
 
75
from bzrlib.tests.TestUtil import (
 
76
                          TestSuite,
 
77
                          TestLoader,
 
78
                          )
49
79
from bzrlib.tests.treeshape import build_tree_contents
 
80
import bzrlib.urlutils as urlutils
 
81
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
 
82
 
 
83
default_transport = LocalRelpathServer
50
84
 
51
85
MODULES_TO_TEST = []
52
86
MODULES_TO_DOCTEST = [
53
87
                      bzrlib.branch,
 
88
                      bzrlib.bundle.serializer,
54
89
                      bzrlib.commands,
55
90
                      bzrlib.errors,
56
91
                      bzrlib.inventory,
 
92
                      bzrlib.iterablefile,
 
93
                      bzrlib.lockdir,
57
94
                      bzrlib.merge3,
 
95
                      bzrlib.option,
58
96
                      bzrlib.osutils,
59
 
                      bzrlib.store,
 
97
                      bzrlib.store
60
98
                      ]
 
99
 
 
100
 
61
101
def packages_to_test():
 
102
    """Return a list of packages to test.
 
103
 
 
104
    The packages are not globally imported so that import failures are
 
105
    triggered when running selftest, not when importing the command.
 
106
    """
 
107
    import bzrlib.doc
62
108
    import bzrlib.tests.blackbox
 
109
    import bzrlib.tests.branch_implementations
 
110
    import bzrlib.tests.bzrdir_implementations
 
111
    import bzrlib.tests.interrepository_implementations
 
112
    import bzrlib.tests.interversionedfile_implementations
 
113
    import bzrlib.tests.intertree_implementations
 
114
    import bzrlib.tests.repository_implementations
 
115
    import bzrlib.tests.revisionstore_implementations
 
116
    import bzrlib.tests.tree_implementations
 
117
    import bzrlib.tests.workingtree_implementations
63
118
    return [
64
 
            bzrlib.tests.blackbox
 
119
            bzrlib.doc,
 
120
            bzrlib.tests.blackbox,
 
121
            bzrlib.tests.branch_implementations,
 
122
            bzrlib.tests.bzrdir_implementations,
 
123
            bzrlib.tests.interrepository_implementations,
 
124
            bzrlib.tests.interversionedfile_implementations,
 
125
            bzrlib.tests.intertree_implementations,
 
126
            bzrlib.tests.repository_implementations,
 
127
            bzrlib.tests.revisionstore_implementations,
 
128
            bzrlib.tests.tree_implementations,
 
129
            bzrlib.tests.workingtree_implementations,
65
130
            ]
66
131
 
67
132
 
68
 
class EarlyStoppingTestResultAdapter(object):
69
 
    """An adapter for TestResult to stop at the first first failure or error"""
70
 
 
71
 
    def __init__(self, result):
72
 
        self._result = result
73
 
 
74
 
    def addError(self, test, err):
75
 
        self._result.addError(test, err)
76
 
        self._result.stop()
77
 
 
78
 
    def addFailure(self, test, err):
79
 
        self._result.addFailure(test, err)
80
 
        self._result.stop()
81
 
 
82
 
    def __getattr__(self, name):
83
 
        return getattr(self._result, name)
84
 
 
85
 
    def __setattr__(self, name, value):
86
 
        if name == '_result':
87
 
            object.__setattr__(self, name, value)
88
 
        return setattr(self._result, name, value)
89
 
 
90
 
 
91
133
class _MyResult(unittest._TextTestResult):
92
134
    """Custom TestResult.
93
135
 
94
136
    Shows output in a different format, including displaying runtime for tests.
95
137
    """
96
 
 
97
 
    def _elapsedTime(self):
98
 
        return "%5dms" % (1000 * (time.time() - self._start_time))
 
138
    stop_early = False
 
139
    
 
140
    def __init__(self, stream, descriptions, verbosity, pb=None,
 
141
                 bench_history=None):
 
142
        """Construct new TestResult.
 
143
 
 
144
        :param bench_history: Optionally, a writable file object to accumulate
 
145
            benchmark results.
 
146
        """
 
147
        unittest._TextTestResult.__init__(self, stream, descriptions, verbosity)
 
148
        self.pb = pb
 
149
        if bench_history is not None:
 
150
            from bzrlib.version import _get_bzr_source_tree
 
151
            src_tree = _get_bzr_source_tree()
 
152
            if src_tree:
 
153
                revision_id = src_tree.last_revision()
 
154
            else:
 
155
                # XXX: If there's no branch, what should we do?
 
156
                revision_id = ''
 
157
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
 
158
        self._bench_history = bench_history
 
159
    
 
160
    def extractBenchmarkTime(self, testCase):
 
161
        """Add a benchmark time for the current test case."""
 
162
        self._benchmarkTime = getattr(testCase, "_benchtime", None)
 
163
    
 
164
    def _elapsedTestTimeString(self):
 
165
        """Return a time string for the overall time the current test has taken."""
 
166
        return self._formatTime(time.time() - self._start_time)
 
167
 
 
168
    def _testTimeString(self):
 
169
        if self._benchmarkTime is not None:
 
170
            return "%s/%s" % (
 
171
                self._formatTime(self._benchmarkTime),
 
172
                self._elapsedTestTimeString())
 
173
        else:
 
174
            return "      %s" % self._elapsedTestTimeString()
 
175
 
 
176
    def _formatTime(self, seconds):
 
177
        """Format seconds as milliseconds with leading spaces."""
 
178
        return "%5dms" % (1000 * seconds)
 
179
 
 
180
    def _ellipsise_unimportant_words(self, a_string, final_width,
 
181
                                   keep_start=False):
 
182
        """Add ellipses (sp?) for overly long strings.
 
183
        
 
184
        :param keep_start: If true preserve the start of a_string rather
 
185
                           than the end of it.
 
186
        """
 
187
        if keep_start:
 
188
            if len(a_string) > final_width:
 
189
                result = a_string[:final_width-3] + '...'
 
190
            else:
 
191
                result = a_string
 
192
        else:
 
193
            if len(a_string) > final_width:
 
194
                result = '...' + a_string[3-final_width:]
 
195
            else:
 
196
                result = a_string
 
197
        return result.ljust(final_width)
99
198
 
100
199
    def startTest(self, test):
101
200
        unittest.TestResult.startTest(self, test)
103
202
        # the beginning, but in an id, the important words are
104
203
        # at the end
105
204
        SHOW_DESCRIPTIONS = False
 
205
 
 
206
        if not self.showAll and self.dots and self.pb is not None:
 
207
            final_width = 13
 
208
        else:
 
209
            final_width = osutils.terminal_width()
 
210
            final_width = final_width - 15 - 8
 
211
        what = None
 
212
        if SHOW_DESCRIPTIONS:
 
213
            what = test.shortDescription()
 
214
            if what:
 
215
                what = self._ellipsise_unimportant_words(what, final_width, keep_start=True)
 
216
        if what is None:
 
217
            what = test.id()
 
218
            if what.startswith('bzrlib.tests.'):
 
219
                what = what[13:]
 
220
            what = self._ellipsise_unimportant_words(what, final_width)
106
221
        if self.showAll:
107
 
            width = osutils.terminal_width()
108
 
            name_width = width - 15
109
 
            what = None
110
 
            if SHOW_DESCRIPTIONS:
111
 
                what = test.shortDescription()
112
 
                if what:
113
 
                    if len(what) > name_width:
114
 
                        what = what[:name_width-3] + '...'
115
 
            if what is None:
116
 
                what = test.id()
117
 
                if what.startswith('bzrlib.tests.'):
118
 
                    what = what[13:]
119
 
                if len(what) > name_width:
120
 
                    what = '...' + what[3-name_width:]
121
 
            what = what.ljust(name_width)
122
222
            self.stream.write(what)
 
223
        elif self.dots and self.pb is not None:
 
224
            self.pb.update(what, self.testsRun - 1, None)
123
225
        self.stream.flush()
 
226
        self._recordTestStartTime()
 
227
 
 
228
    def _recordTestStartTime(self):
 
229
        """Record that a test has started."""
124
230
        self._start_time = time.time()
125
231
 
126
232
    def addError(self, test, err):
127
233
        if isinstance(err[1], TestSkipped):
128
234
            return self.addSkipped(test, err)    
129
235
        unittest.TestResult.addError(self, test, err)
 
236
        self.extractBenchmarkTime(test)
130
237
        if self.showAll:
131
 
            self.stream.writeln("ERROR %s" % self._elapsedTime())
132
 
        elif self.dots:
 
238
            self.stream.writeln("ERROR %s" % self._testTimeString())
 
239
        elif self.dots and self.pb is None:
133
240
            self.stream.write('E')
 
241
        elif self.dots:
 
242
            self.pb.update(self._ellipsise_unimportant_words('ERROR', 13), self.testsRun, None)
 
243
            self.pb.note(self._ellipsise_unimportant_words(
 
244
                            test.id() + ': ERROR',
 
245
                            osutils.terminal_width()))
134
246
        self.stream.flush()
 
247
        if self.stop_early:
 
248
            self.stop()
135
249
 
136
250
    def addFailure(self, test, err):
137
251
        unittest.TestResult.addFailure(self, test, err)
 
252
        self.extractBenchmarkTime(test)
138
253
        if self.showAll:
139
 
            self.stream.writeln(" FAIL %s" % self._elapsedTime())
140
 
        elif self.dots:
 
254
            self.stream.writeln(" FAIL %s" % self._testTimeString())
 
255
        elif self.dots and self.pb is None:
141
256
            self.stream.write('F')
 
257
        elif self.dots:
 
258
            self.pb.update(self._ellipsise_unimportant_words('FAIL', 13), self.testsRun, None)
 
259
            self.pb.note(self._ellipsise_unimportant_words(
 
260
                            test.id() + ': FAIL',
 
261
                            osutils.terminal_width()))
142
262
        self.stream.flush()
 
263
        if self.stop_early:
 
264
            self.stop()
143
265
 
144
266
    def addSuccess(self, test):
 
267
        self.extractBenchmarkTime(test)
 
268
        if self._bench_history is not None:
 
269
            if self._benchmarkTime is not None:
 
270
                self._bench_history.write("%s %s\n" % (
 
271
                    self._formatTime(self._benchmarkTime),
 
272
                    test.id()))
145
273
        if self.showAll:
146
 
            self.stream.writeln('   OK %s' % self._elapsedTime())
147
 
        elif self.dots:
 
274
            self.stream.writeln('   OK %s' % self._testTimeString())
 
275
            for bench_called, stats in getattr(test, '_benchcalls', []):
 
276
                self.stream.writeln('LSProf output for %s(%s, %s)' % bench_called)
 
277
                stats.pprint(file=self.stream)
 
278
        elif self.dots and self.pb is None:
148
279
            self.stream.write('~')
 
280
        elif self.dots:
 
281
            self.pb.update(self._ellipsise_unimportant_words('OK', 13), self.testsRun, None)
149
282
        self.stream.flush()
150
283
        unittest.TestResult.addSuccess(self, test)
151
284
 
152
285
    def addSkipped(self, test, skip_excinfo):
 
286
        self.extractBenchmarkTime(test)
153
287
        if self.showAll:
154
 
            print >>self.stream, ' SKIP %s' % self._elapsedTime()
 
288
            print >>self.stream, ' SKIP %s' % self._testTimeString()
155
289
            print >>self.stream, '     %s' % skip_excinfo[1]
156
 
        elif self.dots:
 
290
        elif self.dots and self.pb is None:
157
291
            self.stream.write('S')
 
292
        elif self.dots:
 
293
            self.pb.update(self._ellipsise_unimportant_words('SKIP', 13), self.testsRun, None)
158
294
        self.stream.flush()
159
295
        # seems best to treat this as success from point-of-view of unittest
160
296
        # -- it actually does nothing so it barely matters :)
161
 
        unittest.TestResult.addSuccess(self, test)
 
297
        try:
 
298
            test.tearDown()
 
299
        except KeyboardInterrupt:
 
300
            raise
 
301
        except:
 
302
            self.addError(test, test.__exc_info())
 
303
        else:
 
304
            unittest.TestResult.addSuccess(self, test)
162
305
 
163
306
    def printErrorList(self, flavour, errors):
164
307
        for test, err in errors:
165
308
            self.stream.writeln(self.separator1)
166
 
            self.stream.writeln("%s: %s" % (flavour,self.getDescription(test)))
167
 
            if hasattr(test, '_get_log'):
 
309
            self.stream.writeln("%s: %s" % (flavour, self.getDescription(test)))
 
310
            if getattr(test, '_get_log', None) is not None:
168
311
                print >>self.stream
169
312
                print >>self.stream, \
170
 
                        ('vvvv[log from %s]' % test).ljust(78,'-')
 
313
                        ('vvvv[log from %s]' % test.id()).ljust(78,'-')
171
314
                print >>self.stream, test._get_log()
172
315
                print >>self.stream, \
173
 
                        ('^^^^[log from %s]' % test).ljust(78,'-')
 
316
                        ('^^^^[log from %s]' % test.id()).ljust(78,'-')
174
317
            self.stream.writeln(self.separator2)
175
318
            self.stream.writeln("%s" % err)
176
319
 
177
320
 
178
 
class TextTestRunner(unittest.TextTestRunner):
 
321
class TextTestRunner(object):
179
322
    stop_on_failure = False
180
323
 
 
324
    def __init__(self,
 
325
                 stream=sys.stderr,
 
326
                 descriptions=0,
 
327
                 verbosity=1,
 
328
                 keep_output=False,
 
329
                 pb=None,
 
330
                 bench_history=None):
 
331
        self.stream = unittest._WritelnDecorator(stream)
 
332
        self.descriptions = descriptions
 
333
        self.verbosity = verbosity
 
334
        self.keep_output = keep_output
 
335
        self.pb = pb
 
336
        self._bench_history = bench_history
 
337
 
181
338
    def _makeResult(self):
182
 
        result = _MyResult(self.stream, self.descriptions, self.verbosity)
183
 
        if self.stop_on_failure:
184
 
            result = EarlyStoppingTestResultAdapter(result)
 
339
        result = _MyResult(self.stream,
 
340
                           self.descriptions,
 
341
                           self.verbosity,
 
342
                           pb=self.pb,
 
343
                           bench_history=self._bench_history)
 
344
        result.stop_early = self.stop_on_failure
 
345
        return result
 
346
 
 
347
    def run(self, test):
 
348
        "Run the given test case or test suite."
 
349
        result = self._makeResult()
 
350
        startTime = time.time()
 
351
        if self.pb is not None:
 
352
            self.pb.update('Running tests', 0, test.countTestCases())
 
353
        test.run(result)
 
354
        stopTime = time.time()
 
355
        timeTaken = stopTime - startTime
 
356
        result.printErrors()
 
357
        self.stream.writeln(result.separator2)
 
358
        run = result.testsRun
 
359
        self.stream.writeln("Ran %d test%s in %.3fs" %
 
360
                            (run, run != 1 and "s" or "", timeTaken))
 
361
        self.stream.writeln()
 
362
        if not result.wasSuccessful():
 
363
            self.stream.write("FAILED (")
 
364
            failed, errored = map(len, (result.failures, result.errors))
 
365
            if failed:
 
366
                self.stream.write("failures=%d" % failed)
 
367
            if errored:
 
368
                if failed: self.stream.write(", ")
 
369
                self.stream.write("errors=%d" % errored)
 
370
            self.stream.writeln(")")
 
371
        else:
 
372
            self.stream.writeln("OK")
 
373
        if self.pb is not None:
 
374
            self.pb.update('Cleaning up', 0, 1)
 
375
        # This is still a little bogus, 
 
376
        # but only a little. Folk not using our testrunner will
 
377
        # have to delete their temp directories themselves.
 
378
        test_root = TestCaseInTempDir.TEST_ROOT
 
379
        if result.wasSuccessful() or not self.keep_output:
 
380
            if test_root is not None:
 
381
                # If LANG=C we probably have created some bogus paths
 
382
                # which rmtree(unicode) will fail to delete
 
383
                # so make sure we are using rmtree(str) to delete everything
 
384
                # except on win32, where rmtree(str) will fail
 
385
                # since it doesn't have the property of byte-stream paths
 
386
                # (they are either ascii or mbcs)
 
387
                if sys.platform == 'win32':
 
388
                    # make sure we are using the unicode win32 api
 
389
                    test_root = unicode(test_root)
 
390
                else:
 
391
                    test_root = test_root.encode(
 
392
                        sys.getfilesystemencoding())
 
393
                osutils.rmtree(test_root)
 
394
        else:
 
395
            if self.pb is not None:
 
396
                self.pb.note("Failed tests working directories are in '%s'\n",
 
397
                             test_root)
 
398
            else:
 
399
                self.stream.writeln(
 
400
                    "Failed tests working directories are in '%s'\n" %
 
401
                    test_root)
 
402
        TestCaseInTempDir.TEST_ROOT = None
 
403
        if self.pb is not None:
 
404
            self.pb.clear()
185
405
        return result
186
406
 
187
407
 
200
420
 
201
421
class TestSkipped(Exception):
202
422
    """Indicates that a test was intentionally skipped, rather than failing."""
203
 
    # XXX: Not used yet
204
423
 
205
424
 
206
425
class CommandFailed(Exception):
207
426
    pass
208
427
 
 
428
 
 
429
class StringIOWrapper(object):
 
430
    """A wrapper around cStringIO which just adds an encoding attribute.
 
431
    
 
432
    Internally we can check sys.stdout to see what the output encoding
 
433
    should be. However, cStringIO has no encoding attribute that we can
 
434
    set. So we wrap it instead.
 
435
    """
 
436
    encoding='ascii'
 
437
    _cstring = None
 
438
 
 
439
    def __init__(self, s=None):
 
440
        if s is not None:
 
441
            self.__dict__['_cstring'] = StringIO(s)
 
442
        else:
 
443
            self.__dict__['_cstring'] = StringIO()
 
444
 
 
445
    def __getattr__(self, name, getattr=getattr):
 
446
        return getattr(self.__dict__['_cstring'], name)
 
447
 
 
448
    def __setattr__(self, name, val):
 
449
        if name == 'encoding':
 
450
            self.__dict__['encoding'] = val
 
451
        else:
 
452
            return setattr(self._cstring, name, val)
 
453
 
 
454
 
209
455
class TestCase(unittest.TestCase):
210
456
    """Base class for bzr unit tests.
211
457
    
227
473
    accidentally overlooked.
228
474
    """
229
475
 
230
 
    BZRPATH = 'bzr'
231
476
    _log_file_name = None
232
477
    _log_contents = ''
 
478
    # record lsprof data when performing benchmark calls.
 
479
    _gather_lsprof_in_benchmarks = False
 
480
 
 
481
    def __init__(self, methodName='testMethod'):
 
482
        super(TestCase, self).__init__(methodName)
 
483
        self._cleanups = []
233
484
 
234
485
    def setUp(self):
235
486
        unittest.TestCase.setUp(self)
236
 
        self._cleanups = []
237
487
        self._cleanEnvironment()
238
488
        bzrlib.trace.disable_default_logging()
239
489
        self._startLogFile()
 
490
        self._benchcalls = []
 
491
        self._benchtime = None
240
492
 
241
493
    def _ndiff_strings(self, a, b):
242
494
        """Return ndiff between two strings containing lines.
253
505
                                  charjunk=lambda x: False)
254
506
        return ''.join(difflines)
255
507
 
256
 
    def assertEqualDiff(self, a, b):
 
508
    def assertEqualDiff(self, a, b, message=None):
257
509
        """Assert two texts are equal, if not raise an exception.
258
510
        
259
511
        This is intended for use with multi-line strings where it can 
262
514
        # TODO: perhaps override assertEquals to call this for strings?
263
515
        if a == b:
264
516
            return
265
 
        raise AssertionError("texts not equal:\n" + 
 
517
        if message is None:
 
518
            message = "texts not equal:\n"
 
519
        raise AssertionError(message + 
266
520
                             self._ndiff_strings(a, b))      
267
521
        
 
522
    def assertEqualMode(self, mode, mode_test):
 
523
        self.assertEqual(mode, mode_test,
 
524
                         'mode mismatch %o != %o' % (mode, mode_test))
 
525
 
268
526
    def assertStartsWith(self, s, prefix):
269
527
        if not s.startswith(prefix):
270
528
            raise AssertionError('string %r does not start with %r' % (s, prefix))
271
529
 
272
530
    def assertEndsWith(self, s, suffix):
273
 
        if not s.endswith(prefix):
 
531
        """Asserts that s ends with suffix."""
 
532
        if not s.endswith(suffix):
274
533
            raise AssertionError('string %r does not end with %r' % (s, suffix))
275
534
 
276
535
    def assertContainsRe(self, haystack, needle_re):
279
538
            raise AssertionError('pattern "%s" not found in "%s"'
280
539
                    % (needle_re, haystack))
281
540
 
282
 
    def AssertSubset(self, sublist, superlist):
 
541
    def assertNotContainsRe(self, haystack, needle_re):
 
542
        """Assert that a does not match a regular expression"""
 
543
        if re.search(needle_re, haystack):
 
544
            raise AssertionError('pattern "%s" found in "%s"'
 
545
                    % (needle_re, haystack))
 
546
 
 
547
    def assertSubset(self, sublist, superlist):
283
548
        """Assert that every entry in sublist is present in superlist."""
284
549
        missing = []
285
550
        for entry in sublist:
289
554
            raise AssertionError("value(s) %r not present in container %r" % 
290
555
                                 (missing, superlist))
291
556
 
 
557
    def assertIs(self, left, right):
 
558
        if not (left is right):
 
559
            raise AssertionError("%r is not %r." % (left, right))
 
560
 
 
561
    def assertTransportMode(self, transport, path, mode):
 
562
        """Fail if a path does not have mode mode.
 
563
        
 
564
        If modes are not supported on this transport, the assertion is ignored.
 
565
        """
 
566
        if not transport._can_roundtrip_unix_modebits():
 
567
            return
 
568
        path_stat = transport.stat(path)
 
569
        actual_mode = stat.S_IMODE(path_stat.st_mode)
 
570
        self.assertEqual(mode, actual_mode,
 
571
            'mode of %r incorrect (%o != %o)' % (path, mode, actual_mode))
 
572
 
 
573
    def assertIsInstance(self, obj, kls):
 
574
        """Fail if obj is not an instance of kls"""
 
575
        if not isinstance(obj, kls):
 
576
            self.fail("%r is an instance of %s rather than %s" % (
 
577
                obj, obj.__class__, kls))
 
578
 
 
579
    def callDeprecated(self, expected, callable, *args, **kwargs):
 
580
        """Assert that a callable is deprecated in a particular way.
 
581
 
 
582
        :param expected: a list of the deprecation warnings expected, in order
 
583
        :param callable: The callable to call
 
584
        :param args: The positional arguments for the callable
 
585
        :param kwargs: The keyword arguments for the callable
 
586
        """
 
587
        local_warnings = []
 
588
        def capture_warnings(msg, cls, stacklevel=None):
 
589
            self.assertEqual(cls, DeprecationWarning)
 
590
            local_warnings.append(msg)
 
591
        method = symbol_versioning.warn
 
592
        symbol_versioning.set_warning_method(capture_warnings)
 
593
        try:
 
594
            result = callable(*args, **kwargs)
 
595
        finally:
 
596
            symbol_versioning.set_warning_method(method)
 
597
        self.assertEqual(expected, local_warnings)
 
598
        return result
 
599
 
292
600
    def _startLogFile(self):
293
601
        """Send bzr and test log messages to a temporary file.
294
602
 
295
603
        The file is removed as the test is torn down.
296
604
        """
297
605
        fileno, name = tempfile.mkstemp(suffix='.log', prefix='testbzr')
298
 
        encoder, decoder, stream_reader, stream_writer = codecs.lookup('UTF-8')
299
 
        self._log_file = stream_writer(os.fdopen(fileno, 'w+'))
300
 
        bzrlib.trace.enable_test_log(self._log_file)
 
606
        self._log_file = os.fdopen(fileno, 'w+')
 
607
        self._log_nonce = bzrlib.trace.enable_test_log(self._log_file)
301
608
        self._log_file_name = name
302
609
        self.addCleanup(self._finishLogFile)
303
610
 
306
613
 
307
614
        Read contents into memory, close, and delete.
308
615
        """
309
 
        bzrlib.trace.disable_test_log()
 
616
        if self._log_file is None:
 
617
            return
 
618
        bzrlib.trace.disable_test_log(self._log_nonce)
310
619
        self._log_file.seek(0)
311
620
        self._log_contents = self._log_file.read()
312
621
        self._log_file.close()
328
637
        new_env = {
329
638
            'HOME': os.getcwd(),
330
639
            'APPDATA': os.getcwd(),
331
 
            'BZREMAIL': None,
 
640
            'BZR_EMAIL': None,
 
641
            'BZREMAIL': None, # may still be present in the environment
332
642
            'EMAIL': None,
333
643
        }
334
644
        self.__old_env = {}
362
672
        self._runCleanups()
363
673
        unittest.TestCase.tearDown(self)
364
674
 
 
675
    def time(self, callable, *args, **kwargs):
 
676
        """Run callable and accrue the time it takes to the benchmark time.
 
677
        
 
678
        If lsprofiling is enabled (i.e. by --lsprof-time to bzr selftest) then
 
679
        this will cause lsprofile statistics to be gathered and stored in
 
680
        self._benchcalls.
 
681
        """
 
682
        if self._benchtime is None:
 
683
            self._benchtime = 0
 
684
        start = time.time()
 
685
        try:
 
686
            if not self._gather_lsprof_in_benchmarks:
 
687
                return callable(*args, **kwargs)
 
688
            else:
 
689
                # record this benchmark
 
690
                ret, stats = bzrlib.lsprof.profile(callable, *args, **kwargs)
 
691
                stats.sort()
 
692
                self._benchcalls.append(((callable, args, kwargs), stats))
 
693
                return ret
 
694
        finally:
 
695
            self._benchtime += time.time() - start
 
696
 
365
697
    def _runCleanups(self):
366
698
        """Run registered cleanup functions. 
367
699
 
368
700
        This should only be called from TestCase.tearDown.
369
701
        """
 
702
        # TODO: Perhaps this should keep running cleanups even if 
 
703
        # one of them fails?
370
704
        for cleanup_fn in reversed(self._cleanups):
371
705
            cleanup_fn()
372
706
 
385
719
        """Shortcut that splits cmd into words, runs, and returns stdout"""
386
720
        return self.run_bzr_captured(cmd.split(), retcode=retcode)[0]
387
721
 
388
 
    def run_bzr_captured(self, argv, retcode=0):
 
722
    def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None):
389
723
        """Invoke bzr and return (stdout, stderr).
390
724
 
391
725
        Useful for code that wants to check the contents of the
402
736
        errors, and with logging set to something approximating the
403
737
        default, so that error reporting can be checked.
404
738
 
405
 
        argv -- arguments to invoke bzr
406
 
        retcode -- expected return code, or None for don't-care.
 
739
        :param argv: arguments to invoke bzr
 
740
        :param retcode: expected return code, or None for don't-care.
 
741
        :param encoding: encoding for sys.stdout and sys.stderr
 
742
        :param stdin: A string to be used as stdin for the command.
407
743
        """
408
 
        stdout = StringIO()
409
 
        stderr = StringIO()
410
 
        self.log('run bzr: %s', ' '.join(argv))
 
744
        if encoding is None:
 
745
            encoding = bzrlib.user_encoding
 
746
        if stdin is not None:
 
747
            stdin = StringIO(stdin)
 
748
        stdout = StringIOWrapper()
 
749
        stderr = StringIOWrapper()
 
750
        stdout.encoding = encoding
 
751
        stderr.encoding = encoding
 
752
 
 
753
        self.log('run bzr: %r', argv)
411
754
        # FIXME: don't call into logging here
412
755
        handler = logging.StreamHandler(stderr)
413
 
        handler.setFormatter(bzrlib.trace.QuietFormatter())
414
756
        handler.setLevel(logging.INFO)
415
757
        logger = logging.getLogger('')
416
758
        logger.addHandler(handler)
 
759
        old_ui_factory = bzrlib.ui.ui_factory
 
760
        bzrlib.ui.ui_factory = bzrlib.tests.blackbox.TestUIFactory(
 
761
            stdout=stdout,
 
762
            stderr=stderr)
 
763
        bzrlib.ui.ui_factory.stdin = stdin
417
764
        try:
418
 
            result = self.apply_redirected(None, stdout, stderr,
 
765
            result = self.apply_redirected(stdin, stdout, stderr,
419
766
                                           bzrlib.commands.run_bzr_catch_errors,
420
767
                                           argv)
421
768
        finally:
422
769
            logger.removeHandler(handler)
 
770
            bzrlib.ui.ui_factory = old_ui_factory
 
771
 
423
772
        out = stdout.getvalue()
424
773
        err = stderr.getvalue()
425
774
        if out:
426
 
            self.log('output:\n%s', out)
 
775
            self.log('output:\n%r', out)
427
776
        if err:
428
 
            self.log('errors:\n%s', err)
 
777
            self.log('errors:\n%r', err)
429
778
        if retcode is not None:
430
 
            self.assertEquals(result, retcode)
 
779
            self.assertEquals(retcode, result)
431
780
        return out, err
432
781
 
433
782
    def run_bzr(self, *args, **kwargs):
439
788
 
440
789
        This sends the stdout/stderr results into the test's log,
441
790
        where it may be useful for debugging.  See also run_captured.
 
791
 
 
792
        :param stdin: A string to be used as stdin for the command.
442
793
        """
443
794
        retcode = kwargs.pop('retcode', 0)
444
 
        return self.run_bzr_captured(args, retcode)
 
795
        encoding = kwargs.pop('encoding', None)
 
796
        stdin = kwargs.pop('stdin', None)
 
797
        return self.run_bzr_captured(args, retcode=retcode, encoding=encoding, stdin=stdin)
 
798
 
 
799
    def run_bzr_decode(self, *args, **kwargs):
 
800
        if 'encoding' in kwargs:
 
801
            encoding = kwargs['encoding']
 
802
        else:
 
803
            encoding = bzrlib.user_encoding
 
804
        return self.run_bzr(*args, **kwargs)[0].decode(encoding)
 
805
 
 
806
    def run_bzr_error(self, error_regexes, *args, **kwargs):
 
807
        """Run bzr, and check that stderr contains the supplied regexes
 
808
        
 
809
        :param error_regexes: Sequence of regular expressions which 
 
810
            must each be found in the error output. The relative ordering
 
811
            is not enforced.
 
812
        :param args: command-line arguments for bzr
 
813
        :param kwargs: Keyword arguments which are interpreted by run_bzr
 
814
            This function changes the default value of retcode to be 3,
 
815
            since in most cases this is run when you expect bzr to fail.
 
816
        :return: (out, err) The actual output of running the command (in case you
 
817
                 want to do more inspection)
 
818
 
 
819
        Examples of use:
 
820
            # Make sure that commit is failing because there is nothing to do
 
821
            self.run_bzr_error(['no changes to commit'],
 
822
                               'commit', '-m', 'my commit comment')
 
823
            # Make sure --strict is handling an unknown file, rather than
 
824
            # giving us the 'nothing to do' error
 
825
            self.build_tree(['unknown'])
 
826
            self.run_bzr_error(['Commit refused because there are unknown files'],
 
827
                               'commit', '--strict', '-m', 'my commit comment')
 
828
        """
 
829
        kwargs.setdefault('retcode', 3)
 
830
        out, err = self.run_bzr(*args, **kwargs)
 
831
        for regex in error_regexes:
 
832
            self.assertContainsRe(err, regex)
 
833
        return out, err
 
834
 
 
835
    def run_bzr_subprocess(self, *args, **kwargs):
 
836
        """Run bzr in a subprocess for testing.
 
837
 
 
838
        This starts a new Python interpreter and runs bzr in there. 
 
839
        This should only be used for tests that have a justifiable need for
 
840
        this isolation: e.g. they are testing startup time, or signal
 
841
        handling, or early startup code, etc.  Subprocess code can't be 
 
842
        profiled or debugged so easily.
 
843
 
 
844
        :param retcode: The status code that is expected.  Defaults to 0.  If
 
845
            None is supplied, the status code is not checked.
 
846
        :param env_changes: A dictionary which lists changes to environment
 
847
            variables. A value of None will unset the env variable.
 
848
            The values must be strings. The change will only occur in the
 
849
            child, so you don't need to fix the environment after running.
 
850
        """
 
851
        env_changes = kwargs.get('env_changes', {})
 
852
        def cleanup_environment():
 
853
            for env_var, value in env_changes.iteritems():
 
854
                if value is None:
 
855
                    del os.environ[env_var]
 
856
                else:
 
857
                    os.environ[env_var] = value
 
858
 
 
859
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
 
860
        args = list(args)
 
861
        process = Popen([sys.executable, bzr_path]+args,
 
862
                         stdout=PIPE, stderr=PIPE,
 
863
                         preexec_fn=cleanup_environment)
 
864
        out = process.stdout.read()
 
865
        err = process.stderr.read()
 
866
        retcode = process.wait()
 
867
        supplied_retcode = kwargs.get('retcode', 0)
 
868
        if supplied_retcode is not None:
 
869
            assert supplied_retcode == retcode
 
870
        return [out, err]
445
871
 
446
872
    def check_inventory_shape(self, inv, shape):
447
873
        """Compare an inventory to a list of expected names.
473
899
        if stdin is None:
474
900
            stdin = StringIO("")
475
901
        if stdout is None:
476
 
            if hasattr(self, "_log_file"):
 
902
            if getattr(self, "_log_file", None) is not None:
477
903
                stdout = self._log_file
478
904
            else:
479
905
                stdout = StringIO()
480
906
        if stderr is None:
481
 
            if hasattr(self, "_log_file"):
 
907
            if getattr(self, "_log_file", None is not None):
482
908
                stderr = self._log_file
483
909
            else:
484
910
                stderr = StringIO()
495
921
            sys.stderr = real_stderr
496
922
            sys.stdin = real_stdin
497
923
 
 
924
    def merge(self, branch_from, wt_to):
 
925
        """A helper for tests to do a ui-less merge.
 
926
 
 
927
        This should move to the main library when someone has time to integrate
 
928
        it in.
 
929
        """
 
930
        # minimal ui-less merge.
 
931
        wt_to.branch.fetch(branch_from)
 
932
        base_rev = common_ancestor(branch_from.last_revision(),
 
933
                                   wt_to.branch.last_revision(),
 
934
                                   wt_to.branch.repository)
 
935
        merge_inner(wt_to.branch, branch_from.basis_tree(),
 
936
                    wt_to.branch.repository.revision_tree(base_rev),
 
937
                    this_tree=wt_to)
 
938
        wt_to.add_parent_tree_id(branch_from.last_revision())
 
939
 
498
940
 
499
941
BzrTestBase = TestCase
500
942
 
543
985
            break
544
986
        # make a fake bzr directory there to prevent any tests propagating
545
987
        # up onto the source directory's real branch
546
 
        os.mkdir(osutils.pathjoin(TestCaseInTempDir.TEST_ROOT, '.bzr'))
 
988
        bzrdir.BzrDir.create_standalone_workingtree(TestCaseInTempDir.TEST_ROOT)
547
989
 
548
990
    def setUp(self):
549
991
        super(TestCaseInTempDir, self).setUp()
550
992
        self._make_test_root()
551
993
        _currentdir = os.getcwdu()
 
994
        # shorten the name, to avoid test failures due to path length
552
995
        short_id = self.id().replace('bzrlib.tests.', '') \
553
 
                   .replace('__main__.', '')
554
 
        self.test_dir = osutils.pathjoin(self.TEST_ROOT, short_id)
555
 
        os.mkdir(self.test_dir)
556
 
        os.chdir(self.test_dir)
 
996
                   .replace('__main__.', '')[-100:]
 
997
        # it's possible the same test class is run several times for
 
998
        # parameterized tests, so make sure the names don't collide.  
 
999
        i = 0
 
1000
        while True:
 
1001
            if i > 0:
 
1002
                candidate_dir = '%s/%s.%d' % (self.TEST_ROOT, short_id, i)
 
1003
            else:
 
1004
                candidate_dir = '%s/%s' % (self.TEST_ROOT, short_id)
 
1005
            if os.path.exists(candidate_dir):
 
1006
                i = i + 1
 
1007
                continue
 
1008
            else:
 
1009
                self.test_dir = candidate_dir
 
1010
                os.mkdir(self.test_dir)
 
1011
                os.chdir(self.test_dir)
 
1012
                break
557
1013
        os.environ['HOME'] = self.test_dir
558
1014
        os.environ['APPDATA'] = self.test_dir
559
1015
        def _leaveDirectory():
560
1016
            os.chdir(_currentdir)
561
1017
        self.addCleanup(_leaveDirectory)
562
1018
        
563
 
    def build_tree(self, shape, line_endings='native'):
 
1019
    def build_tree(self, shape, line_endings='native', transport=None):
564
1020
        """Build a test tree according to a pattern.
565
1021
 
566
1022
        shape is a sequence of file specifications.  If the final
567
1023
        character is '/', a directory is created.
568
1024
 
 
1025
        This assumes that all the elements in the tree being built are new.
 
1026
 
569
1027
        This doesn't add anything to a branch.
570
1028
        :param line_endings: Either 'binary' or 'native'
571
1029
                             in binary mode, exact contents are written
572
1030
                             in native mode, the line endings match the
573
1031
                             default platform endings.
 
1032
 
 
1033
        :param transport: A transport to write to, for building trees on 
 
1034
                          VFS's. If the transport is readonly or None,
 
1035
                          "." is opened automatically.
574
1036
        """
575
 
        # XXX: It's OK to just create them using forward slashes on windows?
 
1037
        # It's OK to just create them using forward slashes on windows.
 
1038
        if transport is None or transport.is_readonly():
 
1039
            transport = get_transport(".")
576
1040
        for name in shape:
577
1041
            self.assert_(isinstance(name, basestring))
578
1042
            if name[-1] == '/':
579
 
                os.mkdir(name[:-1])
 
1043
                transport.mkdir(urlutils.escape(name[:-1]))
580
1044
            else:
581
1045
                if line_endings == 'binary':
582
 
                    f = file(name, 'wb')
 
1046
                    end = '\n'
583
1047
                elif line_endings == 'native':
584
 
                    f = file(name, 'wt')
 
1048
                    end = os.linesep
585
1049
                else:
586
 
                    raise BzrError('Invalid line ending request %r' % (line_endings,))
587
 
                print >>f, "contents of", name
588
 
                f.close()
 
1050
                    raise errors.BzrError('Invalid line ending request %r' % (line_endings,))
 
1051
                content = "contents of %s%s" % (name.encode('utf-8'), end)
 
1052
                # Technically 'put()' is the right command. However, put
 
1053
                # uses an AtomicFile, which requires an extra rename into place
 
1054
                # As long as the files didn't exist in the past, append() will
 
1055
                # do the same thing as put()
 
1056
                # On jam's machine, make_kernel_like_tree is:
 
1057
                #   put:    4.5-7.5s (averaging 6s)
 
1058
                #   append: 2.9-4.5s
 
1059
                transport.append(urlutils.escape(name), StringIO(content))
589
1060
 
590
1061
    def build_tree_contents(self, shape):
591
1062
        build_tree_contents(shape)
601
1072
    def assertFileEqual(self, content, path):
602
1073
        """Fail if path does not contain 'content'."""
603
1074
        self.failUnless(osutils.lexists(path))
 
1075
        # TODO: jam 20060427 Shouldn't this be 'rb'?
604
1076
        self.assertEqualDiff(content, open(path, 'r').read())
605
1077
 
606
1078
 
 
1079
class TestCaseWithTransport(TestCaseInTempDir):
 
1080
    """A test case that provides get_url and get_readonly_url facilities.
 
1081
 
 
1082
    These back onto two transport servers, one for readonly access and one for
 
1083
    read write access.
 
1084
 
 
1085
    If no explicit class is provided for readonly access, a
 
1086
    ReadonlyTransportDecorator is used instead which allows the use of non disk
 
1087
    based read write transports.
 
1088
 
 
1089
    If an explicit class is provided for readonly access, that server and the 
 
1090
    readwrite one must both define get_url() as resolving to os.getcwd().
 
1091
    """
 
1092
 
 
1093
    def __init__(self, methodName='testMethod'):
 
1094
        super(TestCaseWithTransport, self).__init__(methodName)
 
1095
        self.__readonly_server = None
 
1096
        self.__server = None
 
1097
        self.transport_server = default_transport
 
1098
        self.transport_readonly_server = None
 
1099
 
 
1100
    def get_readonly_url(self, relpath=None):
 
1101
        """Get a URL for the readonly transport.
 
1102
 
 
1103
        This will either be backed by '.' or a decorator to the transport 
 
1104
        used by self.get_url()
 
1105
        relpath provides for clients to get a path relative to the base url.
 
1106
        These should only be downwards relative, not upwards.
 
1107
        """
 
1108
        base = self.get_readonly_server().get_url()
 
1109
        if relpath is not None:
 
1110
            if not base.endswith('/'):
 
1111
                base = base + '/'
 
1112
            base = base + relpath
 
1113
        return base
 
1114
 
 
1115
    def get_readonly_server(self):
 
1116
        """Get the server instance for the readonly transport
 
1117
 
 
1118
        This is useful for some tests with specific servers to do diagnostics.
 
1119
        """
 
1120
        if self.__readonly_server is None:
 
1121
            if self.transport_readonly_server is None:
 
1122
                # readonly decorator requested
 
1123
                # bring up the server
 
1124
                self.get_url()
 
1125
                self.__readonly_server = ReadonlyServer()
 
1126
                self.__readonly_server.setUp(self.__server)
 
1127
            else:
 
1128
                self.__readonly_server = self.transport_readonly_server()
 
1129
                self.__readonly_server.setUp()
 
1130
            self.addCleanup(self.__readonly_server.tearDown)
 
1131
        return self.__readonly_server
 
1132
 
 
1133
    def get_server(self):
 
1134
        """Get the read/write server instance.
 
1135
 
 
1136
        This is useful for some tests with specific servers that need
 
1137
        diagnostics.
 
1138
        """
 
1139
        if self.__server is None:
 
1140
            self.__server = self.transport_server()
 
1141
            self.__server.setUp()
 
1142
            self.addCleanup(self.__server.tearDown)
 
1143
        return self.__server
 
1144
 
 
1145
    def get_url(self, relpath=None):
 
1146
        """Get a URL for the readwrite transport.
 
1147
 
 
1148
        This will either be backed by '.' or to an equivalent non-file based
 
1149
        facility.
 
1150
        relpath provides for clients to get a path relative to the base url.
 
1151
        These should only be downwards relative, not upwards.
 
1152
        """
 
1153
        base = self.get_server().get_url()
 
1154
        if relpath is not None and relpath != '.':
 
1155
            if not base.endswith('/'):
 
1156
                base = base + '/'
 
1157
            base = base + urlutils.escape(relpath)
 
1158
        return base
 
1159
 
 
1160
    def get_transport(self):
 
1161
        """Return a writeable transport for the test scratch space"""
 
1162
        t = get_transport(self.get_url())
 
1163
        self.assertFalse(t.is_readonly())
 
1164
        return t
 
1165
 
 
1166
    def get_readonly_transport(self):
 
1167
        """Return a readonly transport for the test scratch space
 
1168
        
 
1169
        This can be used to test that operations which should only need
 
1170
        readonly access in fact do not try to write.
 
1171
        """
 
1172
        t = get_transport(self.get_readonly_url())
 
1173
        self.assertTrue(t.is_readonly())
 
1174
        return t
 
1175
 
 
1176
    def make_branch(self, relpath, format=None):
 
1177
        """Create a branch on the transport at relpath."""
 
1178
        repo = self.make_repository(relpath, format=format)
 
1179
        return repo.bzrdir.create_branch()
 
1180
 
 
1181
    def make_bzrdir(self, relpath, format=None):
 
1182
        try:
 
1183
            url = self.get_url(relpath)
 
1184
            mutter('relpath %r => url %r', relpath, url)
 
1185
            segments = url.split('/')
 
1186
            if segments and segments[-1] not in ('', '.'):
 
1187
                parent = '/'.join(segments[:-1])
 
1188
                t = get_transport(parent)
 
1189
                try:
 
1190
                    t.mkdir(segments[-1])
 
1191
                except errors.FileExists:
 
1192
                    pass
 
1193
            if format is None:
 
1194
                format=bzrlib.bzrdir.BzrDirFormat.get_default_format()
 
1195
            # FIXME: make this use a single transport someday. RBC 20060418
 
1196
            return format.initialize_on_transport(get_transport(relpath))
 
1197
        except errors.UninitializableFormat:
 
1198
            raise TestSkipped("Format %s is not initializable." % format)
 
1199
 
 
1200
    def make_repository(self, relpath, shared=False, format=None):
 
1201
        """Create a repository on our default transport at relpath."""
 
1202
        made_control = self.make_bzrdir(relpath, format=format)
 
1203
        return made_control.create_repository(shared=shared)
 
1204
 
 
1205
    def make_branch_and_tree(self, relpath, format=None):
 
1206
        """Create a branch on the transport and a tree locally.
 
1207
 
 
1208
        Returns the tree.
 
1209
        """
 
1210
        # TODO: always use the local disk path for the working tree,
 
1211
        # this obviously requires a format that supports branch references
 
1212
        # so check for that by checking bzrdir.BzrDirFormat.get_default_format()
 
1213
        # RBC 20060208
 
1214
        b = self.make_branch(relpath, format=format)
 
1215
        try:
 
1216
            return b.bzrdir.create_workingtree()
 
1217
        except errors.NotLocalUrl:
 
1218
            # new formats - catch No tree error and create
 
1219
            # a branch reference and a checkout.
 
1220
            # old formats at that point - raise TestSkipped.
 
1221
            # TODO: rbc 20060208
 
1222
            return WorkingTreeFormat2().initialize(bzrdir.BzrDir.open(relpath))
 
1223
 
 
1224
    def assertIsDirectory(self, relpath, transport):
 
1225
        """Assert that relpath within transport is a directory.
 
1226
 
 
1227
        This may not be possible on all transports; in that case it propagates
 
1228
        a TransportNotPossible.
 
1229
        """
 
1230
        try:
 
1231
            mode = transport.stat(relpath).st_mode
 
1232
        except errors.NoSuchFile:
 
1233
            self.fail("path %s is not a directory; no such file"
 
1234
                      % (relpath))
 
1235
        if not stat.S_ISDIR(mode):
 
1236
            self.fail("path %s is not a directory; has mode %#o"
 
1237
                      % (relpath, mode))
 
1238
 
 
1239
 
 
1240
class ChrootedTestCase(TestCaseWithTransport):
 
1241
    """A support class that provides readonly urls outside the local namespace.
 
1242
 
 
1243
    This is done by checking if self.transport_server is a MemoryServer. if it
 
1244
    is then we are chrooted already, if it is not then an HttpServer is used
 
1245
    for readonly urls.
 
1246
 
 
1247
    TODO RBC 20060127: make this an option to TestCaseWithTransport so it can
 
1248
                       be used without needed to redo it when a different 
 
1249
                       subclass is in use ?
 
1250
    """
 
1251
 
 
1252
    def setUp(self):
 
1253
        super(ChrootedTestCase, self).setUp()
 
1254
        if not self.transport_server == bzrlib.transport.memory.MemoryServer:
 
1255
            self.transport_readonly_server = bzrlib.transport.http.HttpServer
 
1256
 
 
1257
 
607
1258
def filter_suite_by_re(suite, pattern):
608
 
    result = TestSuite()
 
1259
    result = TestUtil.TestSuite()
609
1260
    filter_re = re.compile(pattern)
610
1261
    for test in iter_suite_tests(suite):
611
1262
        if filter_re.search(test.id()):
614
1265
 
615
1266
 
616
1267
def run_suite(suite, name='test', verbose=False, pattern=".*",
617
 
              stop_on_failure=False, keep_output=False):
 
1268
              stop_on_failure=False, keep_output=False,
 
1269
              transport=None, lsprof_timed=None, bench_history=None):
618
1270
    TestCaseInTempDir._TEST_NAME = name
 
1271
    TestCase._gather_lsprof_in_benchmarks = lsprof_timed
619
1272
    if verbose:
620
1273
        verbosity = 2
 
1274
        pb = None
621
1275
    else:
622
1276
        verbosity = 1
 
1277
        pb = progress.ProgressBar()
623
1278
    runner = TextTestRunner(stream=sys.stdout,
624
1279
                            descriptions=0,
625
 
                            verbosity=verbosity)
 
1280
                            verbosity=verbosity,
 
1281
                            keep_output=keep_output,
 
1282
                            pb=pb,
 
1283
                            bench_history=bench_history)
626
1284
    runner.stop_on_failure=stop_on_failure
627
1285
    if pattern != '.*':
628
1286
        suite = filter_suite_by_re(suite, pattern)
629
1287
    result = runner.run(suite)
630
 
    # This is still a little bogus, 
631
 
    # but only a little. Folk not using our testrunner will
632
 
    # have to delete their temp directories themselves.
633
 
    if result.wasSuccessful() or not keep_output:
634
 
        if TestCaseInTempDir.TEST_ROOT is not None:
635
 
            shutil.rmtree(TestCaseInTempDir.TEST_ROOT) 
636
 
    else:
637
 
        print "Failed tests working directories are in '%s'\n" % TestCaseInTempDir.TEST_ROOT
638
1288
    return result.wasSuccessful()
639
1289
 
640
1290
 
641
1291
def selftest(verbose=False, pattern=".*", stop_on_failure=True,
642
 
             keep_output=False):
 
1292
             keep_output=False,
 
1293
             transport=None,
 
1294
             test_suite_factory=None,
 
1295
             lsprof_timed=None,
 
1296
             bench_history=None):
643
1297
    """Run the whole test suite under the enhanced runner"""
644
 
    return run_suite(test_suite(), 'testbzr', verbose=verbose, pattern=pattern,
645
 
                     stop_on_failure=stop_on_failure, keep_output=keep_output)
 
1298
    # XXX: Very ugly way to do this...
 
1299
    # Disable warning about old formats because we don't want it to disturb
 
1300
    # any blackbox tests.
 
1301
    from bzrlib import repository
 
1302
    repository._deprecation_warning_done = True
 
1303
 
 
1304
    global default_transport
 
1305
    if transport is None:
 
1306
        transport = default_transport
 
1307
    old_transport = default_transport
 
1308
    default_transport = transport
 
1309
    try:
 
1310
        if test_suite_factory is None:
 
1311
            suite = test_suite()
 
1312
        else:
 
1313
            suite = test_suite_factory()
 
1314
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
 
1315
                     stop_on_failure=stop_on_failure, keep_output=keep_output,
 
1316
                     transport=transport,
 
1317
                     lsprof_timed=lsprof_timed,
 
1318
                     bench_history=bench_history)
 
1319
    finally:
 
1320
        default_transport = old_transport
646
1321
 
647
1322
 
648
1323
def test_suite():
649
 
    """Build and return TestSuite for the whole program."""
650
 
    from doctest import DocTestSuite
651
 
 
652
 
    global MODULES_TO_DOCTEST
653
 
 
654
 
    testmod_names = [ \
 
1324
    """Build and return TestSuite for the whole of bzrlib.
 
1325
    
 
1326
    This function can be replaced if you need to change the default test
 
1327
    suite on a global basis, but it is not encouraged.
 
1328
    """
 
1329
    testmod_names = [
655
1330
                   'bzrlib.tests.test_ancestry',
656
 
                   'bzrlib.tests.test_annotate',
657
1331
                   'bzrlib.tests.test_api',
 
1332
                   'bzrlib.tests.test_atomicfile',
658
1333
                   'bzrlib.tests.test_bad_files',
659
 
                   'bzrlib.tests.test_basis_inventory',
660
1334
                   'bzrlib.tests.test_branch',
 
1335
                   'bzrlib.tests.test_bundle',
 
1336
                   'bzrlib.tests.test_bzrdir',
 
1337
                   'bzrlib.tests.test_cache_utf8',
661
1338
                   'bzrlib.tests.test_command',
662
1339
                   'bzrlib.tests.test_commit',
663
1340
                   'bzrlib.tests.test_commit_merge',
664
1341
                   'bzrlib.tests.test_config',
665
1342
                   'bzrlib.tests.test_conflicts',
 
1343
                   'bzrlib.tests.test_decorators',
666
1344
                   'bzrlib.tests.test_diff',
 
1345
                   'bzrlib.tests.test_doc_generate',
 
1346
                   'bzrlib.tests.test_errors',
 
1347
                   'bzrlib.tests.test_escaped_store',
667
1348
                   'bzrlib.tests.test_fetch',
668
1349
                   'bzrlib.tests.test_gpg',
669
1350
                   'bzrlib.tests.test_graph',
670
1351
                   'bzrlib.tests.test_hashcache',
671
1352
                   'bzrlib.tests.test_http',
 
1353
                   'bzrlib.tests.test_http_response',
672
1354
                   'bzrlib.tests.test_identitymap',
 
1355
                   'bzrlib.tests.test_ignores',
673
1356
                   'bzrlib.tests.test_inv',
 
1357
                   'bzrlib.tests.test_knit',
 
1358
                   'bzrlib.tests.test_lockdir',
 
1359
                   'bzrlib.tests.test_lockable_files',
674
1360
                   'bzrlib.tests.test_log',
675
1361
                   'bzrlib.tests.test_merge',
676
1362
                   'bzrlib.tests.test_merge3',
680
1366
                   'bzrlib.tests.test_nonascii',
681
1367
                   'bzrlib.tests.test_options',
682
1368
                   'bzrlib.tests.test_osutils',
683
 
                   'bzrlib.tests.test_parent',
 
1369
                   'bzrlib.tests.test_patch',
 
1370
                   'bzrlib.tests.test_patches',
684
1371
                   'bzrlib.tests.test_permissions',
685
1372
                   'bzrlib.tests.test_plugins',
686
 
                   'bzrlib.tests.test_remove',
 
1373
                   'bzrlib.tests.test_progress',
 
1374
                   'bzrlib.tests.test_reconcile',
 
1375
                   'bzrlib.tests.test_repository',
 
1376
                   'bzrlib.tests.test_revert',
687
1377
                   'bzrlib.tests.test_revision',
688
1378
                   'bzrlib.tests.test_revisionnamespaces',
689
 
                   'bzrlib.tests.test_revprops',
690
 
                   'bzrlib.tests.test_reweave',
 
1379
                   'bzrlib.tests.test_revisiontree',
691
1380
                   'bzrlib.tests.test_rio',
692
1381
                   'bzrlib.tests.test_sampler',
693
1382
                   'bzrlib.tests.test_selftest',
694
1383
                   'bzrlib.tests.test_setup',
695
1384
                   'bzrlib.tests.test_sftp_transport',
 
1385
                   'bzrlib.tests.test_ftp_transport',
696
1386
                   'bzrlib.tests.test_smart_add',
697
1387
                   'bzrlib.tests.test_source',
698
1388
                   'bzrlib.tests.test_status',
699
1389
                   'bzrlib.tests.test_store',
700
1390
                   'bzrlib.tests.test_symbol_versioning',
701
1391
                   'bzrlib.tests.test_testament',
 
1392
                   'bzrlib.tests.test_textfile',
 
1393
                   'bzrlib.tests.test_textmerge',
702
1394
                   'bzrlib.tests.test_trace',
703
1395
                   'bzrlib.tests.test_transactions',
 
1396
                   'bzrlib.tests.test_transform',
704
1397
                   'bzrlib.tests.test_transport',
 
1398
                   'bzrlib.tests.test_tree',
705
1399
                   'bzrlib.tests.test_tsort',
 
1400
                   'bzrlib.tests.test_tuned_gzip',
706
1401
                   'bzrlib.tests.test_ui',
707
 
                   'bzrlib.tests.test_uncommit',
708
1402
                   'bzrlib.tests.test_upgrade',
 
1403
                   'bzrlib.tests.test_urlutils',
 
1404
                   'bzrlib.tests.test_versionedfile',
 
1405
                   'bzrlib.tests.test_version',
709
1406
                   'bzrlib.tests.test_weave',
710
1407
                   'bzrlib.tests.test_whitebox',
711
1408
                   'bzrlib.tests.test_workingtree',
712
1409
                   'bzrlib.tests.test_xml',
713
1410
                   ]
714
 
 
715
 
    TestCase.BZRPATH = osutils.pathjoin(
716
 
            osutils.realpath(osutils.dirname(bzrlib.__path__[0])), 'bzr')
717
 
    print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
718
 
    print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
719
 
    print
720
 
    suite = TestSuite()
721
 
    # python2.4's TestLoader.loadTestsFromNames gives very poor 
722
 
    # errors if it fails to load a named module - no indication of what's
723
 
    # actually wrong, just "no such module".  We should probably override that
724
 
    # class, but for the moment just load them ourselves. (mbp 20051202)
725
 
    loader = TestLoader()
726
 
    for mod_name in testmod_names:
727
 
        mod = _load_module_by_name(mod_name)
728
 
        suite.addTest(loader.loadTestsFromModule(mod))
 
1411
    test_transport_implementations = [
 
1412
        'bzrlib.tests.test_transport_implementations',
 
1413
        'bzrlib.tests.test_read_bundle',
 
1414
        ]
 
1415
    suite = TestUtil.TestSuite()
 
1416
    loader = TestUtil.TestLoader()
 
1417
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
 
1418
    from bzrlib.transport import TransportTestProviderAdapter
 
1419
    adapter = TransportTestProviderAdapter()
 
1420
    adapt_modules(test_transport_implementations, adapter, loader, suite)
729
1421
    for package in packages_to_test():
730
1422
        suite.addTest(package.test_suite())
731
1423
    for m in MODULES_TO_TEST:
732
1424
        suite.addTest(loader.loadTestsFromModule(m))
733
 
    for m in (MODULES_TO_DOCTEST):
734
 
        suite.addTest(DocTestSuite(m))
 
1425
    for m in MODULES_TO_DOCTEST:
 
1426
        suite.addTest(doctest.DocTestSuite(m))
735
1427
    for name, plugin in bzrlib.plugin.all_plugins().items():
736
 
        if hasattr(plugin, 'test_suite'):
 
1428
        if getattr(plugin, 'test_suite', None) is not None:
737
1429
            suite.addTest(plugin.test_suite())
738
1430
    return suite
739
1431
 
740
1432
 
741
 
def _load_module_by_name(mod_name):
742
 
    parts = mod_name.split('.')
743
 
    module = __import__(mod_name)
744
 
    del parts[0]
745
 
    # for historical reasons python returns the top-level module even though
746
 
    # it loads the submodule; we need to walk down to get the one we want.
747
 
    while parts:
748
 
        module = getattr(module, parts.pop(0))
749
 
    return module
 
1433
def adapt_modules(mods_list, adapter, loader, suite):
 
1434
    """Adapt the modules in mods_list using adapter and add to suite."""
 
1435
    for test in iter_suite_tests(loader.loadTestsFromModuleNames(mods_list)):
 
1436
        suite.addTests(adapter.adapt(test))