484 lines
16 KiB
Python
484 lines
16 KiB
Python
# Copyright (c) Twisted Matrix Laboratories.
|
|
# See LICENSE for details.
|
|
|
|
"""
|
|
Tests for L{twisted.internet.testing}.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from typing import Callable
|
|
|
|
from zope.interface.verify import verifyObject
|
|
|
|
from typing import Protocol
|
|
|
|
from twisted.internet.address import IPv4Address
|
|
from twisted.internet.interfaces import (
|
|
IAddress,
|
|
IConnector,
|
|
IConsumer,
|
|
IListeningPort,
|
|
IPushProducer,
|
|
IReactorSSL,
|
|
IReactorTCP,
|
|
IReactorUNIX,
|
|
ITransport,
|
|
)
|
|
from twisted.internet.protocol import ClientFactory, Factory
|
|
from twisted.internet.testing import (
|
|
MemoryReactor,
|
|
NonStreamingProducer,
|
|
RaisingMemoryReactor,
|
|
StringTransport,
|
|
)
|
|
from twisted.python.reflect import namedAny
|
|
from twisted.trial.unittest import TestCase
|
|
|
|
|
|
class StringTransportTests(TestCase):
|
|
"""
|
|
Tests for L{twisted.internet.testing.StringTransport}.
|
|
"""
|
|
|
|
def setUp(self) -> None:
|
|
self.transport = StringTransport()
|
|
|
|
def test_interfaces(self) -> None:
|
|
"""
|
|
L{StringTransport} instances provide L{ITransport}, L{IPushProducer},
|
|
and L{IConsumer}.
|
|
"""
|
|
self.assertTrue(verifyObject(ITransport, self.transport))
|
|
self.assertTrue(verifyObject(IPushProducer, self.transport))
|
|
self.assertTrue(verifyObject(IConsumer, self.transport))
|
|
|
|
def test_registerProducer(self) -> None:
|
|
"""
|
|
L{StringTransport.registerProducer} records the arguments supplied to
|
|
it as instance attributes.
|
|
"""
|
|
producer = object()
|
|
streaming = object()
|
|
self.transport.registerProducer(producer, streaming)
|
|
self.assertIs(self.transport.producer, producer)
|
|
self.assertIs(self.transport.streaming, streaming)
|
|
|
|
def test_disallowedRegisterProducer(self) -> None:
|
|
"""
|
|
L{StringTransport.registerProducer} raises L{RuntimeError} if a
|
|
producer is already registered.
|
|
"""
|
|
producer = object()
|
|
self.transport.registerProducer(producer, True)
|
|
self.assertRaises(
|
|
RuntimeError, self.transport.registerProducer, object(), False
|
|
)
|
|
self.assertIs(self.transport.producer, producer)
|
|
self.assertTrue(self.transport.streaming)
|
|
|
|
def test_unregisterProducer(self) -> None:
|
|
"""
|
|
L{StringTransport.unregisterProducer} causes the transport to forget
|
|
about the registered producer and makes it possible to register a new
|
|
one.
|
|
"""
|
|
oldProducer = object()
|
|
newProducer = object()
|
|
self.transport.registerProducer(oldProducer, False)
|
|
self.transport.unregisterProducer()
|
|
self.assertIsNone(self.transport.producer)
|
|
self.transport.registerProducer(newProducer, True)
|
|
self.assertIs(self.transport.producer, newProducer)
|
|
self.assertTrue(self.transport.streaming)
|
|
|
|
def test_invalidUnregisterProducer(self) -> None:
|
|
"""
|
|
L{StringTransport.unregisterProducer} raises L{RuntimeError} if called
|
|
when no producer is registered.
|
|
"""
|
|
self.assertRaises(RuntimeError, self.transport.unregisterProducer)
|
|
|
|
def test_initialProducerState(self) -> None:
|
|
"""
|
|
L{StringTransport.producerState} is initially C{'producing'}.
|
|
"""
|
|
self.assertEqual(self.transport.producerState, "producing")
|
|
|
|
def test_pauseProducing(self) -> None:
|
|
"""
|
|
L{StringTransport.pauseProducing} changes the C{producerState} of the
|
|
transport to C{'paused'}.
|
|
"""
|
|
self.transport.pauseProducing()
|
|
self.assertEqual(self.transport.producerState, "paused")
|
|
|
|
def test_resumeProducing(self) -> None:
|
|
"""
|
|
L{StringTransport.resumeProducing} changes the C{producerState} of the
|
|
transport to C{'producing'}.
|
|
"""
|
|
self.transport.pauseProducing()
|
|
self.transport.resumeProducing()
|
|
self.assertEqual(self.transport.producerState, "producing")
|
|
|
|
def test_stopProducing(self) -> None:
|
|
"""
|
|
L{StringTransport.stopProducing} changes the C{'producerState'} of the
|
|
transport to C{'stopped'}.
|
|
"""
|
|
self.transport.stopProducing()
|
|
self.assertEqual(self.transport.producerState, "stopped")
|
|
|
|
def test_stoppedTransportCannotPause(self) -> None:
|
|
"""
|
|
L{StringTransport.pauseProducing} raises L{RuntimeError} if the
|
|
transport has been stopped.
|
|
"""
|
|
self.transport.stopProducing()
|
|
self.assertRaises(RuntimeError, self.transport.pauseProducing)
|
|
|
|
def test_stoppedTransportCannotResume(self) -> None:
|
|
"""
|
|
L{StringTransport.resumeProducing} raises L{RuntimeError} if the
|
|
transport has been stopped.
|
|
"""
|
|
self.transport.stopProducing()
|
|
self.assertRaises(RuntimeError, self.transport.resumeProducing)
|
|
|
|
def test_disconnectingTransportCannotPause(self) -> None:
|
|
"""
|
|
L{StringTransport.pauseProducing} raises L{RuntimeError} if the
|
|
transport is being disconnected.
|
|
"""
|
|
self.transport.loseConnection()
|
|
self.assertRaises(RuntimeError, self.transport.pauseProducing)
|
|
|
|
def test_disconnectingTransportCannotResume(self) -> None:
|
|
"""
|
|
L{StringTransport.resumeProducing} raises L{RuntimeError} if the
|
|
transport is being disconnected.
|
|
"""
|
|
self.transport.loseConnection()
|
|
self.assertRaises(RuntimeError, self.transport.resumeProducing)
|
|
|
|
def test_loseConnectionSetsDisconnecting(self) -> None:
|
|
"""
|
|
L{StringTransport.loseConnection} toggles the C{disconnecting} instance
|
|
variable to C{True}.
|
|
"""
|
|
self.assertFalse(self.transport.disconnecting)
|
|
self.transport.loseConnection()
|
|
self.assertTrue(self.transport.disconnecting)
|
|
|
|
def test_specifiedHostAddress(self) -> None:
|
|
"""
|
|
If a host address is passed to L{StringTransport.__init__}, that
|
|
value is returned from L{StringTransport.getHost}.
|
|
"""
|
|
address = object()
|
|
self.assertIs(StringTransport(address).getHost(), address)
|
|
|
|
def test_specifiedPeerAddress(self) -> None:
|
|
"""
|
|
If a peer address is passed to L{StringTransport.__init__}, that
|
|
value is returned from L{StringTransport.getPeer}.
|
|
"""
|
|
address = object()
|
|
self.assertIs(StringTransport(peerAddress=address).getPeer(), address)
|
|
|
|
def test_defaultHostAddress(self) -> None:
|
|
"""
|
|
If no host address is passed to L{StringTransport.__init__}, an
|
|
L{IPv4Address} is returned from L{StringTransport.getHost}.
|
|
"""
|
|
address = StringTransport().getHost()
|
|
self.assertIsInstance(address, IPv4Address)
|
|
|
|
def test_defaultPeerAddress(self) -> None:
|
|
"""
|
|
If no peer address is passed to L{StringTransport.__init__}, an
|
|
L{IPv4Address} is returned from L{StringTransport.getPeer}.
|
|
"""
|
|
address = StringTransport().getPeer()
|
|
self.assertIsInstance(address, IPv4Address)
|
|
|
|
|
|
class ReactorTests(TestCase):
|
|
"""
|
|
Tests for L{MemoryReactor} and L{RaisingMemoryReactor}.
|
|
"""
|
|
|
|
def test_memoryReactorProvides(self) -> None:
|
|
"""
|
|
L{MemoryReactor} provides all of the attributes described by the
|
|
interfaces it advertises.
|
|
"""
|
|
memoryReactor = MemoryReactor()
|
|
verifyObject(IReactorTCP, memoryReactor)
|
|
verifyObject(IReactorSSL, memoryReactor)
|
|
verifyObject(IReactorUNIX, memoryReactor)
|
|
|
|
def test_raisingReactorProvides(self) -> None:
|
|
"""
|
|
L{RaisingMemoryReactor} provides all of the attributes described by the
|
|
interfaces it advertises.
|
|
"""
|
|
raisingReactor = RaisingMemoryReactor()
|
|
verifyObject(IReactorTCP, raisingReactor)
|
|
verifyObject(IReactorSSL, raisingReactor)
|
|
verifyObject(IReactorUNIX, raisingReactor)
|
|
|
|
def test_connectDestination(self) -> None:
|
|
"""
|
|
L{MemoryReactor.connectTCP}, L{MemoryReactor.connectSSL}, and
|
|
L{MemoryReactor.connectUNIX} will return an L{IConnector} whose
|
|
C{getDestination} method returns an L{IAddress} with attributes which
|
|
reflect the values passed.
|
|
"""
|
|
memoryReactor = MemoryReactor()
|
|
for connector in [
|
|
memoryReactor.connectTCP("test.example.com", 8321, ClientFactory()),
|
|
memoryReactor.connectSSL("test.example.com", 8321, ClientFactory(), None),
|
|
]:
|
|
verifyObject(IConnector, connector)
|
|
address = connector.getDestination()
|
|
verifyObject(IAddress, address)
|
|
self.assertEqual(address.host, "test.example.com")
|
|
self.assertEqual(address.port, 8321)
|
|
connector = memoryReactor.connectUNIX(b"/fake/path", ClientFactory())
|
|
verifyObject(IConnector, connector)
|
|
address = connector.getDestination()
|
|
verifyObject(IAddress, address)
|
|
self.assertEqual(address.name, b"/fake/path")
|
|
|
|
def test_listenDefaultHost(self) -> None:
|
|
"""
|
|
L{MemoryReactor.listenTCP}, L{MemoryReactor.listenSSL} and
|
|
L{MemoryReactor.listenUNIX} will return an L{IListeningPort} whose
|
|
C{getHost} method returns an L{IAddress}; C{listenTCP} and C{listenSSL}
|
|
will have a default host of C{'0.0.0.0'}, and a port that reflects the
|
|
value passed, and C{listenUNIX} will have a name that reflects the path
|
|
passed.
|
|
"""
|
|
memoryReactor = MemoryReactor()
|
|
for port in [
|
|
memoryReactor.listenTCP(8242, Factory()),
|
|
memoryReactor.listenSSL(8242, Factory(), None),
|
|
]:
|
|
verifyObject(IListeningPort, port)
|
|
address = port.getHost()
|
|
verifyObject(IAddress, address)
|
|
self.assertEqual(address.host, "0.0.0.0")
|
|
self.assertEqual(address.port, 8242)
|
|
port = memoryReactor.listenUNIX(b"/path/to/socket", Factory())
|
|
verifyObject(IListeningPort, port)
|
|
address = port.getHost()
|
|
verifyObject(IAddress, address)
|
|
self.assertEqual(address.name, b"/path/to/socket")
|
|
|
|
def test_readers(self) -> None:
|
|
"""
|
|
Adding, removing, and listing readers works.
|
|
"""
|
|
reader = object()
|
|
reactor = MemoryReactor()
|
|
|
|
reactor.addReader(reader)
|
|
reactor.addReader(reader)
|
|
|
|
self.assertEqual(reactor.getReaders(), [reader])
|
|
|
|
reactor.removeReader(reader)
|
|
|
|
self.assertEqual(reactor.getReaders(), [])
|
|
|
|
def test_writers(self) -> None:
|
|
"""
|
|
Adding, removing, and listing writers works.
|
|
"""
|
|
writer = object()
|
|
reactor = MemoryReactor()
|
|
|
|
reactor.addWriter(writer)
|
|
reactor.addWriter(writer)
|
|
|
|
self.assertEqual(reactor.getWriters(), [writer])
|
|
|
|
reactor.removeWriter(writer)
|
|
|
|
self.assertEqual(reactor.getWriters(), [])
|
|
|
|
|
|
class TestConsumer:
|
|
"""
|
|
A very basic test consumer for use with the NonStreamingProducerTests.
|
|
"""
|
|
|
|
def __init__(self) -> None:
|
|
self.writes: list[bytes] = []
|
|
self.producer: object = None
|
|
self.producerStreaming: bool | None = None
|
|
|
|
def registerProducer(self, producer: object, streaming: bool) -> None:
|
|
"""
|
|
Registers a single producer with this consumer. Just keeps track of it.
|
|
|
|
@param producer: The producer to register.
|
|
@param streaming: Whether the producer is a streaming one or not.
|
|
"""
|
|
self.producer = producer
|
|
self.producerStreaming = streaming
|
|
|
|
def unregisterProducer(self) -> None:
|
|
"""
|
|
Forget the producer we had previously registered.
|
|
"""
|
|
self.producer = None
|
|
self.producerStreaming = None
|
|
|
|
def write(self, data: bytes) -> None:
|
|
"""
|
|
Some data was written to the consumer: stores it for later use.
|
|
|
|
@param data: The data to write.
|
|
"""
|
|
self.writes.append(data)
|
|
|
|
|
|
class NonStreamingProducerTests(TestCase):
|
|
"""
|
|
Tests for the L{NonStreamingProducer} to validate behaviour.
|
|
"""
|
|
|
|
def test_producesOnly10Times(self) -> None:
|
|
"""
|
|
When the L{NonStreamingProducer} has resumeProducing called 10 times,
|
|
it writes the counter each time and then fails.
|
|
"""
|
|
consumer = TestConsumer()
|
|
producer = NonStreamingProducer(consumer)
|
|
consumer.registerProducer(producer, False)
|
|
|
|
self.assertIs(consumer.producer, producer)
|
|
self.assertIs(producer.consumer, consumer)
|
|
self.assertFalse(consumer.producerStreaming)
|
|
|
|
for _ in range(10):
|
|
producer.resumeProducing()
|
|
|
|
# We should have unregistered the producer and printed the 10 results.
|
|
expectedWrites = [b"0", b"1", b"2", b"3", b"4", b"5", b"6", b"7", b"8", b"9"]
|
|
self.assertIsNone(consumer.producer)
|
|
self.assertIsNone(consumer.producerStreaming)
|
|
self.assertIsNone(producer.consumer)
|
|
self.assertEqual(consumer.writes, expectedWrites)
|
|
|
|
# Another attempt to produce fails.
|
|
self.assertRaises(RuntimeError, producer.resumeProducing)
|
|
|
|
def test_cannotPauseProduction(self) -> None:
|
|
"""
|
|
When the L{NonStreamingProducer} is paused, it raises a
|
|
L{RuntimeError}.
|
|
"""
|
|
consumer = TestConsumer()
|
|
producer = NonStreamingProducer(consumer)
|
|
consumer.registerProducer(producer, False)
|
|
|
|
# Produce once, just to be safe.
|
|
producer.resumeProducing()
|
|
|
|
self.assertRaises(RuntimeError, producer.pauseProducing)
|
|
|
|
|
|
class _SupportsName(Protocol):
|
|
@property
|
|
def __name__(self) -> str:
|
|
...
|
|
|
|
|
|
class DeprecationTests(TestCase):
|
|
"""
|
|
Deprecations in L{twisted.test.proto_helpers}.
|
|
"""
|
|
|
|
def helper(self, test: Callable[..., object], obj: _SupportsName) -> None:
|
|
new_path = f"twisted.internet.testing.{obj.__name__}"
|
|
warnings = self.flushWarnings([test])
|
|
self.assertEqual(DeprecationWarning, warnings[0]["category"])
|
|
self.assertEqual(1, len(warnings))
|
|
self.assertIn(new_path, warnings[0]["message"])
|
|
self.assertIs(obj, namedAny(new_path))
|
|
|
|
def test_accumulatingProtocol(self) -> None:
|
|
from twisted.test.proto_helpers import AccumulatingProtocol
|
|
|
|
self.helper(self.test_accumulatingProtocol, AccumulatingProtocol)
|
|
|
|
def test_lineSendingProtocol(self) -> None:
|
|
from twisted.test.proto_helpers import LineSendingProtocol
|
|
|
|
self.helper(self.test_lineSendingProtocol, LineSendingProtocol)
|
|
|
|
def test_fakeDatagramTransport(self) -> None:
|
|
from twisted.test.proto_helpers import FakeDatagramTransport
|
|
|
|
self.helper(self.test_fakeDatagramTransport, FakeDatagramTransport)
|
|
|
|
def test_stringTransport(self) -> None:
|
|
from twisted.test.proto_helpers import StringTransport
|
|
|
|
self.helper(self.test_stringTransport, StringTransport)
|
|
|
|
def test_stringTransportWithDisconnection(self) -> None:
|
|
from twisted.test.proto_helpers import StringTransportWithDisconnection
|
|
|
|
self.helper(
|
|
self.test_stringTransportWithDisconnection, StringTransportWithDisconnection
|
|
)
|
|
|
|
def test_stringIOWithoutClosing(self) -> None:
|
|
from twisted.test.proto_helpers import StringIOWithoutClosing
|
|
|
|
self.helper(self.test_stringIOWithoutClosing, StringIOWithoutClosing)
|
|
|
|
def test__fakeConnector(self) -> None:
|
|
from twisted.test.proto_helpers import _FakeConnector
|
|
|
|
self.helper(self.test__fakeConnector, _FakeConnector)
|
|
|
|
def test__fakePort(self) -> None:
|
|
from twisted.test.proto_helpers import _FakePort
|
|
|
|
self.helper(self.test__fakePort, _FakePort)
|
|
|
|
def test_memoryReactor(self) -> None:
|
|
from twisted.test.proto_helpers import MemoryReactor
|
|
|
|
self.helper(self.test_memoryReactor, MemoryReactor)
|
|
|
|
def test_memoryReactorClock(self) -> None:
|
|
from twisted.test.proto_helpers import MemoryReactorClock
|
|
|
|
self.helper(self.test_memoryReactorClock, MemoryReactorClock)
|
|
|
|
def test_raisingMemoryReactor(self) -> None:
|
|
from twisted.test.proto_helpers import RaisingMemoryReactor
|
|
|
|
self.helper(self.test_raisingMemoryReactor, RaisingMemoryReactor)
|
|
|
|
def test_nonStreamingProducer(self) -> None:
|
|
from twisted.test.proto_helpers import NonStreamingProducer
|
|
|
|
self.helper(self.test_nonStreamingProducer, NonStreamingProducer)
|
|
|
|
def test_waitUntilAllDisconnected(self) -> None:
|
|
from twisted.test.proto_helpers import waitUntilAllDisconnected
|
|
|
|
self.helper(self.test_waitUntilAllDisconnected, waitUntilAllDisconnected)
|
|
|
|
def test_eventLoggingObserver(self) -> None:
|
|
from twisted.test.proto_helpers import EventLoggingObserver
|
|
|
|
self.helper(self.test_eventLoggingObserver, EventLoggingObserver)
|