← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

sync with bzr.dev mainline

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
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
 
18
24
from cStringIO import StringIO
19
25
import difflib
20
26
import errno
22
28
import os
23
29
import re
24
30
import shutil
 
31
import stat
25
32
import sys
26
33
import tempfile
27
34
import unittest
28
35
import time
 
36
import codecs
29
37
 
 
38
import bzrlib.branch
30
39
import bzrlib.commands
 
40
from bzrlib.errors import BzrError
 
41
import bzrlib.inventory
 
42
import bzrlib.merge3
 
43
import bzrlib.osutils
 
44
import bzrlib.osutils as osutils
 
45
import bzrlib.plugin
 
46
import bzrlib.store
31
47
import bzrlib.trace
32
 
import bzrlib.fetch
33
 
import bzrlib.osutils as osutils
34
 
from bzrlib.selftest import TestUtil
35
 
from bzrlib.selftest.TestUtil import TestLoader, TestSuite
36
 
 
 
48
from bzrlib.transport import urlescape
 
49
from bzrlib.trace import mutter
 
50
from bzrlib.tests.TestUtil import TestLoader, TestSuite
 
51
from bzrlib.tests.treeshape import build_tree_contents
37
52
 
38
53
MODULES_TO_TEST = []
39
 
MODULES_TO_DOCTEST = []
40
 
 
41
 
from logging import debug, warning, error
42
 
 
 
54
MODULES_TO_DOCTEST = [
 
55
                      bzrlib.branch,
 
56
                      bzrlib.commands,
 
57
                      bzrlib.errors,
 
58
                      bzrlib.inventory,
 
59
                      bzrlib.merge3,
 
60
                      bzrlib.osutils,
 
61
                      bzrlib.store,
 
62
                      ]
 
63
def packages_to_test():
 
64
    import bzrlib.tests.blackbox
 
65
    return [
 
66
            bzrlib.tests.blackbox
 
67
            ]
43
68
 
44
69
 
45
70
class EarlyStoppingTestResultAdapter(object):
66
91
 
67
92
 
68
93
class _MyResult(unittest._TextTestResult):
69
 
    """
70
 
    Custom TestResult.
 
94
    """Custom TestResult.
71
95
 
72
 
    No special behaviour for now.
 
96
    Shows output in a different format, including displaying runtime for tests.
