FM / test

/usr/lib/python3/dist-packages/twisted/trial/test/

/usr/lib/python3/dist-packages/twisted/trial/test

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
detests.py	5667	0644	edit dl rm
erroneous.py	4792	0644	edit dl rm
mockcustomsuite.py	536	0644	edit dl rm
mockcustomsuite2.py	533	0644	edit dl rm
mockcustomsuite3.py	676	0644	edit dl rm
mockdoctest.py	2421	0644	edit dl rm
moduleself.py	170	0644	edit dl rm
moduletest.py	302	0644	edit dl rm
novars.py	182	0644	edit dl rm
ordertests.py	864	0644	edit dl rm
packages.py	4651	0644	edit dl rm
sample.py	2084	0644	edit dl rm
scripttest.py	457	0755	edit dl rm
skipping.py	5709	0644	edit dl rm
suppression.py	2499	0644	edit dl rm
test_assertions.py	60813	0644	edit dl rm
test_asyncassertions.py	2552	0644	edit dl rm
test_deferred.py	8822	0644	edit dl rm
test_doctest.py	1713	0644	edit dl rm
test_keyboard.py	3784	0644	edit dl rm
test_loader.py	22360	0644	edit dl rm
test_log.py	8040	0644	edit dl rm
test_output.py	5016	0644	edit dl rm
test_plugins.py	1460	0644	edit dl rm
test_pyunitcompat.py	7620	0644	edit dl rm
test_reporter.py	56709	0644	edit dl rm
test_runner.py	35040	0644	edit dl rm
test_script.py	29377	0644	edit dl rm
test_skip.py	2651	0644	edit dl rm
test_suppression.py	5911	0644	edit dl rm
test_testcase.py	1985	0644	edit dl rm
test_tests.py	49500	0644	edit dl rm
test_util.py	19660	0644	edit dl rm
test_warning.py	17638	0644	edit dl rm
weird.py	675	0644	edit dl rm
__init__.py	130	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/twisted/trial/test/test_pyunitcompat.py (7620B)

# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

import sys
import traceback
import unittest as pyunit
from unittest import skipIf

from zope.interface import implementer

from twisted.python.failure import Failure
from twisted.trial.itrial import IReporter, ITestCase
from twisted.trial.unittest import PyUnitResultAdapter, SynchronousTestCase

class PyUnitTestTests(SynchronousTestCase):
    class PyUnitTest(pyunit.TestCase):
        def test_pass(self):
            pass

def setUp(self):
        self.original = self.PyUnitTest("test_pass")
        self.test = ITestCase(self.original)

def test_callable(self):
        """
        Tests must be callable in order to be used with Python's unittest.py.
        """
        self.assertTrue(callable(self.test), f"{self.test!r} is not callable.")

class PyUnitResultTests(SynchronousTestCase):
    """
    Tests to show that PyUnitResultAdapter wraps TestResult objects from the
    standard library 'unittest' module in such a way as to make them usable and
    useful from Trial.
    """

# Once erroneous is ported to Python 3 this can be replaced with
    # erroneous.ErrorTest:
    class ErrorTest(SynchronousTestCase):
        """
        A test case which has a L{test_foo} which will raise an error.

@ivar ran: boolean indicating whether L{test_foo} has been run.
        """

ran = False

def test_foo(self):
            """
            Set C{self.ran} to True and raise a C{ZeroDivisionError}
            """
            self.ran = True
            1 / 0

def test_dontUseAdapterWhenReporterProvidesIReporter(self):
        """
        The L{PyUnitResultAdapter} is only used when the result passed to
        C{run} does *not* provide L{IReporter}.
        """

@implementer(IReporter)
        class StubReporter:
            """
            A reporter which records data about calls made to it.

@ivar errors: Errors passed to L{addError}.
            @ivar failures: Failures passed to L{addFailure}.
            """

def __init__(self):
                self.errors = []
                self.failures = []

def startTest(self, test):
                """
                Do nothing.
                """

def stopTest(self, test):
                """
                Do nothing.
                """

def addError(self, test, error):
                """
                Record the error.
                """
                self.errors.append(error)

test = self.ErrorTest("test_foo")
        result = StubReporter()
        test.run(result)
        self.assertIsInstance(result.errors[0], Failure)

def test_success(self):
        class SuccessTest(SynchronousTestCase):
            ran = False

