571
548
tree = self.make_branch_and_memory_tree('dir')
572
549
# Guard against regression into MemoryTransport leaking
573
550
# files to disk instead of keeping them in memory.
574
self.assertFalse(osutils.lexists('dir'))
551
self.failIf(osutils.lexists('dir'))
575
552
self.assertIsInstance(tree, memorytree.MemoryTree)
577
554
def test_make_branch_and_memory_tree_with_format(self):
578
555
"""make_branch_and_memory_tree should accept a format option."""
579
556
format = bzrdir.BzrDirMetaFormat1()
580
format.repository_format = repository.format_registry.get_default()
557
format.repository_format = weaverepo.RepositoryFormat7()
581
558
tree = self.make_branch_and_memory_tree('dir', format=format)
582
559
# Guard against regression into MemoryTransport leaking
583
560
# files to disk instead of keeping them in memory.
584
self.assertFalse(osutils.lexists('dir'))
561
self.failIf(osutils.lexists('dir'))
585
562
self.assertIsInstance(tree, memorytree.MemoryTree)
586
563
self.assertEqual(format.repository_format.__class__,
587
564
tree.branch.repository._format.__class__)
591
568
self.assertIsInstance(builder, branchbuilder.BranchBuilder)
592
569
# Guard against regression into MemoryTransport leaking
593
570
# files to disk instead of keeping them in memory.
594
self.assertFalse(osutils.lexists('dir'))
571
self.failIf(osutils.lexists('dir'))
596
573
def test_make_branch_builder_with_format(self):
597
574
# Use a repo layout that doesn't conform to a 'named' layout, to ensure
598
575
# that the format objects are used.
599
576
format = bzrdir.BzrDirMetaFormat1()
600
repo_format = repository.format_registry.get_default()
577
repo_format = weaverepo.RepositoryFormat7()
601
578
format.repository_format = repo_format
602
579
builder = self.make_branch_builder('dir', format=format)
603
580
the_branch = builder.get_branch()
604
581
# Guard against regression into MemoryTransport leaking
605
582
# files to disk instead of keeping them in memory.
606
self.assertFalse(osutils.lexists('dir'))
583
self.failIf(osutils.lexists('dir'))
607
584
self.assertEqual(format.repository_format.__class__,
608
585
the_branch.repository._format.__class__)
609
586
self.assertEqual(repo_format.get_format_string(),
771
750
self.check_timing(ShortDelayTestCase('test_short_delay'),
753
def _patch_get_bzr_source_tree(self):
754
# Reading from the actual source tree breaks isolation, but we don't
755
# want to assume that thats *all* that would happen.
756
self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', lambda: None)
758
def test_assigned_benchmark_file_stores_date(self):
759
self._patch_get_bzr_source_tree()
761
result = bzrlib.tests.TextTestResult(self._log_file,
766
output_string = output.getvalue()
767
# if you are wondering about the regexp please read the comment in
768
# test_bench_history (bzrlib.tests.test_selftest.TestRunner)
769
# XXX: what comment? -- Andrew Bennetts
770
self.assertContainsRe(output_string, "--date [0-9.]+")
772
def test_benchhistory_records_test_times(self):
773
self._patch_get_bzr_source_tree()
774
result_stream = StringIO()
775
result = bzrlib.tests.TextTestResult(
779
bench_history=result_stream
782
# we want profile a call and check that its test duration is recorded
783
# make a new test instance that when run will generate a benchmark
784
example_test_case = TestTestResult("_time_hello_world_encoding")
785
# execute the test, which should succeed and record times
786
example_test_case.run(result)
787
lines = result_stream.getvalue().splitlines()
788
self.assertEqual(2, len(lines))
789
self.assertContainsRe(lines[1],
790
" *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
791
"._time_hello_world_encoding")
774
793
def _time_hello_world_encoding(self):
775
794
"""Profile two sleep calls
816
835
self.assertContainsRe(output,
817
836
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
819
def test_uses_time_from_testtools(self):
820
"""Test case timings in verbose results should use testtools times"""
822
class TimeAddedVerboseTestResult(tests.VerboseTestResult):
823
def startTest(self, test):
824
self.time(datetime.datetime.utcfromtimestamp(1.145))
825
super(TimeAddedVerboseTestResult, self).startTest(test)
826
def addSuccess(self, test):
827
self.time(datetime.datetime.utcfromtimestamp(51.147))
828
super(TimeAddedVerboseTestResult, self).addSuccess(test)
829
def report_tests_starting(self): pass
831
self.get_passing_test().run(TimeAddedVerboseTestResult(sio, 0, 2))
832
self.assertEndsWith(sio.getvalue(), "OK 50002ms\n")
834
838
def test_known_failure(self):
835
839
"""A KnownFailure being raised should trigger several result actions."""
836
840
class InstrumentedTestResult(tests.ExtendedTestResult):
837
841
def stopTestRun(self): pass
838
def report_tests_starting(self): pass
842
def startTests(self): pass
843
def report_test_start(self, test): pass
839
844
def report_known_failure(self, test, err=None, details=None):
840
845
self._call = test, 'known failure'
841
846
result = InstrumentedTestResult(None, None, None, None)
1198
def test_verbose_test_count(self):
1199
"""A verbose test run reports the right test count at the start"""
1200
suite = TestUtil.TestSuite([
1201
unittest.FunctionTestCase(lambda:None),
1202
unittest.FunctionTestCase(lambda:None)])
1203
self.assertEqual(suite.countTestCases(), 2)
1205
runner = tests.TextTestRunner(stream=stream, verbosity=2)
1206
# Need to use the CountingDecorator as that's what sets num_tests
1207
result = self.run_test_runner(runner, tests.CountingDecorator(suite))
1208
self.assertStartsWith(stream.getvalue(), "running 2 tests")
1193
def _patch_get_bzr_source_tree(self):
1194
# Reading from the actual source tree breaks isolation, but we don't
1195
# want to assume that thats *all* that would happen.
1196
self._get_source_tree_calls = []
1198
self._get_source_tree_calls.append("called")
1200
self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', new_get)
1202
def test_bench_history(self):
1203
# tests that the running the benchmark passes bench_history into
1204
# the test result object. We can tell that happens if
1205
# _get_bzr_source_tree is called.
1206
self._patch_get_bzr_source_tree()
1207
test = TestRunner('dummy_test')
1209
runner = tests.TextTestRunner(stream=self._log_file,
1210
bench_history=output)
1211
result = self.run_test_runner(runner, test)
1212
output_string = output.getvalue()
1213
self.assertContainsRe(output_string, "--date [0-9.]+")
1214
self.assertLength(1, self._get_source_tree_calls)
1210
1216
def test_startTestRun(self):
1211
1217
"""run should call result.startTestRun()"""
1213
class LoggingDecorator(ExtendedToOriginalDecorator):
1219
class LoggingDecorator(tests.ForwardingResult):
1214
1220
def startTestRun(self):
1215
ExtendedToOriginalDecorator.startTestRun(self)
1221
tests.ForwardingResult.startTestRun(self)
1216
1222
calls.append('startTestRun')
1217
1223
test = unittest.FunctionTestCase(lambda:None)
1218
1224
stream = StringIO()
1666
1655
self.assertEqual('original', obj.test_attr)
1669
class _MissingFeature(tests.Feature):
1672
missing_feature = _MissingFeature()
1675
def _get_test(name):
1676
"""Get an instance of a specific example test.
1678
We protect this in a function so that they don't auto-run in the test
1682
class ExampleTests(tests.TestCase):
1684
def test_fail(self):
1685
mutter('this was a failing test')
1686
self.fail('this test will fail')
1688
def test_error(self):
1689
mutter('this test errored')
1690
raise RuntimeError('gotcha')
1692
def test_missing_feature(self):
1693
mutter('missing the feature')
1694
self.requireFeature(missing_feature)
1696
def test_skip(self):
1697
mutter('this test will be skipped')
1698
raise tests.TestSkipped('reason')
1700
def test_success(self):
1701
mutter('this test succeeds')
1703
def test_xfail(self):
1704
mutter('test with expected failure')
1705
self.knownFailure('this_fails')
1707
def test_unexpected_success(self):
1708
mutter('test with unexpected success')
1709
self.expectFailure('should_fail', lambda: None)
1711
return ExampleTests(name)
1714
class TestTestCaseLogDetails(tests.TestCase):
1716
def _run_test(self, test_name):
1717
test = _get_test(test_name)
1718
result = testtools.TestResult()
1722
def test_fail_has_log(self):
1723
result = self._run_test('test_fail')
1724
self.assertEqual(1, len(result.failures))
1725
result_content = result.failures[0][1]
1726
self.assertContainsRe(result_content, 'Text attachment: log')
1727
self.assertContainsRe(result_content, 'this was a failing test')
1729
def test_error_has_log(self):
1730
result = self._run_test('test_error')
1731
self.assertEqual(1, len(result.errors))
1732
result_content = result.errors[0][1]
1733
self.assertContainsRe(result_content, 'Text attachment: log')
1734
self.assertContainsRe(result_content, 'this test errored')
1736
def test_skip_has_no_log(self):
1737
result = self._run_test('test_skip')
1738
self.assertEqual(['reason'], result.skip_reasons.keys())
1739
skips = result.skip_reasons['reason']
1740
self.assertEqual(1, len(skips))
1742
self.assertFalse('log' in test.getDetails())
1744
def test_missing_feature_has_no_log(self):
1745
# testtools doesn't know about addNotSupported, so it just gets
1746
# considered as a skip
1747
result = self._run_test('test_missing_feature')
1748
self.assertEqual([missing_feature], result.skip_reasons.keys())
1749
skips = result.skip_reasons[missing_feature]
1750
self.assertEqual(1, len(skips))
1752
self.assertFalse('log' in test.getDetails())
1754
def test_xfail_has_no_log(self):
1755
result = self._run_test('test_xfail')
1756
self.assertEqual(1, len(result.expectedFailures))
1757
result_content = result.expectedFailures[0][1]
1758
self.assertNotContainsRe(result_content, 'Text attachment: log')
1759
self.assertNotContainsRe(result_content, 'test with expected failure')
1761
def test_unexpected_success_has_log(self):
1762
result = self._run_test('test_unexpected_success')
1763
self.assertEqual(1, len(result.unexpectedSuccesses))
1764
# Inconsistency, unexpectedSuccesses is a list of tests,
1765
# expectedFailures is a list of reasons?
1766
test = result.unexpectedSuccesses[0]
1767
details = test.getDetails()
1768
self.assertTrue('log' in details)
1771
class TestTestCloning(tests.TestCase):
1772
"""Tests that test cloning of TestCases (as used by multiply_tests)."""
1774
def test_cloned_testcase_does_not_share_details(self):
1775
"""A TestCase cloned with clone_test does not share mutable attributes
1776
such as details or cleanups.
1778
class Test(tests.TestCase):
1780
self.addDetail('foo', Content('text/plain', lambda: 'foo'))
1781
orig_test = Test('test_foo')
1782
cloned_test = tests.clone_test(orig_test, orig_test.id() + '(cloned)')
1783
orig_test.run(unittest.TestResult())
1784
self.assertEqual('foo', orig_test.getDetails()['foo'].iter_bytes())
1785
self.assertEqual(None, cloned_test.getDetails().get('foo'))
1787
def test_double_apply_scenario_preserves_first_scenario(self):
1788
"""Applying two levels of scenarios to a test preserves the attributes
1789
added by both scenarios.
1791
class Test(tests.TestCase):
1794
test = Test('test_foo')
1795
scenarios_x = [('x=1', {'x': 1}), ('x=2', {'x': 2})]
1796
scenarios_y = [('y=1', {'y': 1}), ('y=2', {'y': 2})]
1797
suite = tests.multiply_tests(test, scenarios_x, unittest.TestSuite())
1798
suite = tests.multiply_tests(suite, scenarios_y, unittest.TestSuite())
1799
all_tests = list(tests.iter_suite_tests(suite))
1800
self.assertLength(4, all_tests)
1801
all_xys = sorted((t.x, t.y) for t in all_tests)
1802
self.assertEqual([(1, 1), (1, 2), (2, 1), (2, 2)], all_xys)
1805
1658
# NB: Don't delete this; it's not actually from 0.11!
1806
1659
@deprecated_function(deprecated_in((0, 11, 0)))
1807
1660
def sample_deprecated_function():
2115
1971
load_list='missing file name', list_only=True)
2118
class TestSubunitLogDetails(tests.TestCase, SelfTestHelper):
2120
_test_needs_features = [features.subunit]
2122
def run_subunit_stream(self, test_name):
2123
from subunit import ProtocolTestCase
2125
return TestUtil.TestSuite([_get_test(test_name)])
2126
stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
2127
test_suite_factory=factory)
2128
test = ProtocolTestCase(stream)
2129
result = testtools.TestResult()
2131
content = stream.getvalue()
2132
return content, result
2134
def test_fail_has_log(self):
2135
content, result = self.run_subunit_stream('test_fail')
2136
self.assertEqual(1, len(result.failures))
2137
self.assertContainsRe(content, '(?m)^log$')
2138
self.assertContainsRe(content, 'this test will fail')
2140
def test_error_has_log(self):
2141
content, result = self.run_subunit_stream('test_error')
2142
self.assertContainsRe(content, '(?m)^log$')
2143
self.assertContainsRe(content, 'this test errored')
2145
def test_skip_has_no_log(self):
2146
content, result = self.run_subunit_stream('test_skip')
2147
self.assertNotContainsRe(content, '(?m)^log$')
2148
self.assertNotContainsRe(content, 'this test will be skipped')
2149
self.assertEqual(['reason'], result.skip_reasons.keys())
2150
skips = result.skip_reasons['reason']
2151
self.assertEqual(1, len(skips))
2153
# RemotedTestCase doesn't preserve the "details"
2154
## self.assertFalse('log' in test.getDetails())
2156
def test_missing_feature_has_no_log(self):
2157
content, result = self.run_subunit_stream('test_missing_feature')
2158
self.assertNotContainsRe(content, '(?m)^log$')
2159
self.assertNotContainsRe(content, 'missing the feature')
2160
self.assertEqual(['_MissingFeature\n'], result.skip_reasons.keys())
2161
skips = result.skip_reasons['_MissingFeature\n']
2162
self.assertEqual(1, len(skips))
2164
# RemotedTestCase doesn't preserve the "details"
2165
## self.assertFalse('log' in test.getDetails())
2167
def test_xfail_has_no_log(self):
2168
content, result = self.run_subunit_stream('test_xfail')
2169
self.assertNotContainsRe(content, '(?m)^log$')
2170
self.assertNotContainsRe(content, 'test with expected failure')
2171
self.assertEqual(1, len(result.expectedFailures))
2172
result_content = result.expectedFailures[0][1]
2173
self.assertNotContainsRe(result_content, 'Text attachment: log')
2174
self.assertNotContainsRe(result_content, 'test with expected failure')
2176
def test_unexpected_success_has_log(self):
2177
content, result = self.run_subunit_stream('test_unexpected_success')
2178
self.assertContainsRe(content, '(?m)^log$')
2179
self.assertContainsRe(content, 'test with unexpected success')
2180
self.expectFailure('subunit treats "unexpectedSuccess"'
2181
' as a plain success',
2182
self.assertEqual, 1, len(result.unexpectedSuccesses))
2183
self.assertEqual(1, len(result.unexpectedSuccesses))
2184
test = result.unexpectedSuccesses[0]
2185
# RemotedTestCase doesn't preserve the "details"
2186
## self.assertTrue('log' in test.getDetails())
2188
def test_success_has_no_log(self):
2189
content, result = self.run_subunit_stream('test_success')
2190
self.assertEqual(1, result.testsRun)
2191
self.assertNotContainsRe(content, '(?m)^log$')
2192
self.assertNotContainsRe(content, 'this test succeeds')
2195
1974
class TestRunBzr(tests.TestCase):
3187
2960
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
3190
class TestThreadLeakDetection(tests.TestCase):
3191
"""Ensure when tests leak threads we detect and report it"""
3193
class LeakRecordingResult(tests.ExtendedTestResult):
3195
tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3197
def _report_thread_leak(self, test, leaks, alive):
3198
self.leaks.append((test, leaks))
3200
def test_testcase_without_addCleanups(self):
3201
"""Check old TestCase instances don't break with leak detection"""
3202
class Test(unittest.TestCase):
3205
result = self.LeakRecordingResult()
3207
result.startTestRun()
3209
result.stopTestRun()
3210
self.assertEqual(result._tests_leaking_threads_count, 0)
3211
self.assertEqual(result.leaks, [])
3213
def test_thread_leak(self):
3214
"""Ensure a thread that outlives the running of a test is reported
3216
Uses a thread that blocks on an event, and is started by the inner
3217
test case. As the thread outlives the inner case's run, it should be
3218
detected as a leak, but the event is then set so that the thread can
3219
be safely joined in cleanup so it's not leaked for real.
3221
event = threading.Event()
3222
thread = threading.Thread(name="Leaker", target=event.wait)
3223
class Test(tests.TestCase):
3224
def test_leak(self):
3226
result = self.LeakRecordingResult()
3227
test = Test("test_leak")
3228
self.addCleanup(thread.join)
3229
self.addCleanup(event.set)
3230
result.startTestRun()
3232
result.stopTestRun()
3233
self.assertEqual(result._tests_leaking_threads_count, 1)
3234
self.assertEqual(result._first_thread_leaker_id, test.id())
3235
self.assertEqual(result.leaks, [(test, set([thread]))])
3236
self.assertContainsString(result.stream.getvalue(), "leaking threads")
3238
def test_multiple_leaks(self):
3239
"""Check multiple leaks are blamed on the test cases at fault
3241
Same concept as the previous test, but has one inner test method that
3242
leaks two threads, and one that doesn't leak at all.
3244
event = threading.Event()
3245
thread_a = threading.Thread(name="LeakerA", target=event.wait)
3246
thread_b = threading.Thread(name="LeakerB", target=event.wait)
3247
thread_c = threading.Thread(name="LeakerC", target=event.wait)
3248
class Test(tests.TestCase):
3249
def test_first_leak(self):
3251
def test_second_no_leak(self):
3253
def test_third_leak(self):
3256
result = self.LeakRecordingResult()
3257
first_test = Test("test_first_leak")
3258
third_test = Test("test_third_leak")
3259
self.addCleanup(thread_a.join)
3260
self.addCleanup(thread_b.join)
3261
self.addCleanup(thread_c.join)
3262
self.addCleanup(event.set)
3263
result.startTestRun()
3265
[first_test, Test("test_second_no_leak"), third_test]
3267
result.stopTestRun()
3268
self.assertEqual(result._tests_leaking_threads_count, 2)
3269
self.assertEqual(result._first_thread_leaker_id, first_test.id())
3270
self.assertEqual(result.leaks, [
3271
(first_test, set([thread_b])),
3272
(third_test, set([thread_a, thread_c]))])
3273
self.assertContainsString(result.stream.getvalue(), "leaking threads")
3276
class TestPostMortemDebugging(tests.TestCase):
3277
"""Check post mortem debugging works when tests fail or error"""
3279
class TracebackRecordingResult(tests.ExtendedTestResult):
3281
tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3282
self.postcode = None
3283
def _post_mortem(self, tb=None):
3284
"""Record the code object at the end of the current traceback"""
3285
tb = tb or sys.exc_info()[2]
3288
while next is not None:
3291
self.postcode = tb.tb_frame.f_code
3292
def report_error(self, test, err):
3294
def report_failure(self, test, err):
3297
def test_location_unittest_error(self):
3298
"""Needs right post mortem traceback with erroring unittest case"""
3299
class Test(unittest.TestCase):
3302
result = self.TracebackRecordingResult()
3304
self.assertEqual(result.postcode, Test.runTest.func_code)
3306
def test_location_unittest_failure(self):
3307
"""Needs right post mortem traceback with failing unittest case"""
3308
class Test(unittest.TestCase):
3310
raise self.failureException
3311
result = self.TracebackRecordingResult()
3313
self.assertEqual(result.postcode, Test.runTest.func_code)
3315
def test_location_bt_error(self):
3316
"""Needs right post mortem traceback with erroring bzrlib.tests case"""
3317
class Test(tests.TestCase):
3318
def test_error(self):
3320
result = self.TracebackRecordingResult()
3321
Test("test_error").run(result)
3322
self.assertEqual(result.postcode, Test.test_error.func_code)
3324
def test_location_bt_failure(self):
3325
"""Needs right post mortem traceback with failing bzrlib.tests case"""
3326
class Test(tests.TestCase):
3327
def test_failure(self):
3328
raise self.failureException
3329
result = self.TracebackRecordingResult()
3330
Test("test_failure").run(result)
3331
self.assertEqual(result.postcode, Test.test_failure.func_code)
3333
def test_env_var_triggers_post_mortem(self):
3334
"""Check pdb.post_mortem is called iff BZR_TEST_PDB is set"""
3336
result = tests.ExtendedTestResult(StringIO(), 0, 1)
3337
post_mortem_calls = []
3338
self.overrideAttr(pdb, "post_mortem", post_mortem_calls.append)
3339
self.overrideEnv('BZR_TEST_PDB', None)
3340
result._post_mortem(1)
3341
self.overrideEnv('BZR_TEST_PDB', 'on')
3342
result._post_mortem(2)
3343
self.assertEqual([2], post_mortem_calls)
3346
2963
class TestRunSuite(tests.TestCase):
3348
2965
def test_runner_class(self):
3359
2976
self.verbosity)
3360
2977
tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
3361
2978
self.assertLength(1, calls)
3364
class TestEnvironHandling(tests.TestCase):
3366
def test_overrideEnv_None_called_twice_doesnt_leak(self):
3367
self.assertFalse('MYVAR' in os.environ)
3368
self.overrideEnv('MYVAR', '42')
3369
# We use an embedded test to make sure we fix the _captureVar bug
3370
class Test(tests.TestCase):
3372
# The first call save the 42 value
3373
self.overrideEnv('MYVAR', None)
3374
self.assertEquals(None, os.environ.get('MYVAR'))
3375
# Make sure we can call it twice
3376
self.overrideEnv('MYVAR', None)
3377
self.assertEquals(None, os.environ.get('MYVAR'))
3379
result = tests.TextTestResult(output, 0, 1)
3380
Test('test_me').run(result)
3381
if not result.wasStrictlySuccessful():
3382
self.fail(output.getvalue())
3383
# We get our value back
3384
self.assertEquals('42', os.environ.get('MYVAR'))
3387
class TestIsolatedEnv(tests.TestCase):
3388
"""Test isolating tests from os.environ.
3390
Since we use tests that are already isolated from os.environ a bit of care
3391
should be taken when designing the tests to avoid bootstrap side-effects.
3392
The tests start an already clean os.environ which allow doing valid
3393
assertions about which variables are present or not and design tests around
3397
class ScratchMonkey(tests.TestCase):
3402
def test_basics(self):
3403
# Make sure we know the definition of BZR_HOME: not part of os.environ
3404
# for tests.TestCase.
3405
self.assertTrue('BZR_HOME' in tests.isolated_environ)
3406
self.assertEquals(None, tests.isolated_environ['BZR_HOME'])
3407
# Being part of isolated_environ, BZR_HOME should not appear here
3408
self.assertFalse('BZR_HOME' in os.environ)
3409
# Make sure we know the definition of LINES: part of os.environ for
3411
self.assertTrue('LINES' in tests.isolated_environ)
3412
self.assertEquals('25', tests.isolated_environ['LINES'])
3413
self.assertEquals('25', os.environ['LINES'])
3415
def test_injecting_unknown_variable(self):
3416
# BZR_HOME is known to be absent from os.environ
3417
test = self.ScratchMonkey('test_me')
3418
tests.override_os_environ(test, {'BZR_HOME': 'foo'})
3419
self.assertEquals('foo', os.environ['BZR_HOME'])
3420
tests.restore_os_environ(test)
3421
self.assertFalse('BZR_HOME' in os.environ)
3423
def test_injecting_known_variable(self):
3424
test = self.ScratchMonkey('test_me')
3425
# LINES is known to be present in os.environ
3426
tests.override_os_environ(test, {'LINES': '42'})
3427
self.assertEquals('42', os.environ['LINES'])
3428
tests.restore_os_environ(test)
3429
self.assertEquals('25', os.environ['LINES'])
3431
def test_deleting_variable(self):
3432
test = self.ScratchMonkey('test_me')
3433
# LINES is known to be present in os.environ
3434
tests.override_os_environ(test, {'LINES': None})
3435
self.assertTrue('LINES' not in os.environ)
3436
tests.restore_os_environ(test)
3437
self.assertEquals('25', os.environ['LINES'])
3440
class TestDocTestSuiteIsolation(tests.TestCase):
3441
"""Test that `tests.DocTestSuite` isolates doc tests from os.environ.
3443
Since tests.TestCase alreay provides an isolation from os.environ, we use
3444
the clean environment as a base for testing. To precisely capture the
3445
isolation provided by tests.DocTestSuite, we use doctest.DocTestSuite to
3448
We want to make sure `tests.DocTestSuite` respect `tests.isolated_environ`,
3449
not `os.environ` so each test overrides it to suit its needs.
3453
def get_doctest_suite_for_string(self, klass, string):
3454
class Finder(doctest.DocTestFinder):
3456
def find(*args, **kwargs):
3457
test = doctest.DocTestParser().get_doctest(
3458
string, {}, 'foo', 'foo.py', 0)
3461
suite = klass(test_finder=Finder())
3464
def run_doctest_suite_for_string(self, klass, string):
3465
suite = self.get_doctest_suite_for_string(klass, string)
3467
result = tests.TextTestResult(output, 0, 1)
3469
return result, output
3471
def assertDocTestStringSucceds(self, klass, string):
3472
result, output = self.run_doctest_suite_for_string(klass, string)
3473
if not result.wasStrictlySuccessful():
3474
self.fail(output.getvalue())
3476
def assertDocTestStringFails(self, klass, string):
3477
result, output = self.run_doctest_suite_for_string(klass, string)
3478
if result.wasStrictlySuccessful():
3479
self.fail(output.getvalue())
3481
def test_injected_variable(self):
3482
self.overrideAttr(tests, 'isolated_environ', {'LINES': '42'})
3485
>>> os.environ['LINES']
3488
# doctest.DocTestSuite fails as it sees '25'
3489
self.assertDocTestStringFails(doctest.DocTestSuite, test)
3490
# tests.DocTestSuite sees '42'
3491
self.assertDocTestStringSucceds(tests.IsolatedDocTestSuite, test)
3493
def test_deleted_variable(self):
3494
self.overrideAttr(tests, 'isolated_environ', {'LINES': None})
3497
>>> os.environ.get('LINES')
3499
# doctest.DocTestSuite fails as it sees '25'
3500
self.assertDocTestStringFails(doctest.DocTestSuite, test)
3501
# tests.DocTestSuite sees None
3502
self.assertDocTestStringSucceds(tests.IsolatedDocTestSuite, test)
added
removed
bzrlib/tests/test_selftest.py
