U


W[���@s�dZd
dl
mZmZ
d
dlZd
dlZd
dlZd
dlZd
dlZd
dl	m
Z

d
dlmZ

d
dlmZmZ
d
dlmZ
d
dlmZmZmZmZ
d
d	lmZmZmZmZ
d
d
lmZ
d
dlm Z m!Z!m"Z"
d
dl#m$Z$
d
d
l%m&Z&m'Z'
d
dl(m)Z)m*Z*m+Z+
d
dl,m-Z-m.Z.
d
dl/m0Z0m1Z1m2Z2
d
dl3m4Z4
Gdd�dej5�Z6Gdd�dej7�Z8ee0j9�
Gdd�de:��
Z;Gdd�d�Z<dd�Z=Gdd�de:�Z>Gdd�de4�Z?d�d d!�
Z@Gd"d#�d#ejA�ZBGd$d%�d%ejA�ZCGd&d'�d'ejD�ZEGd(d)�d)ejF�ZGe�HeEeG�
Gd*d+�d+ejD�ZId,d-�ZJe�KeIeJ�
Gd.d/�d/ejA�ZLGd0d1�d1ejM�ZNGd2d3�d3ejA�ZOGd4d5�d5ejM�ZPGd6d7�d7ejQ�ZRe�HePeR�
Gd8d9�d9ejQ�ZSe�HeNeS�
Gd:d;�d;ejA�ZTGd<d=�d=ejA�ZUGd>d?�d?ejA�ZVGd@dA�dAejA�ZWGdBdC�dCejDejFe:�ZXe�HeXeX�
GdDdE�dEejDejFe:�ZYe�HeYeY�
GdFdG�dGejMejQe:�ZZe�HeZeZ�
GdHdI�dIej[�Z\GdJdK�dKej[�Z]GdLdM�dMej^�Z_GdNdO�dOej`�ZaGdPdQ�dQejb�ZcGdRdS�dSejb�ZddTZedafdagdUdV�ZhGdWdX�dXejA�ZiGdYdZ�dZejA�ZjGd[d\�d\ejb�ZkGd]d^�d^ejl�ZmGd_d`�d`ejn�ZoGdadb�dbejA�Zpe�Hemeo�
Gdcdd�ddejb�ZqGdedf�dfer�ZsGdgdh�dhejD�ZtGdidj�djejA�ZuGdkdl�dlejv�Zweejx�
Gdmdn�dnej7��
ZyGdodp�dpe:�ZzGdqdr�drej5�Z{Gdsdt�dtez�Z|Gdudv�dvejb�Z}Gdwdx�dxejb�Z~eejx�
Gdydz�dz��
ZGd{d|�d|ejb�Z�Gd}d~�d~e�Z�ee��
Gdd��d���
Z�Gd�d��d�ejb�Z�Gd�d��d�ejb�Z�dS)�z�
Tests for Perspective Broker module.

TODO: update protocol level tests to use new connection API, leaving
only specific tests for old API.
�)�absolute_import�divisionN)
�deque)
�BytesIO)�implementer�	Interface)
�unittest)�pb�util�publish�jelly)�protocol�main�reactor�address)
�ConnectionRefusedError)�Deferred�
gatherResults�succeed)
�WrappingFactory)�failure�log)�	iterbytes�range�_PY3)�UnauthorizedLogin�UnhandledCredentials)�portal�checkers�credentials)
�_FakeConnectorc@seZ
dZd
d�ZdS)�DummycCst|
t
�rd
SdSdS)Nzhello world!zgoodbye, cruel world!)�
isinstance�DummyPerspective��self�user�r'�=/usr/lib/python3/dist-packages/twisted/spread/test/test_pb.py�view_doNothing&s


zDummy.view_doNothingN)�__name__�
__module__�__qualname__r)r'r'r'r(r!%s
r!c@seZ
dZd
Zdd�ZdS)r#zE
    An L{IPerspective} avatar which will be used in some tests.
    c


Cst�S�
N)
r!�
r%r'r'r(�perspective_getDummyViewPoint1s
z.DummyPerspective.perspective_getDummyViewPointN)r*r+r,�__doc__r/r'r'r'r(r#-s
r#c@seZ
dZd
d�ZdS)�
DummyRealmcGs.|D]$}|tj
kr|t|
�
d
d�f
SqdS)Nc
SsdSr-r'r'r'r'r(�<lambda>;�z*DummyRealm.requestAvatar.<locals>.<lambda>)r	�IPerspectiver#)r%�avatarId�mindZ
interfacesZifacer'r'r(�
requestAvatar8s



zDummyRealm.requestAvatarN)r*r+r,r7r'r'r'r(r16sr1c@s0eZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
S)�IOPumpz�
    Utility to pump data between clients and servers for protocol testing.

    Perhaps this is a utility worthy of being in protocol.py?
    cCs|
|_||_
||_||_dSr-)�client�server�clientIO�serverIO)r%r9r:r;r<r'r'r(�__init__Ds



zIOPump.__init__c
Cs6d
|_t
�
�d}
|js2|��r2t
�
�|
krdSqdS)z�
        Pump until there is no more input or output or until L{stop} is called.
        This does not run any timers, so don't use it with any code that calls
        reactor.callLater.
        F�N)�_stop�time�pump)r%Ztimeoutr'r'r(�flushKs




zIOPump.flushc

Cs
d
|_dS)zd
        Stop a running L{flush} operation, even if data remains to be
        transferred.
        TN)
r?r.r'r'r(�stopYszIOPump.stopc
Cs�|j�
d
�

|j�
d
�

|j��}
|j��}|j�
d
�

|j�
d
�

|j��
|j��
|jj��
|jj��
t	|
�
D]}|j�
|�

qxt	|�
D]}|j�
|�

q�|
s�|r�dSd
SdS)zX
        Move data back and forth.

        Returns whether any data was moved.
        r
�
N)r;�seekr<�read�truncater9�	transportZ_checkProducerr:rZdataReceived)r%ZcDataZsDataZbyter'r'r(rAas"


















zIOPump.pumpN)r*r+r,r0r=rBrCrAr'r'r'r(r8>s

r8cs�d
}��|�
}|�|�
}t
�}t
�}|�t�|�
�

|�t�|�
�

t||||�}dd�}	�f
dd�}
|�|	|�
|�|	|�
|�|
�

|��
|||fS)al
    Create a server and a client and connect the two with an
    L{IOPump}.

    @param test: the test case where the client and server will be
        used.
    @type test: L{twisted.trial.unittest.TestCase}

    @param clientFactory: The factory that creates the client object.
    @type clientFactory: L{twisted.spread.pb.PBClientFactory}

    @param serverFactory: The factory that creates the server object.
    @type serverFactory: L{twisted.spread.pb.PBServerFactory}

    @return: a 3-tuple of (client, server, pump)
    @rtype: (L{twisted.spread.pb.Broker}, L{twisted.spread.pb.Broker},
        L{IOPump})
    )
�	127.0.0.1c

Ss|js|�
t�tj�
�

dSr-)�disconnected�connectionLostr�Failurer�CONNECTION_DONE)
�brokerr'r'r(�maybeDisconnect�s

z/connectServerAndClient.<locals>.maybeDisconnectcs�jdt
�tj�
d
�
dS)N)�	connector�reason)�clientConnectionLostrrLrrMr'�
�
clientFactoryr'r(�disconnectClientFactory�s


�z7connectServerAndClient.<locals>.disconnectClientFactory)�
buildProtocol�StringIO�makeConnectionr
�FileWrapperr8�
addCleanuprA)�testrT�
serverFactoryZaddr�clientBroker�serverBrokerZclientTransportZserverTransportrArOrUr'rSr(�connectServerAndClient|s






	



r_c@s(eZ
dZd
Zdd�Zdd�Zdd�ZdS)	�_ReconnectingFakeConnectorStatez�
    Manages connection notifications for a
    L{_ReconnectingFakeConnector} instance.

    @ivar notifications: pending L{Deferreds} that will fire when the
        L{_ReconnectingFakeConnector}'s connect method is called
    c

Cst�|_
dSr-)r�
notificationsr.r'r'r(r=�s
z(_ReconnectingFakeConnectorState.__init__c
Cst�}
|j
�|
�

|
S)
z�
        Connection notification.

        @return: A L{Deferred} that fires when this instance's
            L{twisted.internet.interfaces.IConnector.connect} method
            is called.
        @rtype: L{Deferred}
        )rra�
appendleft)r%Znotifierr'r'r(�notifyOnConnect�s	

z/_ReconnectingFakeConnectorState.notifyOnConnectc

Cs|jr|j�
��|�

qd
S)z1
        Fire all pending notifications.
        N)ra�pop�callbackr.r'r'r(�	notifyAll�s
z)_ReconnectingFakeConnectorState.notifyAllN)r*r+r,r0r=rcrfr'r'r'r(r`�s
r`cs,eZ
dZd
Z�f
dd�Z�f
dd�Z�ZS)�_ReconnectingFakeConnectorzc
    A fake L{IConnector} that can fire L{Deferred}s when its
    C{connect} method is called.
    cstt
|��|
�

||_d
S)a

        @param address: An L{IAddress} provider that represents this
            connector's destination.
        @type address: An L{IAddress} provider.

        @param state: The state instance
        @type state: L{_ReconnectingFakeConnectorState}
        N)�superrgr=�_state)r%r�state�
�	__class__r'r(r=�s	
z#_ReconnectingFakeConnector.__init__c

stt
|���
|j��
d
S)zM
        A C{connect} implementation that calls C{reconnectCallback}
        N)rhrg�connectrirfr.rkr'r(rm�s
z"_ReconnectingFakeConnector.connect)r*r+r,r0r=rm�
__classcell__r'r'rkr(rg�s

rgcCs>|
pt�}
t
jd
d�
}t�t�|
|g
��
}t��}t|||�S)z�
    Connect a client and server L{Broker} together with an L{IOPump}

    @param realm: realm to use, defaulting to a L{DummyRealm}

    @returns: a 3-tuple (client, server, pump).
    �guest)
Zguest)	r1r�'InMemoryUsernamePasswordDatabaseDontUser	�PBServerFactoryr�Portal�PBClientFactoryr_)r[�realm�checkerr\rTr'r'r(�connectedServerAndClient�s





rvc@seZ
dZd
d�Zdd�ZdS)�SimpleRemotecCs|
|_|
d
S�NrD)
�arg�r%ryr'r'r(�remote_thunk

s

zSimpleRemote.remote_thunkc
Cs
t��
dSr-)
�	Exceptionrzr'r'r(�remote_knuth
s
zSimpleRemote.remote_knuthN)r*r+r,r{r}r'r'r'r(rw
s
rwc@seZ
dZd
d�ZdS)�NestedRemotec


Cst�Sr-)
rwr.r'r'r(�remote_getSimple

s
zNestedRemote.remote_getSimpleN)r*r+r,rr'r'r'r(r~	
s
r~c@seZ
dZd
d�ZdS)�
SimpleCopyc

Csd
|_ddi
|_
dg
|_dS�NrD�Hello�Worldr[��
x�
y�
zr.r'r'r(r=
s



zSimpleCopy.__init__N�r*r+r,r=r'r'r'r(r�
s
r�c
@seZ
dZd
S)�SimpleLocalCopyN�r*r+r,r'r'r'r(r�
s
r�c@seZ
dZd
ZiZdd�ZdS)�SimpleFactoryCopyz]
    @cvar allIDs: hold every created instances of this class.
    @type allIDs: C{dict}
    cCs|
|_|t
j|
<dSr-)�idr��allIDs)r%r�r'r'r(r=!
s

zSimpleFactoryCopy.__init__N)r*r+r,r0r�r=r'r'r'r(r�
s

r�c
CsZ|�d
d�}
|
dkr&t
dt|�
f
�
�
|
tjkr@t
dtjf
�
�
tj|
}|sVt
d�
�
|S)zl
    Factory of L{SimpleFactoryCopy}, getting a created instance given the
    C{id} found in C{state}.
    r�Nz(factory copy state has no 'id' member %szfactory class has no ID: %sz&factory method found no object with id)�get�RuntimeError�reprr�r�)rjZstateId�instr'r'r(�createFactoryCopy&
s


�


�



r�c@seZ
dZd
d�Zdd�ZdS)�
NestedCopyc


Cst�Sr-)
r�r.r'r'r(�remote_getCopy;
s
zNestedCopy.remote_getCopycCst|
�
Sr-)
r�)r%�valuer'r'r(�remote_getFactory>
s
zNestedCopy.remote_getFactoryN)r*r+r,r�r�r'r'r'r(r�:
s
r�c@seZ
dZd
d�ZdS)�SimpleCachec

Csd
|_ddi
|_
dg
|_dSr�r�r.r'r'r(�	__init___D
s



zSimpleCache.__init___N)r*r+r,r�r'r'r'r(r�C
s
r�c@seZ
dZd
d�Zdd�ZdS)�NestedComplicatedCachec

Cst�|_
dSr-)�VeryVeryComplicatedCacheable�
cr.r'r'r(r=K
s
zNestedComplicatedCache.__init__c


Cs|jSr-)
r�r.r'r'r(�remote_getCacheN
s
z&NestedComplicatedCache.remote_getCacheN)r*r+r,r=r�r'r'r'r(r�J
s
r�c@s,eZ
dZd
d�Zdd�Zdd�Zdd�Zd	S)
r�c

Csd
|_d|_
d|_dS)NrD���r�r��foor.r'r'r(r=S
s


z%VeryVeryComplicatedCacheable.__init__c

Csd
|_|j
�dd
�
dS)N�r�)r��observer�
callRemoter.r'r'r(�setFoo4X
s

z$VeryVeryComplicatedCacheable.setFoo4cCs||_|j
|j|jd
�S)Nr�)r�r�r�r��r%�perspectiver�r'r'r(�getStateToCacheAndObserveFor\
s




�z9VeryVeryComplicatedCacheable.getStateToCacheAndObserveForcCs(t�
d
�

|�d�

||jkr$d|_dS)Nzstopped observing�end)r�msgr�r�r�r'r'r(�stoppedObservingb
s






z-VeryVeryComplicatedCacheable.stoppedObservingN)r*r+r,r=r�r�r�r'r'r'r(r�R
s
r�c@seZ
dZd
d�Zdd�ZdS)�RatherBaroqueCachecCs
|
|_dSr-�
r�)r%ZnewFoor'r'r(�observe_fooj
s
zRatherBaroqueCache.observe_fooc

Cst�
d
�

dS)Nzthe end of things)rr�r.r'r'r(�observe_endm
s
zRatherBaroqueCache.observe_endN)r*r+r,r�r�r'r'r'r(r�i
s
r�c@s,eZ
dZd
d�Zdd�Zdd�Zdd�Zd	S)
�SimpleLocalCachecCs|j�
|
�

dSr-)�__dict__�update)r%rjr'r'r(�setCopyableStatet
s
z!SimpleLocalCache.setCopyableStatec


Cs|jSr-)
�checkr.r'r'r(�checkMethodw
s
zSimpleLocalCache.checkMethodc


Cs|Sr-r'r.r'r'r(�	checkSelfz
s
zSimpleLocalCache.checkSelfc


Csd
Srxr'r.r'r'r(r�}
s
zSimpleLocalCache.checkN)r*r+r,r�r�r�r�r'r'r'r(r�s
s
r�c@s$eZ
dZd
d�Zdd�Zdd�ZdS)�NestedCachec

Cst�|_
dSr-)r�r�r.r'r'r(r=�
s
zNestedCache.__init__c

Cs|j|jgSr-�
r�r.r'r'r(r��
s
zNestedCache.remote_getCachecCs
|j|
kSr-r��r%�cacher'r'r(�remote_putCache�
s
zNestedCache.remote_putCacheN)r*r+r,r=r�r�r'r'r'r(r��
s
r�c@s,eZ
dZd
d�Zdd�Zdd�Zdd�Zd	S)
�
Observablec

Cs
g|_dSr-)
�	observersr.r'r'r(r=�
s
zObservable.__init__cCs|j�
|
�

dSr-)r��append�r%Zobsr'r'r(�remote_observe�
s
zObservable.remote_observecCs|j�
|
�

dSr-)r��remover�r'r'r(�remote_unobserve�
s
zObservable.remote_unobservecCs|jD]}|�
d
||
�
qdS)N�notify)r�r�)r%�objr�r'r'r(r��
s


zObservable.notifyN)r*r+r,r=r�r�r�r'r'r'r(r��
s
r�c@s,eZ
dZd
d�Zdd�Zdd�Zdd�Zd	S)
�DeferredRemotec

Cs
d
|_dS)Nr
�
�runr.r'r'r(r=�
s
zDeferredRemote.__init__cCs|
|_|
d
Srxr�rzr'r'r(�runMe�
s

zDeferredRemote.runMecCsd
std�
�
dS)Nr
zshouldn't have been run!)
�AssertionErrorrzr'r'r(�	dontRunMe�
s
zDeferredRemote.dontRunMec
Cs t�}
|
�
|j|j�
|
|_|
S)
zo
        Return a L{Deferred} to be fired on client side. When fired,
        C{self.runMe} is called.
        )r�addCallbacksr�r��
d)r%r�r'r'r(�remote_doItLater�
s


zDeferredRemote.remote_doItLaterN)r*r+r,r=r�r�r�r'r'r'r(r��
s
r�c@seZ
dZd
ZdZdd�ZdS)�Observerr
NcCs"||_|j
d
|_
|
�d|�
dS)NrDZ	unobserve)r��notifiedr�)r%�otherr�r'r'r(�
remote_notify�
s


zObserver.remote_notify)r*r+r,r�r�r�r'r'r'r(r��
s


r�c@seZ
dZd
d�ZdS)�NewStyleCopycCs
|
|_dSr-)
�
s)r%r�r'r'r(r=�
s
zNewStyleCopy.__init__Nr�r'r'r'r(r��
s
r�c@s(eZ
dZd
Zd
ZdZdd�Zdd�ZdS)�
NewStyleCopy2r
rDc
Cs"tj
d
7_
t�|�
}
d|
_|
S)NrDr�)r��	allocated�object�__new__r�)r%r�r'r'r(r��
s




zNewStyleCopy2.__new__c

Cstj
d
7_
dSrx)r��initializedr.r'r'r(r=�
s
zNewStyleCopy2.__init__N)r*r+r,r�r�r�r�r=r'r'r'r(r��
s



r�c@seZ
dZd
d�ZdS)�NewStyleCacheCopyc
Cs|jSr-)
r�r�r'r'r(r��
s
z.NewStyleCacheCopy.getStateToCacheAndObserveForN)r*r+r,r�r'r'r'r(r��
s
r�c@seZ
dZd
d�Zdd�ZdS)�Echoerc
Cs|
Sr-r'�r%�str'r'r(�remote_echo�
s
zEchoer.remote_echocKs|
|fSr-r')r%r��kwr'r'r(�remote_echoWithKeywords�
s
zEchoer.remote_echoWithKeywordsN)r*r+r,r�r�r'r'r'r(r��
s
r�c@seZ
dZd
d�Zdd�ZdS)�CachedReturnercCs
|
|_dSr-�
r�r�r'r'r(r=�
s
zCachedReturner.__init__c
Cs|jSr-r�r�r'r'r(�remote_giveMeCache�
s
z!CachedReturner.remote_giveMeCacheN)r*r+r,r=r�r'r'r'r(r��
s
r�c@s4eZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�ZdS)�
NewStyleTestsc
CsDt�
t��
|_t��}
t||
|jd
�\}|_|_|�|
�	��
|_
dS)zY
        Create a pb server using L{Echoer} protocol and connect a client to it.
        )r[rTr\N)r	rqr�r\rsr_r:rAZsuccessResultOf�
getRootObject�ref)r%rTr9r'r'r(�setUp�
s




�zNewStyleTests.setUpc

Csd
t_
d
t_dt_dS)zp
        Close client and server connections, reset values of L{NewStyleCopy2}
        class variables.
        r
rDN)r�r�r�r�r.r'r'r(�tearDown�
s

zNewStyleTests.tearDownc
s<td
�
��
j
�d��}
�
j��
��
fdd�}|
�|�

|
S)zY
        Create a new style object, send it over the wire, and check the result.
        r��echoc

s,�
�|t
�
�
�|jd
�
�
�|�k�

dS)Nr�)�assertIsInstancer��assertEqualr��assertFalse�
�res��origr%r'r(�cb
s


z'NewStyleTests.test_newStyle.<locals>.cb�r�r�r�rArB�addCallback�r%r�r�r'r�r(�
test_newStyles





zNewStyleTests.test_newStylec
sVt���
�
tjd
�
�
�
tjd
�
�
j�d��}
�
j��
��
fdd�}|
�|�

|
S)zN
        Send a new style object and check the number of allocations.
        rDr�c

sF�
�|t
�
�
�|jd
�
�
�t
jd�
�
�t
jd�
�
�|��
dS)Nr�r�rD)r�r�r�r�r�r��assertIsNotr�r�r'r(r�s




z$NewStyleTests.test_alloc.<locals>.cb)	r�r�r�r�r�r�rArBr�r�r'r�r(�
test_allocs







zNewStyleTests.test_allocc
sBtd
�
��
j
jd�ddd�}
�
j��
��
fdd�}|
�|�

|
S)zo
        Create a new style object with keywords,
        send it over the wire, and check the result.
        �value1ZechoWithKeywords�one�two�Zkeyword1Zkeyword2c

sh�
�|t
�
�
�|d
t�
�
�|dt�
�
�|d
jd�
�
�|d
��
�
�|dddd��
dS)Nr
rDr�r�r�r�)r��tupler��dictr�r�r�r�r�r'r(r�/s





z3NewStyleTests.test_newStyleWithKeywords.<locals>.cbr�r�r'r�r(�test_newStyleWithKeywords&s


�



z'NewStyleTests.test_newStyleWithKeywordsN)r*r+r,r�r�r�r�r�r'r'r'r(r��
s


r�c@s$eZ
dZd
ZdZdd�Zdd�ZdS)�ConnectionNotifyServerFactoryaj

    A server factory which stores the last connection and fires a
    L{Deferred} on connection made. This factory can handle only one
    client connection.

    @ivar protocolInstance: the last protocol instance.
    @type protocolInstance: C{pb.Broker}

    @ivar connectionMade: the deferred fired upon connection.
    @type connectionMade: C{Deferred}
    NcCstj
�||
�
t�|_d
S)z)
        Initialize the factory.
        N)r	rqr=r�connectionMade)r%�rootr'r'r(r=Is
z&ConnectionNotifyServerFactory.__init__cCs*|
|_|j
d
}|_
|d
k	r&|�d
�

d
S)zF
        Store the protocol and fire the connection deferred.
        N)�protocolInstancer�re)r%r
r�r'r'r(�clientConnectionMadeQs


z2ConnectionNotifyServerFactory.clientConnectionMade)r*r+r,r0r
r=r

r'r'r'r(r�;s
r�c@s$eZ
dZd
d�Zdd�Zdd�ZdS)�NewStyleCachedTestsc
svt��_
d
�j
_t�dtt�j
�
�
��_t�	�}
t�
d�j��j|
�
�f
dd�}|
�
��|�
}�jjj}t||g�
S)zi
        Create a pb server using L{CachedReturner} protocol and connect a
        client to it.
        r�r
Z	localhostc

s
|�_dSr-�
r�r
r.r'r(�gotRootis
z*NewStyleCachedTests.setUp.<locals>.gotRoot)r�r�r�r�	listenTCPr�r�r:r	rs�
connectTCP�getHost�portr�r��factoryr�r)r%rTr
Zd1Zd2r'r.r(r�]s


�

�


zNewStyleCachedTests.setUpc

Cs(|jj
jj��
|jjj��
|j��S)
z6
        Close client and server connections.
        )r:r	
r
rH�loseConnectionr�rN�
stopListeningr.r'r'r(r�ps

zNewStyleCachedTests.tearDownc
s8�j�
d
�j�}
�f
dd�}|
�|d�
|
�|d�
|
S)z�
        A new-style cacheable object can be retrieved and re-retrieved over a
        single connection.  The value of an attribute of the cacheable can be
        accessed on the receiving side.
        �giveMeCachecsF��|t
�
��d
|j�
���j|�
|
rB|�_�j�d�j�SdS)Nr�r
)	r�r�r�r�r�r�r�r�r�)r�Zagainr.r'r(r��s

z2NewStyleCachedTests.test_newStyleCache.<locals>.cbTF)r�r�r�r�r�r'r.r(�test_newStyleCacheys



z&NewStyleCachedTests.test_newStyleCacheN)r*r+r,r�r�r

r'r'r'r(r
\s
	r
c@s�eZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd
S)$�BrokerTestsNc

Cs(zt�
d
�

Wntk
r"


YnXdS)N�None-None-TESTING.pub)�os�unlink�OSErrorr.r'r'r(r��s


zBrokerTests.tearDowncCs|�d
|
f
�

dS)Nz(This should cause a return value, not %s�
�fail)r%�errorr'r'r(�
thunkErrorBad�s
zBrokerTests.thunkErrorBadcCs
|
|_dSr-)
�thunkResult�r%�resultr'r'r(�thunkResultGood�s
zBrokerTests.thunkResultGoodc
CsdSr-r')r%�tbr'r'r(�thunkErrorGood�s
zBrokerTests.thunkErrorGoodcCs|�d
|
f
�

dS)Nz"This should cause an error, not %sr
r
r'r'r(�thunkResultBad�s
zBrokerTests.thunkResultBadc
	Cs�t|d
�
\}
}}Gdd�dt
j�}Gdd�dt
j�}|�d|��
|
�d�
}|�}|�}|�d||�
|��
|��
|��
|�|j|d�
|�	|�
d�
|�
d�
�
dS)	N�
r[c@seZ
dZd
d�ZdS)z%BrokerTests.test_reference.<locals>.XcSs
|
|_dSr-)
�caughtrzr'r'r(�remote_catch�s
z2BrokerTests.test_reference.<locals>.X.remote_catchN)r*r+r,r 
r'r'r'r(�
X�s
r!
c@seZ
dZd
d�ZdS)z%BrokerTests.test_reference.<locals>.YcSs|
�d
|�
dS)NZcatch�
r��r%�
a�
br'r'r(�remote_throw�s
z2BrokerTests.test_reference.<locals>.Y.remote_throwN)r*r+r,r&
r'r'r'r(�
Y�s
r'
r��throwzX should have caught Z)rvr	�
Referenceable�setNameForLocal�
remoteForNamer�rA�assertIsr
r��remoteMethod)	r%r�r�rAr!
r'
r�r�r�r'r'r(�test_reference�s









zBrokerTests.test_referencec
Cs�t|d
�
\}
}}|
|f||
ffD]j\}}t
�}|�d|�
|�d�
}d|_|�d|jd��|j|j�
|�	�
|�	�
|�
|j|jd�
q dS)Nr
r��ZthunkrDzresult wasn't received.)rvrwr*
r+
ZexpectedThunkResultr�r�r
r
rAr�r
)r%r�r�rAr�r�r��barr'r'r(�test_result�s







�
�zBrokerTests.test_resultcCs
|
|_dSr-)
�nestedRemoter
r'r'r(�refcountResult�s
zBrokerTests.refcountResultc

Cs�g}
g}t|d
�
\}}}t
�}|�d|�
|�d�
}ttjd�
D]6}|jjsV|jjrZ
qz|�	d�
�
|
j|j�
|��
qBtjd}	|�
|jjd�
|�t|
�
|	d|	t|
�
f�
dS)Nr
r��
�	getSimplerDztransport was not closedzexpected %s got %s)rvr~r*
r+
rr	ZMAX_BROKER_REFSrH�closedr�r�r�rA�
assertTruer��len)
r%�
l�
er�r�rAr�r�ZignoZexpectedr'r'r(�test_tooManyRefs�s 

















�zBrokerTests.test_tooManyRefsc
Cs�t|d
�
\}
}}t
�}|�d|�
|
�d�
}|�d�
�|j|j�
|��
|��
|�	|j
jd�
|�	|j
jdd�
|�	|j
j
dd�
dS)	Nr
r�ZgetCopyrDr�r�r
r[)rvr�r*
r+
r�r�r
r
rAr�r
r�r�r�)r%r�r�rAr�r�r'r'r(�	test_copy�s







�



zBrokerTests.test_copyc
Cs�t|d
�
\}
}}t
�}t�}|�d|�
|
�d�
}|�d|�
|��
|�d�

|��
|��
|�d�

|��
|��
|�|j	d�
|�
|j	dd�
dS)Nr
r$
ZobserverDr4
z
didn't notifyznotified too much)rvr�r�r*
r+
r�rAr�ZassertIsNotNoner�r�)r%r�r�rAr$
r%
Zrar'r'r(�test_observe�s
















zBrokerTests.test_observec
Cs�t|d
�
\}
}}t
�}|�d|�
|
�d�
}|��
|��
g}|�d�
�|j�

|��
|��
|�|j	d�
|j
�d�

|�|j	dd�
|��
|��
|�|ddd	�
dS)
Nr
r�Z	doItLaterzDeferred method run too early.r>zDeferred method run too late.r
�zIncorrect result.)
rvr�r*
r+
rAr�r�r�r�r�r�rer�)r%r�r�rAr�r:
Zresultsr'r'r(�
test_defers 













zBrokerTests.test_deferc
Cs�t|d
�
\}
}}t
�}|�d|�
|
�d�
}|�d�
�|j|j�
|��
|��
|j	j
}|�||j�
|`	t
jdkr~t��
|��
|��
|��
|�||j�
dS)Nr
r�r5
�)rvr~r*
r+
r�r�r3
r
rAr2
�luid�assertInZlocalObjects�sys�
hexversion�gc�collect�assertNotIn)r%r�r�rAr�r0
Zrluidr'r'r(�
test_refcounts&







�






zBrokerTests.test_refcountc
CsLt|d
�
\}
}}t
�}t�}|j}|�d|�
|�d|�
|
�d�
}|
�d�
}g}	|�d�
�|	j�
�	|	j�

