39
40
import testtools.testresult.doubles
61
from bzrlib.repofmt import (
63
62
groupcompress_repo,
65
from ..sixish import (
69
from ..symbol_versioning import (
64
from bzrlib.symbol_versioning import (
70
65
deprecated_function,
69
from bzrlib.tests import (
80
from ..trace import note, mutter
81
from ..transport import memory
75
from bzrlib.trace import note, mutter
76
from bzrlib.transport import memory
84
79
def _test_ids(test_suite):
106
101
self.requireFeature(features.UnicodeFilenameFeature)
108
103
filename = u'hell\u00d8'
109
self.build_tree_contents([(filename, b'contents of hello')])
104
self.build_tree_contents([(filename, 'contents of hello')])
110
105
self.assertPathExists(filename)
113
108
class TestClassesAvailable(tests.TestCase):
114
"""As a convenience we expose Test* classes from breezy.tests"""
109
"""As a convenience we expose Test* classes from bzrlib.tests"""
116
111
def test_test_case(self):
117
from . import TestCase
112
from bzrlib.tests import TestCase
119
114
def test_test_loader(self):
120
from . import TestLoader
115
from bzrlib.tests import TestLoader
122
117
def test_test_suite(self):
123
from . import TestSuite
118
from bzrlib.tests import TestSuite
126
121
class TestTransportScenarios(tests.TestCase):
139
134
class MockModule(object):
140
135
def get_test_permutations(self):
141
136
return sample_permutation
142
sample_permutation = [(1, 2), (3, 4)]
143
from .per_transport import get_transport_test_permutations
137
sample_permutation = [(1,2), (3,4)]
138
from bzrlib.tests.per_transport import get_transport_test_permutations
144
139
self.assertEqual(sample_permutation,
145
140
get_transport_test_permutations(MockModule()))
149
144
# as there are in all the registered transport modules - we assume if
150
145
# this matches its probably doing the right thing especially in
151
146
# combination with the tests for setting the right classes below.
152
from .per_transport import transport_test_permutations
153
from ..transport import _get_transport_modules
147
from bzrlib.tests.per_transport import transport_test_permutations
148
from bzrlib.transport import _get_transport_modules
154
149
modules = _get_transport_modules()
155
150
permutation_count = 0
156
151
for module in modules:
167
162
# This test used to know about all the possible transports and the
168
163
# order they were returned but that seems overly brittle (mbp
170
from .per_transport import transport_test_permutations
165
from bzrlib.tests.per_transport import transport_test_permutations
171
166
scenarios = transport_test_permutations()
172
167
# there are at least that many builtin transports
173
168
self.assertTrue(len(scenarios) > 6)
174
169
one_scenario = scenarios[0]
175
170
self.assertIsInstance(one_scenario[0], str)
176
171
self.assertTrue(issubclass(one_scenario[1]["transport_class"],
177
breezy.transport.Transport))
172
bzrlib.transport.Transport))
178
173
self.assertTrue(issubclass(one_scenario[1]["transport_server"],
179
breezy.transport.Server))
174
bzrlib.transport.Server))
182
177
class TestBranchScenarios(tests.TestCase):
184
179
def test_scenarios(self):
185
180
# check that constructor parameters are passed through to the adapted
187
from .per_branch import make_scenarios
182
from bzrlib.tests.per_branch import make_scenarios
190
185
formats = [("c", "C"), ("d", "D")]
232
227
class TestRepositoryScenarios(tests.TestCase):
234
229
def test_formats_to_scenarios(self):
235
from .per_repository import formats_to_scenarios
230
from bzrlib.tests.per_repository import formats_to_scenarios
236
231
formats = [("(c)", remote.RemoteRepositoryFormat()),
237
232
("(d)", repository.format_registry.get(
238
b'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
233
'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
239
234
no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
241
236
vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
273
268
"""Tests for the test adaption facilities."""
275
270
def test_apply_scenario(self):
276
from breezy.tests import apply_scenario
271
from bzrlib.tests import apply_scenario
277
272
input_test = TestTestScenarioApplication("test_apply_scenario")
278
273
# setup two adapted tests
279
274
adapted_test1 = apply_scenario(input_test,
295
290
self.assertEqual("readonly-server",
296
291
adapted_test1.transport_readonly_server)
297
292
self.assertEqual(
298
"breezy.tests.test_selftest.TestTestScenarioApplication."
293
"bzrlib.tests.test_selftest.TestTestScenarioApplication."
299
294
"test_apply_scenario(new id)",
300
295
adapted_test1.id())
301
296
self.assertEqual(None, adapted_test2.bzrdir_format)
302
297
self.assertEqual(
303
"breezy.tests.test_selftest.TestTestScenarioApplication."
298
"bzrlib.tests.test_selftest.TestTestScenarioApplication."
304
299
"test_apply_scenario(new id 2)",
305
300
adapted_test2.id())
310
305
def test_scenarios(self):
311
306
# check that constructor parameters are passed through to the adapted
313
from .per_interrepository import make_scenarios
308
from bzrlib.tests.per_interrepository import make_scenarios
316
311
formats = [("C0", "C1", "C2", "C3"), ("D0", "D1", "D2", "D3")]
347
342
remote_backing_server='e')
348
343
self.assertEqual([
349
344
('WorkingTreeFormat4',
350
{'bzrdir_format': formats[0]._matchingcontroldir,
345
{'bzrdir_format': formats[0]._matchingbzrdir,
351
346
'transport_readonly_server': 'b',
352
347
'transport_server': 'a',
353
348
'workingtree_format': formats[0]}),
354
349
('WorkingTreeFormat3',
355
{'bzrdir_format': formats[1]._matchingcontroldir,
350
{'bzrdir_format': formats[1]._matchingbzrdir,
356
351
'transport_readonly_server': 'b',
357
352
'transport_server': 'a',
358
353
'workingtree_format': formats[1]}),
359
354
('WorkingTreeFormat6',
360
{'bzrdir_format': formats[2]._matchingcontroldir,
355
{'bzrdir_format': formats[2]._matchingbzrdir,
361
356
'transport_readonly_server': 'b',
362
357
'transport_server': 'a',
363
358
'workingtree_format': formats[2]}),
364
359
('WorkingTreeFormat6,remote',
365
{'bzrdir_format': formats[2]._matchingcontroldir,
360
{'bzrdir_format': formats[2]._matchingbzrdir,
366
361
'repo_is_remote': True,
367
362
'transport_readonly_server': 'd',
368
363
'transport_server': 'c',
406
401
wt6_format = workingtree_4.WorkingTreeFormat6()
407
402
expected_scenarios = [
408
403
('WorkingTreeFormat4',
409
{'bzrdir_format': formats[0]._matchingcontroldir,
404
{'bzrdir_format': formats[0]._matchingbzrdir,
410
405
'transport_readonly_server': 'b',
411
406
'transport_server': 'a',
412
407
'workingtree_format': formats[0],
413
408
'_workingtree_to_test_tree': return_parameter,
415
410
('WorkingTreeFormat3',
416
{'bzrdir_format': formats[1]._matchingcontroldir,
411
{'bzrdir_format': formats[1]._matchingbzrdir,
417
412
'transport_readonly_server': 'b',
418
413
'transport_server': 'a',
419
414
'workingtree_format': formats[1],
420
415
'_workingtree_to_test_tree': return_parameter,
422
417
('WorkingTreeFormat6,remote',
423
{'bzrdir_format': wt6_format._matchingcontroldir,
418
{'bzrdir_format': wt6_format._matchingbzrdir,
424
419
'repo_is_remote': True,
425
420
'transport_readonly_server': smart_readonly_server,
426
421
'transport_server': smart_server,
432
427
{'_workingtree_to_test_tree': revision_tree_from_workingtree,
433
'bzrdir_format': default_wt_format._matchingcontroldir,
428
'bzrdir_format': default_wt_format._matchingbzrdir,
434
429
'transport_readonly_server': 'b',
435
430
'transport_server': 'a',
436
431
'workingtree_format': default_wt_format,
438
433
('DirStateRevisionTree,WT4',
439
434
{'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
440
'bzrdir_format': wt4_format._matchingcontroldir,
435
'bzrdir_format': wt4_format._matchingbzrdir,
441
436
'transport_readonly_server': 'b',
442
437
'transport_server': 'a',
443
438
'workingtree_format': wt4_format,
445
440
('DirStateRevisionTree,WT5',
446
441
{'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
447
'bzrdir_format': wt5_format._matchingcontroldir,
442
'bzrdir_format': wt5_format._matchingbzrdir,
448
443
'transport_readonly_server': 'b',
449
444
'transport_server': 'a',
450
445
'workingtree_format': wt5_format,
453
448
{'_workingtree_to_test_tree': preview_tree_pre,
454
'bzrdir_format': default_wt_format._matchingcontroldir,
449
'bzrdir_format': default_wt_format._matchingbzrdir,
455
450
'transport_readonly_server': 'b',
456
451
'transport_server': 'a',
457
452
'workingtree_format': default_wt_format}),
458
453
('PreviewTreePost',
459
454
{'_workingtree_to_test_tree': preview_tree_post,
460
'bzrdir_format': default_wt_format._matchingcontroldir,
455
'bzrdir_format': default_wt_format._matchingbzrdir,
461
456
'transport_readonly_server': 'b',
462
457
'transport_server': 'a',
463
458
'workingtree_format': default_wt_format}),
478
473
# unlike the TestProviderAdapter we dont want to automatically add a
479
474
# parameterized one for WorkingTree - the optimisers will tell us what
481
from .per_tree import (
476
from bzrlib.tests.per_tree import (
482
477
return_parameter,
484
from .per_intertree import (
479
from bzrlib.tests.per_intertree import (
487
from ..bzr.workingtree_3 import WorkingTreeFormat3
488
from ..bzr.workingtree_4 import WorkingTreeFormat4
482
from bzrlib.workingtree_3 import WorkingTreeFormat3
483
from bzrlib.workingtree_4 import WorkingTreeFormat4
489
484
input_test = TestInterTreeScenarios(
490
485
"test_scenarios")
498
493
self.assertEqual(2, len(scenarios))
499
494
expected_scenarios = [
501
"bzrdir_format": format1._matchingcontroldir,
496
"bzrdir_format": format1._matchingbzrdir,
502
497
"intertree_class": formats[0][1],
503
498
"workingtree_format": formats[0][2],
504
499
"workingtree_format_to": formats[0][3],
508
503
"transport_readonly_server": server2,
511
"bzrdir_format": format2._matchingcontroldir,
506
"bzrdir_format": format2._matchingbzrdir,
512
507
"intertree_class": formats[1][1],
513
508
"workingtree_format": formats[1][2],
514
509
"workingtree_format_to": formats[1][3],
530
525
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
532
527
def test_assertEqualStat_equal(self):
533
from .test_dirstate import _FakeStat
528
from bzrlib.tests.test_dirstate import _FakeStat
534
529
self.build_tree(["foo"])
535
530
real = os.lstat("foo")
536
531
fake = _FakeStat(real.st_size, real.st_mtime, real.st_ctime,
542
537
self.assertRaises(AssertionError, self.assertEqualStat,
543
538
os.lstat("foo"), os.lstat("longname"))
540
def test_failUnlessExists(self):
541
"""Deprecated failUnlessExists and failIfExists"""
542
self.applyDeprecated(
543
deprecated_in((2, 4)),
544
self.failUnlessExists, '.')
545
self.build_tree(['foo/', 'foo/bar'])
546
self.applyDeprecated(
547
deprecated_in((2, 4)),
548
self.failUnlessExists, 'foo/bar')
549
self.applyDeprecated(
550
deprecated_in((2, 4)),
551
self.failIfExists, 'foo/foo')
545
553
def test_assertPathExists(self):
546
554
self.assertPathExists('.')
547
555
self.build_tree(['foo/', 'foo/bar'])
555
563
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
557
565
This is because TestCaseWithMemoryTransport is for tests that do not
558
need any disk resources: they should be hooked into breezy in such a
566
need any disk resources: they should be hooked into bzrlib in such a
559
567
way that no global settings are being changed by the test (only a
560
568
few tests should need to do that), and having a missing dir as home is
561
569
an effective way to ensure that this is the case.
570
578
cwd = osutils.getcwd()
571
579
self.assertIsSameRealPath(self.test_dir, cwd)
573
def test_BRZ_HOME_and_HOME_are_bytestrings(self):
574
"""The $BRZ_HOME and $HOME environment variables should not be unicode.
581
def test_BZR_HOME_and_HOME_are_bytestrings(self):
582
"""The $BZR_HOME and $HOME environment variables should not be unicode.
576
584
See https://bugs.launchpad.net/bzr/+bug/464174
578
self.assertIsInstance(os.environ['BRZ_HOME'], str)
586
self.assertIsInstance(os.environ['BZR_HOME'], str)
579
587
self.assertIsInstance(os.environ['HOME'], str)
581
589
def test_make_branch_and_memory_tree(self):
632
640
# Guard against regression into MemoryTransport leaking
633
641
# files to disk instead of keeping them in memory.
634
642
self.assertFalse(osutils.lexists('dir'))
635
dir_format = controldir.format_registry.make_controldir('knit')
643
dir_format = controldir.format_registry.make_bzrdir('knit')
636
644
self.assertEqual(dir_format.repository_format.__class__,
637
645
the_branch.repository._format.__class__)
638
self.assertEqual(b'Bazaar-NG Knit Repository Format 1',
646
self.assertEqual('Bazaar-NG Knit Repository Format 1',
639
647
self.get_transport().get_bytes(
640
648
'dir/.bzr/repository/format'))
661
669
"""Tests for the convenience functions TestCaseWithTransport introduces."""
663
671
def test_get_readonly_url_none(self):
664
from ..transport.readonly import ReadonlyTransportDecorator
672
from bzrlib.transport.readonly import ReadonlyTransportDecorator
665
673
self.vfs_transport_factory = memory.MemoryServer
666
674
self.transport_readonly_server = None
667
675
# calling get_readonly_transport() constructs a decorator on the url
675
683
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
677
685
def test_get_readonly_url_http(self):
678
from .http_server import HttpServer
679
from ..transport.http import HttpTransport
686
from bzrlib.tests.http_server import HttpServer
687
from bzrlib.transport.http import HttpTransportBase
680
688
self.transport_server = test_server.LocalURLServer
681
689
self.transport_readonly_server = HttpServer
682
690
# calling get_readonly_transport() gives us a HTTP server instance.
685
693
# the transport returned may be any HttpTransportBase subclass
686
694
t = transport.get_transport_from_url(url)
687
695
t2 = transport.get_transport_from_url(url2)
688
self.assertIsInstance(t, HttpTransport)
689
self.assertIsInstance(t2, HttpTransport)
696
self.assertIsInstance(t, HttpTransportBase)
697
self.assertIsInstance(t2, HttpTransportBase)
690
698
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
692
700
def test_is_directory(self):
716
724
super(TestTestCaseTransports, self).setUp()
717
725
self.vfs_transport_factory = memory.MemoryServer
719
def test_make_controldir_preserves_transport(self):
727
def test_make_bzrdir_preserves_transport(self):
720
728
t = self.get_transport()
721
result_bzrdir = self.make_controldir('subdir')
729
result_bzrdir = self.make_bzrdir('subdir')
722
730
self.assertIsInstance(result_bzrdir.transport,
723
731
memory.MemoryTransport)
724
732
# should not be on disk, should only be in memory
756
764
class TestTestResult(tests.TestCase):
758
766
def check_timing(self, test_case, expected_re):
759
result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
767
result = bzrlib.tests.TextTestResult(self._log_file,
760
771
capture = testtools.testresult.doubles.ExtendedTestResult()
761
772
test_case.run(MultiTestResult(result, capture))
762
773
run_case = capture._events[0][1]
957
968
self.assertEqual(0, result.error_count)
959
970
def test_strict_with_unsupported_feature(self):
960
result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
971
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
961
973
test = self.get_passing_test()
962
974
feature = "Unsupported Feature"
963
975
result.addNotSupported(test, feature)
965
977
self.assertEqual(None, result._extractBenchmarkTime(test))
967
979
def test_strict_with_known_failure(self):
968
result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
980
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
969
982
test = _get_test("test_xfail")
971
984
self.assertFalse(result.wasStrictlySuccessful())
972
985
self.assertEqual(None, result._extractBenchmarkTime(test))
974
987
def test_strict_with_success(self):
975
result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
988
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
976
990
test = self.get_passing_test()
977
991
result.addSuccess(test)
978
992
self.assertTrue(result.wasStrictlySuccessful())
1000
1014
unittest.FunctionTestCase(lambda: None),
1001
1015
unittest.FunctionTestCase(lambda: None)])
1002
1016
suite.run(result)
1003
self.assertEqual(1, result.calls)
1004
self.assertEqual(2, result.count)
1017
self.assertEquals(1, result.calls)
1018
self.assertEquals(2, result.count)
1007
1021
class TestRunner(tests.TestCase):
1016
1030
TestCaseInTempDir.TEST_ROOT
1018
1032
There should be no tests in this file that use
1019
breezy.tests.TextTestRunner without using this convenience method,
1033
bzrlib.tests.TextTestRunner without using this convenience method,
1020
1034
because of our use of global state.
1022
1036
old_root = tests.TestCaseInTempDir.TEST_ROOT
1115
1129
class SkippingTest(tests.TestCase):
1116
1130
def skipping_test(self):
1117
1131
raise tests.TestSkipped('test intentionally skipped')
1118
runner = tests.TextTestRunner(stream=StringIO())
1132
runner = tests.TextTestRunner(stream=self._log_file)
1119
1133
test = SkippingTest("skipping_test")
1120
1134
result = self.run_test_runner(runner, test)
1121
1135
self.assertTrue(result.wasSuccessful())
1173
1187
runner = tests.TextTestRunner(stream=out, verbosity=2)
1174
1188
test = Test("not_applicable_test")
1175
1189
result = self.run_test_runner(runner, test)
1176
self.log(out.getvalue())
1190
self._log_file.write(out.getvalue())
1177
1191
self.assertTrue(result.wasSuccessful())
1178
1192
self.assertTrue(result.wasStrictlySuccessful())
1179
1193
self.assertContainsRe(out.getvalue(),
1180
r'(?m)not_applicable_test * N/A')
1194
r'(?m)not_applicable_test * N/A')
1181
1195
self.assertContainsRe(out.getvalue(),
1182
1196
r'(?m)^ this test never runs')
1320
1334
self.assertEqual(1, result.testsRun)
1322
1336
def test_debug_flags_sanitised(self):
1323
"""The breezy debug flags should be sanitised by setUp."""
1337
"""The bzrlib debug flags should be sanitised by setUp."""
1324
1338
if 'allow_debug' in tests.selftest_debug_flags:
1325
1339
raise tests.TestNotApplicable(
1326
1340
'-Eallow_debug option prevents debug flag sanitisation')
1331
1345
if self._lock_check_thorough:
1332
1346
flags.add('strict_locks')
1333
self.assertEqual(flags, breezy.debug.debug_flags)
1347
self.assertEqual(flags, bzrlib.debug.debug_flags)
1335
1349
def change_selftest_debug_flags(self, new_flags):
1336
1350
self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
1338
1352
def test_allow_debug_flag(self):
1339
"""The -Eallow_debug flag prevents breezy.debug.debug_flags from being
1353
"""The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1340
1354
sanitised (i.e. cleared) before running a test.
1342
self.change_selftest_debug_flags({'allow_debug'})
1343
breezy.debug.debug_flags = {'a-flag'}
1356
self.change_selftest_debug_flags(set(['allow_debug']))
1357
bzrlib.debug.debug_flags = set(['a-flag'])
1344
1358
class TestThatRecordsFlags(tests.TestCase):
1345
1359
def test_foo(nested_self):
1346
self.flags = set(breezy.debug.debug_flags)
1360
self.flags = set(bzrlib.debug.debug_flags)
1347
1361
test = TestThatRecordsFlags('test_foo')
1348
1362
test.run(self.make_test_result())
1363
flags = set(['a-flag'])
1350
1364
if 'disable_lock_checks' not in tests.selftest_debug_flags:
1351
1365
flags.add('strict_locks')
1352
1366
self.assertEqual(flags, self.flags)
1355
1369
"""The -Edisable_lock_checks flag disables thorough checks."""
1356
1370
class TestThatRecordsFlags(tests.TestCase):
1357
1371
def test_foo(nested_self):
1358
self.flags = set(breezy.debug.debug_flags)
1372
self.flags = set(bzrlib.debug.debug_flags)
1359
1373
self.test_lock_check_thorough = nested_self._lock_check_thorough
1360
1374
self.change_selftest_debug_flags(set())
1361
1375
test = TestThatRecordsFlags('test_foo')
1363
1377
# By default we do strict lock checking and thorough lock/unlock
1365
1379
self.assertTrue(self.test_lock_check_thorough)
1366
self.assertEqual({'strict_locks'}, self.flags)
1380
self.assertEqual(set(['strict_locks']), self.flags)
1367
1381
# Now set the disable_lock_checks flag, and show that this changed.
1368
self.change_selftest_debug_flags({'disable_lock_checks'})
1382
self.change_selftest_debug_flags(set(['disable_lock_checks']))
1369
1383
test = TestThatRecordsFlags('test_foo')
1370
1384
test.run(self.make_test_result())
1371
1385
self.assertFalse(self.test_lock_check_thorough)
1374
1388
def test_this_fails_strict_lock_check(self):
1375
1389
class TestThatRecordsFlags(tests.TestCase):
1376
1390
def test_foo(nested_self):
1377
self.flags1 = set(breezy.debug.debug_flags)
1391
self.flags1 = set(bzrlib.debug.debug_flags)
1378
1392
self.thisFailsStrictLockCheck()
1379
self.flags2 = set(breezy.debug.debug_flags)
1393
self.flags2 = set(bzrlib.debug.debug_flags)
1380
1394
# Make sure lock checking is active
1381
1395
self.change_selftest_debug_flags(set())
1382
1396
test = TestThatRecordsFlags('test_foo')
1383
1397
test.run(self.make_test_result())
1384
self.assertEqual({'strict_locks'}, self.flags1)
1398
self.assertEqual(set(['strict_locks']), self.flags1)
1385
1399
self.assertEqual(set(), self.flags2)
1387
1401
def test_debug_flags_restored(self):
1388
"""The breezy debug flags should be restored to their original state
1402
"""The bzrlib debug flags should be restored to their original state
1389
1403
after the test was run, even if allow_debug is set.
1391
self.change_selftest_debug_flags({'allow_debug'})
1405
self.change_selftest_debug_flags(set(['allow_debug']))
1392
1406
# Now run a test that modifies debug.debug_flags.
1393
breezy.debug.debug_flags = {'original-state'}
1407
bzrlib.debug.debug_flags = set(['original-state'])
1394
1408
class TestThatModifiesFlags(tests.TestCase):
1395
1409
def test_foo(self):
1396
breezy.debug.debug_flags = {'modified'}
1410
bzrlib.debug.debug_flags = set(['modified'])
1397
1411
test = TestThatModifiesFlags('test_foo')
1398
1412
test.run(self.make_test_result())
1399
self.assertEqual({'original-state'}, breezy.debug.debug_flags)
1413
self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1401
1415
def make_test_result(self):
1402
"""Get a test result that writes to a StringIO."""
1403
return tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
1416
"""Get a test result that writes to the test log file."""
1417
return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1405
1419
def inner_test(self):
1406
1420
# the inner child test
1427
1441
# one child, we should instead see the bad result inside our test with
1428
1442
# the two children.
1429
1443
# the outer child test
1430
original_trace = breezy.trace._trace_file
1444
original_trace = bzrlib.trace._trace_file
1431
1445
outer_test = TestTestCase("outer_child")
1432
1446
result = self.make_test_result()
1433
1447
outer_test.run(result)
1434
self.assertEqual(original_trace, breezy.trace._trace_file)
1448
self.assertEqual(original_trace, bzrlib.trace._trace_file)
1436
1450
def method_that_times_a_bit_twice(self):
1437
1451
# call self.time twice to ensure it aggregates
1454
1468
def test_hooks_sanitised(self):
1455
"""The breezy hooks should be sanitised by setUp."""
1469
"""The bzrlib hooks should be sanitised by setUp."""
1456
1470
# Note this test won't fail with hooks that the core library doesn't
1457
1471
# use - but it trigger with a plugin that adds hooks, so its still a
1458
1472
# useful warning in that case.
1459
self.assertEqual(breezy.branch.BranchHooks(), breezy.branch.Branch.hooks)
1461
breezy.bzr.smart.server.SmartServerHooks(),
1462
breezy.bzr.smart.server.SmartTCPServer.hooks)
1464
breezy.commands.CommandHooks(), breezy.commands.Command.hooks)
1473
self.assertEqual(bzrlib.branch.BranchHooks(), bzrlib.branch.Branch.hooks)
1475
bzrlib.smart.server.SmartServerHooks(),
1476
bzrlib.smart.server.SmartTCPServer.hooks)
1478
bzrlib.commands.CommandHooks(), bzrlib.commands.Command.hooks)
1466
1480
def test__gather_lsprof_in_benchmarks(self):
1467
1481
"""When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1477
1491
self.assertEqual(2, len(self._benchcalls))
1478
1492
self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
1479
1493
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1480
self.assertIsInstance(self._benchcalls[0][1], breezy.lsprof.Stats)
1481
self.assertIsInstance(self._benchcalls[1][1], breezy.lsprof.Stats)
1494
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1495
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1482
1496
del self._benchcalls[:]
1484
1498
def test_knownFailure(self):
1713
1727
self.assertRaises(AttributeError, getattr, obj, 'test_attr')
1715
1729
def test_recordCalls(self):
1716
from breezy.tests import test_selftest
1730
from bzrlib.tests import test_selftest
1717
1731
calls = self.recordCalls(
1718
1732
test_selftest, '_add_numbers')
1719
1733
self.assertEqual(test_selftest._add_numbers(2, 10),
1721
self.assertEqual(calls, [((2, 10), {})])
1735
self.assertEquals(calls, [((2, 10), {})])
1724
1738
def _add_numbers(a, b):
1770
1784
return ExampleTests(name)
1773
def _get_skip_reasons(result):
1774
# GZ 2017-06-06: Newer testtools doesn't have this, uses detail instead
1775
return result.skip_reasons
1778
1787
class TestTestCaseLogDetails(tests.TestCase):
1780
1789
def _run_test(self, test_name):
1802
1811
def test_skip_has_no_log(self):
1803
1812
result = self._run_test('test_skip')
1804
reasons = _get_skip_reasons(result)
1805
self.assertEqual({'reason'}, set(reasons))
1806
skips = reasons['reason']
1813
self.assertEqual(['reason'], result.skip_reasons.keys())
1814
skips = result.skip_reasons['reason']
1807
1815
self.assertEqual(1, len(skips))
1808
1816
test = skips[0]
1809
1817
self.assertFalse('log' in test.getDetails())
1812
1820
# testtools doesn't know about addNotSupported, so it just gets
1813
1821
# considered as a skip
1814
1822
result = self._run_test('test_missing_feature')
1815
reasons = _get_skip_reasons(result)
1816
self.assertEqual({str(missing_feature)}, set(reasons))
1817
skips = reasons[str(missing_feature)]
1823
self.assertEqual([missing_feature], result.skip_reasons.keys())
1824
skips = result.skip_reasons[missing_feature]
1818
1825
self.assertEqual(1, len(skips))
1819
1826
test = skips[0]
1820
1827
self.assertFalse('log' in test.getDetails())
1901
1908
class TestExtraAssertions(tests.TestCase):
1902
"""Tests for new test assertions in breezy test suite"""
1909
"""Tests for new test assertions in bzrlib test suite"""
1904
1911
def test_assert_isinstance(self):
1905
1912
self.assertIsInstance(2, int)
1906
self.assertIsInstance(u'', (str, text_type))
1913
self.assertIsInstance(u'', basestring)
1907
1914
e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1908
self.assertEqual(str(e),
1915
self.assertEquals(str(e),
1909
1916
"None is an instance of <type 'NoneType'> rather than <type 'int'>")
1910
1917
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1911
1918
e = self.assertRaises(AssertionError,
1912
1919
self.assertIsInstance, None, int, "it's just not")
1913
self.assertEqual(str(e),
1920
self.assertEquals(str(e),
1914
1921
"None is an instance of <type 'NoneType'> rather than <type 'int'>"
1915
1922
": it's just not")
1921
1928
def test_assertEqualDiff(self):
1922
1929
e = self.assertRaises(AssertionError,
1923
1930
self.assertEqualDiff, '', '\n')
1924
self.assertEqual(str(e),
1931
self.assertEquals(str(e),
1925
1932
# Don't blink ! The '+' applies to the second string
1926
1933
'first string is missing a final newline.\n+ \n')
1927
1934
e = self.assertRaises(AssertionError,
1928
1935
self.assertEqualDiff, '\n', '')
1929
self.assertEqual(str(e),
1936
self.assertEquals(str(e),
1930
1937
# Don't blink ! The '-' applies to the second string
1931
1938
'second string is missing a final newline.\n- \n')
1989
1996
warnings.warn("this is your last warning")
1991
1998
wlist, result = self.callCatchWarnings(meth, 1, 2)
1992
self.assertEqual(3, result)
1999
self.assertEquals(3, result)
1993
2000
# would like just to compare them, but UserWarning doesn't implement
1996
2003
self.assertIsInstance(w0, UserWarning)
1997
self.assertEqual("this is your last warning", str(w0))
2004
self.assertEquals("this is your last warning", str(w0))
2000
2007
class TestConvenienceMakers(tests.TestCaseWithTransport):
2003
2010
def test_make_branch_and_tree_with_format(self):
2004
2011
# we should be able to supply a format to make_branch_and_tree
2005
self.make_branch_and_tree('a', format=breezy.bzr.bzrdir.BzrDirMetaFormat1())
2006
self.assertIsInstance(breezy.controldir.ControlDir.open('a')._format,
2007
breezy.bzr.bzrdir.BzrDirMetaFormat1)
2012
self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
2013
self.assertIsInstance(bzrlib.controldir.ControlDir.open('a')._format,
2014
bzrlib.bzrdir.BzrDirMetaFormat1)
2009
2016
def test_make_branch_and_memory_tree(self):
2010
2017
# we should be able to get a new branch and a mutable tree from
2011
2018
# TestCaseWithTransport
2012
2019
tree = self.make_branch_and_memory_tree('a')
2013
self.assertIsInstance(tree, breezy.memorytree.MemoryTree)
2020
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
2015
2022
def test_make_tree_for_local_vfs_backed_transport(self):
2016
2023
# make_branch_and_tree has to use local branch and repositories
2019
2026
self.transport_server = test_server.FakeVFATServer
2020
2027
self.assertFalse(self.get_url('t1').startswith('file://'))
2021
2028
tree = self.make_branch_and_tree('t1')
2022
base = tree.controldir.root_transport.base
2029
base = tree.bzrdir.root_transport.base
2023
2030
self.assertStartsWith(base, 'file://')
2024
self.assertEqual(tree.controldir.root_transport,
2025
tree.branch.controldir.root_transport)
2026
self.assertEqual(tree.controldir.root_transport,
2027
tree.branch.repository.controldir.root_transport)
2031
self.assertEquals(tree.bzrdir.root_transport,
2032
tree.branch.bzrdir.root_transport)
2033
self.assertEquals(tree.bzrdir.root_transport,
2034
tree.branch.repository.bzrdir.root_transport)
2030
2037
class SelfTestHelper(object):
2032
2039
def run_selftest(self, **kwargs):
2033
2040
"""Run selftest returning its output."""
2034
2041
output = StringIO()
2035
old_transport = breezy.tests.default_transport
2042
old_transport = bzrlib.tests.default_transport
2036
2043
old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
2037
2044
tests.TestCaseWithMemoryTransport.TEST_ROOT = None
2039
2046
self.assertEqual(True, tests.selftest(stream=output, **kwargs))
2041
breezy.tests.default_transport = old_transport
2048
bzrlib.tests.default_transport = old_transport
2042
2049
tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
2047
2054
class TestSelftest(tests.TestCase, SelfTestHelper):
2048
"""Tests of breezy.tests.selftest."""
2055
"""Tests of bzrlib.tests.selftest."""
2050
2057
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
2051
2058
factory_called = []
2054
2061
return TestUtil.TestSuite()
2055
2062
out = StringIO()
2056
2063
err = StringIO()
2057
self.apply_redirected(out, err, None, breezy.tests.selftest,
2064
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
2058
2065
test_suite_factory=factory)
2059
2066
self.assertEqual([True], factory_called)
2122
2129
def test_runner_class(self):
2123
2130
self.requireFeature(features.subunit)
2124
2131
from subunit import ProtocolTestCase
2125
stream = self.run_selftest(
2126
runner_class=tests.SubUnitBzrRunnerv1,
2132
stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
2127
2133
test_suite_factory=self.factory)
2128
2134
test = ProtocolTestCase(stream)
2129
2135
result = unittest.TestResult()
2133
2139
def test_starting_with_single_argument(self):
2134
2140
output = self.run_selftest(test_suite_factory=self.factory,
2135
starting_with=['breezy.tests.test_selftest.Test.a'],
2141
starting_with=['bzrlib.tests.test_selftest.Test.a'],
2136
2142
list_only=True)
2137
self.assertEqual('breezy.tests.test_selftest.Test.a\n',
2143
self.assertEqual('bzrlib.tests.test_selftest.Test.a\n',
2138
2144
output.getvalue())
2140
2146
def test_starting_with_multiple_argument(self):
2141
2147
output = self.run_selftest(test_suite_factory=self.factory,
2142
starting_with=['breezy.tests.test_selftest.Test.a',
2143
'breezy.tests.test_selftest.Test.b'],
2148
starting_with=['bzrlib.tests.test_selftest.Test.a',
2149
'bzrlib.tests.test_selftest.Test.b'],
2144
2150
list_only=True)
2145
self.assertEqual('breezy.tests.test_selftest.Test.a\n'
2146
'breezy.tests.test_selftest.Test.b\n',
2151
self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
2152
'bzrlib.tests.test_selftest.Test.b\n',
2147
2153
output.getvalue())
2149
2155
def check_transport_set(self, transport_server):
2152
2158
captured_transport.append(a_transport)
2153
2159
class Capture(tests.TestCase):
2155
seen_transport(breezy.tests.default_transport)
2161
seen_transport(bzrlib.tests.default_transport)
2157
2163
return TestUtil.TestSuite([Capture("a")])
2158
2164
self.run_selftest(transport=transport_server, test_suite_factory=factory)
2173
2179
def test_load_list(self):
2174
2180
# Provide a list with one test - this test.
2175
test_id_line = b'%s\n' % self.id()
2181
test_id_line = '%s\n' % self.id()
2176
2182
self.build_tree_contents([('test.list', test_id_line)])
2177
2183
# And generate a list of the tests in the suite.
2178
2184
stream = self.run_selftest(load_list='test.list', list_only=True)
2193
2199
from subunit import ProtocolTestCase
2195
2201
return TestUtil.TestSuite([_get_test(test_name)])
2196
stream = self.run_selftest(
2197
runner_class=tests.SubUnitBzrRunnerv1,
2202
stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
2198
2203
test_suite_factory=factory)
2199
2204
test = ProtocolTestCase(stream)
2200
2205
result = testtools.TestResult()
2217
2222
content, result = self.run_subunit_stream('test_skip')
2218
2223
self.assertNotContainsRe(content, '(?m)^log$')
2219
2224
self.assertNotContainsRe(content, 'this test will be skipped')
2220
reasons = _get_skip_reasons(result)
2221
self.assertEqual({'reason'}, set(reasons))
2222
skips = reasons['reason']
2225
self.assertEqual(['reason'], result.skip_reasons.keys())
2226
skips = result.skip_reasons['reason']
2223
2227
self.assertEqual(1, len(skips))
2224
2228
test = skips[0]
2225
2229
# RemotedTestCase doesn't preserve the "details"
2229
2233
content, result = self.run_subunit_stream('test_missing_feature')
2230
2234
self.assertNotContainsRe(content, '(?m)^log$')
2231
2235
self.assertNotContainsRe(content, 'missing the feature')
2232
reasons = _get_skip_reasons(result)
2233
self.assertEqual({'_MissingFeature\n'}, set(reasons))
2234
skips = reasons['_MissingFeature\n']
2236
self.assertEqual(['_MissingFeature\n'], result.skip_reasons.keys())
2237
skips = result.skip_reasons['_MissingFeature\n']
2235
2238
self.assertEqual(1, len(skips))
2236
2239
test = skips[0]
2237
2240
# RemotedTestCase doesn't preserve the "details"
2254
2257
# GZ 2011-05-18: Old versions of subunit treat unexpected success as a
2255
2258
# success, if a min version check is added remove this
2256
2259
from subunit import TestProtocolClient as _Client
2257
if _Client.addUnexpectedSuccess.__func__ is _Client.addSuccess.__func__:
2260
if _Client.addUnexpectedSuccess.im_func is _Client.addSuccess.im_func:
2258
2261
self.expectFailure('subunit treats "unexpectedSuccess"'
2259
2262
' as a plain success',
2260
2263
self.assertEqual, 1, len(result.unexpectedSuccesses))
2297
2300
self.assertEqual(['rocks'], self.argv)
2298
2301
self.assertEqual(34, self.retcode)
2299
2302
self.assertEqual('It sure does!\n', out)
2300
self.assertEqual(out, self.out)
2303
self.assertEquals(out, self.out)
2301
2304
self.assertEqual('', err)
2302
self.assertEqual(err, self.err)
2305
self.assertEquals(err, self.err)
2304
2307
def test_run_bzr_error_regexes(self):
2372
2375
def apply_redirected(self, stdin=None, stdout=None, stderr=None,
2373
2376
a_callable=None, *args, **kwargs):
2374
2377
self.stdin = stdin
2375
self.factory_stdin = getattr(breezy.ui.ui_factory, "stdin", None)
2376
self.factory = breezy.ui.ui_factory
2378
self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
2379
self.factory = bzrlib.ui.ui_factory
2377
2380
self.working_dir = osutils.getcwd()
2378
2381
stdout.write('foo\n')
2379
2382
stderr.write('bar\n')
2396
2399
# own UI factory, which is an instance of TestUIFactory,
2397
2400
# with stdin, stdout and stderr attached to the stdin,
2398
2401
# stdout and stderr of the invoked run_bzr
2399
current_factory = breezy.ui.ui_factory
2402
current_factory = bzrlib.ui.ui_factory
2400
2403
self.run_bzr(['foo'])
2401
2404
self.assertFalse(current_factory is self.factory)
2402
2405
self.assertNotEqual(sys.stdout, self.factory.stdout)
2474
2477
result = self.run_bzr_subprocess(*args, **kwargs)
2476
2479
self.next_subprocess = None
2477
for key, expected in expected_args.items():
2480
for key, expected in expected_args.iteritems():
2478
2481
self.assertEqual(expected, self.subprocess_calls[-1][key])
2481
2484
self.next_subprocess = None
2482
for key, expected in expected_args.items():
2485
for key, expected in expected_args.iteritems():
2483
2486
self.assertEqual(expected, self.subprocess_calls[-1][key])
2583
2586
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [])
2584
2587
command = self._popen_args[0]
2585
2588
self.assertEqual(sys.executable, command[0])
2586
self.assertEqual(self.get_brz_path(), command[1])
2589
self.assertEqual(self.get_bzr_path(), command[1])
2587
2590
self.assertEqual(['--no-plugins'], command[2:])
2589
2592
def test_allow_plugins(self):
2639
2642
working_dir='foo')
2640
2643
self.assertEqual(['foo', 'current'], chdirs)
2642
def test_get_brz_path_with_cwd_breezy(self):
2645
def test_get_bzr_path_with_cwd_bzrlib(self):
2643
2646
self.get_source_path = lambda: ""
2644
2647
self.overrideAttr(os.path, "isfile", lambda path: True)
2645
self.assertEqual(self.get_brz_path(), "brz")
2648
self.assertEqual(self.get_bzr_path(), "bzr")
2648
2651
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2659
2662
result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
2661
2664
self.assertEqual('', result[0])
2662
self.assertEqual('brz: interrupted\n', result[1])
2665
self.assertEqual('bzr: interrupted\n', result[1])
2665
2668
class TestSelftestFiltering(tests.TestCase):
2669
2672
self.suite = TestUtil.TestSuite()
2670
2673
self.loader = TestUtil.TestLoader()
2671
2674
self.suite.addTest(self.loader.loadTestsFromModule(
2672
sys.modules['breezy.tests.test_selftest']))
2675
sys.modules['bzrlib.tests.test_selftest']))
2673
2676
self.all_names = _test_ids(self.suite)
2675
2678
def test_condition_id_re(self):
2676
test_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2679
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2677
2680
'test_condition_id_re')
2678
2681
filtered_suite = tests.filter_suite_by_condition(
2679
2682
self.suite, tests.condition_id_re('test_condition_id_re'))
2680
2683
self.assertEqual([test_name], _test_ids(filtered_suite))
2682
2685
def test_condition_id_in_list(self):
2683
test_names = ['breezy.tests.test_selftest.TestSelftestFiltering.'
2686
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
2684
2687
'test_condition_id_in_list']
2685
2688
id_list = tests.TestIdList(test_names)
2686
2689
filtered_suite = tests.filter_suite_by_condition(
2690
2693
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2692
2695
def test_condition_id_startswith(self):
2693
klass = 'breezy.tests.test_selftest.TestSelftestFiltering.'
2696
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2694
2697
start1 = klass + 'test_condition_id_starts'
2695
2698
start2 = klass + 'test_condition_id_in'
2696
2699
test_names = [ klass + 'test_condition_id_in_list',
2703
2706
def test_condition_isinstance(self):
2704
2707
filtered_suite = tests.filter_suite_by_condition(
2705
2708
self.suite, tests.condition_isinstance(self.__class__))
2706
class_pattern = 'breezy.tests.test_selftest.TestSelftestFiltering.'
2709
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2707
2710
re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
2708
2711
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2710
2713
def test_exclude_tests_by_condition(self):
2711
excluded_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2714
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2712
2715
'test_exclude_tests_by_condition')
2713
2716
filtered_suite = tests.exclude_tests_by_condition(self.suite,
2714
2717
lambda x:x.id() == excluded_name)
2723
2726
self.all_names = _test_ids(self.suite)
2724
2727
filtered_suite = tests.exclude_tests_by_re(self.suite,
2725
2728
'exclude_tests_by_re')
2726
excluded_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2729
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2727
2730
'test_exclude_tests_by_re')
2728
2731
self.assertEqual(len(self.all_names) - 1,
2729
2732
filtered_suite.countTestCases())
2733
2736
self.assertEqual(remaining_names, _test_ids(filtered_suite))
2735
2738
def test_filter_suite_by_condition(self):
2736
test_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2739
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2737
2740
'test_filter_suite_by_condition')
2738
2741
filtered_suite = tests.filter_suite_by_condition(self.suite,
2739
2742
lambda x:x.id() == test_name)
2743
2746
filtered_suite = tests.filter_suite_by_re(self.suite,
2744
2747
'test_filter_suite_by_r')
2745
2748
filtered_names = _test_ids(filtered_suite)
2746
self.assertEqual(filtered_names, ['breezy.tests.test_selftest.'
2749
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
2747
2750
'TestSelftestFiltering.test_filter_suite_by_re'])
2749
2752
def test_filter_suite_by_id_list(self):
2750
test_list = ['breezy.tests.test_selftest.'
2753
test_list = ['bzrlib.tests.test_selftest.'
2751
2754
'TestSelftestFiltering.test_filter_suite_by_id_list']
2752
2755
filtered_suite = tests.filter_suite_by_id_list(
2753
2756
self.suite, tests.TestIdList(test_list))
2754
2757
filtered_names = _test_ids(filtered_suite)
2755
2758
self.assertEqual(
2756
2759
filtered_names,
2757
['breezy.tests.test_selftest.'
2760
['bzrlib.tests.test_selftest.'
2758
2761
'TestSelftestFiltering.test_filter_suite_by_id_list'])
2760
2763
def test_filter_suite_by_id_startswith(self):
2761
2764
# By design this test may fail if another test is added whose name also
2762
2765
# begins with one of the start value used.
2763
klass = 'breezy.tests.test_selftest.TestSelftestFiltering.'
2766
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2764
2767
start1 = klass + 'test_filter_suite_by_id_starts'
2765
2768
start2 = klass + 'test_filter_suite_by_id_li'
2766
2769
test_list = [klass + 'test_filter_suite_by_id_list',
2797
2800
self.all_names = _test_ids(self.suite)
2798
2801
condition = tests.condition_id_re('test_filter_suite_by_r')
2799
2802
split_suite = tests.split_suite_by_condition(self.suite, condition)
2800
filtered_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2803
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2801
2804
'test_filter_suite_by_re')
2802
2805
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2803
2806
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2809
2812
self.all_names = _test_ids(self.suite)
2810
2813
split_suite = tests.split_suite_by_re(self.suite,
2811
2814
'test_filter_suite_by_r')
2812
filtered_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2815
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2813
2816
'test_filter_suite_by_re')
2814
2817
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2815
2818
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2844
2847
self.run_bzr, ['assert-fail'])
2845
2848
# make sure we got the real thing, not an error from somewhere else in
2846
2849
# the test framework
2847
self.assertEqual('always fails', str(e))
2850
self.assertEquals('always fails', str(e))
2848
2851
# check that there's no traceback in the test log
2849
2852
self.assertNotContainsRe(self.get_log(), r'Traceback')
2860
2863
out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2861
2864
self.assertEqual(out, '')
2862
2865
self.assertContainsRe(err,
2863
'brz: ERROR: Not a branch: ".*nonexistantpath/".\n')
2866
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2866
2869
class TestTestLoader(tests.TestCase):
2887
2889
def test_module_load_tests_attribute_gets_called(self):
2888
2890
loader, module = self._get_loader_and_module()
2889
def load_tests(loader, standard_tests, pattern):
2891
# 'self' is here because we're faking the module with a class. Regular
2892
# load_tests do not need that :)
2893
def load_tests(self, standard_tests, module, loader):
2890
2894
result = loader.suiteClass()
2891
2895
for test in tests.iter_suite_tests(standard_tests):
2892
2896
result.addTests([test, test])
2894
2898
# add a load_tests() method which multiplies the tests from the module.
2895
module.__class__.load_tests = staticmethod(load_tests)
2897
2 * [str(module.a_class('test_foo'))],
2898
list(map(str, loader.loadTestsFromModule(module))))
2899
module.__class__.load_tests = load_tests
2900
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
2900
2902
def test_load_tests_from_module_name_smoke_test(self):
2901
2903
loader = TestUtil.TestLoader()
2902
suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
2903
self.assertEqual(['breezy.tests.test_sampler.DemoTest.test_nothing'],
2904
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2905
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2904
2906
_test_ids(suite))
2906
2908
def test_load_tests_from_module_name_with_bogus_module_name(self):
2936
2938
def test_empty_list(self):
2937
2939
id_list = self._create_id_list([])
2938
self.assertEqual({}, id_list.tests)
2939
self.assertEqual({}, id_list.modules)
2940
self.assertEquals({}, id_list.tests)
2941
self.assertEquals({}, id_list.modules)
2941
2943
def test_valid_list(self):
2942
2944
id_list = self._create_id_list(
2966
2968
def test_test_suite_matches_id_list_with_unknown(self):
2967
2969
loader = TestUtil.TestLoader()
2968
suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
2969
test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing',
2970
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2971
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2971
2973
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2972
self.assertEqual(['bogus'], not_found)
2973
self.assertEqual([], duplicates)
2974
self.assertEquals(['bogus'], not_found)
2975
self.assertEquals([], duplicates)
2975
2977
def test_suite_matches_id_list_with_duplicates(self):
2976
2978
loader = TestUtil.TestLoader()
2977
suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
2979
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2978
2980
dupes = loader.suiteClass()
2979
2981
for test in tests.iter_suite_tests(suite):
2980
2982
dupes.addTest(test)
2981
2983
dupes.addTest(test) # Add it again
2983
test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing',]
2985
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2984
2986
not_found, duplicates = tests.suite_matches_id_list(
2985
2987
dupes, test_list)
2986
self.assertEqual([], not_found)
2987
self.assertEqual(['breezy.tests.test_sampler.DemoTest.test_nothing'],
2988
self.assertEquals([], not_found)
2989
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2995
2997
# by _test_suite_testmod_names.
2996
2998
test_list = tests._test_suite_testmod_names()
2997
2999
self.assertSubset([
2998
'breezy.tests.blackbox',
2999
'breezy.tests.per_transport',
3000
'breezy.tests.test_selftest',
3000
'bzrlib.tests.blackbox',
3001
'bzrlib.tests.per_transport',
3002
'bzrlib.tests.test_selftest',
3024
3026
def testmod_names():
3025
3027
calls.append("testmod_names")
3027
'breezy.tests.blackbox.test_branch',
3028
'breezy.tests.per_transport',
3029
'breezy.tests.test_selftest',
3029
'bzrlib.tests.blackbox.test_branch',
3030
'bzrlib.tests.per_transport',
3031
'bzrlib.tests.test_selftest',
3031
3033
self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
3032
3034
def doctests():
3033
3035
calls.append("modules_to_doctest")
3034
3036
if __doc__ is None:
3036
return ['breezy.timestamp']
3038
return ['bzrlib.timestamp']
3037
3039
self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
3038
3040
expected_test_list = [
3039
3041
# testmod_names
3040
'breezy.tests.blackbox.test_branch.TestBranch.test_branch',
3041
('breezy.tests.per_transport.TransportTests'
3042
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
3043
('bzrlib.tests.per_transport.TransportTests'
3042
3044
'.test_abspath(LocalTransport,LocalURLServer)'),
3043
'breezy.tests.test_selftest.TestTestSuite.test_test_suite',
3045
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
3044
3046
# plugins can't be tested that way since selftest may be run with
3047
3049
if __doc__ is not None:
3048
3050
expected_test_list.extend([
3049
3051
# modules_to_doctest
3050
'breezy.timestamp.format_highres_date',
3052
'bzrlib.timestamp.format_highres_date',
3052
3054
suite = tests.test_suite()
3053
self.assertEqual({"testmod_names", "modules_to_doctest"},
3055
self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
3055
3057
self.assertSubset(expected_test_list, _test_ids(suite))
3059
3061
# to know that starting_with == None works. So a second load is
3060
3062
# incurred - note that the starting_with parameter causes a partial load
3061
3063
# rather than a full load so this test should be pretty quick.
3062
test_list = ['breezy.tests.test_selftest.TestTestSuite.test_test_suite']
3064
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
3063
3065
suite = tests.test_suite(test_list,
3064
['breezy.tests.test_selftest.TestTestSuite'])
3066
['bzrlib.tests.test_selftest.TestTestSuite'])
3065
3067
# test_test_suite_list_and_start is not included
3066
self.assertEqual(test_list, _test_ids(suite))
3068
self.assertEquals(test_list, _test_ids(suite))
3069
3071
class TestLoadTestIdList(tests.TestCaseInTempDir):
3082
3084
self._create_test_list_file(test_list_fname,
3083
3085
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
3084
3086
tlist = tests.load_test_id_list(test_list_fname)
3085
self.assertEqual(2, len(tlist))
3086
self.assertEqual('mod1.cl1.meth1', tlist[0])
3087
self.assertEqual('mod2.cl2.meth2', tlist[1])
3087
self.assertEquals(2, len(tlist))
3088
self.assertEquals('mod1.cl1.meth1', tlist[0])
3089
self.assertEquals('mod2.cl2.meth2', tlist[1])
3089
3091
def test_load_dirty_file(self):
3090
3092
test_list_fname = 'test.list'
3092
3094
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
3094
3096
tlist = tests.load_test_id_list(test_list_fname)
3095
self.assertEqual(4, len(tlist))
3096
self.assertEqual('mod1.cl1.meth1', tlist[0])
3097
self.assertEqual('', tlist[1])
3098
self.assertEqual('mod2.cl2.meth2', tlist[2])
3099
self.assertEqual('bar baz', tlist[3])
3097
self.assertEquals(4, len(tlist))
3098
self.assertEquals('mod1.cl1.meth1', tlist[0])
3099
self.assertEquals('', tlist[1])
3100
self.assertEquals('mod2.cl2.meth2', tlist[2])
3101
self.assertEquals('bar baz', tlist[3])
3102
3104
class TestFilteredByModuleTestLoader(tests.TestCase):
3109
3111
def test_load_tests(self):
3110
test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
3112
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3111
3113
loader = self._create_loader(test_list)
3112
suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3113
self.assertEqual(test_list, _test_ids(suite))
3114
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3115
self.assertEquals(test_list, _test_ids(suite))
3115
3117
def test_exclude_tests(self):
3116
3118
test_list = ['bogus']
3117
3119
loader = self._create_loader(test_list)
3118
suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3119
self.assertEqual([], _test_ids(suite))
3120
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3121
self.assertEquals([], _test_ids(suite))
3122
3124
class TestFilteredByNameStartTestLoader(tests.TestCase):
3130
3132
def test_load_tests(self):
3131
test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
3132
loader = self._create_loader('breezy.tests.test_samp')
3133
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3134
loader = self._create_loader('bzrlib.tests.test_samp')
3134
suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3135
self.assertEqual(test_list, _test_ids(suite))
3136
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3137
self.assertEquals(test_list, _test_ids(suite))
3137
3139
def test_load_tests_inside_module(self):
3138
test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
3139
loader = self._create_loader('breezy.tests.test_sampler.Demo')
3140
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3141
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
3141
suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3142
self.assertEqual(test_list, _test_ids(suite))
3143
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3144
self.assertEquals(test_list, _test_ids(suite))
3144
3146
def test_exclude_tests(self):
3145
3147
test_list = ['bogus']
3146
3148
loader = self._create_loader('bogus')
3148
suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3149
self.assertEqual([], _test_ids(suite))
3150
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3151
self.assertEquals([], _test_ids(suite))
3152
3154
class TestTestPrefixRegistry(tests.TestCase):
3158
3160
def test_register_new_prefix(self):
3159
3161
tpr = self._get_registry()
3160
3162
tpr.register('foo', 'fff.ooo.ooo')
3161
self.assertEqual('fff.ooo.ooo', tpr.get('foo'))
3163
self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
3163
3165
def test_register_existing_prefix(self):
3164
3166
tpr = self._get_registry()
3165
3167
tpr.register('bar', 'bbb.aaa.rrr')
3166
3168
tpr.register('bar', 'bBB.aAA.rRR')
3167
self.assertEqual('bbb.aaa.rrr', tpr.get('bar'))
3169
self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
3168
3170
self.assertThat(self.get_log(),
3169
3171
DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR",
3170
3172
doctest.ELLIPSIS))
3176
3178
def test_resolve_prefix(self):
3177
3179
tpr = self._get_registry()
3178
3180
tpr.register('bar', 'bb.aa.rr')
3179
self.assertEqual('bb.aa.rr', tpr.resolve_alias('bar'))
3181
self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
3181
3183
def test_resolve_unknown_alias(self):
3182
3184
tpr = self._get_registry()
3186
3188
def test_predefined_prefixes(self):
3187
3189
tpr = tests.test_prefix_alias_registry
3188
self.assertEqual('breezy', tpr.resolve_alias('breezy'))
3189
self.assertEqual('breezy.doc', tpr.resolve_alias('bd'))
3190
self.assertEqual('breezy.utils', tpr.resolve_alias('bu'))
3191
self.assertEqual('breezy.tests', tpr.resolve_alias('bt'))
3192
self.assertEqual('breezy.tests.blackbox', tpr.resolve_alias('bb'))
3193
self.assertEqual('breezy.plugins', tpr.resolve_alias('bp'))
3190
self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
3191
self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
3192
self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
3193
self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
3194
self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
3195
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
3196
3198
class TestThreadLeakDetection(tests.TestCase):
3238
3240
result.stopTestRun()
3239
3241
self.assertEqual(result._tests_leaking_threads_count, 1)
3240
3242
self.assertEqual(result._first_thread_leaker_id, test.id())
3241
self.assertEqual(result.leaks, [(test, {thread})])
3243
self.assertEqual(result.leaks, [(test, set([thread]))])
3242
3244
self.assertContainsString(result.stream.getvalue(), "leaking threads")
3244
3246
def test_multiple_leaks(self):
3274
3276
self.assertEqual(result._tests_leaking_threads_count, 2)
3275
3277
self.assertEqual(result._first_thread_leaker_id, first_test.id())
3276
3278
self.assertEqual(result.leaks, [
3277
(first_test, {thread_b}),
3278
(third_test, {thread_a, thread_c})])
3279
(first_test, set([thread_b])),
3280
(third_test, set([thread_a, thread_c]))])
3279
3281
self.assertContainsString(result.stream.getvalue(), "leaking threads")
3307
3309
raise RuntimeError
3308
3310
result = self.TracebackRecordingResult()
3309
3311
Test().run(result)
3310
self.assertEqual(result.postcode, Test.runTest.__code__)
3312
self.assertEqual(result.postcode, Test.runTest.func_code)
3312
3314
def test_location_unittest_failure(self):
3313
3315
"""Needs right post mortem traceback with failing unittest case"""
3316
3318
raise self.failureException
3317
3319
result = self.TracebackRecordingResult()
3318
3320
Test().run(result)
3319
self.assertEqual(result.postcode, Test.runTest.__code__)
3321
self.assertEqual(result.postcode, Test.runTest.func_code)
3321
3323
def test_location_bt_error(self):
3322
"""Needs right post mortem traceback with erroring breezy.tests case"""
3324
"""Needs right post mortem traceback with erroring bzrlib.tests case"""
3323
3325
class Test(tests.TestCase):
3324
3326
def test_error(self):
3325
3327
raise RuntimeError
3326
3328
result = self.TracebackRecordingResult()
3327
3329
Test("test_error").run(result)
3328
self.assertEqual(result.postcode, Test.test_error.__code__)
3330
self.assertEqual(result.postcode, Test.test_error.func_code)
3330
3332
def test_location_bt_failure(self):
3331
"""Needs right post mortem traceback with failing breezy.tests case"""
3333
"""Needs right post mortem traceback with failing bzrlib.tests case"""
3332
3334
class Test(tests.TestCase):
3333
3335
def test_failure(self):
3334
3336
raise self.failureException
3335
3337
result = self.TracebackRecordingResult()
3336
3338
Test("test_failure").run(result)
3337
self.assertEqual(result.postcode, Test.test_failure.__code__)
3339
self.assertEqual(result.postcode, Test.test_failure.func_code)
3339
3341
def test_env_var_triggers_post_mortem(self):
3340
"""Check pdb.post_mortem is called iff BRZ_TEST_PDB is set"""
3342
"""Check pdb.post_mortem is called iff BZR_TEST_PDB is set"""
3342
3344
result = tests.ExtendedTestResult(StringIO(), 0, 1)
3343
3345
post_mortem_calls = []
3344
3346
self.overrideAttr(pdb, "post_mortem", post_mortem_calls.append)
3345
self.overrideEnv('BRZ_TEST_PDB', None)
3347
self.overrideEnv('BZR_TEST_PDB', None)
3346
3348
result._post_mortem(1)
3347
self.overrideEnv('BRZ_TEST_PDB', 'on')
3349
self.overrideEnv('BZR_TEST_PDB', 'on')
3348
3350
result._post_mortem(2)
3349
3351
self.assertEqual([2], post_mortem_calls)
3501
3503
_test_needs_features = [features.subunit]
3503
3505
def _run_selftest_with_suite(self, **kwargs):
3504
return TestUncollectedWarnings._run_selftest_with_suite(
3505
self, runner_class=tests.SubUnitBzrRunnerv1, **kwargs)
3506
return TestUncollectedWarnings._run_selftest_with_suite(self,
3507
runner_class=tests.SubUnitBzrRunner, **kwargs)
3508
3510
class TestUncollectedWarningsForked(_ForkedSelftest, TestUncollectedWarnings):
3519
3521
def test_me(self):
3520
3522
# The first call save the 42 value
3521
3523
self.overrideEnv('MYVAR', None)
3522
self.assertEqual(None, os.environ.get('MYVAR'))
3524
self.assertEquals(None, os.environ.get('MYVAR'))
3523
3525
# Make sure we can call it twice
3524
3526
self.overrideEnv('MYVAR', None)
3525
self.assertEqual(None, os.environ.get('MYVAR'))
3527
self.assertEquals(None, os.environ.get('MYVAR'))
3526
3528
output = StringIO()
3527
3529
result = tests.TextTestResult(output, 0, 1)
3528
3530
Test('test_me').run(result)
3529
3531
if not result.wasStrictlySuccessful():
3530
3532
self.fail(output.getvalue())
3531
3533
# We get our value back
3532
self.assertEqual('42', os.environ.get('MYVAR'))
3534
self.assertEquals('42', os.environ.get('MYVAR'))
3535
3537
class TestIsolatedEnv(tests.TestCase):
3550
3552
def test_basics(self):
3551
# Make sure we know the definition of BRZ_HOME: not part of os.environ
3553
# Make sure we know the definition of BZR_HOME: not part of os.environ
3552
3554
# for tests.TestCase.
3553
self.assertTrue('BRZ_HOME' in tests.isolated_environ)
3554
self.assertEqual(None, tests.isolated_environ['BRZ_HOME'])
3555
# Being part of isolated_environ, BRZ_HOME should not appear here
3556
self.assertFalse('BRZ_HOME' in os.environ)
3555
self.assertTrue('BZR_HOME' in tests.isolated_environ)
3556
self.assertEquals(None, tests.isolated_environ['BZR_HOME'])
3557
# Being part of isolated_environ, BZR_HOME should not appear here
3558
self.assertFalse('BZR_HOME' in os.environ)
3557
3559
# Make sure we know the definition of LINES: part of os.environ for
3558
3560
# tests.TestCase
3559
3561
self.assertTrue('LINES' in tests.isolated_environ)
3560
self.assertEqual('25', tests.isolated_environ['LINES'])
3561
self.assertEqual('25', os.environ['LINES'])
3562
self.assertEquals('25', tests.isolated_environ['LINES'])
3563
self.assertEquals('25', os.environ['LINES'])
3563
3565
def test_injecting_unknown_variable(self):
3564
# BRZ_HOME is known to be absent from os.environ
3566
# BZR_HOME is known to be absent from os.environ
3565
3567
test = self.ScratchMonkey('test_me')
3566
tests.override_os_environ(test, {'BRZ_HOME': 'foo'})
3567
self.assertEqual('foo', os.environ['BRZ_HOME'])
3568
tests.override_os_environ(test, {'BZR_HOME': 'foo'})
3569
self.assertEquals('foo', os.environ['BZR_HOME'])
3568
3570
tests.restore_os_environ(test)
3569
self.assertFalse('BRZ_HOME' in os.environ)
3571
self.assertFalse('BZR_HOME' in os.environ)
3571
3573
def test_injecting_known_variable(self):
3572
3574
test = self.ScratchMonkey('test_me')
3573
3575
# LINES is known to be present in os.environ
3574
3576
tests.override_os_environ(test, {'LINES': '42'})
3575
self.assertEqual('42', os.environ['LINES'])
3577
self.assertEquals('42', os.environ['LINES'])
3576
3578
tests.restore_os_environ(test)
3577
self.assertEqual('25', os.environ['LINES'])
3579
self.assertEquals('25', os.environ['LINES'])
3579
3581
def test_deleting_variable(self):
3580
3582
test = self.ScratchMonkey('test_me')
3582
3584
tests.override_os_environ(test, {'LINES': None})
3583
3585
self.assertTrue('LINES' not in os.environ)
3584
3586
tests.restore_os_environ(test)
3585
self.assertEqual('25', os.environ['LINES'])
3587
self.assertEquals('25', os.environ['LINES'])
3588
3590
class TestDocTestSuiteIsolation(tests.TestCase):
3675
3677
# test at the command level without loading the whole test suite
3676
3678
out, err = self.run_bzr(('selftest', '--list') + selftest_args)
3677
3679
actual = out.splitlines()
3678
self.assertEqual(expected, actual)
3680
self.assertEquals(expected, actual)
3680
3682
def test_full_list(self):
3681
3683
self.assertTestList(['a', 'b', 'c'])
3698
3700
def setUp(self):
3699
3701
super(Test, self).setUp()
3700
3702
self.hooks = hooks.Hooks()
3701
self.hooks.add_hook('myhook', 'Foo bar blah', (2, 4))
3703
self.hooks.add_hook('myhook', 'Foo bar blah', (2,4))
3702
3704
self.install_counter_hook(self.hooks, 'myhook')
3704
3706
def no_hook(self):
3715
3717
result = unittest.TestResult()
3716
3718
test.run(result)
3717
3719
self.assertTrue(hasattr(test, '_counters'))
3718
self.assertTrue('myhook' in test._counters)
3719
self.assertEqual(expected_calls, test._counters['myhook'])
3720
self.assertTrue(test._counters.has_key('myhook'))
3721
self.assertEquals(expected_calls, test._counters['myhook'])
3721
3723
def test_no_hook(self):
3722
3724
self.assertHookCalls(0, 'no_hook')
added
removed
bzrlib/tests/test_selftest.py
