HEX
Server: Apache
System: Linux scp1.abinfocom.com 5.4.0-216-generic #236-Ubuntu SMP Fri Apr 11 19:53:21 UTC 2025 x86_64
User: confeduphaar (1010)
PHP: 8.1.33
Disabled: exec,passthru,shell_exec,system
$ pwd: /usr/lib/python3/dist-packages/twisted/names/test/__pycache__/
Upload Files
File: //usr/lib/python3/dist-packages/twisted/names/test/__pycache__/test_client.cpython-38.pyc
U


W[?��@s�dZddlmZmZddlmZmZddlmZddl	m
Z
ddlmZddl
mZddlmZmZdd	lmZdd
lmZddlmZddlmZmZmZmZmZdd
lmZddl m!Z!ddl"m#Z#ddl$m%Z%ddl&m'Z'ddl(m)Z)e�*�r�dZ+ndZ+Gdd�de!�Z,Gdd�de-�Z.Gdd�de-�Z/Gdd�de)j0�Z1Gdd�de)j0e#�Z2Gdd �d e)j0�Z3Gd!d"�d"e)j0�Z4Gd#d$�d$e)j0�Z5Gd%d&�d&e-�Z6Gd'd(�d(e)j0�Z7Gd)d*�d*e)j0�Z8dS)+z)
Test cases for L{twisted.names.client}.
�)�division�absolute_import)�verifyClass�verifyObject)�failure)�FilePath)�platform)�defer)�CannotListenError�ConnectionRefusedError)�	IResolver)�AlternateReactor)�Clock)�error�client�dns�hosts�cache)�DNSQueryTimeoutError)�ResolverBase)�GoodTempPathMixin)�	test_util)�
proto_helpers)�unittestz:These tests need more work before they'll work on Windows.Nc@seZdZdd�ZdS)�FakeResolverc		CsZ|dkr*tj|tj|dtjddd�d�}ntj|||dd�}|g}g}g}t�|||f�S)z�
        The getHostByNameTest does a different type of query that requires it
        return an A record from an ALL_RECORDS lookup, so we accommodate that
        here.
        �getHostByNameTest�<�	127.0.0.1)�address�ttl)�name�type�clsrZpayload)r r!r"r)rZRRHeader�AZRecord_Ar	�succeed)	�selfr r"�qtype�timeoutZrr�results�	authority�
additional�r+�@/usr/lib/python3/dist-packages/twisted/names/test/test_client.py�_lookup*s�zFakeResolver._lookupN)�__name__�
__module__�__qualname__r-r+r+r+r,r(src@seZdZdZdZdd�ZdS)�StubPortz�
    A partial implementation of L{IListeningPort} which only keeps track of
    whether it has been stopped.

    @ivar disconnected: A C{bool} which is C{False} until C{stopListening} is
        called, C{True} afterwards.
    FcCs
d|_dS)NT)�disconnected�r%r+r+r,�
stopListeningGszStubPort.stopListeningN)r.r/r0�__doc__r2r4r+r+r+r,r1=sr1c@s"eZdZdZdd�Zddd�ZdS)	�StubDNSDatagramProtocolz�
    L{dns.DNSDatagramProtocol}-alike.

    @ivar queries: A C{list} of tuples giving the arguments passed to
        C{query} along with the L{defer.Deferred} which was returned from
        the call.
    cCsg|_t�|_dS�N��queriesr1�	transportr3r+r+r,�__init__Tsz StubDNSDatagramProtocol.__init__�
NcCs"t��}|j�|||||f�|S)zv
        Record the given arguments and return a Deferred which will not be
        called back by this code.
        )r	�Deferredr9�append)r%rr9r'�id�resultr+r+r,�queryYszStubDNSDatagramProtocol.query)r<N)r.r/r0r5r;rAr+r+r+r,r6Lsr6c@s(eZdZdZereZdd�Zdd�ZdS)�GetResolverTestsz*
    Tests for L{client.getResolver}.
    c	Cs2tt���t��}W5QRX|�tt|��dS)zQ
        L{client.getResolver} returns an object providing L{IResolver}.
        N)r
rr�getResolver�
assertTruerr�r%�resolverr+r+r,�test_interfacekszGetResolverTests.test_interfacec	Cs6tt���t��}t��}W5QRX|�||�dS)zn
        Multiple calls to L{client.getResolver} return the same L{IResolver}
        implementation.
        N)r
rrrC�assertIs)r%�a�br+r+r,�test_idempotenttsz GetResolverTests.test_idempotentN)r.r/r0r5�windowsSkip�skiprGrKr+r+r+r,rBds
	rBc@sheZdZdZereZdd�Zdd�Zdd�Zdd	�Z	d
d�Z
dd
�Zdd�Zdd�Z
dd�Zdd�ZdS)�CreateResolverTestsz-
    Tests for L{client.createResolver}.
    cCs6dd�|jD�}|�dt|��|�|dj|�dS)NcSsg|]}t|tj�r|�qSr+)�
isinstancer�Resolver��.0�rr+r+r,�
<listcomp>�sz2CreateResolverTests._hostsTest.<locals>.<listcomp>�r)�	resolvers�assertEqual�len�file�r%rF�filename�resr+r+r,�
_hostsTest�szCreateResolverTests._hostsTestc	Cs.tt���t��}W5QRX|�|d�dS)z�
        L{client.createResolver} returns a L{resolve.ResolverChain} including a
        L{hosts.Resolver} using I{/etc/hosts} if no alternate hosts file is
        specified.
        s
