/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: Aaron Bentley
  • Date: 2006-10-12 01:50:46 UTC
  • mfrom: (2072 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2078.
  • Revision ID: aaron.bentley@utoronto.ca-20061012015046-a5a625ca88adf11c
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
71
71
from bzrlib.transport import get_transport
72
72
import bzrlib.transport
73
73
from bzrlib.transport.local import LocalRelpathServer
 
74
from bzrlib.transport.memory import MemoryServer
74
75
from bzrlib.transport.readonly import ReadonlyServer
75
76
from bzrlib.trace import mutter
76
77
from bzrlib.tests import TestUtil
86
87
 
87
88
MODULES_TO_TEST = []
88
89
MODULES_TO_DOCTEST = [
89
 
                      bzrlib.branch,
90
90
                      bzrlib.bundle.serializer,
91
 
                      bzrlib.commands,
92
91
                      bzrlib.errors,
93
92
                      bzrlib.export,
94
93
                      bzrlib.inventory,
96
95
                      bzrlib.lockdir,
97
96
                      bzrlib.merge3,
98
97
                      bzrlib.option,
99
 
                      bzrlib.osutils,
100
98
                      bzrlib.store,
101
 
                      bzrlib.transport,
102
99
                      ]
103
100
 
104
101
 
394
391
        # This is still a little bogus, 
395
392
        # but only a little. Folk not using our testrunner will
396
393
        # have to delete their temp directories themselves.
397
 
        test_root = TestCaseInTempDir.TEST_ROOT
 
394
        test_root = TestCaseWithMemoryTransport.TEST_ROOT
398
395
        if result.wasSuccessful() or not self.keep_output:
399
396
            if test_root is not None:
400
397
                # If LANG=C we probably have created some bogus paths
418
415
                self.stream.writeln(
419
416
                    "Failed tests working directories are in '%s'\n" %
420
417
                    test_root)
421
 
        TestCaseInTempDir.TEST_ROOT = None
 
418
        TestCaseWithMemoryTransport.TEST_ROOT = None
422
419
        if self.pb is not None:
423
420
            self.pb.clear()
424
421
        return result
1108
1105
 
1109
1106
BzrTestBase = TestCase
1110
1107
 
 
1108
 
 
1109
class TestCaseWithMemoryTransport(TestCase):
 
1110
    """Common test class for tests that do not need disk resources.
 
1111
 
 
1112
    Tests that need disk resources should derive from TestCaseWithTransport.
 
1113
 
 
1114
    TestCaseWithMemoryTransport sets the TEST_ROOT variable for all bzr tests.
 
1115
 
 
1116
    For TestCaseWithMemoryTransport the test_home_dir is set to the name of
 
1117
    a directory which does not exist. This serves to help ensure test isolation
 
1118
    is preserved. test_dir is set to the TEST_ROOT, as is cwd, because they
 
1119
    must exist. However, TestCaseWithMemoryTransport does not offer local
 
1120
    file defaults for the transport in tests, nor does it obey the command line
 
1121
    override, so tests that accidentally write to the common directory should
 
1122
    be rare.
 
1123
    """
 
1124
 
 
1125
    TEST_ROOT = None
 
1126
    _TEST_NAME = 'test'
 
1127
 
 
1128
 
 
1129
    def __init__(self, methodName='runTest'):
 
1130
        # allow test parameterisation after test construction and before test
 
1131
        # execution. Variables that the parameteriser sets need to be 
 
1132
        # ones that are not set by setUp, or setUp will trash them.
 
1133
        super(TestCaseWithMemoryTransport, self).__init__(methodName)
 
1134
        self.transport_server = default_transport
 
1135
        self.transport_readonly_server = None
 
1136
 
 
1137
    def failUnlessExists(self, path):
 
1138
        """Fail unless path, which may be abs or relative, exists."""
 
1139
        self.failUnless(osutils.lexists(path))
 
1140
 
 
1141
    def failIfExists(self, path):
 
1142
        """Fail if path, which may be abs or relative, exists."""
 
1143
        self.failIf(osutils.lexists(path))
 
1144
        
 
1145
    def get_transport(self):
 
1146
        """Return a writeable transport for the test scratch space"""
 
1147
        t = get_transport(self.get_url())
 
1148
        self.assertFalse(t.is_readonly())
 
1149
        return t
 
1150
 
 
1151
    def get_readonly_transport(self):
 
1152
        """Return a readonly transport for the test scratch space
 
1153
        
 
1154
        This can be used to test that operations which should only need
 
1155
        readonly access in fact do not try to write.
 
1156
        """
 
1157
        t = get_transport(self.get_readonly_url())
 
1158
        self.assertTrue(t.is_readonly())
 
1159
        return t
 
1160
 
 
1161
    def get_readonly_server(self):
 
1162
        """Get the server instance for the readonly transport
 
1163
 
 
1164
        This is useful for some tests with specific servers to do diagnostics.
 
1165
        """
 
1166
        if self.__readonly_server is None:
 
1167
            if self.transport_readonly_server is None:
 
1168
                # readonly decorator requested
 
1169
                # bring up the server
 
1170
                self.get_url()
 
1171
                self.__readonly_server = ReadonlyServer()
 
1172
                self.__readonly_server.setUp(self.__server)
 
1173
            else:
 
1174
                self.__readonly_server = self.transport_readonly_server()
 
1175
                self.__readonly_server.setUp()
 
1176
            self.addCleanup(self.__readonly_server.tearDown)
 
1177
        return self.__readonly_server
 
1178
 
 
1179
    def get_readonly_url(self, relpath=None):
 
1180
        """Get a URL for the readonly transport.
 
1181
 
 
1182
        This will either be backed by '.' or a decorator to the transport 
 
1183
        used by self.get_url()
 
1184
        relpath provides for clients to get a path relative to the base url.
 
1185
        These should only be downwards relative, not upwards.
 
1186
        """
 
1187
        base = self.get_readonly_server().get_url()
 
1188
        if relpath is not None:
 
1189
            if not base.endswith('/'):
 
1190
                base = base + '/'
 
1191
            base = base + relpath
 
1192
        return base
 
1193
 
 
1194
    def get_server(self):
 
1195
        """Get the read/write server instance.
 
1196
 
 
1197
        This is useful for some tests with specific servers that need
 
1198
        diagnostics.
 
1199
 
 
1200
        For TestCaseWithMemoryTransport this is always a MemoryServer, and there
 
1201
        is no means to override it.
 
1202
        """
 
1203
        if self.__server is None:
 
1204
            self.__server = MemoryServer()
 
1205
            self.__server.setUp()
 
1206
            self.addCleanup(self.__server.tearDown)
 
1207
        return self.__server
 
1208
 
 
1209
    def get_url(self, relpath=None):
 
1210
        """Get a URL (or maybe a path) for the readwrite transport.
 
1211
 
 
1212
        This will either be backed by '.' or to an equivalent non-file based
 
1213
        facility.
 
1214
        relpath provides for clients to get a path relative to the base url.
 
1215
        These should only be downwards relative, not upwards.
 
1216
        """
 
1217
        base = self.get_server().get_url()
 
1218
        if relpath is not None and relpath != '.':
 
1219
            if not base.endswith('/'):
 
1220
                base = base + '/'
 
1221
            # XXX: Really base should be a url; we did after all call
 
1222
            # get_url()!  But sometimes it's just a path (from
 
1223
            # LocalAbspathServer), and it'd be wrong to append urlescaped data
 
1224
            # to a non-escaped local path.
 
1225
            if base.startswith('./') or base.startswith('/'):
 
1226
                base += relpath
 
1227
            else:
 
1228
                base += urlutils.escape(relpath)
 
1229
        return base
 
1230
 
 
1231
    def _make_test_root(self):
 
1232
        if TestCaseWithMemoryTransport.TEST_ROOT is not None:
 
1233
            return
 
1234
        i = 0
 
1235
        while True:
 
1236
            root = u'test%04d.tmp' % i
 
1237
            try:
 
1238
                os.mkdir(root)
 
1239
            except OSError, e:
 
1240
                if e.errno == errno.EEXIST:
 
1241
                    i += 1
 
1242
                    continue
 
1243
                else:
 
1244
                    raise
 
1245
            # successfully created
 
1246
            TestCaseWithMemoryTransport.TEST_ROOT = osutils.abspath(root)
 
1247
            break
 
1248
        # make a fake bzr directory there to prevent any tests propagating
 
1249
        # up onto the source directory's real branch
 
1250
        bzrdir.BzrDir.create_standalone_workingtree(
 
1251
            TestCaseWithMemoryTransport.TEST_ROOT)
 
1252
 
 
1253
    def makeAndChdirToTestDir(self):
 
1254
        """Create a temporary directories for this one test.
 
1255
        
 
1256
        This must set self.test_home_dir and self.test_dir and chdir to
 
1257
        self.test_dir.
 
1258
        
 
1259
        For TestCaseWithMemoryTransport we chdir to the TEST_ROOT for this test.
 
1260
        """
 
1261
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
 
1262
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
 
1263
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
 
1264
        
 
1265
    def make_branch(self, relpath, format=None):
 
1266
        """Create a branch on the transport at relpath."""
 
1267
        repo = self.make_repository(relpath, format=format)
 
1268
        return repo.bzrdir.create_branch()
 
1269
 
 
1270
    def make_bzrdir(self, relpath, format=None):
 
1271
        try:
 
1272
            # might be a relative or absolute path
 
1273
            maybe_a_url = self.get_url(relpath)
 
1274
            segments = maybe_a_url.rsplit('/', 1)
 
1275
            t = get_transport(maybe_a_url)
 
1276
            if len(segments) > 1 and segments[-1] not in ('', '.'):
 
1277
                try:
 
1278
                    t.mkdir('.')
 
1279
                except errors.FileExists:
 
1280
                    pass
 
1281
            if format is None:
 
1282
                format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
 
1283
            return format.initialize_on_transport(t)
 
1284
        except errors.UninitializableFormat:
 
1285
            raise TestSkipped("Format %s is not initializable." % format)
 
1286
 
 
1287
    def make_repository(self, relpath, shared=False, format=None):
 
1288
        """Create a repository on our default transport at relpath."""
 
1289
        made_control = self.make_bzrdir(relpath, format=format)
 
1290
        return made_control.create_repository(shared=shared)
 
1291
 
 
1292
    def make_branch_and_memory_tree(self, relpath):
 
1293
        """Create a branch on the default transport and a MemoryTree for it."""
 
1294
        b = self.make_branch(relpath)
 
1295
        return memorytree.MemoryTree.create_on_branch(b)
 
1296
 
 
1297
    def overrideEnvironmentForTesting(self):
 
1298
        os.environ['HOME'] = self.test_home_dir
 
1299
        os.environ['APPDATA'] = self.test_home_dir
 
1300
        
 
1301
    def setUp(self):
 
1302
        super(TestCaseWithMemoryTransport, self).setUp()
 
1303
        self._make_test_root()
 
1304
        _currentdir = os.getcwdu()
 
1305
        def _leaveDirectory():
 
1306
            os.chdir(_currentdir)
 
1307
        self.addCleanup(_leaveDirectory)
 
1308
        self.makeAndChdirToTestDir()
 
1309
        self.overrideEnvironmentForTesting()
 
1310
        self.__readonly_server = None
 
1311
        self.__server = None
 
1312
 
1111
1313
     
1112
 
class TestCaseInTempDir(TestCase):
 
1314
class TestCaseInTempDir(TestCaseWithMemoryTransport):
1113
1315
    """Derived class that runs a test within a temporary directory.
1114
1316
 
1115
1317
    This is useful for tests that need to create a branch, etc.
1122
1324
    InTempDir is an old alias for FunctionalTestCase.
1123
1325
    """
1124
1326
 
1125
 
    TEST_ROOT = None
1126
 
    _TEST_NAME = 'test'
1127
1327
    OVERRIDE_PYTHON = 'python'
1128
1328
 
1129
1329
    def check_file_contents(self, filename, expect):
1134
1334
            self.log("actually: %r" % contents)
1135
1335
            self.fail("contents of %s not as expected" % filename)
1136
1336
 
1137
 
    def _make_test_root(self):
1138
 
        if TestCaseInTempDir.TEST_ROOT is not None:
1139
 
            return
1140
 
        i = 0
1141
 
        while True:
1142
 
            root = u'test%04d.tmp' % i
1143
 
            try:
1144
 
                os.mkdir(root)
1145
 
            except OSError, e:
1146
 
                if e.errno == errno.EEXIST:
1147
 
                    i += 1
1148
 
                    continue
1149
 
                else:
1150
 
                    raise
1151
 
            # successfully created
1152
 
            TestCaseInTempDir.TEST_ROOT = osutils.abspath(root)
1153
 
            break
1154
 
        # make a fake bzr directory there to prevent any tests propagating
1155
 
        # up onto the source directory's real branch
1156
 
        bzrdir.BzrDir.create_standalone_workingtree(TestCaseInTempDir.TEST_ROOT)
1157
 
 
1158
 
    def setUp(self):
1159
 
        super(TestCaseInTempDir, self).setUp()
1160
 
        self._make_test_root()
1161
 
        _currentdir = os.getcwdu()
 
1337
    def makeAndChdirToTestDir(self):
 
1338
        """See TestCaseWithMemoryTransport.makeAndChdirToTestDir().
 
1339
        
 
1340
        For TestCaseInTempDir we create a temporary directory based on the test
 
1341
        name and then create two subdirs - test and home under it.
 
1342
        """
1162
1343
        # shorten the name, to avoid test failures due to path length
1163
1344
        short_id = self.id().replace('bzrlib.tests.', '') \
1164
1345
                   .replace('__main__.', '')[-100:]
1181
1362
                os.mkdir(self.test_dir)
1182
1363
                os.chdir(self.test_dir)
1183
1364
                break
1184
 
        os.environ['HOME'] = self.test_home_dir
1185
 
        os.environ['APPDATA'] = self.test_home_dir
1186
 
        def _leaveDirectory():
1187
 
            os.chdir(_currentdir)
1188
 
        self.addCleanup(_leaveDirectory)
1189
 
        
 
1365
 
1190
1366
    def build_tree(self, shape, line_endings='native', transport=None):
1191
1367
        """Build a test tree according to a pattern.
1192
1368
 
1233
1409
    def build_tree_contents(self, shape):
1234
1410
        build_tree_contents(shape)
1235
1411
 
1236
 
    def failUnlessExists(self, path):
1237
 
        """Fail unless path, which may be abs or relative, exists."""
1238
 
        self.failUnless(osutils.lexists(path))
1239
 
 
1240
 
    def failIfExists(self, path):
1241
 
        """Fail if path, which may be abs or relative, exists."""
1242
 
        self.failIf(osutils.lexists(path))
1243
 
        
1244
1412
    def assertFileEqual(self, content, path):
1245
1413
        """Fail if path does not contain 'content'."""
1246
1414
        self.failUnless(osutils.lexists(path))
1262
1430
    readwrite one must both define get_url() as resolving to os.getcwd().
1263
1431
    """
1264
1432
 
1265
 
    def __init__(self, methodName='testMethod'):
1266
 
        super(TestCaseWithTransport, self).__init__(methodName)
1267
 
        self.__readonly_server = None
1268
 
        self.__server = None
1269
 
        self.transport_server = default_transport
1270
 
        self.transport_readonly_server = None
1271
 
 
1272
 
    def get_readonly_url(self, relpath=None):
1273
 
        """Get a URL for the readonly transport.
1274
 
 
1275
 
        This will either be backed by '.' or a decorator to the transport 
1276
 
        used by self.get_url()
1277
 
        relpath provides for clients to get a path relative to the base url.
1278
 
        These should only be downwards relative, not upwards.
1279
 
        """
1280
 
        base = self.get_readonly_server().get_url()
1281
 
        if relpath is not None:
1282
 
            if not base.endswith('/'):
1283
 
                base = base + '/'
1284
 
            base = base + relpath
1285
 
        return base
1286
 
 
1287
 
    def get_readonly_server(self):
1288
 
        """Get the server instance for the readonly transport
1289
 
 
1290
 
        This is useful for some tests with specific servers to do diagnostics.
1291
 
        """
1292
 
        if self.__readonly_server is None:
1293
 
            if self.transport_readonly_server is None:
1294
 
                # readonly decorator requested
1295
 
                # bring up the server
1296
 
                self.get_url()
1297
 
                self.__readonly_server = ReadonlyServer()
1298
 
                self.__readonly_server.setUp(self.__server)
1299
 
            else:
1300
 
                self.__readonly_server = self.transport_readonly_server()
1301
 
                self.__readonly_server.setUp()
1302
 
            self.addCleanup(self.__readonly_server.tearDown)
1303
 
        return self.__readonly_server
1304
 
 
1305
1433
    def get_server(self):
1306
 
        """Get the read/write server instance.
 
1434
        """See TestCaseWithMemoryTransport.
1307
1435
 
1308
1436
        This is useful for some tests with specific servers that need
1309
1437
        diagnostics.
1314
1442
            self.addCleanup(self.__server.tearDown)
1315
1443
        return self.__server
1316
1444
 
1317
 
    def get_url(self, relpath=None):
1318
 
        """Get a URL (or maybe a path) for the readwrite transport.
1319
 
 
1320
 
        This will either be backed by '.' or to an equivalent non-file based
1321
 
        facility.
1322
 
        relpath provides for clients to get a path relative to the base url.
1323
 
        These should only be downwards relative, not upwards.
1324
 
        """
1325
 
        base = self.get_server().get_url()
1326
 
        if relpath is not None and relpath != '.':
1327
 
            if not base.endswith('/'):
1328
 
                base = base + '/'
1329
 
            # XXX: Really base should be a url; we did after all call
1330
 
            # get_url()!  But sometimes it's just a path (from
1331
 
            # LocalAbspathServer), and it'd be wrong to append urlescaped data
1332
 
            # to a non-escaped local path.
1333
 
            if base.startswith('./') or base.startswith('/'):
1334
 
                base += relpath
1335
 
            else:
1336
 
                base += urlutils.escape(relpath)
1337
 
        return base
1338
 
 
1339
 
    def get_transport(self):
1340
 
        """Return a writeable transport for the test scratch space"""
1341
 
        t = get_transport(self.get_url())
1342
 
        self.assertFalse(t.is_readonly())
1343
 
        return t
1344
 
 
1345
 
    def get_readonly_transport(self):
1346
 
        """Return a readonly transport for the test scratch space
1347
 
        
1348
 
        This can be used to test that operations which should only need
1349
 
        readonly access in fact do not try to write.
1350
 
        """
1351
 
        t = get_transport(self.get_readonly_url())
1352
 
        self.assertTrue(t.is_readonly())
1353
 
        return t
1354
 
 
1355
 
    def make_branch(self, relpath, format=None):
1356
 
        """Create a branch on the transport at relpath."""
1357
 
        repo = self.make_repository(relpath, format=format)
1358
 
        return repo.bzrdir.create_branch()
1359
 
 
1360
 
    def make_bzrdir(self, relpath, format=None):
1361
 
        try:
1362
 
            # might be a relative or absolute path
1363
 
            maybe_a_url = self.get_url(relpath)
1364
 
            segments = maybe_a_url.rsplit('/', 1)
1365
 
            t = get_transport(maybe_a_url)
1366
 
            if len(segments) > 1 and segments[-1] not in ('', '.'):
1367
 
                try:
1368
 
                    t.mkdir('.')
1369
 
                except errors.FileExists:
1370
 
                    pass
1371
 
            if format is None:
1372
 
                format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
1373
 
            return format.initialize_on_transport(t)
1374
 
        except errors.UninitializableFormat:
1375
 
            raise TestSkipped("Format %s is not initializable." % format)
1376
 
 
1377
 
    def make_repository(self, relpath, shared=False, format=None):
1378
 
        """Create a repository on our default transport at relpath."""
1379
 
        made_control = self.make_bzrdir(relpath, format=format)
1380
 
        return made_control.create_repository(shared=shared)
1381
 
 
1382
 
    def make_branch_and_memory_tree(self, relpath):
1383
 
        """Create a branch on the default transport and a MemoryTree for it."""
1384
 
        b = self.make_branch(relpath)
1385
 
        return memorytree.MemoryTree.create_on_branch(b)
1386
 
 
1387
1445
    def make_branch_and_tree(self, relpath, format=None):
1388
1446
        """Create a branch on the transport and a tree locally.
1389
1447
 
1431
1489
            self.fail("path %s is not a directory; has mode %#o"
1432
1490
                      % (relpath, mode))
1433
1491
 
 
1492
    def setUp(self):
 
1493
        super(TestCaseWithTransport, self).setUp()
 
1494
        self.__server = None
 
1495
        self.transport_server = default_transport
 
1496
 
1434
1497
 
1435
1498
class ChrootedTestCase(TestCaseWithTransport):
1436
1499
    """A support class that provides readonly urls outside the local namespace.
1462
1525
def run_suite(suite, name='test', verbose=False, pattern=".*",
1463
1526
              stop_on_failure=False, keep_output=False,
1464
1527
              transport=None, lsprof_timed=None, bench_history=None):
1465
 
    TestCaseInTempDir._TEST_NAME = name
1466
1528
    TestCase._gather_lsprof_in_benchmarks = lsprof_timed
1467
1529
    if verbose:
1468
1530
        verbosity = 2
1552
1614
                   'bzrlib.tests.test_inv',
1553
1615
                   'bzrlib.tests.test_knit',
1554
1616
                   'bzrlib.tests.test_lazy_import',
 
1617
                   'bzrlib.tests.test_lazy_regex',
1555
1618
                   'bzrlib.tests.test_lockdir',
1556
1619
                   'bzrlib.tests.test_lockable_files',
1557
1620
                   'bzrlib.tests.test_log',
1623
1686
    for m in MODULES_TO_TEST:
1624
1687
        suite.addTest(loader.loadTestsFromModule(m))
1625
1688
    for m in MODULES_TO_DOCTEST:
1626
 
        suite.addTest(doctest.DocTestSuite(m))
 
1689
        try:
 
1690
            suite.addTest(doctest.DocTestSuite(m))
 
1691
        except ValueError, e:
 
1692
            print '**failed to get doctest for: %s\n%s' %(m,e)
 
1693
            raise
1627
1694
    for name, plugin in bzrlib.plugin.all_plugins().items():
1628
1695
        if getattr(plugin, 'test_suite', None) is not None:
1629
1696
            suite.addTest(plugin.test_suite())