Gecko [ gandhischool.edu.np ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxr-xr-x
__init__.py	130 B	-rw-r--r--
detests.py	5.53 KB	-rw-r--r--
erroneous.py	4.68 KB	-rw-r--r--
mockcustomsuite.py	536 B	-rw-r--r--
mockcustomsuite2.py	533 B	-rw-r--r--
mockcustomsuite3.py	676 B	-rw-r--r--
mockdoctest.py	2.36 KB	-rw-r--r--
moduleself.py	170 B	-rw-r--r--
moduletest.py	302 B	-rw-r--r--
novars.py	182 B	-rw-r--r--
ordertests.py	864 B	-rw-r--r--
packages.py	4.54 KB	-rw-r--r--
sample.py	2.04 KB	-rw-r--r--
scripttest.py	457 B	-rwxr-xr-x
skipping.py	5.58 KB	-rw-r--r--
suppression.py	2.44 KB	-rw-r--r--
test_assertions.py	59.39 KB	-rw-r--r--
test_asyncassertions.py	2.49 KB	-rw-r--r--
test_deferred.py	8.62 KB	-rw-r--r--
test_doctest.py	1.67 KB	-rw-r--r--
test_keyboard.py	3.7 KB	-rw-r--r--
test_loader.py	21.84 KB	-rw-r--r--
test_log.py	7.85 KB	-rw-r--r--
test_output.py	4.9 KB	-rw-r--r--
test_plugins.py	1.43 KB	-rw-r--r--
test_pyunitcompat.py	7.44 KB	-rw-r--r--
test_reporter.py	55.38 KB	-rw-r--r--
test_runner.py	34.22 KB	-rw-r--r--
test_script.py	28.69 KB	-rw-r--r--
test_skip.py	2.59 KB	-rw-r--r--
test_suppression.py	5.77 KB	-rw-r--r--
test_testcase.py	1.94 KB	-rw-r--r--
test_tests.py	48.34 KB	-rw-r--r--
test_util.py	19.2 KB	-rw-r--r--
test_warning.py	17.22 KB	-rw-r--r--
weird.py	675 B	-rw-r--r--

Code Editor : test_deferred.py

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

"""
Tests for returning Deferreds from a TestCase.
"""

import unittest as pyunit

from twisted.internet import defer
from twisted.trial import reporter, unittest, util
from twisted.trial.test import detests

class SetUpTests(unittest.TestCase):
    def _loadSuite(self, klass):
        loader = pyunit.TestLoader()
        r = reporter.TestResult()
        s = loader.loadTestsFromTestCase(klass)
        return r, s

def test_success(self):
        result, suite = self._loadSuite(detests.DeferredSetUpOK)
        suite(result)
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)

def test_fail(self):
        self.assertFalse(detests.DeferredSetUpFail.testCalled)
        result, suite = self._loadSuite(detests.DeferredSetUpFail)
        suite(result)
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.failures), 0)
        self.assertEqual(len(result.errors), 1)
        self.assertFalse(detests.DeferredSetUpFail.testCalled)

def test_callbackFail(self):
        self.assertFalse(detests.DeferredSetUpCallbackFail.testCalled)
        result, suite = self._loadSuite(detests.DeferredSetUpCallbackFail)
        suite(result)
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.failures), 0)
        self.assertEqual(len(result.errors), 1)
        self.assertFalse(detests.DeferredSetUpCallbackFail.testCalled)

def test_error(self):
        self.assertFalse(detests.DeferredSetUpError.testCalled)
        result, suite = self._loadSuite(detests.DeferredSetUpError)
        suite(result)
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.failures), 0)
        self.assertEqual(len(result.errors), 1)
        self.assertFalse(detests.DeferredSetUpError.testCalled)

def test_skip(self):
        self.assertFalse(detests.DeferredSetUpSkip.testCalled)
        result, suite = self._loadSuite(detests.DeferredSetUpSkip)
        suite(result)
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.failures), 0)
        self.assertEqual(len(result.errors), 0)
        self.assertEqual(len(result.skips), 1)
        self.assertFalse(detests.DeferredSetUpSkip.testCalled)

class NeverFireTests(unittest.TestCase):
    def setUp(self):
        self._oldTimeout = util.DEFAULT_TIMEOUT_DURATION
        util.DEFAULT_TIMEOUT_DURATION = 0.1