/etc/hostsN�r
rr�createResolverr]rEr+r+r,�test_defaultHosts�sz%CreateResolverTests.test_defaultHostsc	Cs2tt���tjdd�}W5QRX|�|d�dS)z�
        The I{hosts} parameter to L{client.createResolver} overrides the hosts
        file used by the L{hosts.Resolver} in the L{resolve.ResolverChain} it
        returns.
        �/foo/bar)rNr^rEr+r+r,�test_overrideHosts�sz&CreateResolverTests.test_overrideHostscCs6dd�|jD�}|�dt|��|�|dj|�dS)z|
        Verify that C{resolver} has a L{client.Resolver} with a configuration
        filename set to C{filename}.
        cSsg|]}t|tj�r|�qSr+�rOrrPrQr+r+r,rT�sz7CreateResolverTests._resolvConfTest.<locals>.<listcomp>rUrN)rVrWrX�resolvrZr+r+r,�_resolvConfTest�sz#CreateResolverTests._resolvConfTestc	CsXt�}t|��t��}W5QRXdd�|jD�}|�dt|��|�||dj�dS)z�
        The L{client.Resolver} included in the L{resolve.ResolverChain} returned
        by L{client.createResolver} uses the global reactor.
        cSsg|]}t|tj�r|�qSr+rcrQr+r+r,rT�sz4CreateResolverTests.test_reactor.<locals>.<listcomp>rUrN)	rr
rr_rVrWrXrH�_reactor)r%�reactorrFr\r+r+r,�test_reactor�s
z CreateResolverTests.test_reactorc	Cs.tt���t��}W5QRX|�|d�dS)z�
        L{client.createResolver} returns a L{resolve.ResolverChain} including a
        L{client.Resolver} using I{/etc/resolv.conf} if no alternate resolver
        configuration file is specified.
        s/etc/resolv.confN�r
rrr_rerEr+r+r,�test_defaultResolvConf�sz*CreateResolverTests.test_defaultResolvConfc	Cs2tt���tjdd�}W5QRX|�|d�dS)z�
        The I{resolvconf} parameter to L{client.createResolver} overrides the
        resolver configuration file used by the L{client.Resolver} in the
        L{resolve.ResolverChain} it returns.
        ra��
resolvconfNrirEr+r+r,�test_overrideResolvConf�sz+CreateResolverTests.test_overrideResolvConfc	Cs�|��}|�d�tt���tj|jd�}W5QRXdd�|jD�}|�dt|��|�g|dj	�|�dg|dj
�dS)	z�
        If no servers are given, addresses are taken from the file given by the
        I{resolvconf} parameter to L{client.createResolver}.
        �nameserver 127.1.2.3
rkcSsg|]}t|tj�r|�qSr+rcrQr+r+r,rT�sz;CreateResolverTests.test_defaultServers.<locals>.<listcomp>rUr�z	127.1.2.3�5N��pathZ
setContentr
rrr_rVrWrX�servers�
dynServers�r%rlrFr\r+r+r,�test_defaultServers�s
z'CreateResolverTests.test_defaultServersc	Cs�|��}|�d�tt���tjdg|jd�}W5QRXdd�|jD�}|�dt|��|�dg|dj	�|�dg|dj
�d	S)
z�
        Servers passed to L{client.createResolver} are used in addition to any
        found in the file given by the I{resolvconf} parameter.
        rn)z	127.3.2.1rp)rsrlcSsg|]}t|tj�r|�qSr+rcrQr+r+r,rT�sz<CreateResolverTests.test_overrideServers.<locals>.<listcomp>rUrroNrqrur+r+r,�test_overrideServers�s
�z(CreateResolverTests.test_overrideServersc	CsBtt���t��}W5QRXdd�|jD�}|�dt|��dS)zy
        L{client.createResolver} returns a L{resolve.ResolverChain} including a
        L{cache.CacheResolver}.
        cSsg|]}t|tj�r|�qSr+)rOrZ