def test_foo(s):
                s.ran = True

test = SuccessTest("test_foo")
        result = pyunit.TestResult()
        test.run(result)

self.assertTrue(test.ran)
        self.assertEqual(1, result.testsRun)
        self.assertTrue(result.wasSuccessful())

def test_failure(self):
        class FailureTest(SynchronousTestCase):
            ran = False

def test_foo(s):
                s.ran = True
                s.fail("boom!")

test = FailureTest("test_foo")
        result = pyunit.TestResult()
        test.run(result)

self.assertTrue(test.ran)
        self.assertEqual(1, result.testsRun)
        self.assertEqual(1, len(result.failures))
        self.assertFalse(result.wasSuccessful())

def test_error(self):
        test = self.ErrorTest("test_foo")
        result = pyunit.TestResult()
        test.run(result)

self.assertTrue(test.ran)
        self.assertEqual(1, result.testsRun)
        self.assertEqual(1, len(result.errors))
        self.assertFalse(result.wasSuccessful())

def test_setUpError(self):
        class ErrorTest(SynchronousTestCase):
            ran = False

def setUp(self):
                1 / 0

def test_foo(s):
                s.ran = True

test = ErrorTest("test_foo")
        result = pyunit.TestResult()
        test.run(result)

self.assertFalse(test.ran)
        self.assertEqual(1, result.testsRun)
        self.assertEqual(1, len(result.errors))
        self.assertFalse(result.wasSuccessful())

def test_tracebackFromFailure(self):
        """
        Errors added through the L{PyUnitResultAdapter} have the same traceback
        information as if there were no adapter at all.
        """
        try:
            1 / 0
        except ZeroDivisionError:
            exc_info = sys.exc_info()
            f = Failure()
        pyresult = pyunit.TestResult()
        result = PyUnitResultAdapter(pyresult)
        result.addError(self, f)
        self.assertEqual(
            pyresult.errors[0][1], "".join(traceback.format_exception(*exc_info))
        )

def test_traceback(self):
        """
        As test_tracebackFromFailure, but covering more code.
        """

class ErrorTest(SynchronousTestCase):
            exc_info = None

def test_foo(self):
                try:
                    1 / 0
                except ZeroDivisionError:
                    self.exc_info = sys.exc_info()
                    raise

test = ErrorTest("test_foo")
        result = pyunit.TestResult()
        test.run(result)

# We can't test that the tracebacks are equal, because Trial's
        # machinery inserts a few extra frames on the top and we don't really
        # want to trim them off without an extremely good reason.
        #
        # So, we just test that the result's stack ends with the
        # exception's stack.

expected_stack = "".join(traceback.format_tb(test.exc_info[2]))
        observed_stack = "\n".join(result.errors[0][1].splitlines()[:-1])

self.assertEqual(
            expected_stack.strip(), observed_stack[-len(expected_stack) :].strip()
        )

def test_tracebackFromCleanFailure(self):
        """
        Errors added through the L{PyUnitResultAdapter} have the same
        traceback information as if there were no adapter at all, even
        if the Failure that held the information has been cleaned.
        """
        try:
            1 / 0
        except ZeroDivisionError:
            exc_info = sys.exc_info()
            f = Failure()
        f.cleanFailure()
        pyresult = pyunit.TestResult()
        result = PyUnitResultAdapter(pyresult)
        result.addError(self, f)
        self.assertEqual(
            pyresult.errors[0][1], "".join(traceback.format_exception(*exc_info))
        )

def test_trialSkip(self):
        """
        Skips using trial's skipping functionality are reported as skips in
        the L{pyunit.TestResult}.
        """

class SkipTest(SynchronousTestCase):
            @skipIf(True, "Let's skip!")
            def test_skip(self):
                1 / 0

test = SkipTest("test_skip")
        result = pyunit.TestResult()
        test.run(result)
        self.assertEqual(result.skipped, [(test, "Let's skip!")])

def test_pyunitSkip(self):
        """
        Skips using pyunit's skipping functionality are reported as skips in
        the L{pyunit.TestResult}.
        """

class SkipTest(SynchronousTestCase):
            @pyunit.skip("skippy")
            def test_skip(self):
                1 / 0

test = SkipTest("test_skip")
        result = pyunit.TestResult()
        test.run(result)
        self.assertEqual(result.skipped, [(test, "skippy")])

cmd: