~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd

import cStringIO

from StringIO import StringIO

from bzrlib.progress import _BaseProgressBar

                          ChrootedTestCase,

                          ExtendedTestResult,

                          Feature,

                          KnownFailure,

                          TestCase,

                          TestCaseInTempDir,

                          TestCaseWithMemoryTransport,

                          TestCaseWithTransport,

                          TestNotApplicable,

                          TestSkipped,

                          TestSuite,

                          TestUtil,

                          TextTestRunner,

                          UnavailableFeature,

                          condition_id_re,

                          condition_isinstance,

                          exclude_tests_by_condition,

                          exclude_tests_by_re,

                          filter_suite_by_condition,

                          filter_suite_by_re,

                          iter_suite_tests,

                          preserve_input,

                          randomize_suite,

                          run_suite,

                          split_suite_by_condition,

                          split_suite_by_re,

                          test_lsprof,

                          test_suite,

                          )

from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer

from bzrlib.tests.TestUtil import _load_module_by_name

from bzrlib.transport.memory import MemoryServer, MemoryTransport

    return [t.id() for t in iter_suite_tests(test_suite)]

 

 

class SelftestTests(TestCase):

        mod = _load_module_by_name('bzrlib.tests.test_selftest')

                          _load_module_by_name,

class MetaTestLog(TestCase):

        self._log_file.flush()

        self.assertContainsRe(self._get_log(keep_log_file=True),

                              'a test message\n')

 

 

class TestUnicodeFilename(TestCase):

class TestTreeShape(TestCaseInTempDir):

class TestTransportScenarios(TestCase):

        from bzrlib.tests.test_transport_implementations \

            import get_transport_test_permutations

    def test_scenarios_invlude_all_modules(self):

        from bzrlib.tests.test_transport_implementations \

            import transport_test_permutations

        from bzrlib.tests.test_transport_implementations \

            import transport_test_permutations

class TestBranchScenarios(TestCase):

        from bzrlib.tests.branch_implementations import make_scenarios

class TestBzrDirScenarios(TestCase):

        from bzrlib.tests.bzrdir_implementations import make_scenarios