CacheResolverrQr+r+r,rT�sz2CreateResolverTests.test_cache.<locals>.<listcomp>rUN)r
rrr_rVrWrX)r%rFr\r+r+r,�
test_cache�szCreateResolverTests.test_cacheN)r.r/r0r5rLrMr]r`rbrerhrjrmrvrwrxr+r+r+r,rN�s

rNc@s�eZdZdZdd�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$d%�Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6S)7�
ResolverTestsz'
    Tests for L{client.Resolver}.
    cCsttt�dS)z]
        L{client} provides L{IResolver} through a series of free
        functions.
        N)rrrr3r+r+r,�test_clientProvidesIResolversz*ResolverTests.test_clientProvidesIResolvercCstttj�dS)z;
        L{client.Resolver} provides L{IResolver}.
        N)rrrrPr3r+r+r,�$test_clientResolverProvidesIResolver	sz2ResolverTests.test_clientResolverProvidesIResolvercCs|�ttj�dS)z�
        L{client.Resolver} raises L{ValueError} if constructed with neither
        servers nor a nameserver configuration file.
        N)ZassertRaises�
ValueErrorrrPr3r+r+r,�test_noServersszResolverTests.test_noServerscCs(tj|��t�d�}|�dg|j�dS)z�
        A missing nameserver configuration file results in no server information
        being loaded from it (ie, not an exception) and a default server being
        provided.
        �rdrg�rrpN)rrP�mktemprrWrtrEr+r+r,�test_missingConfigurationsz'ResolverTests.test_missingConfigurationcsRt|���}|jdd��G�fdd�dtj�}|ddgdt�d�|��j�d	S)
z�
        As part of its constructor, C{StubResolver} opens C{/etc/resolv.conf};
        then, explicitly closes it and does not count on the GC to do so for
        it.
        zw+)�modecseZdZ�fdd�ZdS)z9ResolverTests.test_closesResolvConf.<locals>.StubResolvercs�Sr7r+)r%r �Z
resolvConfr+r,�	_openFile+szCResolverTests.test_closesResolvConf.<locals>.StubResolver._openFileN)r.r/r0r�r+r�r+r,�StubResolver*sr��example.comrpz/etc/resolv.conf)rsrdrgN)rr��openrrPrrD�closed)r%Zhandler�r+r�r,�test_closesResolvConf"s
�z#ResolverTests.test_closesResolvConfcCs,tjdgd�}|�dg�|�d|j�dS)z�
        L{client.Resolver.parseConfig} treats a I{domain} line without an
        argument as indicating a domain of C{b""}.
        r�rssdomain
�N)rrP�parseConfigrWZdomainrEr+r+r,�test_domainEmptyArgument2sz&ResolverTests.test_domainEmptyArgumentcCs,tjdgd�}|�dg�|�g|j�dS)z�
        L{client.Resolver.parseConfig} treats a I{search} line without an
        argument as indicating an empty search suffix.
        rr�ssearch
N)rrPr�rW�searchrEr+r+r,�test_searchEmptyArgument<sz&ResolverTests.test_searchEmptyArgumentcsdt��ddg}ddg}tj|d�}||_�fdd�|_t�}|�d�}|�|j|�|�t	�j
�d	�|��j
d
d
|d
��j
d
d�t
d
��|�t	�j
�d�|��j
d	d
|d	��j
d	d�t
d	��|�t	�j
�d
�|��j
dd
|d
��j
dd�t
d��|�t	�j
�d�|��j
d
d
|d	��j
d
d�|�|S)a

        L{client.Resolver.queryUDP} should issue queries to its
        L{dns.DNSDatagramProtocol} with server addresses taken from its own
        C{servers} and C{dynServers} lists, proceeding through them in order
        as L{DNSQueryTimeoutError}s occur.
        �z::1rp)z::2rp)z::3rp)z::4rpr�cs�Sr7r+)�	interface��protocolr+r,�<lambda>Sr�z=ResolverTests.test_datagramQueryServerOrder.<locals>.<lambda>NrUr������)r6rrPrt�_connectedProtocol�objectZqueryUDP�addCallbackrWrXr9rH�errbackr�callback)r%rsrtrFZexpectedResult�queryResultr+r�r,�test_datagramQueryServerOrderFs,
z+ResolverTests.test_datagramQueryServerOrderc	s�t��tjdgd�}�fdd�|_�j}t�dtjtj�}|�	|�}��
t|�d�|�	|�}��
t|�d�t��t�
�}|j���|��d�|�t�||g�}��fdd	�}|�|�|S)
z�
        L{client.Resolver.query} only issues one request at a time per query.
        Subsequent requests made before responses to prior ones are received
        are queued and given the same response as is given to the first one.
        �r�rpr�cs�Sr7r+r+r�r+r,r�qr�z<ResolverTests.test_singleConcurrentRequest.<locals>.<lambda>�foo.example.comrUr�cs4|\}}��|�gggf���|�gggf�dSr7�rW)Z	responsesZ
firstResponseZsecondResponse)�answerr%r+r,�
cbFinished�sz>ResolverTests.test_singleConcurrentRequest.<locals>.cbFinished)r6rrPr�r9r�Queryr#�INrArWrXr��Message�answersr>�popr�r	�
gatherResultsr�)	r%rFr9rA�firstResult�secondResult�response�dr�r+)r�r�r%r,�test_singleConcurrentRequestis"


z*ResolverTests.test_singleConcurrentRequestcs�t��tjdgd�}�fdd�|_�j}t�dtj�}|�|�|�	t
|�d�t�dtj�}|�|�|�	t
|�d�t�dtj�}|�|�|�	t
|�d	�d
S)zh
        L{client.Resolver.query} issues a request for each different concurrent
        query.
        r�r�cs�Sr7r+r+r�r+r,r��r�z?ResolverTests.test_multipleConcurrentRequests.<locals>.<lambda>r�rU�bar.example.comr�r�N)r6rrPr�r9rr�r#rArWrX�A6)r%rFr9Z
firstQueryZsecondQueryZ
thirdQueryr+r�r,�test_multipleConcurrentRequests�s


z-ResolverTests.test_multipleConcurrentRequestscs�t��tjdgd�}�fdd�|_�j}t�dtj�}|�|�|�	t
|�d�|��d�t�
��|�|�|�	t
|�d�dS)	z�
        After a response is received to a query issued with
        L{client.Resolver.query}, another query with the same parameters
        results in a new network request.
        r�r�cs�Sr7r+r+r�r+r,r��r�z?ResolverTests.test_multipleSequentialRequests.<locals>.<lambda>r�rUr�N)r6rrPr�r9rr�r#rArWrXr�r�r�)r%rFr9rAr+r�r,�test_multipleSequentialRequests�s

z-ResolverTests.test_multipleSequentialRequestscs�t��tjdgd�}�fdd�|_�j}t�dtj�}|�|�}|�|�}Gdd�dt	�}|�
�d�t�
|���t�|�||�|�||�g�S)	z�
        If the result of a request is an error response, the Deferreds for all
        concurrently issued requests associated with that result fire with the
        L{Failure}.
        r�r�cs�Sr7r+r+r�r+r,r��r�z>ResolverTests.test_multipleConcurrentFailure.<locals>.<lambda>r�c@seZdZdS)zGResolverTests.test_multipleConcurrentFailure.<locals>.ExpectedExceptionN�r.r/r0r+r+r+r,�ExpectedException�sr�r�)r6rrPr�r9rr�r#rA�	Exceptionr�r�r�Failurer	r��
assertFailure)r%rFr9rAr�r�r�r+r�r,�test_multipleConcurrentFailure�s



�z,ResolverTests.test_multipleConcurrentFailurecCsttjdgd�}|��}|��}|�|j�|�|j�|�|j��j|j��j�t�	t�
|jj�t�
|jj�g�S)z�
        L{client.Resolver._connectedProtocol} returns a new
        L{DNSDatagramProtocol} connected to a new address with a
        cryptographically secure random port number.
        r�r�)rrPr�ZassertIsNotNoner:ZassertNotEqual�getHost�portr	r�Z
maybeDeferredr4)r%rFZ
firstProtoZsecondProtor+r+r,�test_connectedProtocol�s

��z$ResolverTests.test_connectedProtocolcCs4t��}tj|��|d�}|��}|�|j|�dS)z�
        If a reactor instance is supplied to L{client.Resolver}
        L{client.Resolver._connectedProtocol} should pass that reactor
        to L{twisted.names.dns.DNSDatagramProtocol}.
        r~N)r�
MemoryReactorrrPr�r�rHrf)r%rgrF�protor+r+r,�)test_resolverUsesOnlyParameterizedReactor�sz7ResolverTests.test_resolverUsesOnlyParameterizedReactorcsdtjdgd�}g�G�fdd�dt�}||_|�t�d��|�t�d��|�tt	���d�dS)	z�
        L{client.Resolver._connectedProtocol} is called once each time a UDP
        request needs to be issued and the resulting protocol instance is used
        for that request.
        r�r�cs"eZdZdd�Zd�fdd�	ZdS)z:ResolverTests.test_differentProtocol.<locals>.FakeProtocolcSst�|_dSr7�r1r:r3r+r+r,r;szCResolverTests.test_differentProtocol.<locals>.FakeProtocol.__init__r<Ncs��|�t�t���Sr7)r>r	r$rr��r%rrAr'r?��	protocolsr+r,rA	s
z@ResolverTests.test_differentProtocol.<locals>.FakeProtocol.query)r<N�r.r/r0r;rAr+r�r+r,�FakeProtocolsr�r�r�r�N)
rrPr�r�rArr�rWrX�set�r%rFr�r+r�r,�test_differentProtocol�sz$ResolverTests.test_differentProtocolcCsRt��}tjdg|d�}|�t�d��|j��\\}}|�	�j
}|�d|�dS)z<
        If the resolver is ipv6, open a ipv6 port.
        r��rsrgr�z::N)rr�rrPrArr�ZudpPorts�itemsr��hostrW)r%ZfakerFr�r:r�r+r+r,�test_ipv6Resolvers�
zResolverTests.test_ipv6ResolvercsNg�G�fdd�dt�}tjdgd�}|�|_|��|�tt���d�dS)z�
        If a port number is initially selected which cannot be bound, the
        L{CannotListenError} is handled and another port number is attempted.
        cseZdZ�fdd�ZdS)z6ResolverTests.test_disallowedPort.<locals>.FakeReactorcs&��|�t��dkr"td|d��dS)NrU)r>rXr
)r%r��args�kwargs�Zportsr+r,�	listenUDP)s
z@ResolverTests.test_disallowedPort.<locals>.FakeReactor.listenUDPN)r.r/r0r�r+r�r+r,�FakeReactor(sr�r�r�r�N)r�rrPrfr�rWrXr�)r%r�rFr+r�r,�test_disallowedPort!sz!ResolverTests.test_disallowedPortcsxtjdgd�}g�t�t�td���t�t�	��g�G��fdd�dt
�}||_|�t�
d��|�tt���d�dS)z|
        When a query issued by L{client.Resolver.query} times out, the retry
        uses a new protocol instance.
        r�r�Ncs$eZdZdd�Zd��fdd�	ZdS)zFResolverTests.test_differentProtocolAfterTimeout.<locals>.FakeProtocolcSst�|_dSr7r�r3r+r+r,r;@szOResolverTests.test_differentProtocolAfterTimeout.<locals>.FakeProtocol.__init__r<Ncs��|���d�S�Nr�r>r�r��r�r(r+r,rACs
zLResolverTests.test_differentProtocolAfterTimeout.<locals>.FakeProtocol.query)r<Nr�r+r�r+r,r�?sr�r�r�)rrPr	�failrr�rr$rr�r�r�rAr�rWrXr�r�r+r�r,�"test_differentProtocolAfterTimeout5s�z0ResolverTests.test_differentProtocolAfterTimeoutcs|tjdgd�}g�t���G��fdd�dt�}||_|�t�d��|�	�dj
j���t�
��|��dj
j�dS)z�
        After the L{Deferred} returned by L{DNSDatagramProtocol.query} is
        called back, the L{DNSDatagramProtocol} is disconnected from its
        transport.
        r�r�cs$eZdZdd�Zd��fdd�	ZdS)z9ResolverTests.test_protocolShutDown.<locals>.FakeProtocolcSst�|_dSr7r�r3r+r+r,r;WszBResolverTests.test_protocolShutDown.<locals>.FakeProtocol.__init__r<Ncs��|��Sr7�r>r��r�r@r+r,rAZs
z?ResolverTests.test_protocolShutDown.<locals>.FakeProtocol.query)r<Nr�r+r�r+r,r�Vsr�r�rN)rrPr	r=r�r�rArr��assertFalser:r2r�r�rDr�r+r�r,�test_protocolShutDownLsz#ResolverTests.test_protocolShutDowncs�tjdgd�}g�t��}t�t�td���|g�G��fdd�dt�}||_	|�
t�d��|�
�djj�|�t���|��djj�dS)z�
        The L{DNSDatagramProtocol} created when an interim timeout occurs is
        also disconnected from its transport after the Deferred returned by its
        query method completes.
        r�r�Ncs$eZdZdd�Zd��fdd�	ZdS)zEResolverTests.test_protocolShutDownAfterTimeout.<locals>.FakeProtocolcSst�|_dSr7r�r3r+r+r,r;sszNResolverTests.test_protocolShutDownAfterTimeout.<locals>.FakeProtocol.__init__r<Ncs��|���d�Sr�r�r�r�r+r,rAvs
zKResolverTests.test_protocolShutDownAfterTimeout.<locals>.FakeProtocol.query)r<Nr�r+r�r+r,r�rsr�r�rU)rrPr	r=r�rr�rr�r�rArr�r�r:r2r�r�rD)r%rFr@r�r+r�r,�!test_protocolShutDownAfterTimeoutfs�z/ResolverTests.test_protocolShutDownAfterTimeoutcs�Gdd�dt�}tjdgd�}g�t���G��fdd�dt�}||_|�t�	d��}|�
�djj���
t�|���|��djj�|�||�S)	z�
        If the L{Deferred} returned by L{DNSDatagramProtocol.query} fires with
        a failure, the L{DNSDatagramProtocol} is still disconnected from its
        transport.
        c@seZdZdS)zJResolverTests.test_protocolShutDownAfterFailure.<locals>.ExpectedExceptionNr�r+r+r+r,r��sr�r�r�cs$eZdZdd�Zd��fdd�	ZdS)zEResolverTests.test_protocolShutDownAfterFailure.<locals>.FakeProtocolcSst�|_dSr7r�r3r+r+r,r;�szNResolverTests.test_protocolShutDownAfterFailure.<locals>.FakeProtocol.__init__r<Ncs��|��Sr7r�r�r�r+r,rA�s
zKResolverTests.test_protocolShutDownAfterFailure.<locals>.FakeProtocol.query)r<Nr�r+r�r+r,r��sr�r�r)r�rrPr	r=r�r�rArr�r�r:r2r�rr�rDr�)r%r�rFr�r�r+r�r,�!test_protocolShutDownAfterFailure�sz/ResolverTests.test_protocolShutDownAfterFailurecCsNtjdgd�}|j�d�}|�d�|�||j�|�d�|�||j�dS)z�
        When a TCP DNS protocol associated with a Resolver disconnects, it is
        removed from the Resolver's connection list.
        r�r�N)	rrP�factoryZ
buildProtocolZmakeConnectionZassertInZconnectionsZconnectionLostZassertNotIn)r%rFr�r+r+r,�(test_tcpDisconnectRemovesFromConnections�s

z6ResolverTests.test_tcpDisconnectRemovesFromConnectionsc
Csvt��}tjdg|d�}|�t�d��}|jd\}}}}}Gdd�dt�}	|�	|j
dt�|	���|�
||	�dS)z�
        The deferred returned by L{client.Resolver.queryTCP} will
        errback when the TCP connection attempt fails. The reason for
        the connection failure is passed as the argument to errback.
        �z192.0.2.100rpr�r�rc@seZdZdS)zVResolverTests.test_singleTCPQueryErrbackOnConnectionFailure.<locals>.SentinelExceptionNr�r+r+r+r,�SentinelException�sr�N)rr�rrP�queryTCPrr��
tcpClientsr��clientConnectionFailed�
connectorsrr��failureResultOf)
r%rgrFr�r�r�r�r'�bindAddressr�r+r+r,�-test_singleTCPQueryErrbackOnConnectionFailure�s�
�z;ResolverTests.test_singleTCPQueryErrbackOnConnectionFailurec
Cs�t��}tjdg|d�}|�t�d��}|�t�d��}|jd\}}}}}	Gdd�dt�}
|�	|j
dt�|
���|�
||
�}|�
||
�}|�||�dS)	z�
        All pending L{resolver.queryTCP} C{deferred}s will C{errback}
        with the same C{Failure} if the connection attempt fails.
        r�r�r�zexample.netrc@seZdZdS)zXResolverTests.test_multipleTCPQueryErrbackOnConnectionFailure.<locals>.SentinelExceptionNr�r+r+r+r,r��sr�N)rr�rrPr�rr�r�r�r�r�rr�r�rH)
r%rgrFZd1Zd2r�r�r�r'r�r��f1�f2r+r+r,�/test_multipleTCPQueryErrbackOnConnectionFailure�s �
�z=ResolverTests.test_multipleTCPQueryErrbackOnConnectionFailurecst��}tjdg|d��t�d������}��fdd�}|�|�|�t	|j
�d�|�t	|j�d�|j
d\}}}}}t�
t��}	|�|jd|	�|�t	|j
�d�|�t	|j�d�|�|�t�
t��}
|�|jd|
�|�|t�}|�||
�d	S)
z{
        An errback on the deferred returned by
        L{client.Resolver.queryTCP} may trigger another TCP query.
        )riE'r�r�cs|�t�����Sr7)�traprr�)�e��qrFr+r,�reissue�s
zOResolverTests.test_reentrantTCPQueryErrbackOnConnectionFailure.<locals>.reissuerUrr�N)rr�rrPrr�r��
addErrbackrWrXr�r�rr�rr�ZassertNoResultr�rH)r%rgr�r�r�r�r�r'r�r�r��fr+r�r,�0test_reentrantTCPQueryErrbackOnConnectionFailure�s6�


�
�z>ResolverTests.test_reentrantTCPQueryErrbackOnConnectionFailurecCs�t��}tjdg|d�}|�t�d��}|jd\}}}}}|j}	|�	t
|	�d�Gdd�dt�}
|�|j
dt�|
���|�||
�|�|j|	�|�	t
|	�d�dS)	z�
        When the TCP connection attempt fails, the
        L{client.Resolver.pending} list is emptied in place. It is not
        replaced with a new empty list.
        r�r�r�rrUc@seZdZdS)zJResolverTests.test_pendingEmptiedInPlaceOnError.<locals>.SentinelExceptionNr�r+r+r+r,r�#sr�N)rr�rrPr�rr�r��pendingrWrXr�r�r�rr�r�rH)r%rgrFr�r�r�r�r'r�Z
prePendingr�r+r+r,�!test_pendingEmptiedInPlaceOnErrors"�
�z/ResolverTests.test_pendingEmptiedInPlaceOnErrorN)r.r/r0r5rzr{r}r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r+r+r+r,ry�s6


#$1ryc@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Zd;S)<�ClientTestscCst�t_d|_d|_dS)z:
        Replace the resolver with a FakeResolver
        �example.comrN)rr�theResolver�hostname�hostnameForGetHostByNamer3r+r+r,�setUp1szClientTests.setUpcCs
dt_dS)zp
        By setting the resolver to None, it will be recreated next time a name
        lookup is done.
        N)rr�r3r+r+r,�tearDown9szClientTests.tearDowncCs6|\}}}|d}|�|jj|j�|�|j|�dS)zT
        Verify that the result is the same query type as what is expected.
        rN)rWr r�r!)r%r(r&r�r)r*r@r+r+r,�checkResult@s
zClientTests.checkResultcCs|�|d�dS)zR
        Test that the getHostByName query returns the 127.0.0.1 address.
        rNr��r%r@r+r+r,�checkGetHostByNameIszClientTests.checkGetHostByNamecCst�|j�}|�|j�|S)zM
        do a getHostByName of a value that should return 127.0.0.1.
        )rZ
getHostByNamer�r�r��r%r�r+r+r,�test_getHostByNameOszClientTests.test_getHostByNamecCs t�|j�}|�|jtj�|S)z�
        Do a lookup and test that the resolver will issue the correct type of
        query type. We do this by checking that FakeResolver returns a result
        record with the same query type as what we issued.
        )r�
lookupAddressr�r�r�rr#rr+r+r,�test_lookupAddressWszClientTests.test_lookupAddresscCs t�|j�}|�|jtj�|S�z+
        See L{test_lookupAddress}
        )rZlookupIPV6Addressr�r�r�rZAAAArr+r+r,�test_lookupIPV6Addressasz"ClientTests.test_lookupIPV6AddresscCs t�|j�}|�|jtj�|Sr)rZlookupAddress6r�r�r�rr�rr+r+r,�test_lookupAddress6iszClientTests.test_lookupAddress6cCs t�|j�}|�|jtj�|Sr)rZlookupNameserversr�r�r�rZNSrr+r+r,�test_lookupNameserversqsz"ClientTests.test_lookupNameserverscCs t�|j�}|�|jtj�|Sr)rZlookupCanonicalNamer�r�r�rZCNAMErr+r+r,�test_lookupCanonicalNameysz$ClientTests.test_lookupCanonicalNamecCs t�|j�}|�|jtj�|Sr)rZlookupAuthorityr�r�r�rZSOArr+r+r,�test_lookupAuthority�sz ClientTests.test_lookupAuthoritycCs t�|j�}|�|jtj�|Sr)rZ
lookupMailBoxr�r�r�rZMBrr+r+r,�test_lookupMailBox�szClientTests.test_lookupMailBoxcCs t�|j�}|�|jtj�|Sr)rZlookupMailGroupr�r�r�rZMGrr+r+r,�test_lookupMailGroup�sz ClientTests.test_lookupMailGroupcCs t�|j�}|�|jtj�|Sr)rZlookupMailRenamer�r�r�rZMRrr+r+r,�test_lookupMailRename�sz!ClientTests.test_lookupMailRenamecCs t�|j�}|�|jtj�|Sr)rZ
lookupNullr�r�r�rZNULLrr+r+r,�test_lookupNull�szClientTests.test_lookupNullcCs t�|j�}|�|jtj�|Sr)rZlookupWellKnownServicesr�r�r�rZWKSrr+r+r,�test_lookupWellKnownServices�sz(ClientTests.test_lookupWellKnownServicescCs t�|j�}|�|jtj�|Sr)rZ
lookupPointerr�r�r�rZPTRrr+r+r,�test_lookupPointer�szClientTests.test_lookupPointercCs t�|j�}|�|jtj�|Sr)rZlookupHostInfor�r�r�rZHINFOrr+r+r,�test_lookupHostInfo�szClientTests.test_lookupHostInfocCs t�|j�}|�|jtj�|Sr)rZlookupMailboxInfor�r�r�rZMINFOrr+r+r,�test_lookupMailboxInfo�sz"ClientTests.test_lookupMailboxInfocCs t�|j�}|�|jtj�|Sr)rZlookupMailExchanger�r�r�rZMXrr+r+r,�test_lookupMailExchange�sz#ClientTests.test_lookupMailExchangecCs t�|j�}|�|jtj�|Sr)rZ
lookupTextr�r�r�rZTXTrr+r+r,�test_lookupText�szClientTests.test_lookupTextcCs t�|j�}|�|jtj�|Sr)rZlookupSenderPolicyr�r�r�rZSPFrr+r+r,�test_lookupSenderPolicy�sz#ClientTests.test_lookupSenderPolicycCs t�|j�}|�|jtj�|Sr)rZlookupResponsibilityr�r�r�rZRPrr+r+r,�test_lookupResponsibility�sz%ClientTests.test_lookupResponsibilitycCs t�|j�}|�|jtj�|Sr)rZlookupAFSDatabaser�r�r�rZAFSDBrr+r+r,�test_lookupAFSDatabase�sz"ClientTests.test_lookupAFSDatabasecCs t�|j�}|�|jtj�|Sr)rZ
lookupServicer�r�r�rZSRVrr+r+r,�test_lookupService�szClientTests.test_lookupServicecCs t�|j�}|�|jtj�|Sr)rZ
lookupZoner�r�r�rZAXFRrr+r+r,�test_lookupZone�szClientTests.test_lookupZonecCs t�|j�}|�|jtj�|Sr)rZlookupAllRecordsr�r�r�rZALL_RECORDSrr+r+r,�test_lookupAllRecordssz!ClientTests.test_lookupAllRecordscCs t�|j�}|�|jtj�|Sr)rZlookupNamingAuthorityPointerr�r�r�rZNAPTRrr+r+r,�!test_lookupNamingAuthorityPointersz-ClientTests.test_lookupNamingAuthorityPointercCs.t�|jtj�}t�|�}|�|jtj�|S)a
        L{client.query} accepts a L{dns.Query} instance and dispatches
        it to L{client.theResolver}.C{query}, which in turn dispatches
        to an appropriate C{lookup*} method of L{client.theResolver},
        based on the L{dns.Query} type.
        )rr�r�r#rrAr�r�)r%r�r�r+r+r,�
test_querys
zClientTests.test_queryN) r.r/r0r�r�r�r�rrrrrrr	r
rrr
rrrrrrrrrrrrrrr+r+r+r,r�/s:	
				r�c@sXeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�ZdS)�FilterAnswersTestsz|
    Test L{twisted.names.client.Resolver.filterAnswers}'s handling of various
    error conditions it might encounter.
    cCstjdgd�|_dS)N)z0.0.0.0rr�)rrPrFr3r+r+r,r�(szFilterAnswersTests.setUpcsVtjdd����d���fdd�}|�j_�j���}|��jdgdgdgf�|S)	zf
        Test that a truncated message results in an equivalent request made via
        TCP.
        T)Ztruncr�cs8��|�j�t��}dg|_dg|_dg|_t�|�S)Nr�r)r*)	rWr9rr�r�r)r*r	r$)r9r���mr%r+r,r�6sz:FilterAnswersTests.test_truncatedMessage.<locals>.queryTCPr�r)r*)rr�ZaddQueryrFr��
filterAnswersr�rW)r%r�r�r+rr,�test_truncatedMessage.s
�z(FilterAnswersTests.test_truncatedMessagecCs&tj|d�}|j�|�}|�|�dS)N)ZrCode)rr�rFrr�)r%Zrcode�excr�errr+r+r,�
_rcodeTestDszFilterAnswersTests._rcodeTestcCs|�tjtj�S)z�
        Test that a message with a result code of C{EFORMAT} results in a
        failure wrapped around L{DNSFormatError}.
        )r#rZEFORMATrZDNSFormatErrorr3r+r+r,�test_formatErrorJsz#FilterAnswersTests.test_formatErrorcCs|�tjtj�S)zP
        Like L{test_formatError} but for C{ESERVER}/L{DNSServerError}.
        )r#rZESERVERrZDNSServerErrorr3r+r+r,�test_serverErrorRsz#FilterAnswersTests.test_serverErrorcCs|�tjtj�S)zL
        Like L{test_formatError} but for C{ENAME}/L{DNSNameError}.
        )r#rZENAMErZDNSNameErrorr3r+r+r,�test_nameErrorYsz!FilterAnswersTests.test_nameErrorcCs|�tjtj�S)zX
        Like L{test_formatError} but for C{ENOTIMP}/L{DNSNotImplementedError}.
        )r#rZENOTIMPrZDNSNotImplementedErrorr3r+r+r,�test_notImplementedError`sz+FilterAnswersTests.test_notImplementedErrorcCs|�tjtj�S)zW
        Like L{test_formatError} but for C{EREFUSED}/L{DNSQueryRefusedError}.
        )r#r�EREFUSEDrZDNSQueryRefusedErrorr3r+r+r,�test_refusedErrorgsz$FilterAnswersTests.test_refusedErrorcCs|�tjdtj�S)zm
        Like L{test_formatError} but for an unrecognized error code and
        L{DNSUnknownError}.
        rU)r#rr(rZDNSUnknownErrorr3r+r+r,�test_refusedErrorUnknownnsz+FilterAnswersTests.test_refusedErrorUnknownN)
