/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: Vincent Ladeuil
  • Date: 2010-07-07 11:21:19 UTC
  • mto: (5193.7.1 unify-confs)
  • mto: This revision was merged to the branch mainline in revision 5349.
  • Revision ID: v.ladeuil+lp@free.fr-20100707112119-jwyh312df41w6l0o
Revert previous change as I can't reproduce the related problem anymore.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
29
29
 
30
30
import atexit
31
31
import codecs
32
 
from copy import copy
 
32
import copy
33
33
from cStringIO import StringIO
34
34
import difflib
35
35
import doctest
37
37
import logging
38
38
import math
39
39
import os
40
 
from pprint import pformat
 
40
import pprint
41
41
import random
42
42
import re
43
43
import shlex
44
44
import stat
45
 
from subprocess import Popen, PIPE, STDOUT
 
45
import subprocess
46
46
import sys
47
47
import tempfile
48
48
import threading
74
74
    ui,
75
75
    urlutils,
76
76
    registry,
 
77
    transport as _mod_transport,
77
78
    workingtree,
78
79
    )
79
80
import bzrlib.branch
103
104
    )
104
105
import bzrlib.trace
105
106
from bzrlib.transport import (
106
 
    get_transport,
107
107
    memory,
108
108
    pathfilter,
109
109
    )
110
 
import bzrlib.transport
111
110
from bzrlib.trace import mutter, note
112
111
from bzrlib.tests import (
113
112
    test_server,
749
748
    # XXX: Should probably unify more with CannedInputUIFactory or a
750
749
    # particular configuration of TextUIFactory, or otherwise have a clearer
751
750
    # idea of how they're supposed to be different.
752
 
    # See https://bugs.edge.launchpad.net/bzr/+bug/408213
 
751
    # See https://bugs.launchpad.net/bzr/+bug/408213
753
752
 
754
753
    def __init__(self, stdout=None, stderr=None, stdin=None):
755
754
        if stdin is not None:
943
942
 
944
943
    def permit_dir(self, name):
945
944
        """Permit a directory to be used by this test. See permit_url."""
946
 
        name_transport = get_transport(name)
 
945
        name_transport = _mod_transport.get_transport(name)
947
946
        self.permit_url(name)
948
947
        self.permit_url(name_transport.base)
949
948
 
1028
1027
        self.addCleanup(transport_server.stop_server)
1029
1028
        # Obtain a real transport because if the server supplies a password, it
1030
1029
        # will be hidden from the base on the client side.
1031
 
        t = get_transport(transport_server.get_url())
 
1030
        t = _mod_transport.get_transport(transport_server.get_url())
1032
1031
        # Some transport servers effectively chroot the backing transport;
1033
1032
        # others like SFTPServer don't - users of the transport can walk up the
1034
1033
        # transport to read the entire backing transport. This wouldn't matter
1095
1094
            message += '\n'
1096
1095
        raise AssertionError("%snot equal:\na = %s\nb = %s\n"
1097
1096
            % (message,
1098
 
               pformat(a), pformat(b)))
 
1097
               pprint.pformat(a), pprint.pformat(b)))
1099
1098
 
1100
1099
    assertEquals = assertEqual
1101
1100
 
1524
1523
            'EDITOR': None,
1525
1524
            'BZR_EMAIL': None,
1526
1525
            'BZREMAIL': None, # may still be present in the environment
1527
 
            'EMAIL': None,
 
1526
            'EMAIL': 'jrandom@example.com', # set EMAIL as bzr does not guess
1528
1527
            'BZR_PROGRESS_BAR': None,
1529
1528
            'BZR_LOG': None,
1530
1529
            'BZR_PLUGIN_PATH': None,
1986
1985
            if not allow_plugins:
1987
1986
                command.append('--no-plugins')
1988
1987
            command.extend(process_args)
1989
 
            process = self._popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
 
1988
            process = self._popen(command, stdin=subprocess.PIPE,
 
1989
                                  stdout=subprocess.PIPE,
 
1990
                                  stderr=subprocess.PIPE)
1990
1991
        finally:
1991
1992
            restore_environment()
1992
1993
            if cwd is not None:
2000
2001
        Allows tests to override this method to intercept the calls made to
