FM / test

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

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

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
cert.pem.no_trailing_newline	1414	0644	edit dl rm
crash_test_dummy.py	543	0644	edit dl rm
iosim.py	17843	0644	edit dl rm
key.pem.no_trailing_newline	1707	0644	edit dl rm
mock_win32process.py	1499	0644	edit dl rm
myrebuilder1.py	158	0644	edit dl rm
myrebuilder2.py	158	0644	edit dl rm
plugin_basic.py	943	0644	edit dl rm
plugin_extra1.py	407	0644	edit dl rm
plugin_extra2.py	579	0644	edit dl rm
process_cmdline.py	162	0644	edit dl rm
process_echoer.py	214	0644	edit dl rm
process_fds.py	945	0644	edit dl rm
process_getargv.py	283	0644	edit dl rm
process_getenv.py	268	0644	edit dl rm
process_linger.py	286	0644	edit dl rm
process_reader.py	188	0644	edit dl rm
process_signal.py	214	0644	edit dl rm
process_stdinreader.py	857	0644	edit dl rm
process_tester.py	1035	0644	edit dl rm
process_tty.py	130	0644	edit dl rm
process_twisted.py	1206	0644	edit dl rm
proto_helpers.py	28687	0644	edit dl rm
raiser.cpython-38-x86_64-linux-gnu.so	23864	0644	edit dl rm
reflect_helper_IE.py	61	0644	edit dl rm
reflect_helper_VE.py	82	0644	edit dl rm
reflect_helper_ZDE.py	47	0644	edit dl rm
server.pem	4444	0644	edit dl rm
ssl_helpers.py	1032	0644	edit dl rm
stdio_test_consumer.py	1216	0644	edit dl rm
stdio_test_halfclose.py	1938	0644	edit dl rm
stdio_test_hostpeer.py	1021	0644	edit dl rm
stdio_test_lastwrite.py	1206	0644	edit dl rm
stdio_test_loseconn.py	1548	0644	edit dl rm
stdio_test_producer.py	1507	0644	edit dl rm
stdio_test_write.py	923	0644	edit dl rm
stdio_test_writeseq.py	915	0644	edit dl rm
testutils.py	5321	0644	edit dl rm
test_abstract.py	3497	0644	edit dl rm
test_adbapi.py	26148	0644	edit dl rm
test_amp.py	110553	0644	edit dl rm
test_application.py	32816	0644	edit dl rm
test_compat.py	29278	0644	edit dl rm
test_context.py	1515	0644	edit dl rm
test_cooperator.py	21467	0644	edit dl rm
test_defer.py	103407	0644	edit dl rm
test_defgen.py	10701	0644	edit dl rm
test_dict.py	1442	0644	edit dl rm
test_dirdbm.py	6695	0644	edit dl rm
test_error.py	8593	0644	edit dl rm
test_factories.py	4637	0644	edit dl rm
test_failure.py	32288	0644	edit dl rm
test_fdesc.py	7371	0644	edit dl rm
test_finger.py	1997	0644	edit dl rm
test_formmethod.py	3645	0644	edit dl rm
test_ftp.py	130321	0644	edit dl rm
test_ftp_options.py	2685	0644	edit dl rm
test_htb.py	3190	0644	edit dl rm
test_ident.py	7015	0644	edit dl rm
test_internet.py	46422	0644	edit dl rm
test_iosim.py	9060	0644	edit dl rm
test_iutils.py	13445	0644	edit dl rm
test_lockfile.py	15506	0644	edit dl rm
test_log.py	36330	0644	edit dl rm
test_logfile.py	18227	0644	edit dl rm
test_loopback.py	14486	0644	edit dl rm
test_main.py	2501	0644	edit dl rm
test_memcache.py	25143	0644	edit dl rm
test_modules.py	17888	0644	edit dl rm
test_monkey.py	5637	0644	edit dl rm
test_nooldstyle.py	5955	0644	edit dl rm
test_paths.py	74357	0644	edit dl rm
test_pcp.py	12551	0644	edit dl rm
test_persisted.py	14624	0644	edit dl rm
test_plugin.py	26113	0644	edit dl rm
test_policies.py	33499	0644	edit dl rm
test_postfix.py	4243	0644	edit dl rm
test_process.py	86120	0644	edit dl rm
test_protocols.py	7450	0644	edit dl rm
test_randbytes.py	3357	0644	edit dl rm
test_rebuild.py	8495	0644	edit dl rm
test_reflect.py	26085	0644	edit dl rm
test_roots.py	1812	0644	edit dl rm
test_shortcut.py	1991	0644	edit dl rm
test_sip.py	25284	0644	edit dl rm
test_sob.py	5632	0644	edit dl rm
test_socks.py	17738	0644	edit dl rm
test_ssl.py	23846	0644	edit dl rm
test_sslverify.py	113322	0644	edit dl rm
test_stateful.py	2021	0644	edit dl rm
test_stdio.py	13156	0644	edit dl rm
test_strerror.py	5183	0644	edit dl rm
test_stringtransport.py	13264	0644	edit dl rm
test_strports.py	1797	0644	edit dl rm
test_task.py	39326	0644	edit dl rm
test_tcp.py	65820	0644	edit dl rm
test_tcp_internals.py	13117	0644	edit dl rm
test_text.py	6456	0644	edit dl rm
test_threadable.py	3738	0644	edit dl rm
test_threadpool.py	22204	0644	edit dl rm
test_threads.py	13268	0644	edit dl rm
test_tpfile.py	1601	0644	edit dl rm
test_twistd.py	74201	0644	edit dl rm
test_twisted.py	11173	0644	edit dl rm
test_udp.py	24676	0644	edit dl rm
test_unix.py	15157	0644	edit dl rm
test_usage.py	23645	0644	edit dl rm
__init__.py	103	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/twisted/test/iosim.py (17843B)