73
97
    """
74
98
 
75
99
    def _elapsedTime(self):
76
 
        return "(Took %.3fs)" % (time.time() - self._start_time)
 
100
        return "%5dms" % (1000 * (time.time() - self._start_time))
77
101
 
78
102
    def startTest(self, test):
79
103
        unittest.TestResult.startTest(self, test)
80
 
        # TODO: Maybe show test.shortDescription somewhere?
81
 
        what = test.shortDescription() or test.id()        
 
104
        # In a short description, the important words are in
 
105
        # the beginning, but in an id, the important words are
 
106
        # at the end
 
107
        SHOW_DESCRIPTIONS = False
82
108
        if self.showAll:
83
 
            self.stream.write('%-70.70s' % what)
 
109
            width = osutils.terminal_width()
 
110
            name_width = width - 15
 
111
            what = None
 
112
            if SHOW_DESCRIPTIONS:
 
113
                what = test.shortDescription()
 
114
                if what:
 
115
                    if len(what) > name_width:
 
116
                        what = what[:name_width-3] + '...'
 
117
            if what is None:
 
118
                what = test.id()
 
119
                if what.startswith('bzrlib.tests.'):
 
120
                    what = what[13:]
 
121
                if len(what) > name_width:
 
122
                    what = '...' + what[3-name_width:]
 
123
            what = what.ljust(name_width)
 
124
            self.stream.write(what)
84
125
        self.stream.flush()
85
126
        self._start_time = time.time()
86
127
 
87
128
    def addError(self, test, err):
 
129
        if isinstance(err[1], TestSkipped):
 
130
            return self.addSkipped(test, err)    
88
131
        unittest.TestResult.addError(self, test, err)
89
132
        if self.showAll:
90
133
            self.stream.writeln("ERROR %s" % self._elapsedTime())
95
138
    def addFailure(self, test, err):
96
139
        unittest.TestResult.addFailure(self, test, err)
97
140
        if self.showAll:
98
 
            self.stream.writeln("FAIL %s" % self._elapsedTime())
 
141
            self.stream.writeln(" FAIL %s" % self._elapsedTime())
99
142
        elif self.dots:
100
143
            self.stream.write('F')
101
144
        self.stream.flush()
102
145
 
103
146
    def addSuccess(self, test):
104
147
        if self.showAll:
105
 
            self.stream.writeln('OK %s' % self._elapsedTime())
 
148
            self.stream.writeln('   OK %s' % self._elapsedTime())
106
149
        elif self.dots:
107
150
            self.stream.write('~')
108
151
        self.stream.flush()
109
152
        unittest.TestResult.addSuccess(self, test)
110
153
 
 
154
    def addSkipped(self, test, skip_excinfo):
 
155
        if self.showAll:
 
156
            print >>self.stream, ' SKIP %s' % self._elapsedTime()
 
157
            print >>self.stream, '     %s' % skip_excinfo[1]
 
158
        elif self.dots:
 
159
            self.stream.write('S')
 
160
        self.stream.flush()
 
161
        # seems best to treat this as success from point-of-view of unittest
 
162
        # -- it actually does nothing so it barely matters :)
 
163
        unittest.TestResult.addSuccess(self, test)
 
164
 
111
165
    def printErrorList(self, flavour, errors):
112
166
        for test, err in errors:
113
167
            self.stream.writeln(self.separator1)
114
 
            self.stream.writeln("%s: %s" % (flavour,self.getDescription(test)))
 
168
            self.stream.writeln("%s: %s" % (flavour, self.getDescription(test)))
115
169
            if hasattr(test, '_get_log'):
116
 
                self.stream.writeln()
117
 
                self.stream.writeln('log from this test:')
 
170
                print >>self.stream
 
171
                print >>self.stream, \
 
172
                        ('vvvv[log from %s]' % test.id()).ljust(78,'-')
118
173
                print >>self.stream, test._get_log()
 
174
                print >>self.stream, \
 
175
                        ('^^^^[log from %s]' % test.id()).ljust(78,'-')
119
176
            self.stream.writeln(self.separator2)
120
177
            self.stream.writeln("%s" % err)
121
178
 
122
179
 
123
180
class TextTestRunner(unittest.TextTestRunner):
 
181
    stop_on_failure = False
124
182
 
125
183
    def _makeResult(self):
126
184
        result = _MyResult(self.stream, self.descriptions, self.verbosity)
127
 
        return EarlyStoppingTestResultAdapter(result)
 
185
        if self.stop_on_failure:
 
186
            result = EarlyStoppingTestResultAdapter(result)
 
187
        return result
128
188
 
129
189
 
130
190
def iter_suite_tests(suite):
156
216
 
157
217
    Error and debug log messages are redirected from their usual
158
218
    location into a temporary file, the contents of which can be
159
 
    retrieved by _get_log().
 
219
    retrieved by _get_log().  We use a real OS file, not an in-memory object,
 
220
    so that it can also capture file IO.  When the test completes this file
 
221
    is read into memory and removed from disk.
160
222
       
161
223
    There are also convenience functions to invoke bzr's command-line
162
 
    routine, and to build and check bzr trees."""
 
224
    routine, and to build and check bzr trees.
 
225
   
 
226
    In addition to the usual method of overriding tearDown(), this class also
 
227
    allows subclasses to register functions into the _cleanups list, which is
 
228
    run in order as the object is torn down.  It's less likely this will be
 
229
    accidentally overlooked.
 
230
    """
163
231
 
164
232
    BZRPATH = 'bzr'
165
233
    _log_file_name = None
 
234
    _log_contents = ''
166
235
 
167
236
    def setUp(self):
168
237
        unittest.TestCase.setUp(self)
 
238
        self._cleanups = []
 
239
        self._cleanEnvironment()
169
240
        bzrlib.trace.disable_default_logging()
170
 
        self._enable_file_logging()
 
241
        self._startLogFile()
171
242
 
172
243
    def _ndiff_strings(self, a, b):
173
 
        """Return ndiff between two strings containing lines."""
 
244
        """Return ndiff between two strings containing lines.
 