2001
2002
        Popen for introspection.
2002
2003
        """
2003
 
        return Popen(*args, **kwargs)
 
2004
        return subprocess.Popen(*args, **kwargs)
2004
2005
 
2005
2006
    def get_source_path(self):
2006
2007
        """Return the path of the directory containing bzrlib."""
2186
2187
 
2187
2188
        :param relpath: a path relative to the base url.
2188
2189
        """
2189
 
        t = get_transport(self.get_url(relpath))
 
2190
        t = _mod_transport.get_transport(self.get_url(relpath))
2190
2191
        self.assertFalse(t.is_readonly())
2191
2192
        return t
2192
2193
 
2198
2199
 
2199
2200
        :param relpath: a path relative to the base url.
2200
2201
        """
2201
 
        t = get_transport(self.get_readonly_url(relpath))
 
2202
        t = _mod_transport.get_transport(self.get_readonly_url(relpath))
2202
2203
        self.assertTrue(t.is_readonly())
2203
2204
        return t
2204
2205
 
2334
2335
        propagating. This method ensures than a test did not leaked.
2335
2336
        """
2336
2337
        root = TestCaseWithMemoryTransport.TEST_ROOT
2337
 
        self.permit_url(get_transport(root).base)
 
2338
        self.permit_url(_mod_transport.get_transport(root).base)
2338
2339
        wt = workingtree.WorkingTree.open(root)
2339
2340
        last_rev = wt.last_revision()
2340
2341
        if last_rev != 'null:':
2385
2386
            # might be a relative or absolute path
2386
2387
            maybe_a_url = self.get_url(relpath)
2387
2388
            segments = maybe_a_url.rsplit('/', 1)
2388
 
            t = get_transport(maybe_a_url)
 
2389
            t = _mod_transport.get_transport(maybe_a_url)
2389
2390
            if len(segments) > 1 and segments[-1] not in ('', '.'):
2390
2391
                t.ensure_base()
2391
2392
            if format is None:
2408
2409
        made_control = self.make_bzrdir(relpath, format=format)
2409
2410
        return made_control.create_repository(shared=shared)
2410
2411
 
2411
 
    def make_smart_server(self, path):
 
2412
    def make_smart_server(self, path, backing_server=None):
 
2413
        if backing_server is None:
 
2414
            backing_server = self.get_server()
2412
2415
        smart_server = test_server.SmartTCPServer_for_testing()
2413
 
        self.start_server(smart_server, self.get_server())
2414
 
        remote_transport = get_transport(smart_server.get_url()).clone(path)
 
2416
        self.start_server(smart_server, backing_server)
 
2417
        remote_transport = _mod_transport.get_transport(smart_server.get_url()
 
2418
                                                   ).clone(path)
2415
2419
        return remote_transport
2416
2420
 
2417
2421
    def make_branch_and_memory_tree(self, relpath, format=None):
2482
2486
 
2483
2487
    def check_file_contents(self, filename, expect):
2484
2488
        self.log("check contents of file %s" % filename)
2485
 
        contents = file(filename, 'r').read()
 
2489
        f = file(filename)
 
2490
        try:
 
2491
            contents = f.read()
 
2492
        finally:
 
2493
            f.close()
2486
2494
        if contents != expect:
2487
2495
            self.log("expected: %r" % expect)
2488
2496
            self.log("actually: %r" % contents)
2562
2570
                "a list or a tuple. Got %r instead" % (shape,))
2563
2571
        # It's OK to just create them using forward slashes on windows.
2564
2572
        if transport is None or transport.is_readonly():
2565
 
            transport = get_transport(".")
 
2573
            transport = _mod_transport.get_transport(".")
2566
2574
        for name in shape:
2567
2575
            self.assertIsInstance(name, basestring)
2568
2576
            if name[-1] == '/':
3309
3317
                '--subunit']
3310
3318
            if '--no-plugins' in sys.argv:
3311
3319
                argv.append('--no-plugins')
3312
 
            # stderr=STDOUT would be ideal, but until we prevent noise on
3313
 
            # stderr it can interrupt the subunit protocol.
3314
 
            process = Popen(argv, stdin=PIPE, stdout=PIPE, stderr=PIPE,
3315
 
                bufsize=1)
 