# -*- test-case-name: twisted.test.test_amp,twisted.test.test_iosim -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Utilities and helpers for simulating a network
"""

from __future__ import absolute_import, division, print_function

import itertools

try:
    from OpenSSL.SSL import Error as NativeOpenSSLError
except ImportError:
    pass

from zope.interface import implementer, directlyProvides
from twisted.internet.endpoints import TCP4ClientEndpoint, TCP4ServerEndpoint
from twisted.internet.protocol import Factory, Protocol
from twisted.internet.error import ConnectionRefusedError

from twisted.python.failure import Failure
from twisted.internet import error
from twisted.internet import interfaces

from .proto_helpers import MemoryReactorClock

class TLSNegotiation:
    def __init__(self, obj, connectState):
        self.obj = obj
        self.connectState = connectState
        self.sent = False
        self.readyToSend = connectState

def __repr__(self):
        return 'TLSNegotiation(%r)' % (self.obj,)

def pretendToVerify(self, other, tpt):
        # Set the transport problems list here?  disconnections?
        # hmmmmm... need some negative path tests.

if not self.obj.iosimVerify(other.obj):
            tpt.disconnectReason = NativeOpenSSLError()
            tpt.loseConnection()

@implementer(interfaces.IAddress)
class FakeAddress(object):
    """
    The default address type for the host and peer of L{FakeTransport}
    connections.
    """

@implementer(interfaces.ITransport,
             interfaces.ITLSTransport)
class FakeTransport:
    """
    A wrapper around a file-like object to make it behave as a Transport.

This doesn't actually stream the file to the attached protocol,
    and is thus useful mainly as a utility for debugging protocols.
    """

_nextserial = staticmethod(lambda counter=itertools.count(): next(counter))
    closed = 0
    disconnecting = 0
    disconnected = 0
    disconnectReason = error.ConnectionDone("Connection done")
    producer = None
    streamingProducer = 0
    tls = None

def __init__(self, protocol, isServer, hostAddress=None, peerAddress=None):
        """
        @param protocol: This transport will deliver bytes to this protocol.
        @type protocol: L{IProtocol} provider

@param isServer: C{True} if this is the accepting side of the
            connection, C{False} if it is the connecting side.
        @type isServer: L{bool}

@param hostAddress: The value to return from C{getHost}.  L{None}
            results in a new L{FakeAddress} being created to use as the value.
        @type hostAddress: L{IAddress} provider or L{None}

@param peerAddress: The value to return from C{getPeer}.  L{None}
            results in a new L{FakeAddress} being created to use as the value.
        @type peerAddress: L{IAddress} provider or L{None}
        """
        self.protocol = protocol
        self.isServer = isServer
        self.stream = []
        self.serial = self._nextserial()
        if hostAddress is None:
            hostAddress = FakeAddress()
        self.hostAddress = hostAddress
        if peerAddress is None:
            peerAddress = FakeAddress()
        self.peerAddress = peerAddress

def __repr__(self):
        return 'FakeTransport<%s,%s,%s>' % (
            self.isServer and 'S' or 'C', self.serial,
            self.protocol.__class__.__name__)

def write(self, data):
        # If transport is closed, we should accept writes but drop the data.
        if self.disconnecting:
            return

if self.tls is not None:
            self.tlsbuf.append(data)
        else:
            self.stream.append(data)

def _checkProducer(self):
        # Cheating; this is called at "idle" times to allow producers to be
        # found and dealt with
        if self.producer and not self.streamingProducer:
            self.producer.resumeProducing()

def registerProducer(self, producer, streaming):
        """
        From abstract.FileDescriptor
        """
        self.producer = producer
        self.streamingProducer = streaming
        if not streaming:
            producer.resumeProducing()

def unregisterProducer(self):
        self.producer = None

def stopConsuming(self):
        self.unregisterProducer()
        self.loseConnection()

def writeSequence(self, iovec):
        self.write(b"".join(iovec))

def loseConnection(self):
        self.disconnecting = True

def abortConnection(self):
        """
        For the time being, this is the same as loseConnection; no buffered
        data will be lost.
        """
        self.disconnecting = True

def reportDisconnect(self):
        if self.tls is not None:
            # We were in the middle of negotiating!  Must have been a TLS
            # problem.
            err = NativeOpenSSLError()
        else:
            err = self.disconnectReason
        self.protocol.connectionLost(Failure(err))

def logPrefix(self):
        """
        Identify this transport/event source to the logging system.
        """
        return "iosim"

def getPeer(self):
        return self.peerAddress

def getHost(self):
        return self.hostAddress

def resumeProducing(self):
        # Never sends data anyways
        pass

def pauseProducing(self):
        # Never sends data anyways
        pass

def stopProducing(self):
        self.loseConnection()

def startTLS(self, contextFactory, beNormal=True):
        # Nothing's using this feature yet, but startTLS has an undocumented
        # second argument which defaults to true; if set to False, servers will
        # behave like clients and clients will behave like servers.
        connectState = self.isServer ^ beNormal
        self.tls = TLSNegotiation(contextFactory, connectState)
        self.tlsbuf = []

def getOutBuffer(self):
        """
        Get the pending writes from this transport, clearing them from the
        pending buffer.

@return: the bytes written with C{transport.write}
        @rtype: L{bytes}
        """
        S = self.stream
        if S:
            self.stream = []
            return b''.join(S)
        elif self.tls is not None:
            if self.tls.readyToSend:
                # Only _send_ the TLS negotiation "packet" if I'm ready to.
                self.tls.sent = True
                return self.tls
            else:
                return None
        else:
            return None

def bufferReceived(self, buf):
        if isinstance(buf, TLSNegotiation):
            assert self.tls is not None # By the time you're receiving a
                                        # negotiation, you have to have called
                                        # startTLS already.
            if self.tls.sent:
                self.tls.pretendToVerify(buf, self)
                self.tls = None # We're done with the handshake if we've gotten
                                # this far... although maybe it failed...?
                # TLS started!  Unbuffer...
                b, self.tlsbuf = self.tlsbuf, None
                self.writeSequence(b)
                directlyProvides(self, interfaces.ISSLTransport)
            else:
                # We haven't sent our own TLS negotiation: time to do that!
                self.tls.readyToSend = True
        else:
            self.protocol.dataReceived(buf)

def makeFakeClient(clientProtocol):
    """
    Create and return a new in-memory transport hooked up to the given protocol.

@param clientProtocol: The client protocol to use.
    @type clientProtocol: L{IProtocol} provider

@return: The transport.
    @rtype: L{FakeTransport}
    """
    return FakeTransport(clientProtocol, isServer=False)

def makeFakeServer(serverProtocol):
    """
    Create and return a new in-memory transport hooked up to the given protocol.

@param serverProtocol: The server protocol to use.
    @type serverProtocol: L{IProtocol} provider