r.r/r0r5r�r r#r$r%r&r'r)r*r+r+r+r,r#src@s&eZdZdd�Zd	dd�Zdd�ZdS)
�FakeDNSDatagramProtocolcCsg|_t�|_dSr7r8r3r+r+r,r;xsz FakeDNSDatagramProtocol.__init__r<NcCs$|j�||||f�t�t�|��Sr7)r9r>r	r�rr)r%rr9r'r?r+r+r,rA|szFakeDNSDatagramProtocol.querycCsdSr7r+)r%r?r+r+r,�removeResend�sz$FakeDNSDatagramProtocol.removeResend)r<N)r.r/r0r;rAr,r+r+r+r,r+ws
r+c@s4eZdZdZddddgZdd�Zdd	�Zd
d�ZdS)
�RetryLogicTestszE
    Tests for query retrying implemented by L{client.Resolver}.
    z1.2.3.4z4.3.2.1za.b.c.dzz.y.x.wcsNdd�|jD�}tjd|d�}t���fdd�|_|�d��|j��|j	��S)a
        When timeouts occur waiting for responses to queries, the next
        configured server is issued the query.  When the query has been issued
        to all configured servers, the timeout is increased and the process
        begins again at the beginning.
        cSsg|]}|df�qS)rpr+)rR�xr+r+r,rT�sz:RetryLogicTests.test_roundRobinBackoff.<locals>.<listcomp>N)rdrscs�Sr7r+r+�r�r+r,r��r�z8RetryLogicTests.test_roundRobinBackoff.<locals>.<lambda>r�)
