/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

Merge cleanup into shell-like-tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
491
491
        self.assertEqualStat(real, fake)
492
492
 
493
493
    def test_assertEqualStat_notequal(self):
494
 
        self.build_tree(["foo", "bar"])
 
494
        self.build_tree(["foo", "longname"])
495
495
        self.assertRaises(AssertionError, self.assertEqualStat,
496
 
            os.lstat("foo"), os.lstat("bar"))
 
496
            os.lstat("foo"), os.lstat("longname"))
497
497
 
498
498
 
499
499
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
517
517
        cwd = osutils.getcwd()
518
518
        self.assertIsSameRealPath(self.test_dir, cwd)
519
519
 
 
520
    def test_BZR_HOME_and_HOME_are_bytestrings(self):
 
521
        """The $BZR_HOME and $HOME environment variables should not be unicode.
 
522
 
 
523
        See https://bugs.launchpad.net/bzr/+bug/464174
 
524
        """
 
525
        self.assertIsInstance(os.environ['BZR_HOME'], str)
 
526
        self.assertIsInstance(os.environ['HOME'], str)
 
527
 
520
528
    def test_make_branch_and_memory_tree(self):
521
529
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
522
530
 
828
836
            def report_known_failure(self, test, err):
829
837
                self._call = test, err
830
838
        result = InstrumentedTestResult(None, None, None, None)
831
 
        def test_function():
832
 
            raise tests.KnownFailure('failed!')
833
 
        test = unittest.FunctionTestCase(test_function)
 
839
        class Test(tests.TestCase):
 
840
            def test_function(self):
 
841
                raise tests.KnownFailure('failed!')
 
842
        test = Test("test_function")
834
843
        test.run(result)
835
844
        # it should invoke 'report_known_failure'.
836
845
        self.assertEqual(2, len(result._call))
914
923
        result.report_unsupported(test, feature)
915
924
        output = result_stream.getvalue()[prefix:]
916
925
        lines = output.splitlines()
917
 
        self.assertEqual(lines, ['NODEP        0ms',
918
 
                                 "    The feature 'Feature' is not available."])
 
926
        # We don't check for the final '0ms' since it may fail on slow hosts
 
927
        self.assertStartsWith(lines[0], 'NODEP')
 
928
        self.assertEqual(lines[1],
 
929
                         "    The feature 'Feature' is not available.")
919
930
 
920
931
    def test_unavailable_exception(self):
921
932
        """An UnavailableFeature being raised should invoke addNotSupported."""
927
938
                self._call = test, feature
928
939
        result = InstrumentedTestResult(None, None, None, None)
929
940
        feature = tests.Feature()
930
 
        def test_function():
931
 
            raise tests.UnavailableFeature(feature)
932
 
        test = unittest.FunctionTestCase(test_function)
 
941
        class Test(tests.TestCase):
 
942
            def test_function(self):
 
943
                raise tests.UnavailableFeature(feature)
 
944
        test = Test("test_function")
933
945
        test.run(result)
934
946
        # it should invoke 'addNotSupported'.
935
947
        self.assertEqual(2, len(result._call))
952
964
                                             verbosity=1)
953
965
        test = self.get_passing_test()
954
966
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
955
 
        result._addKnownFailure(test, err)
 
967
        result.addExpectedFailure(test, err)
956
968
        self.assertFalse(result.wasStrictlySuccessful())
957
969
        self.assertEqual(None, result._extractBenchmarkTime(test))
958
970
 
1015
1027
    def test_known_failure_failed_run(self):
1016
1028
        # run a test that generates a known failure which should be printed in
1017
1029
        # the final output when real failures occur.
1018
 
        def known_failure_test():
1019
 
            raise tests.KnownFailure('failed')
 
1030
        class Test(tests.TestCase):
 
1031
            def known_failure_test(self):
 
1032
                raise tests.KnownFailure('failed')
1020
1033
        test = unittest.TestSuite()
1021
 
        test.addTest(unittest.FunctionTestCase(known_failure_test))
 
1034
        test.addTest(Test("known_failure_test"))
1022
1035
        def failing_test():
1023
1036
            raise AssertionError('foo')
1024
1037
        test.addTest(unittest.FunctionTestCase(failing_test))
1042
1055
            )
1043
1056
 
1044
1057
    def test_known_failure_ok_run(self):
1045
 
        # run a test that generates a known failure which should be printed in the final output.
1046
 
        def known_failure_test():
1047
 
            raise tests.KnownFailure('failed')
1048
 
        test = unittest.FunctionTestCase(known_failure_test)
 
1058
        # run a test that generates a known failure which should be printed in
 
1059
        # the final output.
 
1060
        class Test(tests.TestCase):
 
1061
            def known_failure_test(self):
 
1062
                raise tests.KnownFailure('failed')
 
1063
        test = Test("known_failure_test")
1049
1064
        stream = StringIO()
1050
1065
        runner = tests.TextTestRunner(stream=stream)
1051
1066
        result = self.run_test_runner(runner, test)
1128
1143
 
1129
1144
    def test_not_applicable(self):
1130
1145
        # run a test that is skipped because it's not applicable
1131
 
        def not_applicable_test():
1132
 
            raise tests.TestNotApplicable('this test never runs')
 
1146
        class Test(tests.TestCase):
 
1147
            def not_applicable_test(self):
 
1148
                raise tests.TestNotApplicable('this test never runs')
1133
1149
        out = StringIO()
1134
1150
        runner = tests.TextTestRunner(stream=out, verbosity=2)
1135
 
        test = unittest.FunctionTestCase(not_applicable_test)
 
1151
        test = Test("not_applicable_test")
1136
1152
        result = self.run_test_runner(runner, test)
1137
1153
        self._log_file.write(out.getvalue())
1138
1154
        self.assertTrue(result.wasSuccessful())
2482
2498
        self.assertIs(feature, exception.args[0])
2483
2499
 
2484
2500
 
 
2501
class TestModuleAvailableFeature(tests.TestCase):
 
2502
 
 
2503
    def test_available_module(self):
 
2504
        feature = tests.ModuleAvailableFeature('bzrlib.tests')
 
2505
        self.assertEqual('bzrlib.tests', feature.module_name)
 
2506
        self.assertEqual('bzrlib.tests', str(feature))
 
2507
        self.assertTrue(feature.available())
 
2508
        self.assertIs(tests, feature.module)
 
2509
 
 
2510
    def test_unavailable_module(self):
 
2511
        feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
 
2512
        self.assertEqual('bzrlib.no_such_module_exists', str(feature))
 
2513
        self.assertFalse(feature.available())
 
2514
        self.assertIs(None, feature.module)
 
2515
 
 
2516
 
2485
2517
class TestSelftestFiltering(tests.TestCase):
2486
2518
 
2487
2519
    def setUp(self):