@return: The transport.
    @rtype: L{FakeTransport}
    """
    return FakeTransport(serverProtocol, isServer=True)

class IOPump:
    """
    Utility to pump data between clients and servers for protocol testing.

Perhaps this is a utility worthy of being in protocol.py?
    """
    def __init__(self, client, server, clientIO, serverIO, debug):
        self.client = client
        self.server = server
        self.clientIO = clientIO
        self.serverIO = serverIO
        self.debug = debug

def flush(self, debug=False):
        """
        Pump until there is no more input or output.

Returns whether any data was moved.
        """
        result = False
        for x in range(1000):
            if self.pump(debug):
                result = True
            else:
                break
        else:
            assert 0, "Too long"
        return result

def pump(self, debug=False):
        """
        Move data back and forth.

Returns whether any data was moved.
        """
        if self.debug or debug:
            print('-- GLUG --')
        sData = self.serverIO.getOutBuffer()
        cData = self.clientIO.getOutBuffer()
        self.clientIO._checkProducer()
        self.serverIO._checkProducer()
        if self.debug or debug:
            print('.')
            # XXX slightly buggy in the face of incremental output
            if cData:
                print('C: ' + repr(cData))
            if sData:
                print('S: ' + repr(sData))
        if cData:
            self.serverIO.bufferReceived(cData)
        if sData:
            self.clientIO.bufferReceived(sData)
        if cData or sData:
            return True
        if (self.serverIO.disconnecting and
            not self.serverIO.disconnected):
            if self.debug or debug:
                print('* C')
            self.serverIO.disconnected = True
            self.clientIO.disconnecting = True
            self.clientIO.reportDisconnect()
            return True
        if self.clientIO.disconnecting and not self.clientIO.disconnected:
            if self.debug or debug:
                print('* S')
            self.clientIO.disconnected = True
            self.serverIO.disconnecting = True
            self.serverIO.reportDisconnect()
            return True
        return False

def connect(serverProtocol, serverTransport, clientProtocol, clientTransport,
            debug=False, greet=True):
    """
    Create a new L{IOPump} connecting two protocols.

@param serverProtocol: The protocol to use on the accepting side of the
        connection.
    @type serverProtocol: L{IProtocol} provider

@param serverTransport: The transport to associate with C{serverProtocol}.
    @type serverTransport: L{FakeTransport}

@param clientProtocol: The protocol to use on the initiating side of the
        connection.
    @type clientProtocol: L{IProtocol} provider

@param clientTransport: The transport to associate with C{clientProtocol}.
    @type clientTransport: L{FakeTransport}

@param debug: A flag indicating whether to log information about what the
        L{IOPump} is doing.
    @type debug: L{bool}

@param greet: Should the L{IOPump} be L{flushed <IOPump.flush>} once before
        returning to put the protocols into their post-handshake or
        post-server-greeting state?
    @type greet: L{bool}

@return: An L{IOPump} which connects C{serverProtocol} and
        C{clientProtocol} and delivers bytes between them when it is pumped.
    @rtype: L{IOPump}
    """
    serverProtocol.makeConnection(serverTransport)
    clientProtocol.makeConnection(clientTransport)
    pump = IOPump(
        clientProtocol, serverProtocol, clientTransport, serverTransport, debug
    )
    if greet:
        # Kick off server greeting, etc
        pump.flush()
    return pump

def connectedServerAndClient(ServerClass, ClientClass,
                             clientTransportFactory=makeFakeClient,
                             serverTransportFactory=makeFakeServer,
                             debug=False, greet=True):
    """
    Connect a given server and client class to each other.

@param ServerClass: a callable that produces the server-side protocol.
    @type ServerClass: 0-argument callable returning L{IProtocol} provider.

@param ClientClass: like C{ServerClass} but for the other side of the
        connection.
    @type ClientClass: 0-argument callable returning L{IProtocol} provider.

@param clientTransportFactory: a callable that produces the transport which
        will be attached to the protocol returned from C{ClientClass}.
    @type clientTransportFactory: callable taking (L{IProtocol}) and returning
        L{FakeTransport}

@param serverTransportFactory: a callable that produces the transport which
        will be attached to the protocol returned from C{ServerClass}.
    @type serverTransportFactory: callable taking (L{IProtocol}) and returning
        L{FakeTransport}