�testServersrrPr+r�rr��_cbRoundRobinBackoffr��_ebRoundRobinBackoff)r%ZaddrsrSr+r/r,�test_roundRobinBackoff�s
��z&RetryLogicTests.test_roundRobinBackoffcCs|�d�dS)Nz/Lookup address succeeded, should have timed out)r�r�r+r+r,r1�sz$RetryLogicTests._cbRoundRobinBackoffcCs�|�tj�dD]|}|jdt|j��}|jdt|j��=|��t|j�}|��t||�D],\\}}}}	}
|�	||
df�|�	||�q^q|�
|j�dS)N)rUr���-rp)r�r	�TimeoutErrorr9rXr0�sort�list�ziprWr�)r%rZ	fakeProto�tZtriesZexpectedZaddrrAr'r?ZexpectedAddrr+r+r,r2�s
z$RetryLogicTests._ebRoundRobinBackoffN)r.r/r0r5r0r3r1r2r+r+r+r,r-�s�r-c@seZdZdZdd�ZdS)�ThreadedResolverTestsz/
    Tests for L{client.ThreadedResolver}.
    cCsTt��|j|jgd�}|�|ddd�|�|ddt�|�t|�d�dS)z�
        L{client.ThreadedResolver} is deprecated.  Instantiating it emits a
        deprecation warning pointing at the code that does the instantiation.
        )ZoffendingFunctionsr�messagezztwisted.names.client.ThreadedResolver is deprecated since Twisted 9.0, use twisted.internet.base.ThreadedResolver instead.�categoryrUN)rZThreadedResolverZ
flushWarnings�test_deprecatedrW�DeprecationWarningrX)r%�warningsr+r+r,r>�s
�z%ThreadedResolverTests.test_deprecatedN)r.r/r0r5r>r+r+r+r,r;�sr;)9r5Z
__future__rrZzope.interface.verifyrrZtwisted.pythonrZtwisted.python.filepathrZtwisted.python.runtimerZtwisted.internetr	Ztwisted.internet.errorr
rZtwisted.internet.interfacesrZ#twisted.internet.test.modulehelpersr
Ztwisted.internet.taskrZ
twisted.namesrrrrrZtwisted.names.errorrZtwisted.names.commonrZtwisted.names.test.test_hostsrZtwisted.names.testrZtwisted.testrZ
twisted.trialrZ	isWindowsrLrr�r1r6ZTestCaserBrNryr�rr+r-r;r+r+r+r,�<module>sH|7uT5
@ Telegram