class TestRepositoryScenarios(TestCase):

                        'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]

        self.assertEqual([

            ('RepositoryFormatKnitPack1(d)',

              'repository_format': pack_repo.RepositoryFormatKnitPack1(),

              'transport_server': 'server'})],

            no_vfs_scenarios)

            ('RepositoryFormatKnitPack1(d)',

              'repository_format': pack_repo.RepositoryFormatKnitPack1(),

class TestTestScenarioApplication(TestCase):

class TestInterRepositoryScenarios(TestCase):

        from bzrlib.tests.interrepository_implementations import \

            make_scenarios

        formats = [(str, "C1", "C2"), (int, "D1", "D2")]

            ('str,str,str',

             {'interrepo_class': str,

              'repository_format': 'C1',

            ('int,str,str',

             {'interrepo_class': int,

              'repository_format': 'D1',

class TestWorkingTreeScenarios(TestCase):

        from bzrlib.tests.workingtree_implementations \

            import make_scenarios

class TestTreeScenarios(TestCase):

        from bzrlib.tests.tree_implementations import (

class TestInterTreeScenarios(TestCase):

        from bzrlib.tests.tree_implementations import (

        from bzrlib.tests.intertree_implementations import (

class TestTestCaseInTempDir(TestCaseInTempDir):

        self.build_tree(["foo", "bar"])

            os.lstat("foo"), os.lstat("bar"))

 

 

class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):

    def test_safety_net(self):

        """No test should modify the safety .bzr directory.

 

        We just test that the _check_safety_net private method raises

        AssertionError, it's easier than building a test suite with the same

        test.

        """

        # Oops, a commit in the current directory (i.e. without local .bzr

        # directory) will crawl up the hierarchy to find a .bzr directory.

        self.run_bzr(['commit', '-mfoo', '--unchanged'])

        # But we have a safety net in place.

        self.assertRaises(AssertionError, self._check_safety_net)

 

        class TestDanglingLock(TestCaseWithMemoryTransport):

        self.assertEqual(1, len(result.errors))

 

 

class TestTestCaseWithTransport(TestCaseWithTransport):

        from bzrlib.transport.memory import MemoryServer

        self.vfs_transport_factory = MemoryServer

        from bzrlib.transport.local import LocalURLServer

        self.transport_server = LocalURLServer

class TestTestCaseTransports(TestCaseWithTransport):

        self.vfs_transport_factory = MemoryServer

                              MemoryTransport)

class TestChrootedTest(ChrootedTestCase):

class MockProgress(_BaseProgressBar):

    """Progress-bar standin that records calls.

 

    Useful for testing pb using code.

    """

 

    def __init__(self):

        _BaseProgressBar.__init__(self)

        self.calls = []

 

    def tick(self):

        self.calls.append(('tick',))

 

    def update(self, msg=None, current=None, total=None):

        self.calls.append(('update', msg, current, total))

 

    def clear(self):

        self.calls.append(('clear',))

 

    def note(self, msg, *args):

        self.calls.append(('note', msg, args))

 

 

class TestTestResult(TestCase):

        test_case.run(result)

        timed_string = result._testTimeString(test_case)

        class ShortDelayTestCase(TestCase):

        # if a benchmark time is given, we want a x of y style result.

                          r"^ +[0-9]+ms/ +[0-9]+ms$")

        class InstrumentedTestResult(ExtendedTestResult):

            def done(self): pass

            def report_known_failure(self, test, err):

                self._call = test, err

        def test_function():

            raise KnownFailure('failed!')

        test = unittest.FunctionTestCase(test_function)

        self.assertEqual(test, result._call[0])

        self.assertEqual(KnownFailure, result._call[1][0])

        self.assertIsInstance(result._call[1][1], KnownFailure)

        err = (KnownFailure, KnownFailure('foo'), None)

    def test_text_report_known_failure(self):

        # text test output formatting

        pb = MockProgress()

        result = bzrlib.tests.TextTestResult(

            StringIO(),

            descriptions=0,

            verbosity=1,

            pb=pb,

            )

        test = self.get_passing_test()

        # this seeds the state to handle reporting the test.

        result.startTest(test)

        # the err parameter has the shape:

        # (class, exception object, traceback)

        # KnownFailures dont get their tracebacks shown though, so we

        # can skip that.

        err = (KnownFailure, KnownFailure('foo'), None)

        result.report_known_failure(test, err)

        self.assertEqual(

            [

            ('update', '[1 in 0s] passing_test', None, None),

            ('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))

            ],

            pb.calls)

        # known_failures should be printed in the summary, so if we run a test

        # after there are some known failures, the update prefix should match

        # this.

        result.known_failure_count = 3

        test.run(result)

        self.assertEqual(

            [

            ('update', '[2 in 0s] passing_test', None, None),

            ],

            pb.calls[2:])

 

        class InstrumentedTestResult(ExtendedTestResult):

            def done(self): pass

        feature = Feature()

        feature = Feature()

        self.assertEqual(lines, ['NODEP                   0ms', "    The feature 'Feature' is not available."])

 

    def test_text_report_unsupported(self):

        # text test output formatting

        pb = MockProgress()

        result = bzrlib.tests.TextTestResult(

            StringIO(),

            descriptions=0,

            verbosity=1,

            pb=pb,

            )

        test = self.get_passing_test()

        feature = Feature()

        # this seeds the state to handle reporting the test.

        result.startTest(test)

        result.report_unsupported(test, feature)

        # no output on unsupported features

        self.assertEqual(

            [('update', '[1 in 0s] passing_test', None, None)

            ],

            pb.calls)

        # the number of missing features should be printed in the progress

        # summary, so check for that.

        result.unsupported = {'foo':0, 'bar':0}

        test.run(result)

        self.assertEqual(

            [

            ('update', '[2 in 0s, 2 missing] passing_test', None, None),

            ],

            pb.calls[1:])

        class InstrumentedTestResult(ExtendedTestResult):

            def done(self): pass

        feature = Feature()

        def test_function():

            raise UnavailableFeature(feature)

        test = unittest.FunctionTestCase(test_function)

        self.assertEqual(test, result._call[0])

        err = (KnownFailure, KnownFailure('foo'), None)

        result._addKnownFailure(test, err)

        class InstrumentedTestResult(ExtendedTestResult):

class TestUnicodeFilenameFeature(TestCase):

class TestRunner(TestCase):

        There should be no tests in this file that use bzrlib.tests.TextTestRunner

        without using this convenience method, because of our use of global state.

        old_root = TestCaseInTempDir.TEST_ROOT

            TestCaseInTempDir.TEST_ROOT = None

            TestCaseInTempDir.TEST_ROOT = old_root

        def known_failure_test():

            raise KnownFailure('failed')

        test.addTest(unittest.FunctionTestCase(known_failure_test))

            raise AssertionError('foo')

        runner = TextTestRunner(stream=stream)

        self.assertEqual([

            '',

            '======================================================================',

            'FAIL: unittest.FunctionTestCase (failing_test)',

            '----------------------------------------------------------------------',

            'Traceback (most recent call last):',

            '    raise AssertionError(\'foo\')',

            'AssertionError: foo',

            '',

            '----------------------------------------------------------------------',

            '',

            'FAILED (failures=1, known_failure_count=1)'],

            lines[3:8] + lines[9:13] + lines[14:])

        # run a test that generates a known failure which should be printed in the final output.

        def known_failure_test():

            raise KnownFailure('failed')

        test = unittest.FunctionTestCase(known_failure_test)

        runner = TextTestRunner(stream=stream)

        class SkippingTest(TestCase):

                raise TestSkipped('test intentionally skipped')

        runner = TextTestRunner(stream=self._log_file)

        class SkippedSetupTest(TestCase):

                raise TestSkipped('skipped setup')

        runner = TextTestRunner(stream=self._log_file)

        class SkippedTest(TestCase):

                TestCase.setUp(self)

                raise TestSkipped('skipped test')

        runner = TextTestRunner(stream=self._log_file)

        def not_applicable_test():

            from bzrlib.tests import TestNotApplicable

            raise TestNotApplicable('this test never runs')

        runner = TextTestRunner(stream=out, verbosity=2)

        test = unittest.FunctionTestCase(not_applicable_test)

    def test_not_applicable_demo(self):

        # just so you can see it in the test output

        raise TestNotApplicable('this test is just a demonstation')

 

        class Feature1(Feature):

        class Feature2(Feature):

        runner = TextTestRunner(stream=stream)