245
        
 
246
        A trailing newline is added if missing to make the strings
 
247
        print properly."""
 
248
        if b and b[-1] != '\n':
 
249
            b += '\n'
 
250
        if a and a[-1] != '\n':
 
251
            a += '\n'
174
252
        difflines = difflib.ndiff(a.splitlines(True),
175
253
                                  b.splitlines(True),
176
254
                                  linejunk=lambda x: False,
189
267
        raise AssertionError("texts not equal:\n" + 
190
268
                             self._ndiff_strings(a, b))      
191
269
        
192
 
    def _enable_file_logging(self):
 
270
    def assertStartsWith(self, s, prefix):
 
271
        if not s.startswith(prefix):
 
272
            raise AssertionError('string %r does not start with %r' % (s, prefix))
 
273
 
 
274
    def assertEndsWith(self, s, suffix):
 
275
        if not s.endswith(prefix):
 
276
            raise AssertionError('string %r does not end with %r' % (s, suffix))
 
277
 
 
278
    def assertContainsRe(self, haystack, needle_re):
 
279
        """Assert that a contains something matching a regular expression."""
 
280
        if not re.search(needle_re, haystack):
 
281
            raise AssertionError('pattern "%s" not found in "%s"'
 
282
                    % (needle_re, haystack))
 
283
 
 
284
    def AssertSubset(self, sublist, superlist):
 
285
        """Assert that every entry in sublist is present in superlist."""
 
286
        missing = []
 
287
        for entry in sublist:
 
288
            if entry not in superlist:
 
289
                missing.append(entry)
 
290
        if len(missing) > 0:
 
291
            raise AssertionError("value(s) %r not present in container %r" % 
 
292
                                 (missing, superlist))
 
293
 
 
294
    def assertTransportMode(self, transport, path, mode):
 
295
        """Fail if a path does not have mode mode.
 
296
        
 
297
        If modes are not supported on this platform, the test is skipped.
 
298
        """
 
299
        if sys.platform == 'win32':
 
300
            return
 
301
        path_stat = transport.stat(path)
 
302
        actual_mode = stat.S_IMODE(path_stat.st_mode)
 
303
        self.assertEqual(mode, actual_mode,
 
304
            'mode of %r incorrect (%o != %o)' % (path, mode, actual_mode))
 
305
 
 
306
    def _startLogFile(self):
 
307
        """Send bzr and test log messages to a temporary file.
 
308
 
 
309
        The file is removed as the test is torn down.
 
310
        """
193
311
        fileno, name = tempfile.mkstemp(suffix='.log', prefix='testbzr')
194
 
 
195
 
        self._log_file = os.fdopen(fileno, 'w+')
196
 
 
197
 
        hdlr = logging.StreamHandler(self._log_file)
198
 
        hdlr.setLevel(logging.DEBUG)
199
 
        hdlr.setFormatter(logging.Formatter('%(levelname)8s  %(message)s'))
200
 
        logging.getLogger('').addHandler(hdlr)
201
 
        logging.getLogger('').setLevel(logging.DEBUG)
202
 
        self._log_hdlr = hdlr
203
 
        debug('opened log file %s', name)
204
 
        
 
312
        encoder, decoder, stream_reader, stream_writer = codecs.lookup('UTF-8')
 
313
        self._log_file = stream_writer(os.fdopen(fileno, 'w+'))
 
314
        bzrlib.trace.enable_test_log(self._log_file)
205
315
        self._log_file_name = name
206
 
 
207
 
    def tearDown(self):
208
 
        logging.getLogger('').removeHandler(self._log_hdlr)
209
 
        bzrlib.trace.enable_default_logging()
210
 
        logging.debug('%s teardown', self.id())
 
316
        self.addCleanup(self._finishLogFile)
 
317
 
 
318
    def _finishLogFile(self):
 
319
        """Finished with the log file.
 
320
 
 
321
        Read contents into memory, close, and delete.
 
322
        """
 
323
        bzrlib.trace.disable_test_log()
 
324
        self._log_file.seek(0)
 
325
        self._log_contents = self._log_file.read()
211
326
        self._log_file.close()
 
327
        os.remove(self._log_file_name)
 
328
        self._log_file = self._log_file_name = None
 
329
 
 
330
    def addCleanup(self, callable):
 
331
        """Arrange to run a callable when this case is torn down.
 
332
 
 
333
        Callables are run in the reverse of the order they are registered, 
 
334
        ie last-in first-out.
 
335
        """
 
336
        if callable in self._cleanups:
 
337
            raise ValueError("cleanup function %r already registered on %s" 
 
338
                    % (callable, self))
 
339
        self._cleanups.append(callable)
 
340
 
 
341
    def _cleanEnvironment(self):
 
342
        new_env = {
 
343
            'HOME': os.getcwd(),
 
344
            'APPDATA': os.getcwd(),
 
345
            'BZREMAIL': None,
 
346
            'EMAIL': None,
 
347
        }
 
348
        self.__old_env = {}
 
349
        self.addCleanup(self._restoreEnvironment)
 
350
        for name, value in new_env.iteritems():
 
351
            self._captureVar(name, value)
 
352
 
 
353
 
 
354
    def _captureVar(self, name, newvalue):
 
355
        """Set an environment variable, preparing it to be reset when finished."""
 
356
        self.__old_env[name] = os.environ.get(name, None)
 
357
        if newvalue is None:
 
358
            if name in os.environ:
 
359
                del os.environ[name]
 
360
        else:
 
361
            os.environ[name] = newvalue
 
362
 
 
363
    @staticmethod
 
364
    def _restoreVar(name, value):
 
365
        if value is None:
 
366
            if name in os.environ:
 
367
                del os.environ[name]
 
368
        else:
 
369
            os.environ[name] = value
 
370
 
 
371
    def _restoreEnvironment(self):
 
372
        for name, value in self.__old_env.iteritems():
 
373
            self._restoreVar(name, value)
 
374
 
 
375
    def tearDown(self):
 
376
        self._runCleanups()
212
377
        unittest.TestCase.tearDown(self)
213
378
 
 
379
    def _runCleanups(self):
 
380
        """Run registered cleanup functions. 
 
381
 
 
382
        This should only be called from TestCase.tearDown.
 
383
        """
 
384
        # TODO: Perhaps this should keep running cleanups even if 
 
385
        # one of them fails?
 
386
        for cleanup_fn in reversed(self._cleanups):
 
387
            cleanup_fn()
 
388
 
214
389
    def log(self, *args):
215
 
        logging.debug(*args)
 
390
        mutter(*args)
216
391
 
217
392
    def _get_log(self):
218
393
        """Return as a string the log for this test"""
219
394
        if self._log_file_name:
220
395
            return open(self._log_file_name).read()
221
396
        else:
222
 
            return ''
 
397
            return self._log_contents
 
398
        # TODO: Delete the log after it's been read in
223
399
 
224
 
    def capture(self, cmd):
 
400
    def capture(self, cmd, retcode=0):
225
401
        """Shortcut that splits cmd into words, runs, and returns stdout"""
226
 
        return self.run_bzr_captured(cmd.split())[0]
 
402
        return self.run_bzr_captured(cmd.split(), retcode=retcode)[0]
227
403
 
228
404
    def run_bzr_captured(self, argv, retcode=0):
229
 
        """Invoke bzr and return (result, stdout, stderr).
 
