/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

  • Committer: Andrew Bennetts
  • Date: 2008-03-27 06:10:18 UTC
  • mfrom: (3309 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3320.
  • Revision ID: andrew.bennetts@canonical.com-20080327061018-dxztpxyv6yoeg3am
Merge from bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
32
32
    osutils,
33
33
    repository,
34
34
    symbol_versioning,
 
35
    tests,
35
36
    )
36
37
from bzrlib.progress import _BaseProgressBar
37
38
from bzrlib.repofmt import weaverepo
1119
1120
        self.assertTrue(result.wasSuccessful())
1120
1121
 
1121
1122
    def test_skipped_from_setup(self):
 
1123
        calls = []
1122
1124
        class SkippedSetupTest(TestCase):
1123
1125
 
1124
1126
            def setUp(self):
1125
 
                self.counter = 1
 
1127
                calls.append('setUp')
1126
1128
                self.addCleanup(self.cleanup)
1127
1129
                raise TestSkipped('skipped setup')
1128
1130
 
1130
1132
                self.fail('test reached')
1131
1133
 
1132
1134
            def cleanup(self):
1133
 
                self.counter -= 1
 
1135
                calls.append('cleanup')
1134
1136
 
1135
1137
        runner = TextTestRunner(stream=self._log_file)
1136
1138
        test = SkippedSetupTest('test_skip')
1137
1139
        result = self.run_test_runner(runner, test)
1138
1140
        self.assertTrue(result.wasSuccessful())
1139
1141
        # Check if cleanup was called the right number of times.
1140
 
        self.assertEqual(0, test.counter)
 
1142
        self.assertEqual(['setUp', 'cleanup'], calls)
1141
1143
 
1142
1144
    def test_skipped_from_test(self):
 
1145
        calls = []
1143
1146
        class SkippedTest(TestCase):
1144
1147
 
1145
1148
            def setUp(self):
1146
 
                self.counter = 1
 
1149
                calls.append('setUp')
1147
1150
                self.addCleanup(self.cleanup)
1148
1151
 
1149
1152
            def test_skip(self):
1150
1153
                raise TestSkipped('skipped test')
1151
1154
 
1152
1155
            def cleanup(self):
1153
 
                self.counter -= 1
 
1156
                calls.append('cleanup')
1154
1157
 
1155
1158
        runner = TextTestRunner(stream=self._log_file)
1156
1159
        test = SkippedTest('test_skip')
1157
1160
        result = self.run_test_runner(runner, test)
1158
1161
        self.assertTrue(result.wasSuccessful())
1159
1162
        # Check if cleanup was called the right number of times.
1160
 
        self.assertEqual(0, test.counter)
 
1163
        self.assertEqual(['setUp', 'cleanup'], calls)
1161
1164
 
1162
1165
    def test_not_applicable(self):
1163
1166
        # run a test that is skipped because it's not applicable
1220
1223
            revision_id = workingtree.get_parent_ids()[0]
1221
1224
            self.assertEndsWith(output_string.rstrip(), revision_id)
1222
1225
 
 
1226
    def assertLogDeleted(self, test):
 
1227
        log = test._get_log()
 
1228
        self.assertEqual("DELETED log file to reduce memory footprint", log)
 
1229
        self.assertEqual('', test._log_contents)
 
1230
        self.assertIs(None, test._log_file_name)
 
1231
 
1223
1232
    def test_success_log_deleted(self):
1224
1233
        """Successful tests have their log deleted"""
1225
1234
 
1233
1242
        test = LogTester('test_success')
1234
1243
        result = self.run_test_runner(runner, test)
1235
1244
 
1236
 
        log = test._get_log()
1237
 
        self.assertEqual("DELETED log file to reduce memory footprint", log)
1238
 
        self.assertEqual('', test._log_contents)
1239
 
        self.assertIs(None, test._log_file_name)
 
1245
        self.assertLogDeleted(test)
 
1246
 
 
1247
    def test_skipped_log_deleted(self):
 
1248
        """Skipped tests have their log deleted"""
 
1249
 
 
1250
        class LogTester(TestCase):
 
1251
 
 
1252
            def test_skipped(self):
 
1253
                self.log('this will be removed\n')
 
1254
                raise tests.TestSkipped()
 
1255
 
 
1256
        sio = cStringIO.StringIO()
 
1257
        runner = TextTestRunner(stream=sio)
 
1258
        test = LogTester('test_skipped')
 
1259
        result = self.run_test_runner(runner, test)
 
