# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
Tests for L{twisted.trial._dist.workerreporter}.
"""
from __future__ import annotations
from typing import Sized
from unittest import TestCase
from hamcrest import assert_that, equal_to, has_length
from hamcrest.core.matcher import Matcher
from twisted.internet.defer import Deferred
from twisted.test.iosim import connectedServerAndClient
from twisted.trial._dist.worker import LocalWorkerAMP, WorkerProtocol
from twisted.trial.reporter import TestResult
from twisted.trial.test import erroneous, pyunitcases, sample, skipping
from twisted.trial.unittest import SynchronousTestCase
from .matchers import matches_result
def run(case: SynchronousTestCase, target: TestCase) -> TestResult:
"""
Run C{target} and return a test result as populated by a worker reporter.
@param case: A test case to use to help run the target.
"""
result = TestResult()
worker, local, pump = connectedServerAndClient(LocalWorkerAMP, WorkerProtocol)
d = Deferred.fromCoroutine(local.run(target, result))
pump.flush()
assert_that(case.successResultOf(d), equal_to({"success": True}))
return result
class WorkerReporterTests(SynchronousTestCase):
"""
Tests for L{WorkerReporter}.
"""
def assertTestRun(self, target: TestCase, **expectations: Matcher[Sized]) -> None:
"""
Run the given test and assert that the result matches the given
expectations.
"""
assert_that(run(self, target), matches_result(**expectations))
def test_outsideReportingContext(self) -> None:
"""
L{WorkerReporter}'s implementation of test result methods raise
L{ValueError} when called outside of the
L{WorkerReporter.gatherReportingResults} context manager.
"""
worker, local, pump = connectedServerAndClient(LocalWorkerAMP, WorkerProtocol)
case = sample.FooTest("test_foo")
with self.assertRaises(ValueError):
worker._result.addSuccess(case)
def test_addSuccess(self) -> None:
"""
L{WorkerReporter} propagates successes.
"""
self.assertTestRun(sample.FooTest("test_foo"), successes=equal_to(1))
def test_addError(self) -> None:
"""
L{WorkerReporter} propagates errors from trial's TestCases.
"""
self.assertTestRun(
erroneous.TestAsynchronousFail("test_exception"), errors=has_length(1)
)
def test_addErrorGreaterThan64k(self) -> None:
"""
L{WorkerReporter} propagates errors with large string representations.
"""
self.assertTestRun(
erroneous.TestAsynchronousFail("test_exceptionGreaterThan64k"),
errors=has_length(1),
)
def test_addErrorGreaterThan64kEncoded(self) -> None:
"""
L{WorkerReporter} propagates errors with a string representation that
is smaller than an implementation-specific limit but which encode to a
byte representation that exceeds this limit.
"""
self.assertTestRun(
erroneous.TestAsynchronousFail("test_exceptionGreaterThan64kEncoded"),
errors=has_length(1),
)
def test_addErrorTuple(self) -> None:
"""
L{WorkerReporter} propagates errors from pyunit's TestCases.
"""
self.assertTestRun(pyunitcases.PyUnitTest("test_error"), errors=has_length(1))
def test_addFailure(self) -> None:
"""
L{WorkerReporter} propagates test failures from trial's TestCases.
"""
self.assertTestRun(
erroneous.TestRegularFail("test_fail"), failures=has_length(1)
)
def test_addFailureGreaterThan64k(self) -> None:
"""
L{WorkerReporter} propagates test failures with large string representations.
"""
self.assertTestRun(
erroneous.TestAsynchronousFail("test_failGreaterThan64k"),
failures=has_length(1),
)
def test_addFailureTuple(self) -> None:
"""
L{WorkerReporter} propagates test failures from pyunit's TestCases.
"""
self.assertTestRun(pyunitcases.PyUnitTest("test_fail"), failures=has_length(1))
def test_addSkip(self) -> None:
"""
L{WorkerReporter} propagates skips.
"""
self.assertTestRun(
skipping.SynchronousSkipping("test_skip1"), skips=has_length(1)
)
def test_addSkipPyunit(self) -> None:
"""
L{WorkerReporter} propagates skips from L{unittest.TestCase} cases.
"""
self.assertTestRun(
pyunitcases.PyUnitTest("test_skip"),
skips=has_length(1),
)
def test_addExpectedFailure(self) -> None:
"""
L{WorkerReporter} propagates expected failures.
"""
self.assertTestRun(
skipping.SynchronousStrictTodo("test_todo1"), expectedFailures=has_length(1)
)
def test_addExpectedFailureGreaterThan64k(self) -> None:
"""
WorkerReporter propagates expected failures with large string representations.
"""
self.assertTestRun(
skipping.ExpectedFailure("test_expectedFailureGreaterThan64k"),
expectedFailures=has_length(1),
)
def test_addUnexpectedSuccess(self) -> None:
"""
L{WorkerReporter} propagates unexpected successes.
"""
self.assertTestRun(
skipping.SynchronousTodo("test_todo3"), unexpectedSuccesses=has_length(1)
)
|