405
        """Invoke bzr and return (stdout, stderr).
230
406
 
231
407
        Useful for code that wants to check the contents of the
232
408
        output, the way error messages are presented, etc.
248
424
        stdout = StringIO()
249
425
        stderr = StringIO()
250
426
        self.log('run bzr: %s', ' '.join(argv))
 
427
        # FIXME: don't call into logging here
251
428
        handler = logging.StreamHandler(stderr)
252
429
        handler.setFormatter(bzrlib.trace.QuietFormatter())
253
430
        handler.setLevel(logging.INFO)
368
545
            return
369
546
        i = 0
370
547
        while True:
371
 
            root = 'test%04d.tmp' % i
 
548
            root = u'test%04d.tmp' % i
372
549
            try:
373
550
                os.mkdir(root)
374
551
            except OSError, e:
378
555
                else:
379
556
                    raise
380
557
            # successfully created
381
 
            TestCaseInTempDir.TEST_ROOT = os.path.abspath(root)
 
558
            TestCaseInTempDir.TEST_ROOT = osutils.abspath(root)
382
559
            break
383
560
        # make a fake bzr directory there to prevent any tests propagating
384
561
        # up onto the source directory's real branch
385
 
        os.mkdir(os.path.join(TestCaseInTempDir.TEST_ROOT, '.bzr'))
 
562
        os.mkdir(osutils.pathjoin(TestCaseInTempDir.TEST_ROOT, '.bzr'))
386
563
 
387
564
    def setUp(self):
388
565
        super(TestCaseInTempDir, self).setUp()
389
566
        self._make_test_root()
390
 
        self._currentdir = os.getcwdu()
391
 
        short_id = self.id().replace('bzrlib.selftest.', '') \
 
567
        _currentdir = os.getcwdu()
 
568
        short_id = self.id().replace('bzrlib.tests.', '') \
392
569
                   .replace('__main__.', '')
393
 
        self.test_dir = os.path.join(self.TEST_ROOT, short_id)
 
570
        self.test_dir = osutils.pathjoin(self.TEST_ROOT, short_id)
394
571
        os.mkdir(self.test_dir)
395
572
        os.chdir(self.test_dir)
 
573
        os.environ['HOME'] = self.test_dir
 
574
        os.environ['APPDATA'] = self.test_dir
 
575
        def _leaveDirectory():
 
576
            os.chdir(_currentdir)
 
577
        self.addCleanup(_leaveDirectory)
396
578
        
397
 
    def tearDown(self):
398
 
        os.chdir(self._currentdir)
399
 
        super(TestCaseInTempDir, self).tearDown()
400
 
 
401
 
    def build_tree(self, shape):
 
579
    def build_tree(self, shape, line_endings='native', transport=None):
402
580
        """Build a test tree according to a pattern.
403
581
 
404
582
        shape is a sequence of file specifications.  If the final
405
583
        character is '/', a directory is created.
406
584
 
407
585
        This doesn't add anything to a branch.
 
586
        :param line_endings: Either 'binary' or 'native'
 
587
                             in binary mode, exact contents are written
 
588
                             in native mode, the line endings match the
 
589
                             default platform endings.
 
590
 
 
591
        :param transport: A transport to write to, for building trees on 
 
592
                          VFS's. If the transport is readonly or None,
 
593
                          "." is opened automatically.