3320
            # stderr=subprocess.STDOUT would be ideal, but until we prevent
 
3321
            # noise on stderr it can interrupt the subunit protocol.
 
3322
            process = subprocess.Popen(argv, stdin=subprocess.PIPE,
 
3323
                                      stdout=subprocess.PIPE,
 
3324
                                      stderr=subprocess.PIPE,
 
3325
                                      bufsize=1)
3316
3326
            test = TestInSubprocess(process, test_list_file_name)
3317
3327
            result.append(test)
3318
3328
        except:
3367
3377
 
3368
3378
    def startTest(self, test):
3369
3379
        self.profiler = bzrlib.lsprof.BzrProfiler()
 
3380
        # Prevent deadlocks in tests that use lsprof: those tests will
 
3381
        # unavoidably fail.
 
3382
        bzrlib.lsprof.BzrProfiler.profiler_block = 0
3370
3383
        self.profiler.start()
3371
3384
        ForwardingResult.startTest(self, test)
3372
3385
 
3700
3713
        'bzrlib.tests.test_export',
3701
3714
        'bzrlib.tests.test_extract',
3702
3715
        'bzrlib.tests.test_fetch',
 
3716
        'bzrlib.tests.test_fixtures',
3703
3717
        'bzrlib.tests.test_fifo_cache',
3704
3718
        'bzrlib.tests.test_filters',
3705
3719
        'bzrlib.tests.test_ftp_transport',
3726
3740
        'bzrlib.tests.test_knit',
3727
3741
        'bzrlib.tests.test_lazy_import',
3728
3742
        'bzrlib.tests.test_lazy_regex',
 
3743
        'bzrlib.tests.test_library_state',
3729
3744
        'bzrlib.tests.test_lock',
3730
3745
        'bzrlib.tests.test_lockable_files',
3731
3746
        'bzrlib.tests.test_lockdir',
3733
3748
        'bzrlib.tests.test_lru_cache',
3734
3749
        'bzrlib.tests.test_lsprof',
3735
3750
        'bzrlib.tests.test_mail_client',
 
3751
        'bzrlib.tests.test_matchers',
3736
3752
        'bzrlib.tests.test_memorytree',
3737
3753
        'bzrlib.tests.test_merge',
3738
3754
        'bzrlib.tests.test_merge3',
3834
3850
        'bzrlib.option',
3835
3851
        'bzrlib.symbol_versioning',
3836
3852
        'bzrlib.tests',
 
3853
        'bzrlib.tests.fixtures',
3837
3854
        'bzrlib.timestamp',
3838
3855
        'bzrlib.version_info_formats.format_custom',
3839
3856
        ]
4033
4050
    :param new_id: The id to assign to it.
4034
4051
    :return: The new test.
4035
4052
    """
4036
 
    new_test = copy(test)
 
4053
    new_test = copy.copy(test)
4037
4054
    new_test.id = lambda: new_id
4038
4055
    return new_test
4039
4056
 
4100
4117
        if test_id != None:
4101
4118
            ui.ui_factory.clear_term()
4102
4119
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
 
4120
        # Ugly, but the last thing we want here is fail, so bear with it.
 
4121
        printable_e = str(e).decode(osutils.get_user_encoding(), 'replace'
 
4122
                                    ).encode('ascii', 'replace')
4103
4123
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4104
 
                         % (os.path.basename(dirname), e))
 
4124
                         % (os.path.basename(dirname), printable_e))
4105
4125
 
4106
4126
 
4107
4127
class Feature(object):
4337
4357
UnicodeFilename = _UnicodeFilename()
4338
4358
 
4339
4359
 
 
4360
class _ByteStringNamedFilesystem(Feature):
 
4361
    """Is the filesystem based on bytes?"""
 
4362
 
 
4363
    def _probe(self):
 
4364
        if os.name == "posix":
 
4365
            return True
 
4366
        return False
 
4367
 
 
4368
ByteStringNamedFilesystem = _ByteStringNamedFilesystem()
 
4369
 
 
4370
 
4340
4371
class _UTF8Filesystem(Feature):
4341
4372
    """Is the filesystem UTF-8?"""
4342
4373