|�d�
�|	j�
�	|	j�

g}
|�d�
�|
j�

|�d�
�|
j�

|�
�
|�|
djd�
|�|
dj
d�
|�|
djd�
|��
|�
�
|�|
djd	�
|�t|	�
d�
|	dd}|�t�
r>|��jn|��j|d
�
|�|��|d�
g}|�d|��|j�

|�
�
|�|d�

|�|�d�
|�d�
�
|j}
|
dj}|�|
|jd
�
~	~|�
�
~
~|�
�
tjdk�
r�t��
|�
�
|� |
|jd�
|� |
|
j!d�
|� ||jd�
|� ||
j!d�
|�"|j#d�
dS)Nr
r�ZxxxZgetCacher
rDr�r�r�zpotential refcounting issuez!other potential refcounting issueZputCachezremote cache doesn't have itr@
zServer still had it after GCzClient still had it after GCz!Server still had complex after GCz!Client still had complex after GCzobserver was not removed)$rvr�r�r�r*
r+
r�r�r��
addErrbackrBr�r�r�r�r�r8
ZassertIdenticalrr��__self__Zim_selfr�r7
r-
rA
rB
ZremotelyCachedObjectsrC
rD
rE
rF
rG
ZlocallyCachedObjects�assertIsNoner�)r%r�r�rAr�Zobj2ZvccZo2Zo3Zcoll�complex�cpZcol2rA
ZbaroqueLuidr'r'r(�
test_cache2s�













�
�

�
�











�
�


�




�






�

�

�

�zBrokerTests.test_cachec
Cs
zt�
d
�

Wntk
r"


YnXt|d�
\}
}}t�}|�d|�
|
�d�
}g}|�d�
�|j	|j
�
|��
|��}|�
|jd�
|�
|jd�
|�
|jd�
|�
|jd�
t|d�
\}
}}|�d|�
|
�d�
}|�d�
�|j	|j
�
|��
|��}|�
|jd�
dS)Nr
r
r�ZgetPubrDr
)r
r
r
rv�GetPublisherr*
r+
r�r�r�r
rBrdr��activateCalledZisActivated�yayIGotPublishedZ_wasCleanWhenLoaded)r%r�r�rAr�r0
Zaccumr�r'r'r(�test_publishableys.





















zBrokerTests.test_publishablecCs|
j|_
dSr-)r�r
)r%�valr'r'r(�gotCopy�s
zBrokerTests.gotCopyc
Cs|t|d
�
\}
}}d}t
�}|�d|�
|
�d�
}|�d|��|j|j�
|��
|��
|��
|�	|j
|d|j
f
�
dS)Nr
�cr�Z
getFactoryz#ID not correct on factory object %s)rvr�r*
r+
r�r�rT
r
rAr�r
)r%r�r�rAZIDr�r�r'r'r(�test_factoryCopy�s







�





�zBrokerTests.test_factoryCopy)r*r+r,r
r�r
r
r
r
r.
r1
r3
r;
r<
r=
r?
rH
rN
rR
rT
rV
r'r'r'r(r
�s$

Gr
s�
helloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldc
Os|a|
a
dSr-)�callbackArgs�callbackKeyword)�argsr�r'r'r(�finishedCallback�s
rZ
c@seZ
dZd
d�Zdd�ZdS)�	PagerizercOs|
|||_|_
|_dSr-)rerY
r�)r%rerY
r�r'r'r(r=�s
zPagerizer.__init__cCs.tj
|
td
|jf|j�|j�

d|_|_dS)N�d)r
ZStringPager�	bigStringrerY
r��r%Z	collectorr'r'r(�remote_getPages�s


�
�
�zPagerizer.remote_getPagesN)r*r+r,r=r_
r'r'r'r(r[
�s
r[
c@s eZ
dZd
Zdd�Zdd�Zd
S)�
FilePagerizerNcOs |
|_||||_
|_|_dSr-)�filenamererY
r�)r%ra
rerY
r�r'r'r(r=�s

zFilePagerizer.__init__cCs6tj
|
t|jd
�|jf|j�|j�
|_d|_|_dS)N�rb)r
Z	FilePager�openra
rerY
r��pagerr^
r'r'r(r_
�s

�
�
�zFilePagerizer.remote_getPages)r*r+r,rd
r=r_
r'r'r'r(r`
�s
r`
c@s@eZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)�PagingTestsz0
    Test pb objects sending data by pages.
    c
	Cs0|��|_
t|j
d
��}
|
�t�

W5QRXdS)z?
        Create a file used to test L{util.FilePager}.
        �wbN)�mktempra
rc
�writer]
)r%�
fr'r'r(r��s


zPagingTests.setUpc
Cs�t|d
�
\}
}}|�
dttddd��
|
�d�
}g}t�|d��|j�

|sV|�	�
qH|�
d�|d�
td	�
|�
t
d
d�
|�
tddi
d�
d
S)zg
        Test L{util.StringPager}, passing a callback to fire when all pages
        are sent.
        r
r��hellor4
�
r��getPagesr3r
�'Pages received not equal to pages sent!)
rj
�Completed callback not invokedr�N)rvr*
r[
rZ
r+
r
�getAllPagesr�r�rAr��joinr]
rW
rX
�r%r�r�rAr�r9
r'r'r(�test_pagingWithCallback�s 









�
�
�z#PagingTests.test_pagingWithCallbackc
Cslt|d
�
\}
}}|�
dtd�
�
|
�d�
}g}t�|d��|j�

|sP|��
qB|�	d�
|d�
td�
dS)z>
        Test L{util.StringPager} without a callback.
        r
r�Nrl
r3r
rm
)rvr*
r[
r+
r
ro
r�r�rAr�rp
r]
rq
r'r'r(�test_pagingWithoutCallback�s









�z&PagingTests.test_pagingWithoutCallbackc
	Cs�|��}
t
|
d
���
t|d�
\}}}t|
d�}|�d|�
|�d�
}g}t�|d��	|j
�

d}|s�|dkr�|��
|d8}qb|s�|�d	�

|�
d
�|d�
d
d�
dS)z@
        Test L{util.FilePager}, sending an empty file.
        �
wr
Nr0
rl
r4
r
rDzgetAllPages timed outr3rm
)rg
rc
�closervr`
r*
r+
r
ro
r�r�rAr
r�rp
)	r%Z
filenameEmptyr�r�rA�	pagerizerr�r9
Zttlr'r'r(�test_emptyFilePaging�s"


















�z PagingTests.test_emptyFilePagingc
Cs�t|d
�
\}
}}t
|jtddd�}|�d|�
|
�d�
}g}t�|d��|j	�

|s^|�
�
qP|�d�|d�
t
d	�
|�td
d�
|�tddi
d�
|�|jjg�
d
S)z�
        Test L{util.FilePager}, passing a callback to fire when all pages
        are sent, and verify that the pager doesn't keep chunks in memory.
        r
�frodo�	rk
r0
rl
r3r
rm
)
rx
rn
r�N)rvr`
ra
rZ
r*
r+
r
ro
r�r�rAr�rp
r]
rW
rX
rd
�chunks�r%r�r�rArv
r�r9
r'r'r(�test_filePagingWithCallbacks*

�








�
�
�z'PagingTests.test_filePagingWithCallbackc
Cs�t|d
�
\}
}}t
|jd�}|�d|�
|
�d�
}g}t�|d��|j�

|sX|�	�
qJ|�
d�|d�
td�
|�
|j
jg�
dS)z<
        Test L{util.FilePager} without a callback.
        r
Nr0
rl
r3r
rm
)rvr`
ra
r*
r+
r
ro
r�r�rAr�rp
r]
rd
rz
r{
r'r'r(�test_filePagingWithoutCallback)s










�z*PagingTests.test_filePagingWithoutCallbackN)
r*r+r,r0r�rr
rs
rw
r|
r}
r'r'r'r(re
�s
	re
c@seZ
dZd
d�ZdS)�DumbPublishablec

Csd
di
S)NrQ
rDr'r.r'r'r(�getStateToPublish<s
z!DumbPublishable.getStateToPublishN)r*r+r,r
r'r'r'r(r~
;s
r~
c@seZ
dZd
d�ZdS)�DumbPubc

Cs
d
|_dSrx)
rP
r.r'r'r(�	activatedAs
zDumbPub.activatedN)r*r+r,r�
r'r'r'r(r�
@s
r�
c@seZ
dZd
d�Zdd�ZdS)rO
c

Cstd
�
|_
dS)NZTESTING)r~
�pubr.r'r'r(r=Fs
zGetPublisher.__init__c


Cs|jSr-)
r�
r.r'r'r(�
remote_getPubIs
zGetPublisher.remote_getPubN)r*r+r,r=r�
r'r'r'r(rO
Es
rO
c@s8eZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�DisconnectionTestsz'
    Test disconnection callbacks.
    c
Gstd
|
f
�
�
dS)Nz I shouldn't have been called: %s�
r�)r%rY
r'r'r(r
Ts
zDisconnectionTests.errorc

Cs
d
|_dS)z.
        Called on broker disconnect.
        rDN)
�gotCallbackr.r'r'r(�gotDisconnectedXsz"DisconnectionTests.gotDisconnectedcCs|�|
|j
�
d
|_dS)z7
        Called on RemoteReference disconnect.
        rDN)r��remoteObject�objectCallback�r%�
or'r'r(�objectDisconnected^s
z%DisconnectionTests.objectDisconnectedc
Csft|d
�
\}
}}|�
�
|�dt��
|
�d�
}g}|�dt���|j�

|�	�
|�
t|�
d�
dS)Nr
r�
Z
setBadCopyrD)rvrAr*
�
BadCopySetr+
r��BadCopyablerI
r�rBr�r8
)r%r�r�rA�
gr9
r'r'r(�test_badSerializationes








z(DisconnectionTests.test_badSerializationc
Cs$
t|d
�
\}
}}|�
�
|�dt��
|
�d�
}|�
�
|�
�
|�
�
|
�|j�

|�|j|
j�
|
�	|j�

|�
|j|
j�
|�|j�

|�|j|
j�
|�|j|j�
|�	|j�

|�
|j|
j�
|�
|j|j�
|
�|j
�

|�|j�

||_|
�t�tj�
�

|�|j�

|�|j�

dS)Nr
r�
)rvrAr*
rwr+
�notifyOnDisconnectr
rB
ZdisconnectsZdontNotifyOnDisconnectrG
Z
_disconnectedZdisconnectCallbacksr�
r�
r�
rKrrLrrMr7
r�
r�
)r%r�r�rA�
rr'r'r(�test_disconnectionos.


















z%DisconnectionTests.test_disconnectionN)	r*r+r,r0r
r�
r�
r�
r�
r'r'r'r(r�
Os

r�
c
@seZ
dZd
S)�FreakOutNr�r'r'r'r(r�
�s
r�
c@seZ
dZd
d�ZdS)r�
c
Cs
t��
dSr-)
r�
)r%�
pr'r'r(�getStateToCopyFor�s
zBadCopyable.getStateToCopyForN)r*r+r,r�
r'r'r'r(r�
�s
r�
c@seZ
dZd
d�ZdS)r�
c
CsdSr-r')r%Zbcr'r'r(�remote_setBadCopy�s
zBadCopySet.remote_setBadCopyN)r*r+r,r�
r'r'r'r(r�
�s
r�
c@s*eZ
dZd
Zdd�Zd
dd�
Zdd�Zd	S)�LocalRemoteTestr
cCs|
d
Srxr')r%r�r'r'r(�	sync_add1�s
zLocalRemoteTest.sync_add1rDcCs|
|Sr-r')r%r�r�r'r'r(�	async_add�s
zLocalRemoteTest.async_addc


Cs
t��
dSr-r�
r.r'r'r(�
async_fail�s
zLocalRemoteTest.async_failN)r
rD)r*r+r,ZreportAllTracebacksr�
r�
r�
r'r'r'r(r�
�s

r�
c@s@eZ
dZd
ZdZZdd�Zdd�Zdd�Zd	d
�Z	dd�Z
d
S)�
MyPerspectivez�
    @ivar loggedIn: set to C{True} when the avatar is logged in.
    @type loggedIn: C{bool}

    @ivar loggedOut: set to C{True} when the avatar is logged out.
    @type loggedOut: C{bool}
    FcCs
|
|_dSr-�
r5�r%r5r'r'r(r=�s
zMyPerspective.__init__c


Cs|jS)
zT
        Return the avatar identifier which was used to access this avatar.
        r�
r.r'r'r(�perspective_getAvatarId�sz%MyPerspective.perspective_getAvatarIdc


Cst�Sr-)
�MyViewr.r'r'r(�perspective_getViewPoint�s
z&MyPerspective.perspective_getViewPointcCs|
|S)
z�
        Add the given objects and return the result.  This is a method
        unavailable on L{Echoer}, so it can only be invoked by authenticated
        users who received their avatar from L{TestRealm}.
        r'r#
r'r'r(�perspective_add�szMyPerspective.perspective_addc

Cs
d
|_dS�NT�
�	loggedOutr.r'r'r(�logout�s
zMyPerspective.logoutN)r*r+r,r0�loggedInr�
r=r�
r�
r�
r�
r'r'r'r(r�
�s	r�
c@s eZ
dZd
ZeZdZdd�ZdS)�	TestRealma�

    A realm which repeatedly gives out a single instance of L{MyPerspective}
    for non-anonymous logins and which gives out a new instance of L{Echoer}
    for each anonymous login.

    @ivar lastPerspective: The L{MyPerspective} most recently created and
        returned from C{requestAvatar}.

    @ivar perspectiveFactory: A one-argument callable which will be used to
        create avatars to be returned from C{requestAvatar}.
    NcCs`|tj
kst�
|d
kst�
|
tjkr6tj
t�dd�fS|�|
�
|_d|j_tj
|j|jj	fSdS)z�
        Verify that the mind and interface supplied have the expected values
        (this should really be done somewhere else, like inside a test method)
        and return an avatar appropriate for the given identifier.
        �BRAINS!c
SsdSr-r'r'r'r'r(r2�r3z)TestRealm.requestAvatar.<locals>.<lambda>TN)
r	r4r�rZ	ANONYMOUSr��perspectiveFactory�lastPerspectiver�
r�
�r%r5r6�	interfacer'r'r(r7�s





�zTestRealm.requestAvatar)r*r+r,r0r�
r�
r�
r7r'r'r'r(r�
�s
r�
c@seZ
dZd
d�ZdS)r�
cCs
t|
t
�Sr-)r"r�
r$r'r'r(�
view_check�s
zMyView.view_checkN)r*r+r,r�
r'r'r'r(r�
�sr�
c@s eZ
dZd
Zdd�Zdd�ZdS)�
LeakyRealmz]
    A realm which hangs onto a reference to the mind object in its logout
    function.
    cCs
|
|_d
S)z�
        Create a L{LeakyRealm}.

        @param mindEater: a callable that will be called with the C{mind}
        object when it is available
        N)
�
_mindEater)r%Z	mindEaterr'r'r(r=szLeakyRealm.__init__cs*|���

|�
|
�
�
tj�
��
fd
d�fS)Ncs��
��fSr-)
r�
r'�r6Zperspr'r(r2r3z*LeakyRealm.requestAvatar.<locals>.<lambda>)r�
r�
r	r4r�
r'r�
r(r7s




zLeakyRealm.requestAvatarN)r*r+r,r0r=r7r'r'r'r(r�

s

r�
c@seZ
dZd
Zdd�ZdS)�NewCredLeakTestsz/
    Tests to try to trigger memory leaks.
    c
s�d
�_�f
dd�}
t
�t|
�
d�\}��
g�|�d�
}|�dd�}dd	�}|�|�

��
�fd
d�}|�|�

�
��
���dg
�
t�	�
��
����

d
S)
z�
        The server does not leak a reference when the client disconnects
        suddenly, even if the cred logout function forms a reference cycle with
        the perspective.
        Nc

st�
|�
�_dSr-)�weakrefr��mindRef)
r6r.r'r(�
setMindRef$s
z4NewCredLeakTests.test_logoutLeak.<locals>.setMindRef)r[rtr��loginroc
Ss$|\}
}t�}|�
d
t�|
d�|�S)N�respondro)rwr�r	r�
)r�Z	challengeZ
challengerr6r'r'r(�
cbResponse/s




�z4NewCredLeakTests.test_logoutLeak.<locals>.cbResponsec

s*�
��
��
d
�

��t�td�
�
�

dS)NrDZboom)rCr�rKrrLr�)
�
_)�connectionBrokenrAr^r'r(rK5s



z8NewCredLeakTests.test_logoutLeak.<locals>.connectionLostrD)r�
rvr�
r+
r�r�rBr�rE
rF
rK
)r%r�
r]r�r�r�
rKr')r�
rAr%r^r(�test_logoutLeaks"

�








z NewCredLeakTests.test_logoutLeakN)r*r+r,r0r�
r'r'r'r(r�
s
r�
c@s�eZ
dZd
Zdd�Zd%dd�
Ze�ej	�
f
dd�
Z
d	d
�Zdd�Zd
d�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�ZdS)&�NewCredTestsz=
    Tests related to the L{twisted.cred} support in PB.
    c

Cs0t�|_
t�|j
�
|_t|j�
|_t��|_d
S)z�
        Create a portal with no checkers and wrap it around a simple test
        realm.  Set up a PB server on a TCP port which serves perspectives
        using that portal.
        N)	r�
rtrrrr�r\r	rsrTr.r'r'r(r�Ks


zNewCredTests.setUpNcCsRt||j
|j�\|_|_|_t�|_tt	�
d
dd�|j�|_|j���
|j�

dS)a�
        Connect a client obtained from C{clientFactory} and a server
        obtained from the current server factory via an L{IOPump},
        then assign them to the appropriate instance variables

        @ivar clientFactory: the broker client factory
        @ivar clientFactory: L{pb.PBClientFactory} instance

        @ivar client: the client broker
        @type client: L{pb.Broker}

        @ivar server: the server broker
        @type server: L{pb.Broker}

        @ivar pump: the IOPump connecting the client and server
        @type pump: L{IOPump}

        @ivar connector: A connector whose connect method recreates
            the above instance variables
        @type connector: L{twisted.internet.base.IConnector}
        ZTCPrIi�N)r_rTr\r9r:rAr`ZconnectorStatergrZIPv4AddressrPrcr��establishClientAndServer)r%Z_ignoredr'r'r(r�
Ws
�


�

�z%NewCredTests.establishClientAndServercCs0|�|j
jj�

|j
�|
�

|j�|j|
�
d
S)a�

        Asserts that the client broker's transport was closed and then
        mimics the event loop by calling the broker's connectionLost
        callback with C{reason}, followed by C{self.clientFactory}'s
        C{clientConnectionLost}

        @param reason: (optional) the reason to pass to the client
            broker's connectionLost callback
        @type reason: L{Failure}
        N)r7
r9rHr6
rKrTrRrP)r%rQr'r'r(�completeClientLostConnectionxs
z)NewCredTests.completeClientLostConnectionc
sB���
�j
��}
�f
d
d�}�f
dd�}|
�|�

|
�|�

|
S)z�
        Assert that L{PBClientFactory.getRootObject}'s Deferred fires with
        a L{RemoteReference}, and that disconnecting it runs its
        disconnection callbacks.
        c

s��|t
j�
|Sr-)r�r	�RemoteReference�
�rootObjr.r'r(�
gotRootObject�s

z6NewCredTests.test_getRootObject.<locals>.gotRootObjectc
s(t�}
|�
|
j�

�j��
���
|
Sr-)rr�
rerT�
disconnectr�
)r�
�disconnectedDeferredr.r'r(r�
�s




z3NewCredTests.test_getRootObject.<locals>.disconnect�r�
rTr�r�)r%�rootObjDeferredr�
r�
r'r.r(�test_getRootObject�s

	


zNewCredTests.test_getRootObjectc
s(���
�j
��}
�f
d
d�}|
�|�
S)z�
        Test that when a connection is lost, calling a method on a
        RemoteReference obtained from it raises L{DeadReferenceError}.
        c
s@t�}
��
|
j�

��
fd
d�}|
�|�

�
j��
�
��
|
S)Nc

s�
�t
j�jd
�
dS)N�method)ZassertRaisesr	ZDeadReferenceErrorr�)
�ign)r�
r%r'r(�lostConnection�s



�zSNewCredTests.test_deadReferenceError.<locals>.gotRootObject.<locals>.lostConnection)rr�
rer�rTr�
r�
)r�
r�
r�
r.r�
r(r�
�s




z;NewCredTests.test_deadReferenceError.<locals>.gotRootObjectr�
)r%r�
r�
r'r.r(�test_deadReferenceError�s

z$NewCredTests.test_deadReferenceErrorc
sBGd
d�dtj
�}
|
��_���
�j��}�f
dd�}|�|�
S)z�
        Test that if the L{reconnecting} flag is passed with a True value then
        a remote call made from a disconnection notification callback gets a
        result successfully.
        c@seZ
dZd
Zdd�ZdS)z=NewCredTests.test_clientConnectionLost.<locals>.ReconnectOnceFcSs0|j}d
|_t
j�||
||�}|r,|
��
|Sr�
)�reconnectedAlreadyr	rsrRrm)r%rPrQZreconnectingr
r'r'r(rR�s



�

zRNewCredTests.test_clientConnectionLost.<locals>.ReconnectOnce.clientConnectionLostN)r*r+r,r�
rRr'r'r'r(�
ReconnectOnce�s
r�
c
sH��|t
j�
t�}
|�|
j�

�j��
���
�f
d
d�}|
�	|�
S)Nc
s �j�
�}
�f
d
d�}|
�|�
S)Nc
s6��|t
j�
t�}
|�|
j�

�j��
���
|
Sr-)	r�r	r�
rr�
rerTr�
r�
)ZanotherRootObjr�r.r'r(�gotAnotherRootObject�s






zqNewCredTests.test_clientConnectionLost.<locals>.gotRootObject.<locals>.disconnected.<locals>.gotAnotherRootObject)rTr�r�)r�
r�r�
r.r'r(rJ�s

zSNewCredTests.test_clientConnectionLost.<locals>.gotRootObject.<locals>.disconnected)
r�r	r�
rr�
rerTr�
r�
r�)r�
r�rJr.r'r(r�
�s



z=NewCredTests.test_clientConnectionLost.<locals>.gotRootObject)r	rsrTr�
r�r�)r%r�
r�
r�
r'r.r(�test_clientConnectionLost�s

z&NewCredTests.test_clientConnectionLostc
Cs<|��
|j
�d
�
}
|
�t�t��
�

|
�t�	t
j�
�

dS)z�
        Test that if a Broker loses its connection without receiving any bytes,
        it doesn't raise any exceptions or log any errors.
        )rIi90N)r�
r\rVrXr
rYrWrKrrLrrM)r%ZserverProtor'r'r(�test_immediateClose�s


z NewCredTests.test_immediateClosec
Cs<t�
�}
|
�t�d
d��
}|
�dt�td�
�
�
|�	|t�S)z�
        L{PBClientFactory.login} returns a L{Deferred} which is errbacked
        with the L{ConnectionRefusedError} if the underlying connection is
        refused.
        �foo�barNz!Test simulated refused connection)
r	rsr�
r�UsernamePasswordZclientConnectionFailedrrLr�
assertFailure)r%rTZ
loginDeferredr'r'r(�test_loginConnectionRefused�s


�


��z(NewCredTests.test_loginConnectionRefusedc
s��
j�
tjd
d�
�

t�dd
�}
d}t���
j�|
|�}��
fdd�}�
f
dd�}|�	|�

|�	|�

�
f
d	d
�}|�	|�

�
�
�
�
j��
t
��
�
j��
��d�

|S)z�
        Test that login can be performed with IUsernamePassword credentials and
        that when the connection is dropped the avatar is logged out.
        �pass�
r&�userr�
c

s"�
��
j
jj�

�
�|tj�
�Sr-)r7
rtr�
r�
r�r	r�
�
r��ZloginCompletedr%r'r(�cbLogin!s


z.NewCredTests.test_loginLogout.<locals>.cbLoginc

s�j�
�
���
dSr-)rTr�
r�
�
�ignoredr.r'r(�cbDisconnect&s


z3NewCredTests.test_loginLogout.<locals>.cbDisconnectc

s���j
jj�

dSr-)r7
rtr�
r�
r�
r.r'r(�cbLogout-s
z/NewCredTests.test_loginLogout.<locals>.cbLogoutN)r�registerCheckerrrprr�
rrTr�
r�r�
rArBrE
rF
re)r%Zcredsr6r�r�
r�
r�
r'r�
r(�test_loginLogouts&

�









zNewCredTests.test_loginLogoutc
s�t��G�f
d
d�dt
j�}
|
�
j_�
j�tjdd�
�

�
j	�
t�dd�d�}�f
dd�}|�
|�

�
f
d	d
�}|�
|�

�
��
�
j��
t��
�
j��
|S)z�
        If a L{RemoteReference} to an L{IPerspective} avatar is decrefed and
        there remain no other references to the avatar on the server, the
        avatar is garbage collected and the logout method called.
        cs$eZ
dZd
Zdd�Z�f
dd�ZdS)z=NewCredTests.test_logoutAfterDecref.<locals>.EventPerspectivezQ
            An avatar which fires a Deferred when it is logged out.
            c
SsdSr-r'r�
r'r'r(r=Is
zFNewCredTests.test_logoutAfterDecref.<locals>.EventPerspective.__init__c

s��d�

dSr-)
rer.r�
r'r(r�
Ls
zDNewCredTests.test_logoutAfterDecref.<locals>.EventPerspective.logoutN)r*r+r,r0r=r�
r'r�
r'r(�EventPerspectiveEs
r�
r�
r�r�
r�
c


s�Sr-r')
Zavatarr�
r'r(�
cbLoggedInWsz7NewCredTests.test_logoutAfterDecref.<locals>.cbLoggedInc

s���j
jji�
dSr-)r�r\r
Z
_localCleanupr�
r.r'r(�cbLoggedOut]sz8NewCredTests.test_logoutAfterDecref.<locals>.cbLoggedOut)rr	�Avatarrtr�
rr�
rrprTr�
rr�
r�r�
rArBrE
rF
)r%r�
r�r�
r�
r')r�
r%r(�test_logoutAfterDecref=s&


�

�





z#NewCredTests.test_logoutAfterDecrefc
s��j�
tjd
dd��

�j�t�dd
�d�}
�j�t�dd�d�}t|
|g�
}dd�}|�	|�

�f
d	d
�}|�	|�

��
�
�j��
|S)z�
        Two different correct login attempts can be made on the same root
        object at the same time and produce two different resulting avatars.
        r�
squux)r��bazr�
r�
�bazc
Ss |\}
}t|
�
d
�
|�
d
�
g�
S)NZgetAvatarId)rr�)r
�first�secondr'r'r(r�
}s




�z5NewCredTests.test_concurrentLogin.<locals>.cbLoggedInc
s$|\}
}��|
d
�
��|d�
dS)Nr�
r�
)
r�)r�r�
r�
r.r'r(�cbAvatarIds�s


z6NewCredTests.test_concurrentLogin.<locals>.cbAvatarIds)
rr�
rrprTr�
rr�
rr�r�
rArB)r%�
firstLogin�secondLoginr�r�
r�
r'r.r(�test_concurrentLoginos,

��

�

�





z!NewCredTests.test_concurrentLoginc
s��j�
tjd
d�
�

�j�t�dd
��
}
�j�t�dd��
}��|
t	�
��|t	�
t
|
|g�
}�f
dd�}|�|�

���
�j
��
|S)zz
        Test that a login attempt with an invalid user or invalid password
        fails in the appropriate way.
        r�
r�
s
nosuchuserr�
s	wrongpassc
s��t
�
}
��t|
�
d
�
dS)Nr�)�flushLoggedErrorsrr�r8
��ignore�errorsr.r'r(�cleanup�s


z;NewCredTests.test_badUsernamePasswordLogin.<locals>.cleanup)rr�
rrprTr�
rr�
r�
rrr�r�
rArB)r%r�
r�
r�r�
r'r.r(�test_badUsernamePasswordLogin�s"

�

�

�




z*NewCredTests.test_badUsernamePasswordLoginc
CsX|j�
t���

|j�t��d
�}
dd�}|
�|�

|
�|j	d�
|�
�
|j��
|
S)z�
        Verify that a PB server using a portal configured with a checker which
        allows IAnonymous credentials can be logged into using IAnonymous
        credentials.
        r�
c

Ss|�d
d�S�Nr��{r"
r�
r'r'r(r�
�s
z4NewCredTests.test_anonymousLogin.<locals>.cbLoggedInr�
)
rr�
r�AllowAnonymousAccessrTr�
r�	Anonymousr�r�r�
rArB)r%r�r�
r'r'r(�test_anonymousLogin�s




z NewCredTests.test_anonymousLoginc
s^�j�
tjd
d�
�

�j�t��d�}
��|
t	�
�f
dd�}|
�
|�

���
�j�
�
|
S)zg
        Verify that without an anonymous checker set up, anonymous login is
        rejected.
        �passr�
r�
c
s��t
�
}
��t|
�
d
�
dSrx)r�
rr�r8
r�
r.r'r(r�
�s


z=NewCredTests.test_anonymousLoginNotPermitted.<locals>.cleanup)rr�
rrprTr�
rr�
r�
rr�r�
rArB�r%r�r�
r'r.r(�test_anonymousLoginNotPermitted�s

�



z,NewCredTests.test_anonymousLoginNotPermittedc
Csl|j�
t���

|j�
tjd
d�
�

|j�t��d�}
dd�}|
�	|�

|
�	|j
d�
|��
|j�
�
|
S)z�
        Like L{test_anonymousLogin} but against a portal with a checker for
        both IAnonymous and IUsernamePassword.
        r�
r�
r�
c

Ss|�d
d�Sr�
r"
r�
r'r'r(r�
�s
zENewCredTests.test_anonymousLoginWithMultipleCheckers.<locals>.cbLoginr�
)rr�
rr�
rprTr�
rr�
r�r�r�
rArB�r%r�r�
r'r'r(�'test_anonymousLoginWithMultipleCheckers�s


�


z4NewCredTests.test_anonymousLoginWithMultipleCheckersc
Csp|j�
t���

|j�
tjd
d�
�

|j�t�dd
�d�}
dd�}|
�	|�

|
�	|j
d�
|��
|j�
�
|
S)z�
        Like L{test_anonymousLoginWithMultipleCheckers} but check that
        username/password authentication works.
        r�
r�
r�
r�
c

Ss|�d
dd�S)N�addr\
�r"
r�
r'r'r(r�
�s
zINewCredTests.test_authenticatedLoginWithMultipleCheckers.<locals>.cbLoginr�
)rr�
rr�
rprTr�
rr�
r�r�r�
rArBr�
r'r'r(�+test_authenticatedLoginWithMultipleCheckers�s


�

�


z8NewCredTests.test_authenticatedLoginWithMultipleCheckersc
Csp|j�
tjd
d�
�

|j�t�dd
�d�}
dd�}|
�|�

dd�}|
�|�

|
�|j	�

|�
�
|j��
|
S)	zb
        Verify that a viewpoint can be retrieved after authenticating with
        cred.
        r�
r�
r�
r�
c

Ss
|�d
�
S)NZgetViewPointr"
r�
r'r'r(r�
s
z'NewCredTests.test_view.<locals>.cbLoginc

Ss
|�d
�
S)Nr�r"
)
Z	viewpointr'r'r(�cbViews
z&NewCredTests.test_view.<locals>.cbView)
rr�
rrprTr�
rr�
r�r7
r�
rArB)r%r�r�
rr'r'r(�	test_view
s

�

�



zNewCredTests.test_view)
N)r*r+r,r0r�r�
rrLrrMr�
r�
r�
r�
r�
r�
r�
r�
r�
r�
r�
r�
r�
r
rr'r'r'r(r�
Gs&

"
�
0/2 r�
c@s$eZ
dZd
d�Zdd�Zdd�ZdS)�NonSubclassingPerspectivec
CsdSr-r'r�
r'r'r(r=s
z"NonSubclassingPerspective.__init__cCs(|
�||�}|
�||�}|
�
|||f�
Sr-)ZunserializeZ	serialize)r%rN�messagerY
�kwargsr'r'r(�perspectiveMessageReceived"s


z4NonSubclassingPerspective.perspectiveMessageReceivedc

Cs
d
|_dSr�
r�
r.r'r'r(r�
(s
z NonSubclassingPerspective.logoutN)r*r+r,r=rr�
r'r'r'r(rsrc@s eZ
dZd
Zdd�Zdd�ZdS)�NSPTestsz
    Tests for authentication against a realm where the L{IPerspective}
    implementation is not a subclass of L{Avatar}.
    c

Cs�t�|_
t|j
_t�|j
�
|_t��|_|j�	d
d�
|j�
|j�

tt�
|j�
�
|_tjd|jdd�|_|�|jj�

|j��j|_dS)Nr�
r�
r
rI)
r�
)r�
rtrr�
rrrrrpruZaddUserr�
rr	rqr	
rr
r
rZr
r
�portnor.r'r'r(r�2s










zNSPTests.setUpc
snt�
����t�d
d�d�}
t�d�
j��
|
�dd��

|
��
j	ddd	d
i
f�
��
fdd�}|
�|�

|
S)
z�
        An L{IPerspective} implementation which does not subclass
        L{Avatar} can expose remote methods for the client to call.
        r�
r�
r�
rIc

Ss|jd
ddd�S)N�ANYTHING�herer�
)
r0
r"
)
r�
r'r'r(r2Hr3z#NSPTests.test_NSP.<locals>.<lambda>r
)
rr0
r�
c
s$���
�
j
jD]}
|
j��
qdSr-)r�
r	
Z	protocolsrHr

)r�
r�
�r	
r%r'r(r�
Ks


z"NSPTests.test_NSP.<locals>.cleanup)
r	rsr�
rr�
rr
r	r�r�r�
r'rr(�test_NSP?s

�


�

zNSPTests.test_NSPN)r*r+r,r0r�r
r'r'r'r(r-s

rc@s eZ
dZd
Zdd�Zdd�ZdS)�
IForwardedzA
    Interface used for testing L{util.LocalAsyncForwarder}.
    c
Csd
S)z,
        Simple synchronous method.
        Nr'r'r'r'r(�	forwardMeYs
zIForwarded.forwardMec
Csd
S)z-
        Simple asynchronous method.
        Nr'r'r'r'r(�forwardDeferred^s
zIForwarded.forwardDeferredN)r*r+r,r0rrr'r'r'r(rTs
rc@s0eZ
dZd
ZdZdZdd�Zdd�Zdd�Zd	S)
�	Forwardedz�
    Test implementation of L{IForwarded}.

    @ivar forwarded: set if C{forwardMe} is called.
    @type forwarded: C{bool}
    @ivar unforwarded: set if C{dontForwardMe} is called.
    @type unforwarded: C{bool}
    Fc

Cs
d
|_dS)z6
        Set a local flag to test afterwards.
        TN)
�	forwardedr.r'r'r(rqszForwarded.forwardMec

Cs
d
|_dS)zv
        Set a local flag to test afterwards. This should not be called as it's
        not in the interface.
        TN)
�unforwardedr.r'r'r(�
dontForwardMewszForwarded.dontForwardMec

Cstd
�
S)z0
        Asynchronously return C{True}.
        T)
rr.r'r'r(r~szForwarded.forwardDeferredN)	r*r+r,r0rrrrrr'r'r'r(rds
rc@s8eZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�SpreadUtilTestsz+
    Tests for L{twisted.spread.util}.
    c
Cst�}
|�
|
�d
d�d�
dS)zk
        Call a synchronous method of a L{util.LocalAsRemote} object and check
        the result.
        �add1r�r�N)r�
r�r�r�
r'r'r(�	test_sync�s
zSpreadUtilTests.test_syncc
Cs:t�}
t�}
|
j
d
ddd�}|�|t�
|�|jd�
|S)zm
        Call an asynchronous method of a L{util.LocalAsRemote} object and check
        the result.
        r�
r�r�)
r�r>
)r�
r�r�rr�r�)r%r�
r�r'r'r(�
test_async�s




zSpreadUtilTests.test_asyncc
s4t�}
|
�
d
�
}�f
dd�}|��f
dd�|�
|S)zG
        Test an asynchronous failure on a remote method call.
        r
c

s��|t
j�
|�t�

dSr-)r�rrLZtrapr�)
ri
r.r'r(�eb�s

z*SpreadUtilTests.test_asyncFail.<locals>.ebc

s
��d
�
S)Nzsupposed to failr
r�r.r'r(r2�r3z0SpreadUtilTests.test_asyncFail.<locals>.<lambda>)r�
r�r�)r%r�
r�rr'r.r(�test_asyncFail�s




zSpreadUtilTests.test_asyncFailc
Cs$t�}
|
�
d
�
}|�|d�
d�
dS)zM
        Test the C{remoteMethod} facility of L{util.LocalAsRemote}.
        rr�r�N)r�
r-
r�)r%r�
�
mr'r'r(�test_remoteMethod�s


z!SpreadUtilTests.test_remoteMethodc
Cslt�}
t
�|
t�}|�d
�

|�|
j�

|�d�

|�|
j�

|�d�
}g}|�	|j
�

|�|dd�
dS)ze
        Test a call to L{util.LocalAsyncForwarder} using L{Forwarded} local
        object.
        rrrr
rDN)rr
ZLocalAsyncForwarderrr�r7
rr�rr�r�r�)r%ri
ZlfZrrr9
r'r'r(�test_localAsyncForwarder�s











z(SpreadUtilTests.test_localAsyncForwarderN)	r*r+r,r0rrrrrr'r'r'r(r�s
rc@s0eZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
S)�PBWithSecurityOptionsTestsz&
    Test security customization.
    c
Cs&t�
�}
|
�d
�
}|�|jtj�
d
S)zl
        By default, client broker should use C{jelly.globalSecurity} as
        security settings.
        N)r	rsrVr,
�securityr�globalSecurity�r%r	
rNr'r'r(�!test_clientDefaultSecurityOptions�s


z<PBWithSecurityOptionsTests.test_clientDefaultSecurityOptionsc
Cs*t�
t��
}
|
�d
�
}|�|jtj�
d
S)zl
        By default, server broker should use C{jelly.globalSecurity} as
        security settings.
        N)r	rqr�rVr,
rrr r!r'r'r(�!test_serverDefaultSecurityOptions�s


z<PBWithSecurityOptionsTests.test_serverDefaultSecurityOptionsc
Cs0t�
�}
tj|
d
�
}|�d�
}|�|j|
�
dS)zs
        Check that the security settings are passed from the client factory to
        the broker object.
        �
rN)r�SecurityOptionsr	rsrVr,
r�r%rr	
rNr'r'r(� test_clientSecurityCustomization�s



z;PBWithSecurityOptionsTests.test_clientSecurityCustomizationc
Cs4t�
�}
tjt�|
d
�}|�d�
}|�|j|
�
dS)zs
        Check that the security settings are passed from the server factory to
        the broker object.
        r$N)rr%r	rqr�rVr,
rr&r'r'r(� test_serverSecurityCustomization�s



z;PBWithSecurityOptionsTests.test_serverSecurityCustomizationN)r*r+r,r0r"r#r'r(r'r'r'r(r�s



r)
N)�r0Z
__future__rrrC
r
r@rE
r�
�collectionsr�iorrWZzope.interfacerrZ
twisted.trialrZtwisted.spreadr	r
rrZtwisted.internetr
rrrZtwisted.internet.errorrZtwisted.internet.deferrrrZtwisted.protocols.policiesrZtwisted.pythonrrZtwisted.python.compatrrrZtwisted.cred.errorrrZtwisted.credrrrZtwisted.test.proto_helpersr ZViewabler!r�
r#ZIRealmr�r1r8r_r`rgrvr)
rwr~ZCopyabler�Z
RemoteCopyr�ZsetUnjellyableForClassr�r�ZsetUnjellyableFactoryForClassr�Z	Cacheabler�r�r�ZRemoteCacher�r�r�r�r�r�r�r�r�ZRootr�r�ZSynchronousTestCaser�rqr�ZTestCaser
r
r]
rW
rX
rZ
r[
r`
re
ZPublishabler~
ZRemotePublishedr�
rO
r�
r|r�
r�
r�
Z
LocalAsRemoter�
r4r�
r�
r�
r�
r�
r�
rrrrrrr'r'r'r(�<module>s�
(










	
>4$
		
		Q!6

pD
'#0X
'
 ?