408
594
        """
409
595
        # XXX: It's OK to just create them using forward slashes on windows?
 
596
        if transport is None or transport.is_readonly():
 
597
            transport = bzrlib.transport.get_transport(".")
410
598
        for name in shape:
411
 
            assert isinstance(name, basestring)
 
599
            self.assert_(isinstance(name, basestring))
412
600
            if name[-1] == '/':
413
 
                os.mkdir(name[:-1])
 
601
                transport.mkdir(urlescape(name[:-1]))
414
602
            else:
415
 
                f = file(name, 'wt')
416
 
                print >>f, "contents of", name
417
 
                f.close()
 
603
                if line_endings == 'binary':
 
604
                    end = '\n'
 
605
                elif line_endings == 'native':
 
606
                    end = os.linesep
 
607
                else:
 
608
                    raise BzrError('Invalid line ending request %r' % (line_endings,))
 
609
                content = "contents of %s%s" % (name, end)
 
610
                transport.put(urlescape(name), StringIO(content))
 
611
 
 
612
    def build_tree_contents(self, shape):
 
613
        build_tree_contents(shape)
418
614
 
419
615
    def failUnlessExists(self, path):
420
616
        """Fail unless path, which may be abs or relative, exists."""
421
617
        self.failUnless(osutils.lexists(path))
 
618
 
 
619
    def failIfExists(self, path):
 
620
        """Fail if path, which may be abs or relative, exists."""
 
621
        self.failIf(osutils.lexists(path))
422
622
        
423
 
 
424
 
class MetaTestLog(TestCase):
425
 
    def test_logging(self):
426
 
        """Test logs are captured when a test fails."""
427
 
        logging.info('an info message')
428
 
        warning('something looks dodgy...')
429
 
        logging.debug('hello, test is running')
430
 
        ##assert 0
 
623
    def assertFileEqual(self, content, path):
 
624
        """Fail if path does not contain 'content'."""
 
625
        self.failUnless(osutils.lexists(path))
 
626
        self.assertEqualDiff(content, open(path, 'r').read())
431
627
 
432
628
 
433
629
def filter_suite_by_re(suite, pattern):
434
 
    result = TestUtil.TestSuite()
 
630
    result = TestSuite()
435
631
    filter_re = re.compile(pattern)
436
632
    for test in iter_suite_tests(suite):
437
633
        if filter_re.search(test.id()):
439
635
    return result
440
636
 
441
637
 
442
 
def run_suite(suite, name='test', verbose=False, pattern=".*"):
 
638
def run_suite(suite, name='test', verbose=False, pattern=".*",
 
639
              stop_on_failure=False, keep_output=False):
443
640
    TestCaseInTempDir._TEST_NAME = name
444
641
    if verbose:
445
642
        verbosity = 2
448
645
    runner = TextTestRunner(stream=sys.stdout,
449
646
                            descriptions=0,
450
647
                            verbosity=verbosity)
 
648
    runner.stop_on_failure=stop_on_failure
451
649
    if pattern != '.*':
452
650
        suite = filter_suite_by_re(suite, pattern)
453
651
    result = runner.run(suite)
454
652
    # This is still a little bogus, 
455
653
    # but only a little. Folk not using our testrunner will
456
654
    # have to delete their temp directories themselves.
457
 
    if result.wasSuccessful():
 
655
    if result.wasSuccessful() or not keep_output:
458
656
        if TestCaseInTempDir.TEST_ROOT is not None:
459
657
            shutil.rmtree(TestCaseInTempDir.TEST_ROOT) 
460
658
    else:
462
660
    return result.wasSuccessful()
463
661
 
464
662
 
465
 
def selftest(verbose=False, pattern=".*"):
 
663
def selftest(verbose=False, pattern=".*", stop_on_failure=True,
 
664
             keep_output=False):
466
665
    """Run the whole test suite under the enhanced runner"""
467
 
    return run_suite(test_suite(), 'testbzr', verbose=verbose, pattern=pattern)
 
666
    return run_suite(test_suite(), 'testbzr', verbose=verbose, pattern=pattern,
 
667
                     stop_on_failure=stop_on_failure, keep_output=keep_output)
468
668
 
469
669
 
470
670
def test_suite():
471
671
    """Build and return TestSuite for the whole program."""
472
 
    import bzrlib.store, bzrlib.inventory, bzrlib.branch
473
 
    import bzrlib.osutils, bzrlib.merge3, bzrlib.plugin
474
672
    from doctest import DocTestSuite
475
673
 
476
 
    global MODULES_TO_TEST, MODULES_TO_DOCTEST
 
674
    global MODULES_TO_DOCTEST
477
675
 
478
 
    testmod_names = \
479
 
                  ['bzrlib.selftest.MetaTestLog',
480
 
                   'bzrlib.selftest.testidentitymap',
481
 
                   'bzrlib.selftest.testinv',
482
 
                   'bzrlib.selftest.test_ancestry',
483
 
                   'bzrlib.selftest.test_commit',
484
 
                   'bzrlib.selftest.test_commit_merge',
485
 
                   'bzrlib.selftest.testconfig',
486
 
                   'bzrlib.selftest.versioning',
487
 
                   'bzrlib.selftest.testmerge3',
488
 
                   'bzrlib.selftest.testmerge',
489
 
                   'bzrlib.selftest.testhashcache',
490
 
                   'bzrlib.selftest.teststatus',
491
 
                   'bzrlib.selftest.testlog',
492
 
                   'bzrlib.selftest.testrevisionnamespaces',
493
 
                   'bzrlib.selftest.testbranch',
494
 
                   'bzrlib.selftest.testrevision',
495
 
                   'bzrlib.selftest.test_revision_info',
496
 
                   'bzrlib.selftest.test_merge_core',
497
 
                   'bzrlib.selftest.test_smart_add',
498
 
                   'bzrlib.selftest.test_bad_files',
499
 
                   'bzrlib.selftest.testdiff',
500
 
                   'bzrlib.selftest.test_parent',
501
 
                   'bzrlib.selftest.test_xml',
502
 
                   'bzrlib.selftest.test_weave',
503
 
                   'bzrlib.selftest.testfetch',
504
 
                   'bzrlib.selftest.whitebox',
505
 
                   'bzrlib.selftest.teststore',
506
 
                   'bzrlib.selftest.blackbox',
507
 
                   'bzrlib.selftest.testsampler',
508
 
                   'bzrlib.selftest.testtransactions',
509
 
                   'bzrlib.selftest.testtransport',
510
 
                   'bzrlib.selftest.testgraph',
511
 
                   'bzrlib.selftest.testworkingtree',
512
 
                   'bzrlib.selftest.test_upgrade',
513
 
                   'bzrlib.selftest.test_conflicts',
514
 
                   'bzrlib.selftest.testtestament',
515
 
                   'bzrlib.selftest.testannotate',
516
 
                   'bzrlib.selftest.testrevprops',
 
676
    testmod_names = [ \
 
677
                   'bzrlib.tests.test_ancestry',
 
678
                   'bzrlib.tests.test_annotate',
 
679
                   'bzrlib.tests.test_api',
 
680
                   'bzrlib.tests.test_bad_files',
 
681
                   'bzrlib.tests.test_basis_inventory',
 
682
                   'bzrlib.tests.test_branch',
 
683
                   'bzrlib.tests.test_command',
 
684
                   'bzrlib.tests.test_commit',
 
685
                   'bzrlib.tests.test_commit_merge',
 
686
                   'bzrlib.tests.test_config',
 
687
                   'bzrlib.tests.test_conflicts',
 
688
                   'bzrlib.tests.test_diff',
 
689
                   'bzrlib.tests.test_fetch',
 
690
                   'bzrlib.tests.test_gpg',
 
691
                   'bzrlib.tests.test_graph',
 
692
                   'bzrlib.tests.test_hashcache',
 
693
                   'bzrlib.tests.test_http',
 
694
                   'bzrlib.tests.test_identitymap',
 
695
                   'bzrlib.tests.test_inv',
 
696
                   'bzrlib.tests.test_log',
 
697
                   'bzrlib.tests.test_merge',
 
698
                   'bzrlib.tests.test_merge3',
 
699
                   'bzrlib.tests.test_merge_core',
 
700
                   'bzrlib.tests.test_missing',
 
701
                   'bzrlib.tests.test_msgeditor',
 
702
                   'bzrlib.tests.test_nonascii',
 
703
                   'bzrlib.tests.test_options',
 
704
                   'bzrlib.tests.test_osutils',
 
705
                   'bzrlib.tests.test_parent',
 
706
                   'bzrlib.tests.test_permissions',
 
707
                   'bzrlib.tests.test_plugins',
 
708
                   'bzrlib.tests.test_remove',
 
709
                   'bzrlib.tests.test_revision',
 
710
                   'bzrlib.tests.test_revisionnamespaces',
 
711
                   'bzrlib.tests.test_revprops',
 
712
                   'bzrlib.tests.test_reweave',
 
713
                   'bzrlib.tests.test_rio',
 
714
                   'bzrlib.tests.test_sampler',
 
715
                   'bzrlib.tests.test_selftest',
 
716
                   'bzrlib.tests.test_setup',
 
717
                   'bzrlib.tests.test_sftp_transport',
 
718
                   'bzrlib.tests.test_smart_add',
 
719
                   'bzrlib.tests.test_source',
 
720
                   'bzrlib.tests.test_status',
 
721
                   'bzrlib.tests.test_store',
 
722
                   'bzrlib.tests.test_symbol_versioning',
 
723
                   'bzrlib.tests.test_testament',
 
724
                   'bzrlib.tests.test_trace',
 
725
                   'bzrlib.tests.test_transactions',
 
726
                   'bzrlib.tests.test_transport',
 
727
                   'bzrlib.tests.test_tsort',
 
728
                   'bzrlib.tests.test_ui',
 
729
                   'bzrlib.tests.test_uncommit',
 
730
                   'bzrlib.tests.test_upgrade',
 
731
                   'bzrlib.tests.test_weave',
 
732
                   'bzrlib.tests.test_whitebox',
 
733
                   'bzrlib.tests.test_workingtree',
 
734
                   'bzrlib.tests.test_xml',
517
735
                   ]
518
 
 
519
 
    for m in (bzrlib.store, bzrlib.inventory, bzrlib.branch,
520
 
              bzrlib.osutils, bzrlib.commands, bzrlib.merge3):
521
 
        if m not in MODULES_TO_DOCTEST:
522
 
            MODULES_TO_DOCTEST.append(m)
523
 
 
524
 
    TestCase.BZRPATH = os.path.join(os.path.realpath(os.path.dirname(bzrlib.__path__[0])), 'bzr')
525
 
    print '%-30s %s' % ('bzr binary', TestCase.BZRPATH)
 
736
    test_transport_implementations = [
 
737
        'bzrlib.tests.test_transport_implementations']
 
738
 
 
739
    TestCase.BZRPATH = osutils.pathjoin(
 
740
            osutils.realpath(osutils.dirname(bzrlib.__path__[0])), 'bzr')
 
741
    print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
 
742
    print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
526
743
    print
527
744
    suite = TestSuite()
528
 
    suite.addTest(TestLoader().loadTestsFromNames(testmod_names))
 
745
    # python2.4's TestLoader.loadTestsFromNames gives very poor 
 
746
    # errors if it fails to load a named module - no indication of what's
 
747
    # actually wrong, just "no such module".  We should probably override that
 
748
    # class, but for the moment just load them ourselves. (mbp 20051202)
 
749
    loader = TestLoader()
 
750
    from bzrlib.transport import TransportTestProviderAdapter
 
751
    adapter = TransportTestProviderAdapter()
 
752
    for mod_name in test_transport_implementations:
 
753
        mod = _load_module_by_name(mod_name)
 
754
        for test in iter_suite_tests(loader.loadTestsFromModule(mod)):
 
755
            suite.addTests(adapter.adapt(test))
 
756
    for mod_name in testmod_names:
 
757
        mod = _load_module_by_name(mod_name)
 
758
        suite.addTest(loader.loadTestsFromModule(mod))
 
759
    for package in packages_to_test():
 
760
        suite.addTest(package.test_suite())
529
761
    for m in MODULES_TO_TEST:
530
 
         suite.addTest(TestLoader().loadTestsFromModule(m))
 
762
        suite.addTest(loader.loadTestsFromModule(m))
531
763
    for m in (MODULES_TO_DOCTEST):
532
764
        suite.addTest(DocTestSuite(m))
533
 
    for p in bzrlib.plugin.all_plugins:
534
 
        if hasattr(p, 'test_suite'):
535
 
            suite.addTest(p.test_suite())
 
765
    for name, plugin in bzrlib.plugin.all_plugins().items():
 
766
        if hasattr(plugin, 'test_suite'):
 
767
            suite.addTest(plugin.test_suite())
536
768
    return suite
537
769
 
 
770
 
 
771
def _load_module_by_name(mod_name):
 
772
    parts = mod_name.split('.')
 
773
    module = __import__(mod_name)
 
774
    del parts[0]
 
775
    # for historical reasons python returns the top-level module even though
 
776
    # it loads the submodule; we need to walk down to get the one we want.
 
777
    while parts:
 
778
        module = getattr(module, parts.pop(0))
 
779
    return module