֛h2dSrSSKJr SSKJr SSKJrJrJrJ r SSK J r SSK J r Jr SSKJrJrJrJrJrJrJrJrJrJrJrJrJrJr SSKJrJ r SS K!J"r" SS K#J$r$ SS K%J&r& SS K'J(r( SS K)J*r*J+r+ Sr,Sr-"SS\+5r."SS\/5r0Sr1"SS\+5r2/SQr3\"\ 5"SS55r4\"\ \45 "SS\*5r5"SS5r6\(Rn"\8SS9r9g )!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*UupnUSR$)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 gC:\Users\psant\Downloads\Noiseback\school\venv\Lib\site-packages\twisted/names/test/test_rootresolve.py getOnePayloadr+&s NCs q6>>c4[U5R5$)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,c\rSrSrSrSrSrSr///\4Sjr SSjr Sr S r S r S rS rS rSrSrSrSrSrSrSrg)RootResolverTests7z+ Tests for L{twisted.names.root.Resolver}. cP[5n[/US9nUR[S[[ 5S/SU5nUR R5upVURuupx[5n U RU5 URU R[S[[ 5/5 URU R/5 URU R/5 URU R/5 /n UR!U R"5 URU /5 U RSS2 SU lU RR#['S[)S5S95 UR*R-U R/5S5 U S $) a 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) selffilterr5resolverd portNumber transportpacketaddressmessageresponses r* _queryTestRootResolverTests._queryTest<sc /B0 OO $a ,/@.A5&  !( 0 0 8 8 : (44 &) 51CQ+K*LM "- **B/ ++R0 hoo& 2& OOA  '+1F G  ,,W]]_>OP{r,c URS5upnURU[S[SSS9S9/5 URU/5 URU/5 g)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. Tr6r:rttlr#N)rUr@rr)rKrGrCrDs r*test_filteredQuery$RootResolverTests.test_filteredQuerygs_)-(=%:  X0(;TU:VWX  B' R(r,c TURS5nURU[5 URUR/5 URUR [ S[SSS9S9/5 URUR/5 URUR/5 g)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. Fr6r:rrXr#N) rUassertIsInstancerr@rArBrrrCrD)rKrSs r*test_unfilteredQuery&RootResolverTests.test_unfilteredQueryus //%( gw/ "-  OO ((;A2N O P  **B/ ++R0r,c[US9nURU4URU4URU44HMupgUR UVV s/sH)up[ XR [U S[5U S9PM+ sn n5 MO U$s sn nf)aK 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. )rCodeCLASSr#) rrBrCrDextendrTYPEgetattrr) rKrBrCrDrarTsectiondatanamerecords r*_respondRootResolverTests._responds'   w '    +  * - MG NN +/ +/kk767B+GQW+/    s0B c@^^S/n[X25nUU4SjnXTlU$)ah 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. r7c>[SURSU<35 UHHnTUnXPRRUR4n[ TR "S0UD65s $ g![a MZf=f)NzQuery for QNAME z at )rrhKeyErrortyperrj) queryserverAddressestimeoutrLaddrserverrecordsrKserverResponsess r*rq-RootResolverTests._getResolver..querys} "5::,d?2EF G',T2F!%**!<=t}}7w788 ( sA-- A;:A;)rr;)rKrwmaximumQueriesrootsrMrqs`` r* _getResolverRootResolverTests._getResolvers' E2 9 r,c(S[4S[S54/S[S54/S.0S[4SS[S54/00S.nURU5nUR S5nUR [ 5 UR URS5 U$)z 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. r6ns1.example.com 34.55.89.144rCrDrB10.0.0.1)r75)rrrrrr{ lookupAddressrEr0r@rKserversrMrNs r*test_lookupAddress$RootResolverTests.test_lookupAddresss$Q'#5yAS7T"U!V$68P#Q"R*$Q'!3Xj5I JK*#  $$W-  " "#5 6 m$ d&& 3r,cn[S5n[UlS[4SU4/S[ S54/S[S54/S.0S[4SS[S54/00S.nUR U5nUR S5nUR[5 URUR[S55 U$) 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. rr6r~10.0.0.2)rBrCrDrB10.0.0.3)rrr) rrrbrrr{rrEr+r@)rKbadClassrrMrNs r*test_lookupChecksClass(RootResolverTests.test_lookupChecksClasss J'$Q'!3X >?#5yAS7T"U!V$68L#M"N*$Q'!3Xj5I JK*  $$W-  " "#5 6 m$ d&&(<=r,c:S[4SS[S54/0S[4SS[S54/00S[4SS[S54/00S.nURU5nUR S5nUR [ 5 UR URS5 U$)z~ If an intermediate response includes no glue records for the authorities, separate queries are made to find those addresses. r6rCsns1.example.orgrBrr)r)rrrrs r*test_missingGlue"RootResolverTests.test_missingGlues$Q'#5yAS7T"U!V*$Q'!3Xj5I JK* $Q'!3Xj5I JK*  $$W-  " "#5 6 m$ d&& 3r,cSS[4S[000nURU5nURS5nUR U[ 5$)zi If a name is missing, L{Resolver.lookupAddress} returns a L{Deferred} which fails with L{DNSNameError}. rr6ra)rr r{r assertFailurerrs r*test_missingName"RootResolverTests.test_missingNames[ #Q'U* $$W-  " "#5 6!!!\22r,cSS[4000nURU5nURS5nURU[5$)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)rr{rrrrs r*test_answerless!RootResolverTests.test_answerlesssR #R  $$W-  " "> 2!!!]33r,cSS[4SS[S54/0S[4S[000nURU5nUR S5nUR U[ 5$)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. rrrCr~ra)rrr r{rrrrs r*test_delegationLookupError,RootResolverTests.test_delegationLookupError.s| #>9=O3P"Q!R&$Q'U*   $$W-  " "> 2!!!\22r,cSS[4SS[S54/0S[4000nURU5nURS5nUR U[ 5$)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}. rrrCr~)rrr{rrrrs r*test_delegationLookupEmpty,RootResolverTests.test_delegationLookupEmptyBst #>9=O3P"Q!R&$Q'  $$W-  " "> 2!!!]33r,c  SS[4S[0S[4SS[S54/000nUR U5nUR S5nSnUR U5 UR UR[S55 U$)z L{Resolver.lookupNameservers} is like L{Resolver.lookupAddress}, except it queries for I{NS} records instead of I{A} records. rrrarBr~c>UupnUSRR$Nr)r$rhr%s r* getOneName.getOneNamefs$NCsq6>>&& &r,) rr rrr{lookupNameserversrEr@r)rKrrMrNrs r*test_lookupNameservers(RootResolverTests.test_lookupNameserversTs #U& $;M1N OP'   $$W-  & &~ 6 ' j! d&&-?(@Ar,c NSS[4SS[S54S[S54/000nURU5nUR S5nUR S5 UR UR [S[[S5S9[S[[S5S9/5 U$)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. rrrB example.netz10.0.0.7c US$rrnr/s r*.gajr,r# rrrr{rrEr@rr rs r*test_returnCanonicalName*RootResolverTests.test_returnCanonicalNamens #'n)EF'*)=> &  $$W-  " "> 2 01    ^8TUHZ4HI  r,c bSS[4SS[S54/0S[4SS[S54/000nURU5nUR S5nUR S5 UR UR [S[[S5S9[S[[S5S9/5 U$)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}. rrrBrz10.0.0.5c US$rrnr/s r*r.rr,r#rrs r*test_followCanonicalName*RootResolverTests.test_followCanonicalNames #n1M NO& #*1E FG&   $$W-  " "> 2 01    ^8TUHZ4HI  r,cSS[4SS[S54S[S54/000nURU5nURS5nUR U[ 5$)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}. rrrBr)rrr{rrrrs r*test_detectCanonicalNameLoop.RootResolverTests.test_detectCanonicalNameLoopsw #'n)EF'n)EF &  $$W-  " "> 2!!!]33r,cS[4SS[S54/0S[4SS[S54/00S[4S[S54/S[S54/S.0S[4SS[S 54/00S .nURUS 5nUR UR S5[ 5nURUS 5nUR S5nUR[5 URUR[S 55 [X5/5$) zt L{Resolver.lookupAddress} won't issue more queries following delegations than the limit passed to its initializer. rrCr~rBrsns2.example.comrrz10.0.0.4)rr)rr) rrrr{rrrrEr+r@r)rKrfailerfailD succeedersucceedDs r*test_boundedQueries%RootResolverTests.test_boundedQueriess8 #>9=O3P"Q!R& $Q'!3Xj5I JK*   ##19=O3P"Q!R$68L#M"N&  #*1E FG&- B""7A.""6#7#7#GW%%gq1 **>:]+T--x /CDe.//r,rnN) )__name__ __module__ __qualname____firstlineno____doc__rUrZr^rrjr{rrrrrrrrrrrr__static_attributes__rnr,r*r2r27sh)V )1 "RBb>44863 43(4$4684(.0r,r2c\rSrSrSrSrSrg)ResolverFactoryArgumentsizZ Raised by L{raisingResolverFactory} with the *args and **kwargs passed to that function. cXlX lg)zy Store the supplied args and kwargs as attributes. @param args: Positional arguments. @param kwargs: Keyword arguments. Nargskwargs)rKrrs r*__init__!ResolverFactoryArguments.__init__s  r,rN)rrrrrrrrnr,r*rrs  r,rc[X5e)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 00r,c*\rSrSrSrSrSrSrSrg) RootResolverResolverFactoryTestsi z. Tests for L{root.Resolver._resolverFactory}. cb[S/[S9nURUR[5 g)zm L{root.Resolver.__init__} accepts a C{resolverFactory} argument and assigns it to C{self._resolverFactory}. N)hintsresolverFactory)rrassertIs_resolverFactoryrKrs r*#test_resolverFactoryArgumentPresentDRootResolverResolverFactoryTests.test_resolverFactoryArgumentPresents( D63I J a((*@Ar,cl[S/S9nURUR[R5 g)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_resolverFactoryArgumentAbsentCRootResolverResolverFactoryTests.test_resolverFactoryArgumentAbsents( D6 " a((&//:r,c[5n[S/[US9nUR[UR S5nUR SUS/S.4URUR45 g)za L{root.Resolver._resolverFactory} is supplied with C{reactor} and C{servers} keyword arguments. 192.0.2.101)rrr5z example.comrn)rr)r5rN) objectrr assertRaisesrrr@rr)rK dummyReactorres r*)test_resolverFactoryOnlyExpectedArgumentsJRootResolverResolverFactoryTests.test_resolverFactoryOnlyExpectedArgumentssj x  /2     6 W  \7J6KL M VVQXX  r,rnN) rrrrrrrrrrnr,r*rr sB; 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.netc$\rSrSrSrSrSrSrg) StubResolveriDz An L{IResolverSimple} implementer which traces all getHostByName calls and their deferred results. The deferred results can be accessed and fired synchronously. c /Ul/Ulg)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}. NcallspendingResults)rKs r*rStubResolver.__init__Ls  r,cURRX45 [5nURRU5 U$)a, 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. )rrFrr)rKrrrNs r* getHostByNameStubResolver.getHostByNameVs8 4.) J ""1%r,rN)rrrrrrrrrnr,r*rrDs !r,rcB\rSrSrSrSrSrSrSrSr Sr S r S r g ) BootstrapTestsilz Tests for L{root.bootstrap} c[R"[55nURU[R5 g)zT L{root.bootstrap} returns an object which is initially a L{root.DeferredResolver}. N)r bootstraprr]DeferredResolver)rKdeferredResolvers r*test_returnsDeferredResolver+BootstrapTests.test_returnsDeferredResolverqs,  >>,.9 .0E0EFr,c[5n[R"U5 URUR[ Vs/sHo"404PM sn5 gs snf)zv The L{IResolverSimple} supplied to L{root.bootstrap} is used to lookup the IP addresses of the 13 root name servers. N)rr rr@r ROOT_SERVERS)rK stubResolverss r*test_resolves13RootServers)BootstrapTests.test_resolves13RootServersysC $~  |$ ++,-O,QtRj,-OP-OsA c[5n[R"U5nURHnUR S5 M UR U[ 5 g)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 rrcallbackr]rrKrrrNs r*test_becomesResolver#BootstrapTests.test_becomesResolversG $~ >>,7,,A JJ} %- .9r,c[5n[R"U5nURHnUR S5 M UR UR S/S-5 g)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_resolverReceivesRootHints-BootstrapTests.test_resolverReceivesRootHintssT $~ >>,7,,A JJ} %- )//-21EFr,c^^[5n[R"U5m[UR5n[ U5nUHnUR S5 M UR[55 UU4SjnURU5 g)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}. rcF>TRTRS/S-5 g)Nr r@rresrrKs r* checkHintsFBootstrapTests.test_continuesWhenSomeRootHintsFail..checkHintss!   -33m_r5I Jr,N) rr riterrnextrerrbackraddBothrKrr&d1rNrrs` @r*#test_continuesWhenSomeRootHintsFail2BootstrapTests.test_continuesWhenSomeRootHintsFailsl $~ >>,7|223 ']A JJ} % <>" K :r,cn^^[5n[R"U5m[UR5n[ U5nUHnUR [55 M UR [55 UU4SjnURU5 TRTR[5 g)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>>TRTR/5 gNrrs r*rEBootstrapTests.test_continuesWhenAllRootHintsFail..checkHintss   -33R 8r,N) rr rrrrrrr addCleanupflushLoggedErrorsrs` @r*"test_continuesWhenAllRootHintsFail1BootstrapTests.test_continuesWhenAllRootHintsFails $~ >>,7|223 ']A IIln % <>" 9 : .. =r,c[5n[R"U[S9nURHnUR S5 M UR UR[5 g)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_passesResolverFactory)BootstrapTests.test_passesResolverFactorysV $~ >> *@ ,,A JJ} %- &779OPr,rnN) rrrrrrrrr rr"r%rrnr,r*rrls.GQ : G&>*Qr,rc\rSrSrSrSrSrg)StubDNSDatagramProtocoliz 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. c[5$r)r)rKakws r*rqStubDNSDatagramProtocol.querys zr,rnN)rrrrrrqrrnr,r*r(r(s  r,r(zbtwisted.names.root.retry is deprecated since Twisted 10.0. Use a Resolver object for retry logic.)categoryrSN):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 Exceptionrrrrrrr(suppressDeprecationWarning_retrySuppressionrnr,r*r>s'-QQ7& <'6"@/p0p0f y" 1' x' T " _!!!H O\*cQ(cQLMM  +r,