1260
 
 
1261
        self.assertLogDeleted(test)
 
1262
 
 
1263
    def test_not_aplicable_log_deleted(self):
 
1264
        """Not applicable tests have their log deleted"""
 
1265
 
 
1266
        class LogTester(TestCase):
 
1267
 
 
1268
            def test_not_applicable(self):
 
1269
                self.log('this will be removed\n')
 
1270
                raise tests.TestNotApplicable()
 
1271
 
 
1272
        sio = cStringIO.StringIO()
 
1273
        runner = TextTestRunner(stream=sio)
 
1274
        test = LogTester('test_not_applicable')
 
1275
        result = self.run_test_runner(runner, test)
 
1276
 
 
1277
        self.assertLogDeleted(test)
 
1278
 
 
1279
    def test_known_failure_log_deleted(self):
 
1280
        """Know failure tests have their log deleted"""
 
1281
 
 
1282
        class LogTester(TestCase):
 
1283
 
 
1284
            def test_known_failure(self):
 
1285
                self.log('this will be removed\n')
 
1286
                raise tests.KnownFailure()
 
1287
 
 
1288
        sio = cStringIO.StringIO()
 
1289
        runner = TextTestRunner(stream=sio)
 
1290
        test = LogTester('test_known_failure')
 
1291
        result = self.run_test_runner(runner, test)
 
1292
 
 
1293
        self.assertLogDeleted(test)
1240
1294
 
1241
1295
    def test_fail_log_kept(self):
1242
1296
        """Failed tests have their log kept"""
1682
1736
            condition_id_re('test_condition_id_re'))
1683
1737
        self.assertEqual([test_name], self._test_ids(filtered_suite))
1684
1738
 
 
1739
    def test_condition_id_in_list(self):
 
1740
        test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
1741
                      'test_condition_id_in_list']
 
1742
        id_list = tests.TestIdList(test_names)
 
1743
        filtered_suite = filter_suite_by_condition(
 
1744
            self.suite, tests.condition_id_in_list(id_list))
 
1745
        my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
 
1746
        re_filtered = filter_suite_by_re(self.suite, my_pattern)
 
1747
        self.assertEqual(self._test_ids(re_filtered),
 
1748
                         self._test_ids(filtered_suite))
 
1749
 
1685
1750
    def test_condition_isinstance(self):
1686
1751
        filtered_suite = filter_suite_by_condition(self.suite,
1687
1752
            condition_isinstance(self.__class__))
1727
1792
        self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1728
1793
            'TestSelftestFiltering.test_filter_suite_by_re'])
1729
1794
 
 
1795
    def test_filter_suite_by_id_list(self):
 
1796
        test_list = ['bzrlib.tests.test_selftest.'
 
1797
                     'TestSelftestFiltering.test_filter_suite_by_id_list']
 
1798
        filtered_suite = tests.filter_suite_by_id_list(
 
1799
            self.suite, tests.TestIdList(test_list))
 
1800
        filtered_names = self._test_ids(filtered_suite)
 
1801
        self.assertEqual(
 
1802
            filtered_names,
 
1803
            ['bzrlib.tests.test_selftest.'
 
1804
             'TestSelftestFiltering.test_filter_suite_by_id_list'])
 
1805
 
1730
1806
    def test_preserve_input(self):
1731
1807
        # NB: Surely this is something in the stdlib to do this?
1732
1808
        self.assertTrue(self.suite is preserve_input(self.suite))
1842
1918
        module.__class__.load_tests = load_tests
1843
1919
        self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
1844
1920
 
 
1921
 
 
1922
class TestTestIdList(tests.TestCase):
 
1923
 
 
1924
    def _create_id_list(self, test_list):
 
1925
        return tests.TestIdList(test_list)
 
1926
 
 
1927
    def _create_suite(self, test_id_list):
 
1928
 
 
1929
        class Stub(TestCase):
 
1930
            def test_foo(self):
 
1931
                pass
 
1932
 
 
1933
        def _create_test_id(id):
 
1934
            return lambda: id
 
1935
 
 
1936
        suite = TestUtil.TestSuite()
 
1937
        for id in test_id_list:
 
1938
            t  = Stub('test_foo')
 
1939
            t.id = _create_test_id(id)
 
1940
            suite.addTest(t)
 
1941
        return suite
 
1942
 
 
1943
    def _test_ids(self, test_suite):
 
1944
        """Get the ids for the tests in a test suite."""
 
1945
        return [t.id() for t in iter_suite_tests(test_suite)]
 
