/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

Merge cleanup into texinfo

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,
114
113
    TestUtil,
 
114
    treeshape,
115
115
    )
116
116
from bzrlib.tests.http_server import HttpServer
117
117
from bzrlib.tests.TestUtil import (
118
118
                          TestSuite,
119
119
                          TestLoader,
120
120
                          )
121
 
from bzrlib.tests.treeshape import build_tree_contents
122
121
from bzrlib.ui import NullProgressView
123
122
from bzrlib.ui.text import TextUIFactory
124
123
import bzrlib.version_info_formats.format_custom
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] == '/':
2578
2586
                content = "contents of %s%s" % (name.encode('utf-8'), end)
2579
2587
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
2580
2588
 
2581
 
    def build_tree_contents(self, shape):
2582
 
        build_tree_contents(shape)
 
2589
    build_tree_contents = staticmethod(treeshape.build_tree_contents)
2583
2590
 
2584
2591
    def assertInWorkingTree(self, path, root_path='.', tree=None):
2585
2592
        """Assert whether path or paths are in the WorkingTree"""
3310
3317
                '--subunit']
3311
3318
            if '--no-plugins' in sys.argv:
3312
3319
                argv.append('--no-plugins')
3313
 
            # stderr=STDOUT would be ideal, but until we prevent noise on
3314
 
            # stderr it can interrupt the subunit protocol.
3315
 
            process = Popen(argv, stdin=PIPE, stdout=PIPE, stderr=PIPE,
3316
 
                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)
3317
3326
            test = TestInSubprocess(process, test_list_file_name)
3318
3327
            result.append(test)
3319
3328
        except:
3368
3377
 
3369
3378
    def startTest(self, test):
3370
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
3371
3383
        self.profiler.start()
3372
3384
        ForwardingResult.startTest(self, test)
3373
3385
 
3702
3714
        'bzrlib.tests.test_export',
3703
3715
        'bzrlib.tests.test_extract',
3704
3716
        'bzrlib.tests.test_fetch',
 
3717
        'bzrlib.tests.test_fixtures',
3705
3718
        'bzrlib.tests.test_fifo_cache',
3706
3719
        'bzrlib.tests.test_filters',
3707
3720
        'bzrlib.tests.test_ftp_transport',
3728
3741
        'bzrlib.tests.test_knit',
3729
3742
        'bzrlib.tests.test_lazy_import',
3730
3743
        'bzrlib.tests.test_lazy_regex',
 
3744
        'bzrlib.tests.test_library_state',
3731
3745
        'bzrlib.tests.test_lock',
3732
3746
        'bzrlib.tests.test_lockable_files',
3733
3747
        'bzrlib.tests.test_lockdir',
3735
3749
        'bzrlib.tests.test_lru_cache',
3736
3750
        'bzrlib.tests.test_lsprof',
3737
3751
        'bzrlib.tests.test_mail_client',
 
3752
        'bzrlib.tests.test_matchers',
3738
3753
        'bzrlib.tests.test_memorytree',
3739
3754
        'bzrlib.tests.test_merge',
3740
3755
        'bzrlib.tests.test_merge3',
3836
3851
        'bzrlib.option',
3837
3852
        'bzrlib.symbol_versioning',
3838
3853
        'bzrlib.tests',
 
3854
        'bzrlib.tests.fixtures',
3839
3855
        'bzrlib.timestamp',
3840
3856
        'bzrlib.version_info_formats.format_custom',
3841
3857
        ]
4035
4051
    :param new_id: The id to assign to it.
4036
4052
    :return: The new test.
4037
4053
    """
4038
 
    new_test = copy(test)
 
4054
    new_test = copy.copy(test)
4039
4055
    new_test.id = lambda: new_id
4040
4056
    return new_test
4041
4057
 
4102
4118
        if test_id != None:
4103
4119
            ui.ui_factory.clear_term()
4104
4120
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
 
4121
        # Ugly, but the last thing we want here is fail, so bear with it.
 
4122
        printable_e = str(e).decode(osutils.get_user_encoding(), 'replace'
 
4123
                                    ).encode('ascii', 'replace')
4105
4124
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4106
 
                         % (os.path.basename(dirname), e))
 
4125
                         % (os.path.basename(dirname), printable_e))
4107
4126
 
4108
4127
 
4109
4128
class Feature(object):
4339
4358
UnicodeFilename = _UnicodeFilename()
4340
4359
 
4341
4360
 
 
4361
class _ByteStringNamedFilesystem(Feature):
 
4362
    """Is the filesystem based on bytes?"""
 
4363
 
 
4364
    def _probe(self):
 
4365
        if os.name == "posix":
 
4366
            return True
 
4367
        return False
 
4368
 
 
4369
ByteStringNamedFilesystem = _ByteStringNamedFilesystem()
 
4370
 
 
4371
 
4342
4372
class _UTF8Filesystem(Feature):
4343
4373
    """Is the filesystem UTF-8?"""
4344
4374