twisted.test.iosim

module documentation

(source)

Utilities and helpers for simulating a network

Class	`ConnectionCompleter`	A `ConnectionCompleter` can cause synthetic TCP connections established by `MemoryReactor.connectTCP` and `MemoryReactor.listenTCP` to succeed or fail.
Class	`FakeAddress`	The default address type for the host and peer of `FakeTransport` connections.
Class	`FakeTransport`	A wrapper around a file-like object to make it behave as a Transport.
Class	`IOPump`	Utility to pump data between clients and servers for protocol testing.
Class	`TLSNegotiation`	Undocumented
Function	`connect`	Create a new `IOPump` connecting two protocols.
Function	`connectableEndpoint`	Create an endpoint that can be fired on demand.
Function	`connectedServerAndClient`	Connect a given server and client class to each other.
Function	`makeFakeClient`	Create and return a new in-memory transport hooked up to the given protocol.
Function	`makeFakeServer`	Create and return a new in-memory transport hooked up to the given protocol.
Function	`_factoriesShouldConnect`	Should the client and server described by the arguments be connected to each other, i.e. do their port numbers match?

def connect(serverProtocol, serverTransport, clientProtocol, clientTransport, debug=False, greet=True): (source) ¶

Create a new IOPump connecting two protocols.

Parameters
serverProtocol:`IProtocol` provider	The protocol to use on the accepting side of the connection.
serverTransport:`FakeTransport`	The transport to associate with `serverProtocol`.
clientProtocol:`IProtocol` provider	The protocol to use on the initiating side of the connection.
clientTransport:`FakeTransport`	The transport to associate with `clientProtocol`.
debug:`bool`	A flag indicating whether to log information about what the `IOPump` is doing.
greet:`bool`	Should the `IOPump` be `flushed` once before returning to put the protocols into their post-handshake or post-server-greeting state?
Returns
`IOPump`	An `IOPump` which connects `serverProtocol` and `clientProtocol` and delivers bytes between them when it is pumped.

Create an endpoint that can be fired on demand.

Parameters
debug:`bool`	A flag; whether to dump output from the established connection to stdout.
Returns
2-`tuple` of (`IStreamClientEndpoint`, `ConnectionCompleter`)	A client endpoint, and an object that will cause one of the `Deferred`s returned by that client endpoint.

def connectedServerAndClient(ServerClass, ClientClass, clientTransportFactory=makeFakeClient, serverTransportFactory=makeFakeServer, debug=False, greet=True): (source) ¶

Connect a given server and client class to each other.

Parameters
ServerClass:0-argument callable returning `IProtocol` provider.	a callable that produces the server-side protocol.
ClientClass:0-argument callable returning `IProtocol` provider.	like `ServerClass` but for the other side of the connection.
clientTransportFactory:callable taking (`IProtocol`) and returning `FakeTransport`	a callable that produces the transport which will be attached to the protocol returned from `ClientClass`.
serverTransportFactory:callable taking (`IProtocol`) and returning `FakeTransport`	a callable that produces the transport which will be attached to the protocol returned from `ServerClass`.
debug:`bool`	Should this dump an escaped version of all traffic on this connection to stdout for inspection?
greet:`bool`	Should the `IOPump` be `flushed` once before returning to put the protocols into their post-handshake or post-server-greeting state?
Returns
3-`tuple` of `IProtocol`, `IProtocol`, `IOPump`	the client protocol, the server protocol, and an `IOPump` which, when its `pump` and `flush` methods are called, will move data between the created client and server protocol instances.

def makeFakeClient(clientProtocol): (source) ¶

Create and return a new in-memory transport hooked up to the given protocol.

Parameters
clientProtocol:`IProtocol` provider	The client protocol to use.
Returns
`FakeTransport`	The transport.

def makeFakeServer(serverProtocol): (source) ¶

Create and return a new in-memory transport hooked up to the given protocol.

Parameters
serverProtocol:`IProtocol` provider	The server protocol to use.
Returns
`FakeTransport`	The transport.

def _factoriesShouldConnect(clientInfo, serverInfo): (source) ¶

Should the client and server described by the arguments be connected to each other, i.e. do their port numbers match?

Parameters
clientInfo:`tuple`	the args for connectTCP
serverInfo:`tuple`	the args for listenTCP
Returns
`None` or 2-`tuple` of (`ClientFactory`, `IProtocolFactory`)	If they do match, return factories for the client and server that should connect; otherwise return `None`, indicating they shouldn't be connected.