o b4d@sdZddlmZddlmZddlmZmZmZm Z ddl m Z ddl m Z mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZm Z dd l!m"Z"dd l#m$Z$dd l%m&Z&dd l'm(Z(dd l)m*Z*m+Z+ddZ,ddZ-Gddde+Z.Gddde/Z0ddZ1Gddde+Z2gdZ3ee GdddZ4ee e4Gddde*Z5Gdd d Z6e(j7e8d!d"Z9d#S)$z. Test cases for Twisted.names' root resolver. ) implementer) verifyClass)Deferred TimeoutError gatherResultssucceed)IResolverSimple)clientroot)CNAMEENAMEHSINNSOKAMessageNameQueryRecord_A Record_CNAME Record_NSRRHeader) DNSNameError ResolverError)Resolver) MemoryReactor)msg)util)SynchronousTestCaseTestCasecCs|\}}}|djS)z From the result of a L{Deferred} returned by L{IResolver.lookupAddress}, return the payload of the first record in the answer section. rpayloadresultsansauthaddr(E/usr/lib/python3/dist-packages/twisted/names/test/test_rootresolve.py getOnePayload&s  r*cCs t|S)z From the result of a L{Deferred} returned by L{IResolver.lookupAddress}, return the first IPv4 address from the answer section. )r* dottedQuadr$r(r(r) getOneAddress/s r-c@seZdZdZddZddZddZgggefdd Zd&d d Z d dZ ddZ ddZ ddZ ddZddZddZddZddZdd Zd!d"Zd#d$Zd%S)'RootResolverTestsz3 Tests for L{twisted.names.root.Resolver}. c Cst}tg|d}|tdttdgd|}|j\}}|j\\}}t } | || | j tdttg| | j g| | jg| | jgg} || j| | g| j dd=d| _| j tdtdd|j| d| d S) aK Invoke L{Resolver._query} and verify that it sends the correct DNS query. Deliver a canned response to the query and return whatever the L{Deferred} returned by L{Resolver._query} fires with. @param filter: The value to pass for the C{filter} parameter to L{Resolver._query}. )reactorfoo.example.com)1.1.2.3i)N 5.8.13.21r!r)rr_queryrrrudpPortspopitem _sentPacketsrfromStr assertEqualqueriesanswers authority additional addCallbackappendanswerrr _protocoldatagramReceivedtoStr) selffilterr/resolverd portNumber transportpacketaddressmessageresponser(r(r) _queryTest<s.      zRootResolverTests._queryTestc CsJ|d\}}}||tdtddddg||g||gdS)a) L{Resolver._query} accepts a L{Query} instance and an address, issues the query, and returns a L{Deferred} which fires with the response to the query. If a true value is passed for the C{filter} parameter, the result is a three-tuple of lists of records. Tr0r4rttlr!N)rOr:rr)rErAr=r>r(r(r)test_filteredQuerygs  z$RootResolverTests.test_filteredQueryc Csd|d}||t||jg||jtdtddddg||jg||j gdS)z Similar to L{test_filteredQuery}, but for the case where a false value is passed for the C{filter} parameter. In this case, the result is a L{Message} instance. Fr0r4rrPr!N) rOassertIsInstancerr:r;r<rrr=r>)rErMr(r(r)test_unfilteredQueryus  z&RootResolverTests.test_unfilteredQuerycCsHt|d}|j|f|j|f|j|ffD]\}}|dd|Dq|S)a Create a L{Message} suitable for use as a response to a query. @param answers: A C{list} of two-tuples giving data for the answers section of the message. The first element of each tuple is a name for the L{RRHeader}. The second element is the payload. @param authority: A C{list} like C{answers}, but for the authority section of the response. @param additional: A C{list} like C{answers}, but for the additional section of the response. @param rCode: The response code the message will be created with. @return: A new L{Message} initialized with the given values. )rCodec Ss*g|]\}}t||jt|dt|dqS)CLASSr!)rTYPEgetattrr).0namerecordr(r(r) s z.RootResolverTests._respond..)rr<r=r>extend)rEr<r=r>rUrNsectiondatar(r(r)_responds  zRootResolverTests._respond cs(dg}t||}fdd}||_|S)a Create and return a new L{root.Resolver} modified to resolve queries against the record data represented by C{servers}. @param serverResponses: A mapping from dns server addresses to mappings. The inner mappings are from query two-tuples (name, type) to dictionaries suitable for use as **arguments to L{_respond}. See that method for details. r1c sltd|jd||D]&}z|}Wn tyYq w||jj|jf}tjdi|SdS)NzQuery for QNAME z at r()rrZKeyErrortyperr`)queryserverAddressestimeoutrFaddrserverrecordsrEserverResponsesr(r)rds  z-RootResolverTests._getResolver..query)rr5)rErkmaximumQueriesrootsrGrdr(rjr) _getResolvers   zRootResolverTests._getResolvercCsrdtfdtdfgdtdfgdidtfddtdfgiid}||}|d}|t||jd|S)a L{root.Resolver.lookupAddress} looks up the I{A} records for the specified hostname by first querying one of the root servers the resolver was created with and then following the authority delegations until a result is received. r0ns1.example.com 34.55.89.144r=r>r<10.0.0.1)r15)rprtrrrrn lookupAddressr?r-r:rEserversrGrHr(r(r)test_lookupAddresss    z$RootResolverTests.test_lookupAddresscCstd}t|_dtfd|fgdtdfgdtdfgdidtfddtdfgiid}||}|d}|t||j td|S) z If a response includes a record with a class different from the one in the query, it is ignored and lookup continues until a record with the right class is found. rrr0ro10.0.0.2)r<r=r>r<10.0.0.3)rsrzrt) rr rVrrrnrvr?r*r:)rEbadClassrxrGrHr(r(r)test_lookupChecksClasss$     z(RootResolverTests.test_lookupChecksClasscCs|dtfddtdfgidtfddtdfgiidtfddtdfgiid}||}|d}|t||jd|S)z If an intermediate response includes no glue records for the authorities, separate queries are made to find those addresses. r0r=sns1.example.orgr<rrrz)rs)rrrtrurwr(r(r)test_missingGlues"    z"RootResolverTests.test_missingGluecCs4ddtfdtiii}||}|d}||tS)z If a name is missing, L{Resolver.lookupAddress} returns a L{Deferred} which fails with L{DNSNameError}. rsr0rU)rr rnrv assertFailurerrwr(r(r)test_missingNames   z"RootResolverTests.test_missingNamecCs0ddtfiii}||}|d}||tS)z If a query is responded to with no answers or nameserver records, the L{Deferred} returned by L{Resolver.lookupAddress} fires with L{ResolverError}. rs example.com)rrnrvrrrwr(r(r)test_answerlesss   z!RootResolverTests.test_answerlesscCsJddtfddtdfgidtfdtiii}||}|d}||tS)z If there is an error resolving the nameserver in a delegation response, the L{Deferred} returned by L{Resolver.lookupAddress} fires with that error. rsrr=rorU)rrr rnrvrrrwr(r(r)test_delegationLookupError.s  z,RootResolverTests.test_delegationLookupErrorcCsFddtfddtdfgidtfiii}||}|d}||tS)z If there are no records in the response to a lookup of a delegation nameserver, the L{Deferred} returned by L{Resolver.lookupAddress} fires with L{ResolverError}. rsrr=ro)rrrnrvrrrwr(r(r)test_delegationLookupEmptyBs   z,RootResolverTests.test_delegationLookupEmptycCsfddtfdtidtfddtdfgiii}||}|d}dd}||||jtd|S)z L{Resolver.lookupNameservers} is like L{Resolver.lookupAddress}, except it queries for I{NS} records instead of I{A} records. rsrrUr<rocSs|\}}}|djjSNr)r"rZr#r(r(r) getOneNamefs  z.getOneName) rr rrrnlookupNameserversr?r:r)rErxrGrHrr(r(r)test_lookupNameserversTs  z(RootResolverTests.test_lookupNameserversc Cs|ddtfddtdfdtdfgiii}||}|d}|dd||jtdttddtdttddg|S) z If a I{CNAME} record is encountered as the answer to a query for another record type, that record is returned as the answer. rsrr< example.netz10.0.0.7cS|dSrr(r,r(r(r)z.r! rrrrnrvr?r:rr rwr(r(r)test_returnCanonicalNamens&   z*RootResolverTests.test_returnCanonicalNamec Csddtfddtdfgidtfddtdfgiii}||}|d}|dd||jtdttddtdttddg|S) z If no record of the requested type is included in a response, but a I{CNAME} record for the query name is included, queries are made to resolve the value of the I{CNAME}. rsrr<rz10.0.0.5cSrrr(r,r(r(r)rrz.r!rrwr(r(r)test_followCanonicalNames& z*RootResolverTests.test_followCanonicalNamecCsHddtfddtdfdtdfgiii}||}|d}||tS)z If there is a cycle between I{CNAME} records in a response, this is detected and the L{Deferred} returned by the lookup method fails with L{ResolverError}. rsrr<r)rrrnrvrrrwr(r(r)test_detectCanonicalNameLoops    z.RootResolverTests.test_detectCanonicalNameLoopcCsdtfddtdfgidtfddtdfgiidtfdtdfgdtdfgdidtfddtd fgiid }||d }||dt}||d }|d}|t||j td t ||gS) z L{Resolver.lookupAddress} won't issue more queries following delegations than the limit passed to its initializer. rr=ror<rzsns2.example.comr{rqz10.0.0.4)rsr|)r{rt) rrrrnrrvrr?r*r:r)rErxfailerfailD succeedersucceedDr(r(r)test_boundedQueriess0     !    z%RootResolverTests.test_boundedQueriesN)ra)__name__ __module__ __qualname____doc__rOrRrTrr`rnryr~rrrrrrrrrrr(r(r(r)r.7s&+  r.c@eZdZdZddZdS)ResolverFactoryArgumentszf Raised by L{raisingResolverFactory} with the *args and **kwargs passed to that function. cCs||_||_dS)z Store the supplied args and kwargs as attributes. @param args: Positional arguments. @param kwargs: Keyword arguments. Nargskwargs)rErrr(r(r)__init__ z!ResolverFactoryArguments.__init__N)rrrrrr(r(r(r)r rcOs t||)a= Raise a L{ResolverFactoryArguments} exception containing the positional and keyword arguments passed to resolverFactory. @param args: A L{list} of all the positional arguments supplied by the caller. @param kwargs: A L{list} of all the keyword arguments supplied by the caller. )rrr(r(r)raisingResolverFactorys rc@s(eZdZdZddZddZddZdS) RootResolverResolverFactoryTestsz6 Tests for L{root.Resolver._resolverFactory}. cCs tdgtd}||jtdS)z L{root.Resolver.__init__} accepts a C{resolverFactory} argument and assigns it to C{self._resolverFactory}. N)hintsresolverFactory)rrassertIs_resolverFactoryrErr(r(r)#test_resolverFactoryArgumentPresentszDRootResolverResolverFactoryTests.test_resolverFactoryArgumentPresentcCs tdgd}||jtjdS)z L{root.Resolver.__init__} sets L{client.Resolver} as the C{_resolverFactory} if a C{resolverFactory} argument is not supplied. N)r)rrrr rr(r(r)"test_resolverFactoryArgumentAbsents zCRootResolverResolverFactoryTests.test_resolverFactoryArgumentAbsentcCsJt}tdgt|d}|t|jd}|d|dgdf|j|jfdS)zy L{root.Resolver._resolverFactory} is supplied with C{reactor} and C{servers} keyword arguments. 192.0.2.101)rrr/z example.comr()rrt)r/rxN) objectrr assertRaisesrrvr:rr)rE dummyReactorrer(r(r))test_resolverFactoryOnlyExpectedArgumentss zJRootResolverResolverFactoryTests.test_resolverFactoryOnlyExpectedArgumentsN)rrrrrrrr(r(r(r)r s  r) za.root-servers.netzb.root-servers.netzc.root-servers.netzd.root-servers.netze.root-servers.netzf.root-servers.netzg.root-servers.netzh.root-servers.netzi.root-servers.netzj.root-servers.netzk.root-servers.netzl.root-servers.netzm.root-servers.netc@s eZdZdZddZddZdS) StubResolverz An L{IResolverSimple} implementer which traces all getHostByName calls and their deferred results. The deferred results can be accessed and fired synchronously. cCsg|_g|_dS)z @type calls: L{list} of L{tuple} containing C{args} and C{kwargs} supplied to C{getHostByName} calls. @type pendingResults: L{list} of L{Deferred} returned by C{getHostByName}. N)callspendingResults)rEr(r(r)rLrzStubResolver.__init__cOs&|j||ft}|j||S)al A fake implementation of L{IResolverSimple.getHostByName} @param args: A L{list} of all the positional arguments supplied by the caller. @param kwargs: A L{list} of all the keyword arguments supplied by the caller. @return: A L{Deferred} which may be fired later from the test fixture. )rr@rr)rErrrHr(r(r) getHostByNameVs  zStubResolver.getHostByNameN)rrrrrrr(r(r(r)rDs rc@sHeZdZdZddZddZddZdd Zd d Zd d Z ddZ dS)BootstrapTestsz% Tests for L{root.bootstrap} cCstt}||tjdS)zl L{root.bootstrap} returns an object which is initially a L{root.DeferredResolver}. N)r bootstraprrSDeferredResolver)rEdeferredResolverr(r(r)test_returnsDeferredResolverqs z+BootstrapTests.test_returnsDeferredResolvercCs,t}t|||jddtDdS)z The L{IResolverSimple} supplied to L{root.bootstrap} is used to lookup the IP addresses of the 13 root name servers. cSsg|]}|fifqSr(r()rYsr(r(r)r\sz=BootstrapTests.test_resolves13RootServers..N)rr rr:r ROOT_SERVERS)rE stubResolverr(r(r)test_resolves13RootServersys z)BootstrapTests.test_resolves13RootServerscCs6t}t|}|jD]}|dq ||tdS)z The L{root.DeferredResolver} initially returned by L{root.bootstrap} becomes a L{root.Resolver} when the supplied resolver has successfully looked up all root hints. rN)rr rrcallbackrSrrErrrHr(r(r)test_becomesResolvers    z#BootstrapTests.test_becomesResolvercCs>t}t|}|jD]}|dq ||jdgddS)z The L{root.Resolver} which eventually replaces L{root.DeferredResolver} is supplied with the IP addresses of the 13 root servers. r N)rr rrrr:rrr(r(r)test_resolverReceivesRootHintss    z-BootstrapTests.test_resolverReceivesRootHintscs^t}t|t|j}t|}|D]}|dq|tfdd}| |dS)z The L{root.Resolver} is eventually created, even if some of the root hint lookups fail. Only the working root hint IP addresses are supplied to the L{root.Resolver}. rcsjdgddS)Nr r:rresrrEr(r) checkHintsszFBootstrapTests.test_continuesWhenSomeRootHintsFail..checkHintsN) rr riterrnextrerrbackraddBothrErr$d1rHrr(rr)#test_continuesWhenSomeRootHintsFails    z2BootstrapTests.test_continuesWhenSomeRootHintsFailcsnt}t|t|j}t|}|D]}|tq|tfdd}|| j tdS)z The L{root.Resolver} is eventually created, even if all of the root hint lookups fail. Pending and new lookups will then fail with AttributeError. csjgdSNrrrr(r)rszEBootstrapTests.test_continuesWhenAllRootHintsFail..checkHintsN) rr rrrrrrr addCleanupflushLoggedErrorsrr(rr)"test_continuesWhenAllRootHintsFails    z1BootstrapTests.test_continuesWhenAllRootHintsFailcCs<t}tj|td}|jD]}|dq ||jtdS)z L{root.bootstrap} accepts a C{resolverFactory} argument which is passed as an argument to L{root.Resolver} when it has successfully looked up root hints. )rrN)rr rrrrrrrr(r(r)test_passesResolverFactorys  z)BootstrapTests.test_passesResolverFactoryN) rrrrrrrrrrrr(r(r(r)rls    rc@r)StubDNSDatagramProtocolz A do-nothing stand-in for L{DNSDatagramProtocol} which can be used to avoid network traffic in tests where that kind of thing doesn't matter. cOstSr)r)rEakwr(r(r)rdszStubDNSDatagramProtocol.queryN)rrrrrdr(r(r(r)rrrzbtwisted.names.root.retry is deprecated since Twisted 10.0. Use a Resolver object for retry logic.)categoryrMN):rzope.interfacerzope.interface.verifyrtwisted.internet.deferrrrrtwisted.internet.interfacesr twisted.namesr r twisted.names.dnsr r r rrrrrrrrrrrtwisted.names.errorrrtwisted.names.rootrtwisted.names.test.test_utilrtwisted.python.logr twisted.trialrtwisted.trial.unittestrr r*r-r. ExceptionrrrrrrrsuppressDeprecationWarning_retrySuppressionr(r(r(r)s@   @     6* $f