֛hLSrSSKJr SSKJrJrJrJrJrJ r J r J r J r SSK JrJr SSKJr SSKJr SSKJrJrJr SSKJrJrJr SS KJrJr SS KJ r J!r! SS K"J#r# SS K$J%r% SS K&J'r'J(r(J)r)J*r* SSK+J,r, SSK-J.r/ "SS\,5r0Sr1Sr2"SS5r3\"\)5"SS55r4"SS\/5r5"SS\/5r6\"\*5"SS55r7"SS\/5r8"S S!\!5r9"S"S#\/5r:g$)%zh Tests for implementations of L{IHostnameResolver} and their interactions with reactor implementations. ) defaultdict) AF_INETAF_INET6 AF_UNSPEC EAI_NONAME IPPROTO_TCP SOCK_DGRAM SOCK_STREAMgaierror getaddrinfo)Locklocal) implementer) verifyObject) LockWorkerTeamcreateMemoryWorker)ComplexResolverSimplifier GAIResolverSimpleResolverComplexifier) IPv4Address IPv6Address)PluggableResolverMixin ReactorBase)Deferred)DNSLookupError)IHostnameResolverIReactorPluggableNameResolverIResolutionReceiverIResolverSimple) ThreadPool)SynchronousTestCasec\rSrSrSrSrSrg)DeterministicThreadPool/z. Create a deterministic L{ThreadPool} object. cHSUlSUlSUl/UlXlg)z5 Create a L{DeterministicThreadPool} from a L{Team}. N)minmaxnamethreads_team)selfteams gC:\Users\psant\Downloads\Noiseback\school\venv\Lib\site-packages\twisted/internet/test/test_resolver.py__init__ DeterministicThreadPool.__init__4s%   )r,r)r(r*r+N)__name__ __module__ __qualname____firstlineno____doc__r0__static_attributes__r2r/r$r$/s r2r$c ^[5umn[[[[ 5[ 55U4SjS55U4$)z Create a deterministic threadpool. @return: 2-tuple of L{ThreadPool}, 0-argument C{work} callable; when C{work} is called, do the work. c>T$Nr9workersr/#deterministicPool..Isvr2cgr<r9r9r2r/r?r@Isr2)rr$rrr r)doerr>s @r/deterministicPoolrC?s?&'LFD DFEG,~ M   r2cJ^[5umn"U4SjS5nU"5U4$)z Create a deterministic L{IReactorThreads} @return: a 2-tuple consisting of an L{IReactorThreads}-like object and a 0-argument callable that will perform one unit of work invoked via that object's C{callFromThread} method. c">\rSrSrU4SjrSrg)(deterministicReactorThreads..CFTYc:>^^^TRUUU4Sj5 g)Nc>T"T0TD6$r<r9)afksr/r?IdeterministicReactorThreads..CFT.callFromThread..[s ajajr2)do)r-rKrJrLr>s ```r/callFromThread7deterministicReactorThreads..CFT.callFromThreadZs II( )r2r9N)r3r4r5r6rOr8r=sr/CFTrFYs  * *r2rQ)r)rBrQr>s @r/deterministicReactorThreadsrROs)&'LFD** 5$;r2c:\rSrSrSrSrS Sjr\\\ S4Sjr Sr g) FakeAddrInfoGetter`z' Test object implementing getaddrinfo. c:/Ul[[5Ulg)z! Create a L{FakeAddrInfoGetter}. N)callsrlistresultsr-s r/r0FakeAddrInfoGetter.__init__es "4( r2cURRXX4XV45 URUnU(aU$[[S5e)a9 Mock for L{socket.getaddrinfo}. @param host: see L{socket.getaddrinfo} @param port: see L{socket.getaddrinfo} @param family: see L{socket.getaddrinfo} @param socktype: see L{socket.getaddrinfo} @param proto: see L{socket.getaddrinfo} @param flags: see L{socket.getaddrinfo} @return: L{socket.getaddrinfo} z,nodename nor servname provided, or not known)rWappendrYr r)r-hostportfamilysocktypeprotoflagsrYs r/r FakeAddrInfoGetter.getaddrinfolsA$ 4vFG,,t$ N:'UV Vr2r2cFURURX4XVU45 g)aH Add a result for a given hostname. When this hostname is resolved, the result will be a L{list} of all results C{addResultForHost} has been called with using that hostname so far. @param host: The hostname to give this result for. This will be the next result from L{FakeAddrInfoGetter.getaddrinfo} when passed this host. @type canonname: native L{str} @param sockaddr: The resulting socket address; should be a 2-tuple for IPv4 or a 4-tuple for IPv6. @param family: An C{AF_*} constant that will be returned from C{getaddrinfo}. @param socktype: A C{SOCK_*} constant that will be returned from C{getaddrinfo}. @param proto: An C{IPPROTO_*} constant that will be returned from C{getaddrinfo}. @param canonname: A canonical name that will be returned from C{getaddrinfo}. @type canonname: native L{str} N)rYr])r-r^sockaddrr`rarb canonnames r/addResultForHost#FakeAddrInfoGetter.addResultForHosts#H T!!6Ux"PQr2)rWrYN)rrrr) r3r4r5r6r7r0r rr rrhr8r9r2r/rTrT`s&)W:$Rr2rTc8\rSrSrSrSrSrSrSrSr Sr Sr g ) ResultHolderzA A resolution receiver which holds onto the results it received. FcXlg)z. Create a L{ResultHolder} with a L{UnitTest}. N) _testCase)r-testCases r/r0ResultHolder.__init__s "r2c,SUlXl/Ulg)zO Hostname resolution began. @param hostResolution: see L{IResolutionReceiver} TN)_started _resolution _addresses)r-hostResolutions r/resolutionBeganResultHolder.resolutionBegans  )r2c:URRU5 g)zF An address was resolved. @param address: see L{IResolutionReceiver} N)rtr])r-addresss r/addressResolvedResultHolder.addressResolveds w'r2cSUlg)z" Hostname resolution is complete. TN)_endedrZs r/resolutionCompleteResultHolder.resolutionCompletes  r2)rtr}rsrrrnN) r3r4r5r6r7rrr}r0rvrzr~r8r9r2r/rkrks'H F" (r2rkc\rSrSrSrSrSrg) HelperTestsz7 Tests for error cases of helpers used in this module. c[5uUlUlSnURRU5 UR5 UR [ UR [55S5 g)zY L{DeterministicThreadPool} will log any exceptions that its "thread" workers encounter. c SS- $)Nr'rr9r9r2r/ divideByZero9HelperTests.test_logErrorsInThreads..divideByZeros q5Lr2r'N)rCpool doThreadWork callInThread assertEquallenflushLoggedErrorsZeroDivisionError)r-rs r/test_logErrorsInThreads#HelperTests.test_logErrorsInThreadss\ (9':$ 4$  |,  T334EFGKr2)rrN)r3r4r5r6r7rr8r9r2r/rrs  Lr2rcT\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rg)HostnameResolutionTestsz Tests for hostname resolution. c^[5uTlTl[5uTlTl[ 5Tl[TRU4SjTRR5Tl g)z Set up a L{GAIResolver}. c>TR$r<rrZsr/r?/HostnameResolutionTests.setUp.. $))r2N) rCrrrRreactor doReactorWorkrTgetterrr resolverrZs`r/setUpHostnameResolutionTests.setUpsU(9':$ 4$+F+H( d((* # LL+T[[-D-D  r2c[U5nURRSS5 URR US5nUR UR U5 URURS5 URURS5 UR5 UR5 URURS5 URUR[SSS5/5 g) z Resolving an individual hostname that results in one address from getaddrinfo results in a single call each to C{resolutionBegan}, C{addressResolved}, and C{resolutionComplete}. sample.example.com)4.3.2.1rTFTCPrrN)rkrrhrresolveHostNameassertIsrsrrrr}rrrtrr-receiver resolutions r/test_resolveOneHost+HostnameResolutionTests.test_resolveOneHosts  % $$%9>J]]228=QR  h**J7 **D1 %0   $/ ,,{5)Q/O.PQr2c [U5nSnSnURRSSSX#4[S9 URR US5nUR URU5 URURS5 URURS5 UR5 UR5 URURS5 URUR[S SSX#5/5 g ) z Resolving an individual hostname that results in one address from getaddrinfo results in a single call each to C{resolutionBegan}, C{addressResolved}, and C{resolutionComplete}; C{addressResolved} will receive an L{IPv6Address}. r'r::1r)r`TFrN)rkrrhrrrrrsrrrr}rrrtr)r-rflowInfoscopeIDrs r/test_resolveOneIPv6Host/HostnameResolutionTests.test_resolveOneIPv6Host s % $$ 5!X"? % ]]228=QR  h**J7 **D1 %0   $/    +eUAx"Q!R r2cr[U5nURRUS5nURURU5 UR 5 UR 5 URURS5 URURS5 URUR/5 g)z Resolving a hostname that results in C{getaddrinfo} raising a L{gaierror} will result in the L{IResolutionReceiver} receiving a call to C{resolutionComplete} with no C{addressResolved} calls in between; no failure is logged. rTN) rkrrrrsrrrrrr}rtrs r/ test_gaierror%HostnameResolutionTests.test_gaierror!s %]]228=QR  h**J7   **D1 $/ ,,b1r2c$[U5nURRUSUS9nURURU5 UR 5 UR 5 URRSupVpxpURXr5 g)z Verify that the given set of address types results in the given C{AF_} constant being passed to C{getaddrinfo}. @param addrTypes: iterable of L{IAddress} implementers @param expectedAF: an C{AF_*} constant r) addressTypesrN) rkrrrrsrrrrWr) r- addrTypes expectedAFrrr^r_r`rarbrcs r/_resolveOnlyTest(HostnameResolutionTests._resolveOnlyTest1s %]]22 *3  h**J7  59[[5F5Fq5I2Fe ,r2c:UR[/[5 g)z When passed an C{addressTypes} parameter containing only L{IPv4Address}, L{GAIResolver} will pass C{AF_INET} to C{getaddrinfo}. N)rrrrZs r/test_resolveOnlyIPv4,HostnameResolutionTests.test_resolveOnlyIPv4Ds {mW5r2c:UR[/[5 g)z When passed an C{addressTypes} parameter containing only L{IPv6Address}, L{GAIResolver} will pass C{AF_INET6} to C{getaddrinfo}. N)rrrrZs r/test_resolveOnlyIPv6,HostnameResolutionTests.test_resolveOnlyIPv6Ks {mX6r2cpUR[[/[5 URS[5 g)z When passed an C{addressTypes} parameter containing both L{IPv4Address} and L{IPv6Address} (or the default of C{None}, which carries the same meaning), L{GAIResolver} will pass C{AF_UNSPEC} to C{getaddrinfo}. N)rrrrrZs r/test_resolveBoth(HostnameResolutionTests.test_resolveBothRs) {K8)D dI.r2c[U5nURRUSSS9 [U5nURRUSSS9 UR5 UR 5 UR5 UR 5 UR R Sup4pVpxUR R Sup4pYpxURU[5 URU [5 g)z When passed a C{transportSemantics} paramter, C{'TCP'} (the value present in L{IPv4Address.type} to indicate a stream transport) maps to C{SOCK_STREAM} and C{'UDP'} maps to C{SOCK_DGRAM}. example.comr)transportSemanticsUDPrr'N) rkrrrrrrWrr r ) r-r receiver2r^r_r` socktypeTrbrc socktypeUs r/#test_transportSemanticsToSocketType;HostnameResolutionTests.test_transportSemanticsToSocketType[s  % %%h RW%X &  %% } &     6:kk6G6G6J3Fu6:kk6G6G6J3Fu K0 J/r2cD[U5nSnSn[[4HFnURR SSSX#4[ US9 URR SS[ US9 MH URRUS5 UR5 UR5 URupVpxURURS5 URURS5 URURS 5 URURS 5 g ) z When L{GAIResolver} receives a C{SOCK_DGRAM} result from C{getaddrinfo}, it returns a C{'TCP'} L{IPv4Address} or L{IPv6Address}; if it receives C{SOCK_STREAM} then it returns a C{'UDP'} type of same. r'rrrr)r`ra)z 127.0.0.3rrrN)rkr r rrhrrrrrrrtrtype) r-rrrrastream4stream6dgram4dgram6s r/test_socketTypeToAddressType4HostnameResolutionTests.test_socketTypeToAddressTypeps  %#Z/H KK ( (8-! )  KK ( (/( ) 0 %%h >  +3+>+>(& u- u- e, e,r2rrrrrrN)r3r4r5r6r7rrrrrrrrrrr8r9r2r/rrs:  R" 02 -&67/0*-r2rc(\rSrSrSrSrSSjrSrg)SillyResolverSimpleiz. Trivial implementation of L{IResolverSimple} c/Ulg)zL Create a L{SillyResolverSimple} with a queue of requests it is working on. N _requestsrZs r/r0SillyResolverSimple.__init__s r2cfURR[55 URS$)z Implement L{IResolverSimple.getHostByName}. @param name: see L{IResolverSimple.getHostByName}. @param timeout: see L{IResolverSimple.getHostByName}. @return: see L{IResolverSimple.getHostByName}. )rr]r)r-r*timeouts r/ getHostByName!SillyResolverSimple.getHostByNames' hj)~~b!!r2rN)r9)r3r4r5r6r7r0rr8r9r2r/rrs "r2rc6\rSrSrSrSrSrSrSrSr Sr g ) LegacyCompatibilityTestsiz Older applications may supply an object to the reactor via C{installResolver} that only provides L{IResolverSimple}. L{SimpleResolverComplexifier} is a wrapper for an L{IResolverSimple}. c [5n[U5n[U5nURURS5 UR US5 URURS5 URUR S5 URUR/5 URSRS5 URUR[SSS5/5 URUR S5 g)zj L{SimpleResolverComplexifier} translates C{resolveHostName} into L{IResolutionReceiver.addressResolved}. FrTr 192.168.1.1rN) rrrkrrrrr}rtrcallbackrr-simplecomplexrs r/ test_success%LegacyCompatibilityTests.test_successs %&,V4% **E2-8 **D1 %0 ,,b1$$]3 ,,{5-QR/S.TU $/r2c[5n[U5n[U5nURURS5 UR US5 URURS5 URUR S5 URUR/5 URSR[S55 URUR S5 URUR/5 g)z} L{SimpleResolverComplexifier} translates a known error result from L{IResolverSimple.resolveHostName} into an empty result. FrTrnopeN) rrrkrrrrr}rtrerrbackrrs r/ test_failure%LegacyCompatibilityTests.test_failures %&,V4% **E2-8 **D1 %0 ,,b1##N6$:; $/ ,,b1r2cb[5n[U5n[U5nURURS5 UR US5 URURS5 URUR S5 URUR/5 URSR[S55 UR[UR[55S5 URUR S5 URUR/5 g)z L{SimpleResolverComplexifier} translates an unknown error result from L{IResolverSimple.resolveHostName} into an empty result and a logged error. FrTrzowr'N) rrrkrrrrr}rtrrrrrrs r/ test_error#LegacyCompatibilityTests.test_errors %&,V4% **E2-8 **D1 %0 ,,b1##$5e$<= T334EFGK $/ ,,b1r2c^[5uTlTl[5uTlTl[ 5Tl[TRU4SjTRR5Tl [TR5nTRRSS5 URS5nURS5nTR5 TR 5 TR5 TR 5 TRTRU5R ["5 TRTR%U5S5 g)z L{ComplexResolverSimplifier} translates an L{IHostnameResolver} into an L{IResolverSimple} for applications that still expect the old interfaces to be in place. c>TR$r<rrZsr/r?:LegacyCompatibilityTests.test_simplifier..rr2r) 192.168.3.4znx.example.comrN)rCrrrRrrrTrrr rrrhrrfailureResultOfrrsuccessResultOf)r-simpleResolversuccessfailures` r/test_simplifier(LegacyCompatibilityTests.test_simplifiers (9':$ 4$+F+H( d((* # LL+T[[-D-D  34==A $$]4IJ ..}= ../?@     --g6;;^L --g6 Fr2c[5n[U5n[U5nURUSS5 UR UR S5 UR UR S5 UR UR/5 URSRS5 UR UR[SSS5/5 UR UR S5 g) zv L{SimpleResolverComplexifier} preserves the C{port} argument passed to C{resolveHostName} in its returned addresses. rrTFrrrN) rrrkrrrrr}rtrrrrs r/test_portNumber(LegacyCompatibilityTests.test_portNumbers %&,V4%-> **D1 %0 ,,b1$$]3 ,,{5-QU/V.WX $/r2rN) r3r4r5r6r7rrrrrr8r9r2r/rrs! 0"2"2&G.0r2rc\rSrSrSrSrSrg)JustEnoughReactori zL Just enough subclass implementation to be a valid L{ReactorBase} subclass. cg)z Do nothing. Nr9rZs r/ installWakerJustEnoughReactor.installWakersr2r9N)r3r4r5r6r7rr8r9r2r/rr s  r2rc*\rSrSrSrSrSrSrSrg)ReactorInstallationTestsiz Tests for installing old and new resolvers onto a L{PluggableResolverMixin} and L{ReactorBase} (from which all of Twisted's reactor implementations derive). c[5n[[U5 [[UR5 [[ UR 5 g)z L{PluggableResolverMixin} (and its subclasses) implement both L{IReactorPluggableNameResolver} and L{IReactorPluggableResolver}. N)rrrr rr nameResolverr-rs r/test_interfaceCompliance1ReactorInstallationTests.test_interfaceCompliances8 )*2G<_g&6&67&(<(<=r2c[5n[5n[[UR U55 UR UR [5 URUR RU5 g)zN L{PluggableResolverMixin} will wrap an L{IResolverSimple} in a complexifier. N) rrrr installResolverassertIsInstancer rr_simpleResolver)r-rits r/test_installingOldStyleResolver8ReactorInstallationTests.test_installingOldStyleResolver(sZ )* "_g&=&=b&AB g224NO g**::B?r2c[5nURUR[5 UR URR [ 5 URUR[5 UR URRU5 UR URRUR5 g)z4 L{ReactorBase} defaults to using a L{GAIResolver}. N) rrr rr _getaddrinfor rr_reactor _nameResolverr s r/test_defaultToGAIResolver2ReactorInstallationTests.test_defaultToGAIResolver3s$% g22K@ g**77E g..0IJ g**33W= g&&44g6J6JKr2r9N) r3r4r5r6r7r rrr8r9r2r/rrs > @ Lr2rN);r7 collectionsrsocketrrrrrr r r r threadingr rzope.interfacerzope.interface.verifyrtwisted._threadsrrrtwisted.internet._resolverrrrtwisted.internet.addressrrtwisted.internet.baserrtwisted.internet.deferrtwisted.internet.errorrtwisted.internet.interfacesrrrr twisted.python.threadpoolr!twisted.trial.unittestr"UnitTestr$rCrRrTrkrrrrrrr9r2r/r)s $   "&.AA >E+1 1B j   "IRIRX !$$"$NL(L(b-hb-J _"""4a0xa0H  %Lx%Lr2