tf2ddZddlmZddlmZddlmZmZmZm 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+dZ,dZ-Gdde+Z.Gdde/Z0dZ1Gdde+Z2gdZ3ee GddZ4ee e4Gdde*Z5GddZ6e(j7e8dZ9d 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)SynchronousTestCaseTestCasec(|\}}}|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. rpayloadresultsansauthadds b/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/twisted/names/test/test_rootresolve.py getOnePayloadr+&s NCs q6>cDt|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&s r* getOneAddressr0/s  ! ! , , . ..r,ceZdZdZdZdZdZgggefdZddZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdS)RootResolverTestsz3 Tests for L{twisted.names.root.Resolver}. ct}tg|}|tdtt dgd|}|j\}}|j\\}}t} | || | j tdtt g| | j g| | jg| | jgg} || j| | g| j dd=d| _| j t'dt)d|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) selffilterr4resolverd portNumber transportpacketaddressmessageresponses r* _queryTestzRootResolverTests._queryTest<s //B000 OO $a , ,/@.A5&   !( 0 8 8 : : I(4 &')) 51CQ+K+K*LMMM "--- *B/// +R000 ho&&& 2&&& OAAA  '+1F1F G G G    ,,W]]__>OPPP{r,c |d\}}}||tdtddg||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. Tr5r9rttlr#N)rTr?rr)rJrFrBrCs r*test_filteredQueryz$RootResolverTests.test_filteredQuerygs)-(=(=% :  X0(;TU:V:V:VWWWX    B''' R(((((r,c ||d}||t||jg||jt dtddg||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. Fr5r9rrVr#N) rTassertIsInstancerr?r@rArrrBrC)rJrRs r*test_unfilteredQueryz&RootResolverTests.test_unfilteredQueryus //%(( gw/// "---  O ((;A2N2N2N O O O P    *B/// +R00000r,ct|}|j|f|j|f|j|ffD]$\}}|d|D%|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 lg|]1\}}t||jt|dt|2S)CLASSr#)rTYPEgetattrr).0namerecords r* z.RootResolverTests._respond..sU'vfk767B+G+GQWr,)rrArBrCextend)rJrArBrCr]rSsectiondatas r*_respondzRootResolverTests._responds'''  w '   +  * -  MGT NN+/     r, cJdg}t||}fd}||_|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. r6ctd|jd||D]P} |}n#t$rYwxYw||jj|jf}t jdi|cSdS)NzQuery for QNAME z at )rrcKeyErrortyperri) queryserverAddressestimeoutrKaddrserverrecordsrJserverResponsess r*rpz-RootResolverTests._getResolver..querys F5:FF?FF G G G' 9 9,T2FFH %*!<=}t}77w7788888  9 9s * 77)rr:)rJrvmaximumQueriesrootsrLrps`` r* _getResolverzRootResolverTests._getResolversH E>22 9 9 9 9 9 9 r,c\dtfdtdfgdtdfgdidtfddtdfgiid}||}|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. r5ns1.example.com 34.55.89.144rBrCrA10.0.0.1)r65)r|rrrrry lookupAddressrDr0r?rJserversrLrMs r*test_lookupAddressz$RootResolverTests.test_lookupAddresss$Q'#5yAS7T7T"U!V$68P8P#Q"R**$Q'!3Xj5I5I JK*#   $$W--  " "#5 6 6 m$$$ d& 333r,ctd}t|_dtfd|fgdt dfgdtdfgdidtfddtdfgiid}||}|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~r5r{10.0.0.2)rArBrCrA10.0.0.3)rrr) rrr_rrryrrDr+r?)rJbadClassrrLrMs r*test_lookupChecksClassz(RootResolverTests.test_lookupChecksClasss J''$Q'!3X >?#5yAS7T7T"U!V$68L8L#M"N**$Q'!3Xj5I5I JK*   $$W--  " "#5 6 6 m$$$ d&(<(<===r,cpdtfddtdfgidtfddtdfgiidtfddtdfgiid}||}|d}|t ||jd|S)z If an intermediate response includes no glue records for the authorities, separate queries are made to find those addresses. r5rBsns1.example.orgrAr~r)r)r~rrrs r*test_missingGluez"RootResolverTests.test_missingGlues$Q'#5yAS7T7T"U!V*$Q'!3Xj5I5I JK* $Q'!3Xj5I5I JK*   $$W--  " "#5 6 6 m$$$ d& 333r,cddtfdtiii}||}|d}||t S)z If a name is missing, L{Resolver.lookupAddress} returns a L{Deferred} which fails with L{DNSNameError}. rr5r])rr ryr assertFailurerrs r*test_missingNamez"RootResolverTests.test_missingNamesd #Q'U* $$W--  " "#5 6 6!!!\222r,cddtfiii}||}|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)rryrrrrs r*test_answerlessz!RootResolverTests.test_answerlesss[ #R  $$W--  " "> 2 2!!!]333r,cddtfddtdfgidtfdtiii}||}|d}||t S)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. rrrBr{r])rrr ryrrrrs r*test_delegationLookupErrorz,RootResolverTests.test_delegationLookupError.s #>9=O3P3P"Q!R&$Q'U*   $$W--  " "> 2 2!!!\222r,cddtfddtdfgidtfiii}||}|d}||t S)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}. rrrBr{)rrryrrrrs r*test_delegationLookupEmptyz,RootResolverTests.test_delegationLookupEmptyBs #>9=O3P3P"Q!R&$Q'  $$W--  " "> 2 2!!!]333r,c 8ddtfdtidtfddtdfgiii}||}|d}d}||||jtd|S)z L{Resolver.lookupNameservers} is like L{Resolver.lookupAddress}, except it queries for I{NS} records instead of I{A} records. rrr]rAr{c2|\}}}|djjSNr)r$rcr%s r* getOneNamez.getOneNamefs$NCsq6>& &r,) rr rrrylookupNameserversrDr?r)rJrrLrMrs r*test_lookupNameserversz(RootResolverTests.test_lookupNameserversTs #U& $;M1N1N OP'   $$W--  & &~ 6 6 ' ' ' j!!! d&-?(@(@AAAr,c ddtfddtdfdtdfgiii}||}|d}|d||jtdttdtdttdg|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. rrrA example.netz10.0.0.7c|dSrrmr/s r*z. gajr,r# rrrryrrDr?rr rs r*test_returnCanonicalNamez*RootResolverTests.test_returnCanonicalNamens #'n)E)EF'*)=)=> &  $$W--  " "> 2 2 00111   ^8T8TUUUHZ4H4HIII    r,c ddtfddtdfgidtfddtdfgiii}||}|d}|d||jtdttdtdttdg|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}. rrrArz10.0.0.5c|dSrrmr/s r*rz.rr,r#rrs r*test_followCanonicalNamez*RootResolverTests.test_followCanonicalNames #n1M1M NO& #*1E1E FG&   $$W--  " "> 2 2 00111   ^8T8TUUUHZ4H4HIII    r,cddtfddtdfdtdfgiii}||}|d}||t S)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}. rrrAr)rrryrrrrs r*test_detectCanonicalNameLoopz.RootResolverTests.test_detectCanonicalNameLoops #'n)E)EF'n)E)EF &  $$W--  " "> 2 2!!!]333r,cdtfddtdfgidtfddtdfgiidtfdtdfgdtdfgdidtfddtd 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. rrBr{rArsns2.example.comrr}z10.0.0.4)rr)rr) rrrryrrrrDr+r?r)rJrfailerfailD succeedersucceedDs r*test_boundedQueriesz%RootResolverTests.test_boundedQueriessq #>9=O3P3P"Q!R& $Q'!3Xj5I5I JK*   ##19=O3P3P"Q!R$68L8L#M"N&&  #*1E1E FG&-  B""7A..""6#7#7#G#GWW%%gq11 **>::]+++T-x /C/CDDDeX.///r,N)rj)__name__ __module__ __qualname____doc__rTrXr[rriryrrrrrrrrrrrrrmr,r*r2r27s3)))V ) ) )111 "RBb>4486333 4 4 4333(444$468444(.0.0.0.0.0r,r2ceZdZdZdZdS)ResolverFactoryArgumentszf Raised by L{raisingResolverFactory} with the *args and **kwargs passed to that function. c"||_||_dS)z Store the supplied args and kwargs as attributes. @param args: Positional arguments. @param kwargs: Keyword arguments. Nargskwargs)rJrrs r*__init__z!ResolverFactoryArguments.__init__s  r,N)rrrrrrmr,r*rrs- r,rc"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. )rrs r*raisingResolverFactoryrs #4 0 00r,c$eZdZdZdZdZdZdS) RootResolverResolverFactoryTestsz6 Tests for L{root.Resolver._resolverFactory}. cttdgt}||jtdS)z L{root.Resolver.__init__} accepts a C{resolverFactory} argument and assigns it to C{self._resolverFactory}. N)hintsresolverFactory)rrassertIs_resolverFactoryrJrs r*#test_resolverFactoryArgumentPresentzDRootResolverResolverFactoryTests.test_resolverFactoryArgumentPresents7 D63I J J J a(*@AAAAAr,crtdg}||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 rs r*"test_resolverFactoryArgumentAbsentzCRootResolverResolverFactoryTests.test_resolverFactoryArgumentAbsents5 D6 " " " a(&/:::::r,ct}tdgt|}|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)rrr4z example.comrm)rr)r4rN) objectrr assertRaisesrrr?rr)rJ dummyReactorres r*)test_resolverFactoryOnlyExpectedArgumentszJRootResolverResolverFactoryTests.test_resolverFactoryOnlyExpectedArgumentss xx  /2       6 W W  \7J6KLL M VQX      r,N)rrrrrrrrmr,r*rr sNBBB;;;     r,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.netceZdZdZdZdZdS) StubResolverz An L{IResolverSimple} implementer which traces all getHostByName calls and their deferred results. The deferred results can be accessed and fired synchronously. c"g|_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)rJs r*rzStubResolver.__init__Ls  r,c|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. )rrErr)rJrrrMs r* getHostByNamezStubResolver.getHostByNameVsC 4.))) JJ ""1%%%r,N)rrrrrrrmr,r*rrDs< !!!r,rc<eZdZdZdZdZdZdZdZdZ dZ d S) BootstrapTestsz% Tests for L{root.bootstrap} ctjt}||tjdS)zl L{root.bootstrap} returns an object which is initially a L{root.DeferredResolver}. N)r bootstraprrZDeferredResolver)rJdeferredResolvers r*test_returnsDeferredResolverz+BootstrapTests.test_returnsDeferredResolverqs8  >,..99 .0EFFFFFr,ct}tj|||jdt DdS)z The L{IResolverSimple} supplied to L{root.bootstrap} is used to lookup the IP addresses of the 13 root name servers. cg|]}|fifSrmrm)rbss r*rez=BootstrapTests.test_resolves13RootServers..s-O-O-OQtRj-O-O-Or,N)rr rr?r ROOT_SERVERS)rJ stubResolvers r*test_resolves13RootServersz)BootstrapTests.test_resolves13RootServersysK $~~  |$$$ +-O-O,-O-O-OPPPPPr,ct}tj|}|jD]}|d||t dS)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 rrcallbackrZrrJrrrMs r*test_becomesResolverz#BootstrapTests.test_becomesResolversa $~~ >,77, & &A JJ} % % % % .99999r,ct}tj|}|jD]}|d||jdgdzdS)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?rrs r*test_resolverReceivesRootHintsz-BootstrapTests.test_resolverReceivesRootHintssk $~~ >,77, & &A JJ} % % % % )/-21EFFFFFr,c@t}tj|t|j}t |}|D]}|d|tfd}| |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}. rcFjdgdzdS)Nr r?rresrrJs r* checkHintszFBootstrapTests.test_continuesWhenSomeRootHintsFail..checkHintss*   -3m_r5I J J J J Jr,N) rr riterrnextrerrbackraddBothrJrr&d1rMrrs` @r*#test_continuesWhenSomeRootHintsFailz2BootstrapTests.test_continuesWhenSomeRootHintsFails $~~ >,77|233 ']] & &A JJ} % % % % <>>""" K K K K K K :r,ct}tj|t|j}t |}|D]#}|t$|tfd}|| 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. c>jgdSNrrs r*rzEBootstrapTests.test_continuesWhenAllRootHintsFail..checkHintss#   -3R 8 8 8 8 8r,N) rr rrrrrrr addCleanupflushLoggedErrorsrs` @r*"test_continuesWhenAllRootHintsFailz1BootstrapTests.test_continuesWhenAllRootHintsFails $~~ >,77|233 ']] & &A IIlnn % % % % <>>""" 9 9 9 9 9 9 : . =====r,ct}tj|t}|jD]}|d||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 rrrrrrrs r*test_passesResolverFactoryz)BootstrapTests.test_passesResolverFactorysr $~~ > *@   , & &A JJ} % % % % &79OPPPPPr,N) rrrrrrrrrrrrmr,r*rrlsGGGQQQ : : : G G G&>>>*QQQQQr,rceZdZdZdZdS)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. ctSr)r)rJakws r*rpzStubDNSDatagramProtocol.querys zzr,N)rrrrrprmr,r*rrs- r,rzbtwisted.names.root.retry is deprecated since Twisted 10.0. Use a Resolver object for retry logic.)categoryrRN):rzope.interfacerzope.interface.verifyrtwisted.internet.deferrrrrtwisted.internet.interfacesr twisted.namesr r twisted.names.dnsr r rrrrrrrrrrrrtwisted.names.errorrrtwisted.names.rootrtwisted.names.test.test_utilrtwisted.python.logr twisted.trialrtwisted.trial.unittestr r!r+r0r2 ExceptionrrrrrrrsuppressDeprecationWarning_retrySuppressionrmr,r*rsD'&&&&&------QQQQQQQQQQQQ777777&&&&&&&& <;;;;;;;''''''666666""""""@@@@@@@@///p0p0p0p0p0p0p0p0f y" 1 1 1' ' ' ' ' x' ' ' T " _!!!!!!!!H O\***cQcQcQcQcQ(cQcQcQL"DM  +r,