def tearDown(self):
        util.DEFAULT_TIMEOUT_DURATION = self._oldTimeout

def _loadSuite(self, klass):
        loader = pyunit.TestLoader()
        r = reporter.TestResult()
        s = loader.loadTestsFromTestCase(klass)
        return r, s

def test_setUp(self):
        self.assertFalse(detests.DeferredSetUpNeverFire.testCalled)
        result, suite = self._loadSuite(detests.DeferredSetUpNeverFire)
        suite(result)
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.failures), 0)
        self.assertEqual(len(result.errors), 1)
        self.assertFalse(detests.DeferredSetUpNeverFire.testCalled)
        self.assertTrue(result.errors[0][1].check(defer.TimeoutError))

class TestTester(unittest.TestCase):
    def getTest(self, name):
        raise NotImplementedError("must override me")

def runTest(self, name):
        result = reporter.TestResult()
        self.getTest(name).run(result)
        return result

class DeferredTests(TestTester):
    def getTest(self, name):
        return detests.DeferredTests(name)

def test_pass(self):
        result = self.runTest("test_pass")
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)

def test_passGenerated(self):
        result = self.runTest("test_passGenerated")
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertTrue(detests.DeferredTests.touched)

test_passGenerated.supress = [  # type: ignore[attr-defined]
        util.suppress(message="twisted.internet.defer.deferredGenerator is deprecated")
    ]

def test_passInlineCallbacks(self):
        """
        The body of a L{defer.inlineCallbacks} decorated test gets run.
        """
        result = self.runTest("test_passInlineCallbacks")
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertTrue(detests.DeferredTests.touched)

def test_fail(self):
        result = self.runTest("test_fail")
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.failures), 1)

def test_failureInCallback(self):
        result = self.runTest("test_failureInCallback")
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.failures), 1)

def test_errorInCallback(self):
        result = self.runTest("test_errorInCallback")
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.errors), 1)

def test_skip(self):
        result = self.runTest("test_skip")
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.skips), 1)
        self.assertFalse(detests.DeferredTests.touched)

def test_todo(self):
        result = self.runTest("test_expectedFailure")
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.errors), 0)
        self.assertEqual(len(result.failures), 0)
        self.assertEqual(len(result.expectedFailures), 1)

def test_thread(self):
        result = self.runTest("test_thread")
        self.assertEqual(result.testsRun, 1)
        self.assertTrue(result.wasSuccessful(), result.errors)

class TimeoutTests(TestTester):
    def getTest(self, name):
        return detests.TimeoutTests(name)

def _wasTimeout(self, error):
        self.assertEqual(error.check(defer.TimeoutError), defer.TimeoutError)

def test_pass(self):
        result = self.runTest("test_pass")
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)

def test_passDefault(self):
        result = self.runTest("test_passDefault")
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)

def test_timeout(self):
        result = self.runTest("test_timeout")
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.errors), 1)
        self._wasTimeout(result.errors[0][1])

def test_timeoutZero(self):
        result = self.runTest("test_timeoutZero")
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.errors), 1)
        self._wasTimeout(result.errors[0][1])

def test_todo(self):
        result = self.runTest("test_expectedFailure")
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(len(result.expectedFailures), 1)
        self._wasTimeout(result.expectedFailures[0][1])

def test_errorPropagation(self):
        result = self.runTest("test_errorPropagation")
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(result.testsRun, 1)
        self._wasTimeout(detests.TimeoutTests.timedOut)

def test_classTimeout(self):
        loader = pyunit.TestLoader()
        suite = loader.loadTestsFromTestCase(detests.TestClassTimeoutAttribute)
        result = reporter.TestResult()
        suite.run(result)
        self.assertEqual(len(result.errors), 1)
        self._wasTimeout(result.errors[0][1])

def test_callbackReturnsNonCallingDeferred(self):
        # hacky timeout
        # raises KeyboardInterrupt because Trial sucks
        from twisted.internet import reactor

call = reactor.callLater(2, reactor.crash)
        result = self.runTest("test_calledButNeverCallback")
        if call.active():
            call.cancel()
        self.assertFalse(result.wasSuccessful())
        self._wasTimeout(result.errors[0][1])

# The test loader erroneously attempts to run this:
del TestTester

${this.title}

Code Editor : test_deferred.py