U P|j2d @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+Z2ddddddd d!d"d#d$d%d&g Z3ee Gd'd(d(Z4ee e4Gd)d*d*e*Z5Gd+d,d,Z6e(j7e8d-d.Z9d/S)0z. 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. rpayloadresultsZansauthaddr'G/tmp/pip-unpacked-wheel-audpp6lv/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)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)rr_queryrrrZudpPortspopitemZ _sentPacketsrZfromStr assertEqualqueriesanswers authority additional addCallbackappendanswerrr _protocolZdatagramReceivedZtoStr) selffilterr-resolverdZ portNumber transportpacketaddressmessageresponser'r'r( _queryTest<s4        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.r2rZttlr!N)rGr5rr)r>r<r8r9r'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. Fr.r2rrHr!N) rGassertIsInstancerr5r6r7rrr8r9)r>rEr'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!)rZTYPEgetattrr).0namerecordr'r'r( s z.RootResolverTests._respond..)rr7r8r9extend)r>r7r8r9rLrFsectiondatar'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. r/c sntd|jd||D]N}z |}Wntk rBYqYnX||jj|jf}tjf|SdS)NzQuery for QNAME z at )rrPKeyErrortyperrV)queryZserverAddressestimeoutr?addrserverrecordsr>serverResponsesr'r(rZs  z-RootResolverTests._getResolver..query)rr3)r>r`ZmaximumQueriesrootsr@rZr'r_r( _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.144r8r9r710.0.0.1)r/5)rdrhrrrrb lookupAddressr:r+r5r>serversr@rAr'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. rfr.rc10.0.0.2)r7r8r9r710.0.0.3)rgrnrh) rr rMrrrbrjr:r)r5)r>ZbadClassrlr@rAr'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.r8sns1.example.orgr7rfrn)rg)rfrhrirkr'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}. rgr.rL)rr rbrj assertFailurerrkr'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}. rg example.com)rrbrjrsrrkr'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. rgrur8rcrL)rrr rbrjrsrrkr'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}. rgrur8rc)rrrbrjrsrrkr'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. rgrurLr7rccSs|\}}}|djjSNr)r"rPr#r'r'r( getOneNamefs z.getOneName) rr rrrbZlookupNameserversr:r5r)r>rlr@rArzr'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. rgrur7 example.netz10.0.0.7cSs|dSryr'r*r'r'r(z.r! rrrrbrjr:r5rr rkr'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}. rgrur7r|z10.0.0.5cSs|dSryr'r*r'r'r(r}r~z.r!rrkr'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}. rgrur7r|)rrrbrjrsrrkr'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. rur8rcr7rnsns2.example.comrorez10.0.0.4)rgrp)rorh) rrrrbrsrjrr:r)r5r)r>rlZfailerZfailDZ succeederZsucceedDr'r'r(test_boundedQueriess6       !    z%RootResolverTests.test_boundedQueriesN)rW)__name__ __module__ __qualname____doc__rGrIrKrrVrbrmrqrrrtrvrwrxr{rrrrr'r'r'r(r,7s$+ 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)rrrrrr'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_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')rrh)r-rlN) objectrr assertRaisesrrjr5rr)r>Z dummyReactorrer'r'r()test_resolverFactoryOnlyExpectedArgumentss zJRootResolverResolverFactoryTests.test_resolverFactoryOnlyExpectedArgumentsN)rrrrrrrr'r'r'r(r s 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(rLszStubResolver.__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>rrrAr'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 bootstraprrJZDeferredResolver)r>deferredResolverr'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')rOsr'r'r(rRsz=BootstrapTests.test_resolves13RootServers..N)rr rr5r ROOT_SERVERS)r> 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 rrcallbackrJrr>rrrAr'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 rrrr5rrr'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 r5rresrr>r'r( checkHintsszFBootstrapTests.test_continuesWhenSomeRootHintsFail..checkHintsN) rr riterrnextrerrbackraddBothr>rr$d1rArr'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 rrrrrrrZ 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)rr rrrrrrrr'r'r(test_passesResolverFactorys  z)BootstrapTests.test_passesResolverFactoryN) rrrrrrrrrrrr'r'r'r(rls   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(rZszStubDNSDatagramProtocol.queryN)rrrrrZr'r'r'r(rsrzbtwisted.names.root.retry is deprecated since Twisted 10.0. Use a Resolver object for retry logic.)categoryrEN):rZzope.interfacerZzope.interface.verifyrZtwisted.internet.deferrrrrZtwisted.internet.interfacesrZ twisted.namesr r Ztwisted.names.dnsr r r rrrrrrrrrrrZtwisted.names.errorrrZtwisted.names.rootrZtwisted.names.test.test_utilrZtwisted.python.logrZ twisted.trialrZtwisted.trial.unittestrr r)r+r, ExceptionrrrrrrrsuppressDeprecationWarningZ_retrySuppressionr'r'r'r(sX   @     6+$ f