U  W[+d @sdZddlmZddlmZddlmZddlmZddl m Z m Z ddl m Z mZmZmZddlmZdd lmZmZdd lmZdd lmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(m)Z)dd l*m+Z+ddZ,ddZ-Gddde Z.Gddde/Z0ddZ1Gddde Z2ddddddd d!d"d#d$d%d&g Z3eeGd'd(d(e4Z5eee5Gd)d*d*e Z6Gd+d,d,Z7ej8e9d-d.Z:d/S)0z. Test cases for Twisted.names' root resolver. ) implementer) verifyClass)msg)util)SynchronousTestCaseTestCase)Deferredsucceed gatherResults TimeoutError)IResolverSimple)clientroot)Resolver)INHSANSCNAMEOKENAME Record_CNAMENameQueryMessageRRHeaderRecord_A Record_NS) DNSNameError ResolverError) MemoryReactorcCs|\}}}|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. rpayloadresultsZansZauthaddr&E/usr/lib/python3/dist-packages/twisted/names/test/test_rootresolve.py getOnePayloads 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(Z dottedQuadr$r&r&r' getOneAddress#sr*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)r r_queryrrrZudpPortspopitemZ _sentPacketsrZfromStr assertEqualqueriesanswers authority additional addCallbackappendanswerrrZ _protocolZdatagramReceivedZtoStr) selffilterr,resolverdZ portNumberZ transportZpacketZaddressmessageresponser&r&r' _queryTest0s<        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. Tr-r1rZttlr!N)rBr4rr)r<r;r7r8r&r&r'test_filteredQuery\s 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. Fr-r1rrCr!N) rBassertIsInstancerr4r5r6rrr7r8)r<r@r&r&r'test_unfilteredQueryks  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!)rZTYPEgetattrr).0namerecordr&r&r' sz.RootResolverTests._respond..)rr6r7r8extend)r<r6r7r8rGrAZsectiondatar&r&r'_respond{s    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. r.c sjtd|j|f|D]N}z |}Wntk r>YqYnX||jj|jf}tjf|SdS)NzQuery for QNAME %s at %r)rrKKeyErrortyper rP)queryZserverAddressesZtimeoutr=ZaddrZserverZrecordsr<serverResponsesr&r'rTs  z-RootResolverTests._getResolver..query)rr2)r<rVZmaximumQueriesrootsr>rTr&rUr' _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. r-ns1.example.com 34.55.89.144r7r8r610.0.0.1)r.5)rZr^rrrrX lookupAddressr9r*r4r<serversr>r?r&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. r\r-rY10.0.0.2)r6r7r8r610.0.0.3)r]rdr^) rrrHrrrXr`r9r(r4)r<ZbadClassrbr>r?r&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. r-r7sns1.example.orgr6r\rd)r])r\r^r_rar&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}. r]r-rG)rrrXr` assertFailurerrar&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}. r] example.com)rrXr`rirrar&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. r]rkr7rYrG)rrrrXr`rirrar&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}. r]rkr7rY)rrrXr`rirrar&r&r'test_delegationLookupEmpty:s   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. r]rkrGr6rYcSs|\}}}|djjSNr)r"rKr#r&r&r' getOneName_s z.getOneName) rrrrrXZlookupNameserversr9r4r)r<rbr>r?rpr&r&r'test_lookupNameserversNs"    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. r]rkr6 example.netz10.0.0.7cSs|dSror&r)r&r&r'vz.r! rrrrXr`r9r4rrrar&r&r'test_returnCanonicalNamegs&    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}. r]rkr6rrz10.0.0.5cSs|dSror&r)r&r&r'rsrtz.r!rurar&r&r'test_followCanonicalName~s*    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}. r]rkr6rr)rrrXr`rirrar&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. rkr7rYr6rdsns2.example.comrer[z10.0.0.4)r]rf)rer^) rrrrXrir`rr9r(r4r )r<rbZfailerZfailDZ succeederZsucceedDr&r&r'test_boundedQueriess<       !    z%RootResolverTests.test_boundedQueriesN)rQ)__name__ __module__ __qualname____doc__rBrDrFrrPrXrcrgrhrjrlrmrnrqrvrwrxr{r&r&r&r'r+,s$, r+c@seZdZdZddZdS)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)r<rrr&r&r'__init__sz!ResolverFactoryArguments.__init__N)r|r}r~rrr&r&r&r'rsrcOst||dS)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. N)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_resolverFactoryr<rr&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_resolverFactoryArgumentAbsent s 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&)rr^)r,rbN) objectrrZ assertRaisesrr`r4rr)r<Z dummyReactorrer&r&r')test_resolverFactoryOnlyExpectedArgumentss zJRootResolverResolverFactoryTests.test_resolverFactoryOnlyExpectedArgumentsN)r|r}r~rrrrr&r&r&r'rs  rza.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)r<r&r&r'rAszStubResolver.__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)r<rrr?r&r&r' getHostByNameLs  zStubResolver.getHostByNameN)r|r}r~rrrr&r&r&r'r:s 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 bootstraprrEZDeferredResolver)r<deferredResolverr&r&r'test_returnsDeferredResolverhs 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&)rJsr&r&r'rMzsz=BootstrapTests.test_resolves13RootServers..N)rrrr4r ROOT_SERVERS)r< stubResolverr&r&r'test_resolves13RootServersqs   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)rrrrcallbackrErr<rrr?r&r&r'test_becomesResolver}s    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)rrrrrr4rrr&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 r4rresrr<r&r' checkHintsszFBootstrapTests.test_continuesWhenSomeRootHintsFail..checkHintsN) rrriterrnextrerrbackr addBothr<rr$Zd1r?rr&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) rrrrrrrr rZ addCleanupZflushLoggedErrorsrr&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)rrrrrrrrrr&r&r'test_passesResolverFactorys  z)BootstrapTests.test_passesResolverFactoryN) r|r}r~rrrrrrrrr&r&r&r'rds    rc@seZdZdZddZdS)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)r<akwr&r&r'rTszStubDNSDatagramProtocol.queryN)r|r}r~rrTr&r&r&r'rsrzbtwisted.names.root.retry is deprecated since Twisted 10.0. Use a Resolver object for retry logic.)categoryr@N);rZzope.interfacerZzope.interface.verifyrZtwisted.python.logrZ twisted.trialrZtwisted.trial.unittestrrZtwisted.internet.deferrr r r Ztwisted.internet.interfacesr Z twisted.namesr rZtwisted.names.rootrZtwisted.names.dnsrrrrrrrrrrrrrrZtwisted.names.errorrrZtwisted.names.test.test_utilr r(r*r+ ExceptionrrrrrrrrsuppressDeprecationWarningZ_retrySuppressionr&r&r&r'sX      @   5,% l