1946
 
 
1947
    def test_empty_list(self):
 
1948
        id_list = self._create_id_list([])
 
1949
        self.assertEquals({}, id_list.tests)
 
1950
        self.assertEquals({}, id_list.modules)
 
1951
 
 
1952
    def test_valid_list(self):
 
1953
        id_list = self._create_id_list(
 
1954
            ['mod1.cl1.meth1', 'mod1.cl1.meth2',
 
1955
             'mod1.func1', 'mod1.cl2.meth2',
 
1956
             'mod1.submod1',
 
1957
             'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
 
1958
             ])
 
1959
        self.assertTrue(id_list.is_module_name_used('mod1'))
 
1960
        self.assertTrue(id_list.is_module_name_used('mod1.submod1'))
 
1961
        self.assertTrue(id_list.is_module_name_used('mod1.submod2'))
 
1962
        self.assertTrue(id_list.test_in('mod1.cl1.meth1'))
 
1963
        self.assertTrue(id_list.test_in('mod1.submod1'))
 
1964
        self.assertTrue(id_list.test_in('mod1.func1'))
 
1965
 
 
1966
    def test_bad_chars_in_params(self):
 
1967
        id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
 
1968
        self.assertTrue(id_list.is_module_name_used('mod1'))
 
1969
        self.assertTrue(id_list.test_in('mod1.cl1.meth1(xx.yy)'))
 
1970
 
 
1971
    def test_module_used(self):
 
1972
        id_list = self._create_id_list(['mod.class.meth'])
 
1973
        self.assertTrue(id_list.is_module_name_used('mod'))
 
1974
        self.assertTrue(id_list.is_module_name_used('mod.class'))
 
1975
        self.assertTrue(id_list.is_module_name_used('mod.class.meth'))
 
1976
 
 
1977
    def test_test_suite(self):
 
1978
        # This test is slow, so we do a single test with one test in each
 
1979
        # category
 
1980
        test_list = [
 
1981
            # testmod_names
 
1982
            'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
 
1983
            # transport implementations
 
1984
            'bzrlib.tests.test_transport_implementations.TransportTests'
 
1985
            '.test_abspath(LocalURLServer)',
 
1986
            # packages_to_test()
 
1987
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
 
1988
            # MODULES_TO_DOCTEST
 
1989
            'bzrlib.timestamp.format_highres_date',
 
1990
            # plugins can't be tested that way since selftest may be run with
 
1991
            # --no-plugins
 
1992
            ]
 
1993
        suite = tests.test_suite(test_list)
 
1994
        self.assertEquals(test_list, self._test_ids(suite))
 
1995
 
 
1996
 
 
1997
class TestLoadTestIdList(tests.TestCaseInTempDir):
 
1998
 
 
1999
    def _create_test_list_file(self, file_name, content):
 
2000
        fl = open(file_name, 'wt')
 
2001
        fl.write(content)
 
2002
        fl.close()
 
2003
 
 
2004
    def test_load_unknown(self):
 
2005
        self.assertRaises(errors.NoSuchFile,
 
2006
                          tests.load_test_id_list, 'i_do_not_exist')
 
2007
 
 
2008
    def test_load_test_list(self):
 
2009
        test_list_fname = 'test.list'
 
2010
        self._create_test_list_file(test_list_fname,
 
2011
                                    'mod1.cl1.meth1\nmod2.cl2.meth2\n')
 
2012
        tlist = tests.load_test_id_list(test_list_fname)
 
2013
        self.assertEquals(2, len(tlist))
 
2014
        self.assertEquals('mod1.cl1.meth1', tlist[0])
 
2015
        self.assertEquals('mod2.cl2.meth2', tlist[1])
 
2016
 
 
2017
    def test_load_dirty_file(self):
 
2018
        test_list_fname = 'test.list'
 
2019
        self._create_test_list_file(test_list_fname,
 
2020
                                    '  mod1.cl1.meth1\n\nmod2.cl2.meth2  \n'
 
2021
                                    'bar baz\n')
 
2022
        tlist = tests.load_test_id_list(test_list_fname)
 
2023
        self.assertEquals(4, len(tlist))
 
2024
        self.assertEquals('mod1.cl1.meth1', tlist[0])
 
2025
        self.assertEquals('', tlist[1])
 
2026
        self.assertEquals('mod2.cl2.meth2', tlist[2])
 
2027
        self.assertEquals('bar baz', tlist[3])
 
2028
 
 
2029