@param debug: Should this dump an escaped version of all traffic on this
        connection to stdout for inspection?
    @type debug: L{bool}

@return: the client protocol, the server protocol, and an L{IOPump} which,
        when its C{pump} and C{flush} methods are called, will move data
        between the created client and server protocol instances.
    @rtype: 3-L{tuple} of L{IProtocol}, L{IProtocol}, L{IOPump}
    """
    c = ClientClass()
    s = ServerClass()
    cio = clientTransportFactory(c)
    sio = serverTransportFactory(s)
    return c, s, connect(s, sio, c, cio, debug, greet)

def _factoriesShouldConnect(clientInfo, serverInfo):
    """
    Should the client and server described by the arguments be connected to
    each other, i.e. do their port numbers match?

@param clientInfo: the args for connectTCP
    @type clientInfo: L{tuple}

@param serverInfo: the args for listenTCP
    @type serverInfo: L{tuple}

@return: If they do match, return factories for the client and server that
        should connect; otherwise return L{None}, indicating they shouldn't be
        connected.
    @rtype: L{None} or 2-L{tuple} of (L{ClientFactory},
        L{IProtocolFactory})
    """
    (clientHost, clientPort, clientFactory, clientTimeout,
     clientBindAddress) = clientInfo
    (serverPort, serverFactory, serverBacklog,
     serverInterface) = serverInfo
    if serverPort == clientPort:
        return clientFactory, serverFactory
    else:
        return None

class ConnectionCompleter(object):
    """
    A L{ConnectionCompleter} can cause synthetic TCP connections established by
    L{MemoryReactor.connectTCP} and L{MemoryReactor.listenTCP} to succeed or
    fail.
    """
    def __init__(self, memoryReactor):
        """
        Create a L{ConnectionCompleter} from a L{MemoryReactor}.

@param memoryReactor: The reactor to attach to.
        @type memoryReactor: L{MemoryReactor}
        """
        self._reactor = memoryReactor

def succeedOnce(self, debug=False):
        """
        Complete a single TCP connection established on this
        L{ConnectionCompleter}'s L{MemoryReactor}.

@param debug: A flag; whether to dump output from the established
            connection to stdout.
        @type debug: L{bool}

@return: a pump for the connection, or L{None} if no connection could
            be established.
        @rtype: L{IOPump} or L{None}
        """
        memoryReactor = self._reactor
        for clientIdx, clientInfo in enumerate(memoryReactor.tcpClients):
            for serverInfo in memoryReactor.tcpServers:
                factories = _factoriesShouldConnect(clientInfo, serverInfo)
                if factories:
                    memoryReactor.tcpClients.remove(clientInfo)
                    memoryReactor.connectors.pop(clientIdx)
                    clientFactory, serverFactory = factories
                    clientProtocol = clientFactory.buildProtocol(None)
                    serverProtocol = serverFactory.buildProtocol(None)
                    serverTransport = makeFakeServer(serverProtocol)
                    clientTransport = makeFakeClient(clientProtocol)
                    return connect(serverProtocol, serverTransport,
                                   clientProtocol, clientTransport,
                                   debug)

def failOnce(self, reason=Failure(ConnectionRefusedError())):
        """
        Fail a single TCP connection established on this
        L{ConnectionCompleter}'s L{MemoryReactor}.

@param reason: the reason to provide that the connection failed.
        @type reason: L{Failure}
        """
        self._reactor.tcpClients.pop(0)[2].clientConnectionFailed(
            self._reactor.connectors.pop(0), reason
        )

def connectableEndpoint(debug=False):
    """
    Create an endpoint that can be fired on demand.

@param debug: A flag; whether to dump output from the established
        connection to stdout.
    @type debug: L{bool}

@return: A client endpoint, and an object that will cause one of the
        L{Deferred}s returned by that client endpoint.
    @rtype: 2-L{tuple} of (L{IStreamClientEndpoint}, L{ConnectionCompleter})
    """
    reactor = MemoryReactorClock()
    clientEndpoint = TCP4ClientEndpoint(reactor, "0.0.0.0", 4321)
    serverEndpoint = TCP4ServerEndpoint(reactor, 4321)
    serverEndpoint.listen(Factory.forProtocol(Protocol))
    return clientEndpoint, ConnectionCompleter(reactor)

cmd: