489
490
self.assertEqualStat(real, fake)
491
492
def test_assertEqualStat_notequal(self):
492
self.build_tree(["foo", "bar"])
493
self.build_tree(["foo", "longname"])
493
494
self.assertRaises(AssertionError, self.assertEqualStat,
494
os.lstat("foo"), os.lstat("bar"))
495
os.lstat("foo"), os.lstat("longname"))
497
498
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
515
516
cwd = osutils.getcwd()
516
517
self.assertIsSameRealPath(self.test_dir, cwd)
519
def test_BZR_HOME_and_HOME_are_bytestrings(self):
520
"""The $BZR_HOME and $HOME environment variables should not be unicode.
522
See https://bugs.launchpad.net/bzr/+bug/464174
524
self.assertIsInstance(os.environ['BZR_HOME'], str)
525
self.assertIsInstance(os.environ['HOME'], str)
518
527
def test_make_branch_and_memory_tree(self):
519
528
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
576
585
self.get_transport().get_bytes(
577
586
'dir/.bzr/repository/format'))
579
def test_safety_net(self):
580
"""No test should modify the safety .bzr directory.
582
We just test that the _check_safety_net private method raises
583
AssertionError, it's easier than building a test suite with the same
586
# Oops, a commit in the current directory (i.e. without local .bzr
587
# directory) will crawl up the hierarchy to find a .bzr directory.
588
self.run_bzr(['commit', '-mfoo', '--unchanged'])
589
# But we have a safety net in place.
590
self.assertRaises(AssertionError, self._check_safety_net)
592
588
def test_dangling_locks_cause_failures(self):
593
589
class TestDanglingLock(tests.TestCaseWithMemoryTransport):
594
590
def test_function(self):
739
735
self.check_timing(ShortDelayTestCase('test_short_delay'),
738
def _patch_get_bzr_source_tree(self):
739
# Reading from the actual source tree breaks isolation, but we don't
740
# want to assume that thats *all* that would happen.
741
def _get_bzr_source_tree():
743
orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
744
bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
746
bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
747
self.addCleanup(restore)
742
749
def test_assigned_benchmark_file_stores_date(self):
750
self._patch_get_bzr_source_tree()
743
751
output = StringIO()
744
752
result = bzrlib.tests.TextTestResult(self._log_file,
753
761
self.assertContainsRe(output_string, "--date [0-9.]+")
755
763
def test_benchhistory_records_test_times(self):
764
self._patch_get_bzr_source_tree()
756
765
result_stream = StringIO()
757
766
result = bzrlib.tests.TextTestResult(
826
835
def report_known_failure(self, test, err):
827
836
self._call = test, err
828
837
result = InstrumentedTestResult(None, None, None, None)
830
raise tests.KnownFailure('failed!')
831
test = unittest.FunctionTestCase(test_function)
838
class Test(tests.TestCase):
839
def test_function(self):
840
raise tests.KnownFailure('failed!')
841
test = Test("test_function")
833
843
# it should invoke 'report_known_failure'.
834
844
self.assertEqual(2, len(result._call))
912
922
result.report_unsupported(test, feature)
913
923
output = result_stream.getvalue()[prefix:]
914
924
lines = output.splitlines()
915
self.assertEqual(lines, ['NODEP 0ms',
916
" The feature 'Feature' is not available."])
925
# We don't check for the final '0ms' since it may fail on slow hosts
926
self.assertStartsWith(lines[0], 'NODEP')
927
self.assertEqual(lines[1],
928
" The feature 'Feature' is not available.")
918
930
def test_unavailable_exception(self):
919
931
"""An UnavailableFeature being raised should invoke addNotSupported."""
925
937
self._call = test, feature
926
938
result = InstrumentedTestResult(None, None, None, None)
927
939
feature = tests.Feature()
929
raise tests.UnavailableFeature(feature)
930
test = unittest.FunctionTestCase(test_function)
940
class Test(tests.TestCase):
941
def test_function(self):
942
raise tests.UnavailableFeature(feature)
943
test = Test("test_function")
932
945
# it should invoke 'addNotSupported'.
933
946
self.assertEqual(2, len(result._call))
951
964
test = self.get_passing_test()
952
965
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
953
result._addKnownFailure(test, err)
966
result.addExpectedFailure(test, err)
954
967
self.assertFalse(result.wasStrictlySuccessful())
955
968
self.assertEqual(None, result._extractBenchmarkTime(test))
1013
1026
def test_known_failure_failed_run(self):
1014
1027
# run a test that generates a known failure which should be printed in
1015
1028
# the final output when real failures occur.
1016
def known_failure_test():
1017
raise tests.KnownFailure('failed')
1029
class Test(tests.TestCase):
1030
def known_failure_test(self):
1031
raise tests.KnownFailure('failed')
1018
1032
test = unittest.TestSuite()
1019
test.addTest(unittest.FunctionTestCase(known_failure_test))
1033
test.addTest(Test("known_failure_test"))
1020
1034
def failing_test():
1021
1035
raise AssertionError('foo')
1022
1036
test.addTest(unittest.FunctionTestCase(failing_test))
1042
1056
def test_known_failure_ok_run(self):
1043
# run a test that generates a known failure which should be printed in the final output.
1044
def known_failure_test():
1045
raise tests.KnownFailure('failed')
1046
test = unittest.FunctionTestCase(known_failure_test)
1057
# run a test that generates a known failure which should be printed in
1059
class Test(tests.TestCase):
1060
def known_failure_test(self):
1061
raise tests.KnownFailure('failed')
1062
test = Test("known_failure_test")
1047
1063
stream = StringIO()
1048
1064
runner = tests.TextTestRunner(stream=stream)
1049
1065
result = self.run_test_runner(runner, test)
1127
1143
def test_not_applicable(self):
1128
1144
# run a test that is skipped because it's not applicable
1129
def not_applicable_test():
1130
raise tests.TestNotApplicable('this test never runs')
1145
class Test(tests.TestCase):
1146
def not_applicable_test(self):
1147
raise tests.TestNotApplicable('this test never runs')
1131
1148
out = StringIO()
1132
1149
runner = tests.TextTestRunner(stream=out, verbosity=2)
1133
test = unittest.FunctionTestCase(not_applicable_test)
1150
test = Test("not_applicable_test")
1134
1151
result = self.run_test_runner(runner, test)
1135
1152
self._log_file.write(out.getvalue())
1136
1153
self.assertTrue(result.wasSuccessful())
1185
def _patch_get_bzr_source_tree(self):
1186
# Reading from the actual source tree breaks isolation, but we don't
1187
# want to assume that thats *all* that would happen.
1188
self._get_source_tree_calls = []
1189
def _get_bzr_source_tree():
1190
self._get_source_tree_calls.append("called")
1192
orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
1193
bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
1195
bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
1196
self.addCleanup(restore)
1168
1198
def test_bench_history(self):
1169
# tests that the running the benchmark produces a history file
1170
# containing a timestamp and the revision id of the bzrlib source which
1172
workingtree = _get_bzr_source_tree()
1199
# tests that the running the benchmark passes bench_history into
1200
# the test result object. We can tell that happens if
1201
# _get_bzr_source_tree is called.
1202
self._patch_get_bzr_source_tree()
1173
1203
test = TestRunner('dummy_test')
1174
1204
output = StringIO()
1175
1205
runner = tests.TextTestRunner(stream=self._log_file,
1177
1207
result = self.run_test_runner(runner, test)
1178
1208
output_string = output.getvalue()
1179
1209
self.assertContainsRe(output_string, "--date [0-9.]+")
1180
if workingtree is not None:
1181
revision_id = workingtree.get_parent_ids()[0]
1182
self.assertEndsWith(output_string.rstrip(), revision_id)
1210
self.assertLength(1, self._get_source_tree_calls)
1184
1212
def assertLogDeleted(self, test):
1185
1213
log = test._get_log()
1493
1521
outer_test = TestTestCase("outer_child")
1494
1522
result = self.make_test_result()
1495
1523
outer_test.run(result)
1524
self.addCleanup(osutils.delete_any, outer_test._log_file_name)
1496
1525
self.assertEqual(original_trace, bzrlib.trace._trace_file)
1498
1527
def method_that_times_a_bit_twice(self):
1547
1576
"""Self.knownFailure() should raise a KnownFailure exception."""
1548
1577
self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1579
def test_open_bzrdir_safe_roots(self):
1580
# even a memory transport should fail to open when its url isn't
1582
# Manually set one up (TestCase doesn't and shouldn't provide magic
1584
transport_server = MemoryServer()
1585
transport_server.setUp()
1586
self.addCleanup(transport_server.tearDown)
1587
t = transport.get_transport(transport_server.get_url())
1588
bzrdir.BzrDir.create(t.base)
1589
self.assertRaises(errors.BzrError,
1590
bzrdir.BzrDir.open_from_transport, t)
1591
# But if we declare this as safe, we can open the bzrdir.
1592
self.permit_url(t.base)
1593
self._bzr_selftest_roots.append(t.base)
1594
bzrdir.BzrDir.open_from_transport(t)
1550
1596
def test_requireFeature_available(self):
1551
1597
"""self.requireFeature(available) is a no-op."""
1552
1598
class Available(tests.Feature):
1668
def test_start_server_registers_url(self):
1669
transport_server = MemoryServer()
1670
# A little strict, but unlikely to be changed soon.
1671
self.assertEqual([], self._bzr_selftest_roots)
1672
self.start_server(transport_server)
1673
self.assertSubset([transport_server.get_url()],
1674
self._bzr_selftest_roots)
1622
1676
def test_assert_list_raises_on_generator(self):
1623
1677
def generator_which_will_raise():
1624
1678
# This will not raise until after the first yield
1722
1776
self.assertEndsWith('foo', 'oo')
1723
1777
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1779
def test_assertEqualDiff(self):
1780
e = self.assertRaises(AssertionError,
1781
self.assertEqualDiff, '', '\n')
1782
self.assertEquals(str(e),
1783
# Don't blink ! The '+' applies to the second string
1784
'first string is missing a final newline.\n+ \n')
1785
e = self.assertRaises(AssertionError,
1786
self.assertEqualDiff, '\n', '')
1787
self.assertEquals(str(e),
1788
# Don't blink ! The '-' applies to the second string
1789
'second string is missing a final newline.\n- \n')
1792
class TestDeprecations(tests.TestCase):
1725
1794
def test_applyDeprecated_not_deprecated(self):
1726
1795
sample_object = ApplyDeprecatedHelper()
1727
1796
# calling an undeprecated callable raises an assertion
1991
2060
Attempts to run bzr from inside this class don't actually run it.
1993
We test how run_bzr actually invokes bzr in another location.
1994
Here we only need to test that it is run_bzr passes the right
1995
parameters to run_bzr.
2062
We test how run_bzr actually invokes bzr in another location. Here we
2063
only need to test that it passes the right parameters to run_bzr.
1997
2065
self.argv = list(argv)
1998
2066
self.retcode = retcode
1999
2067
self.encoding = encoding
2000
2068
self.stdin = stdin
2001
2069
self.working_dir = working_dir
2002
return self.out, self.err
2070
return self.retcode, self.out, self.err
2004
2072
def test_run_bzr_error(self):
2005
2073
self.out = "It sure does!\n"
2006
2074
out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
2007
2075
self.assertEqual(['rocks'], self.argv)
2008
2076
self.assertEqual(34, self.retcode)
2009
self.assertEqual(out, 'It sure does!\n')
2077
self.assertEqual('It sure does!\n', out)
2078
self.assertEquals(out, self.out)
2079
self.assertEqual('', err)
2080
self.assertEquals(err, self.err)
2011
2082
def test_run_bzr_error_regexes(self):
2013
2084
self.err = "bzr: ERROR: foobarbaz is not versioned"
2014
2085
out, err = self.run_bzr_error(
2015
["bzr: ERROR: foobarbaz is not versioned"],
2016
['file-id', 'foobarbaz'])
2086
["bzr: ERROR: foobarbaz is not versioned"],
2087
['file-id', 'foobarbaz'])
2018
2089
def test_encoding(self):
2019
2090
"""Test that run_bzr passes encoding to _run_bzr_core"""
2353
2424
"""finish_bzr_subprocess raises self.failureException if the retcode is
2354
2425
not the expected one.
2427
self.disable_missing_extensions_warning()
2356
2428
process = self.start_bzr_subprocess(['wait-until-signalled'],
2357
2429
skip_if_plan_to_signal=True)
2358
2430
self.assertEqual('running\n', process.stdout.readline())
2425
2497
self.assertIs(feature, exception.args[0])
2500
class TestModuleAvailableFeature(tests.TestCase):
2502
def test_available_module(self):
2503
feature = tests.ModuleAvailableFeature('bzrlib.tests')
2504
self.assertEqual('bzrlib.tests', feature.module_name)
2505
self.assertEqual('bzrlib.tests', str(feature))
2506
self.assertTrue(feature.available())
2507
self.assertIs(tests, feature.module)
2509
def test_unavailable_module(self):
2510
feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
2511
self.assertEqual('bzrlib.no_such_module_exists', str(feature))
2512
self.assertFalse(feature.available())
2513
self.assertIs(None, feature.module)
2428
2516
class TestSelftestFiltering(tests.TestCase):
2430
2518
def setUp(self):
2616
2704
# Running bzr in blackbox mode, normal/expected/user errors should be
2617
2705
# caught in the regular way and turned into an error message plus exit
2619
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2707
transport_server = MemoryServer()
2708
transport_server.setUp()
2709
self.addCleanup(transport_server.tearDown)
2710
url = transport_server.get_url()
2711
self.permit_url(url)
2712
out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2620
2713
self.assertEqual(out, '')
2621
2714
self.assertContainsRe(err,
2622
2715
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2797
2890
# testmod_names
2798
2891
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2799
2892
('bzrlib.tests.per_transport.TransportTests'
2800
'.test_abspath(LocalURLServer)'),
2893
'.test_abspath(LocalTransport,LocalURLServer)'),
2801
2894
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2802
2895
# modules_to_doctest
2803
2896
'bzrlib.timestamp.format_highres_date',
added
removed
bzrlib/tests/test_selftest.py
