o iL@sdZddlmZddlmZmZmZmZmZm Z m Z m Z m Z ddl mZmZddlmZddlmZddlmZmZmZddlmZmZmZdd lmZmZdd lm Z m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z/Gddde,Z0ddZ1ddZ2GdddZ3ee)GdddZ4Gddde/Z5Gddde/Z6ee*GdddZ7Gd d!d!e/Z8Gd"d#d#e!Z9Gd$d%d%e/Z:d&S)'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@eZdZdZddZdS)DeterministicThreadPoolz6 Create a deterministic L{ThreadPool} object. cCs"d|_d|_d|_g|_||_dS)zE Create a L{DeterministicThreadPool} from a L{Team}. N)minmaxnamethreadsZ_team)selfZteamr*iC:\Users\psant\Downloads\PAF backend\school\venv\Lib\site-packages\twisted/internet/test/test_resolver.py__init__4s  z DeterministicThreadPool.__init__N)__name__ __module__ __qualname____doc__r,r*r*r*r+r#/ r#cs4t\}tttttfdddd|fS)z Create a deterministic threadpool. @return: 2-tuple of L{ThreadPool}, 0-argument C{work} callable; when C{work} is called, do the work. csSNr*r*Zworkerr*r+Iz#deterministicPool..cSsdSr2r*r*r*r*r+r4Ir5N)rr#rrr r )doerr*r3r+deterministicPool?s  r7cs&t\}Gfddd}||fS)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. cseZdZfddZdS)z(deterministicReactorThreads..CFTcsfdddS)NcsiSr2r*r*afkr*r+r4[szIdeterministicReactorThreads..CFT.callFromThread..)do)r)r:r9r;r3r8r+callFromThreadZsz7deterministicReactorThreads..CFT.callFromThreadN)r-r.r/r=r*r3r*r+CFTYsr>N)r)r6r>r*r3r+deterministicReactorThreadsOs  r?c@s4eZdZdZddZd ddZeeedfdd Z d S) FakeAddrInfoGetterz/ Test object implementing getaddrinfo. cCsg|_tt|_dS)z1 Create a L{FakeAddrInfoGetter}. N)callsrlistresultsr)r*r*r+r,eszFakeAddrInfoGetter.__init__rcCs4|j||||||f|j|}|r|Sttd)a 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 knownN)rAappendrCr r)r)hostportfamilysocktypeprotoflagsrCr*r*r+r ls   zFakeAddrInfoGetter.getaddrinfocCs|j||||||fdS)a 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)rCrE)r)rFsockaddrrHrIrJ canonnamer*r*r+addResultForHosts$z#FakeAddrInfoGetter.addResultForHostN)rrrr) r-r.r/r0r,r rr rrOr*r*r*r+r@`s r@c@s8eZdZdZdZdZddZddZddZd d Z d S) ResultHolderzI A resolution receiver which holds onto the results it received. FcCs ||_dS)z> Create a L{ResultHolder} with a L{UnitTest}. N)Z _testCase)r)ZtestCaser*r*r+r, zResultHolder.__init__cCsd|_||_g|_dS)zg Hostname resolution began. @param hostResolution: see L{IResolutionReceiver} TN)_started _resolution _addresses)r)ZhostResolutionr*r*r+resolutionBegans zResultHolder.resolutionBegancCs|j|dS)z^ An address was resolved. @param address: see L{IResolutionReceiver} N)rTrE)r)addressr*r*r+addressResolvedszResultHolder.addressResolvedcCs d|_dS)z2 Hostname resolution is complete. TN)_endedrDr*r*r+resolutionCompleterQzResultHolder.resolutionCompleteN) r-r.r/r0rRrXr,rUrWrYr*r*r*r+rPs rPc@r") HelperTestsz? Tests for error cases of helpers used in this module. cCsDt\|_|_dd}|j|||t|tddS)zq L{DeterministicThreadPool} will log any exceptions that its "thread" workers encounter. cSsddS)Nr$rr*r*r*r*r+ divideByZerosz9HelperTests.test_logErrorsInThreads..divideByZeror$N)r7pool doThreadWorkZ callInThread assertEquallenflushLoggedErrorsZeroDivisionError)r)r[r*r*r+test_logErrorsInThreadss  z#HelperTests.test_logErrorsInThreadsN)r-r.r/r0rbr*r*r*r+rZr1rZc@s`eZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ dS)HostnameResolutionTestsz( Tests for hostname resolution. csDt\__t\__t_tjfddjj _ dS)z* Set up a L{GAIResolver}. cjSr2r\r*rDr*r+r4z/HostnameResolutionTests.setUp..N) r7r\r]r?reactor doReactorWorkr@getterrr resolverrDr*rDr+setUps  zHostnameResolutionTests.setUpcCst|}|jdd|j|d}||j|||jd||j d| | ||j d||j t dddgdS) 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.1rTFTCPrmrN)rPrirOrjresolveHostNameassertIsrSr^rRrXr]rhrTrr)receiver resolutionr*r*r+test_resolveOneHostsz+HostnameResolutionTests.test_resolveOneHostc Cst|}d}d}|jjddd||ftd|j|d}||j|||j d||j d| | ||j d||j td dd||gd S) a 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$rl::1r)rHTFrnN)rPrirOrrjrorprSr^rRrXr]rhrTr)r)rrflowInfoscopeIDrsr*r*r+test_resolveOneIPv6Host s z/HostnameResolutionTests.test_resolveOneIPv6HostcCsbt|}|j|d}||j|||||jd||j d||j gdS)a  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. rlTN) rPrjrorprSr]rhr^rRrXrTrqr*r*r+ test_gaierror!sz%HostnameResolutionTests.test_gaierrorc Cs`t|}|jj|d|d}||j||||jjd\}}}}} } | ||dS)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 rl)Z addressTypesrN) rPrjrorprSr]rhrirAr^) r)Z addrTypesZ expectedAFrrrsrFrGrHrIrJrKr*r*r+_resolveOnlyTest1s z(HostnameResolutionTests._resolveOnlyTestcC|tgtdS)z When passed an C{addressTypes} parameter containing only L{IPv4Address}, L{GAIResolver} will pass C{AF_INET} to C{getaddrinfo}. N)r{rrrDr*r*r+test_resolveOnlyIPv4Dz,HostnameResolutionTests.test_resolveOnlyIPv4cCr|)z When passed an C{addressTypes} parameter containing only L{IPv6Address}, L{GAIResolver} will pass C{AF_INET6} to C{getaddrinfo}. N)r{rrrDr*r*r+test_resolveOnlyIPv6Kr~z,HostnameResolutionTests.test_resolveOnlyIPv6cCs |ttgt|dtdS)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)r{rrrrDr*r*r+test_resolveBothRsz(HostnameResolutionTests.test_resolveBothc Cst|}|jj|dddt|}|jj|ddd|||||jjd\}}}}}}|jjd\}}}} }}||t|| t dS)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.comrn)ZtransportSemanticsUDPrr$N) rPrjror]rhrirAr^r r) r)rrZ receiver2rFrGrHZ socktypeTrJrKZ socktypeUr*r*r+#test_transportSemanticsToSocketType[s z;HostnameResolutionTests.test_transportSemanticsToSocketTypec Cst|}d}d}ttfD]}|jjddd||ft|d|jjddt|dq |j|d| | |j \}}}}| |j d| |j d| |j d | |j d d S) 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$rurrvr)rHrI)z 127.0.0.3rrnrN)rPr rrirOrrrjror]rhrTr^type) r)rrrwrxrIZstream4Zstream6Zdgram4Zdgram6r*r*r+test_socketTypeToAddressTypeps*  z4HostnameResolutionTests.test_socketTypeToAddressTypeN)r-r.r/r0rkrtryrzr{r}rrrrr*r*r*r+rcs  rcc@s"eZdZdZddZdddZdS) SillyResolverSimplez6 Trivial implementation of L{IResolverSimple} cCs g|_dS)zd Create a L{SillyResolverSimple} with a queue of requests it is working on. N) _requestsrDr*r*r+r,s zSillyResolverSimple.__init__r*cCs|jt|jdS)z Implement L{IResolverSimple.getHostByName}. @param name: see L{IResolverSimple.getHostByName}. @param timeout: see L{IResolverSimple.getHostByName}. @return: see L{IResolverSimple.getHostByName}. N)rrEr)r)r'timeoutr*r*r+ getHostByNames z!SillyResolverSimple.getHostByNameN)r*)r-r.r/r0r,rr*r*r*r+rsrc@s8eZdZdZddZddZddZdd Zd d Zd S) LegacyCompatibilityTestsz 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}. cCst}t|}t|}||jd||d||jd||jd||jg|jd d||jt dddg||jddS)z L{SimpleResolverComplexifier} translates C{resolveHostName} into L{IResolutionReceiver.addressResolved}. FrTr 192.168.1.1rnN) rrrPr^rRrorXrTrcallbackrr)simplecomplexrrr*r*r+ test_successs z%LegacyCompatibilityTests.test_successcCst}t|}t|}||jd||d||jd||jd||jg|jd t d||jd||jgdS)z L{SimpleResolverComplexifier} translates a known error result from L{IResolverSimple.resolveHostName} into an empty result. FrTrZnopeN) rrrPr^rRrorXrTrerrbackrrr*r*r+ test_failures z%LegacyCompatibilityTests.test_failurecCst}t|}t|}||jd||d||jd||jd||jg|jd t d|t | t d||jd||jgdS)z L{SimpleResolverComplexifier} translates an unknown error result from L{IResolverSimple.resolveHostName} into an empty result and a logged error. FrTrZzowr$N) rrrPr^rRrorXrTrrrar_r`rr*r*r+ test_errors z#LegacyCompatibilityTests.test_errorcst\__t\__t_tjfddjj _ t j }j dd| d}| d}|jt|ddS)z L{ComplexResolverSimplifier} translates an L{IHostnameResolver} into an L{IResolverSimple} for applications that still expect the old interfaces to be in place. crdr2rer*rDr*r+r4rfz:LegacyCompatibilityTests.test_simplifier..r) 192.168.3.4znx.example.comrN)r7r\r]r?rgrhr@rirr rjrrOrr^ZfailureResultOfrrZsuccessResultOf)r)ZsimpleResolversuccessZfailurer*rDr+test_simplifiers    z(LegacyCompatibilityTests.test_simplifiercCst}t|}t|}||dd||jd||jd||jg|jd d||jt dddg||jddS) z L{SimpleResolverComplexifier} preserves the C{port} argument passed to C{resolveHostName} in its returned addresses. rrTFrrrnN) rrrPror^rRrXrTrrrrr*r*r+test_portNumbersz(LegacyCompatibilityTests.test_portNumberN) r-r.r/r0rrrrrr*r*r*r+rs rc@r")JustEnoughReactorzT Just enough subclass implementation to be a valid L{ReactorBase} subclass. cCsdS)z Do nothing. Nr*rDr*r*r+ installWakerr5zJustEnoughReactor.installWakerN)r-r.r/r0rr*r*r*r+r r1rc@s(eZdZdZddZddZddZdS) ReactorInstallationTestsz Tests for installing old and new resolvers onto a L{PluggableResolverMixin} and L{ReactorBase} (from which all of Twisted's reactor implementations derive). cCs,t}tt|tt|jtt|jdS)z L{PluggableResolverMixin} (and its subclasses) implement both L{IReactorPluggableNameResolver} and L{IReactorPluggableResolver}. N)rrrrrjr nameResolverr)rgr*r*r+test_interfaceCompliances  z1ReactorInstallationTests.test_interfaceCompliancecCs>t}t}tt||||jt||jj |dS)zf L{PluggableResolverMixin} will wrap an L{IResolverSimple} in a complexifier. N) rrrrZinstallResolverassertIsInstancerrrpZ_simpleResolver)r)rgitr*r*r+test_installingOldStyleResolver(s z8ReactorInstallationTests.test_installingOldStyleResolvercCsXt}||jt||jjt||jt||jj |||jj |jdS)zD L{ReactorBase} defaults to using a L{GAIResolver}. N) rrrrrpZ _getaddrinfor rjrZ_reactorZ _nameResolverrr*r*r+test_defaultToGAIResolver3s z2ReactorInstallationTests.test_defaultToGAIResolverN)r-r.r/r0rrrr*r*r*r+rs  rN);r0 collectionsrsocketrrrrrrr r r threadingr r Zzope.interfacerZzope.interface.verifyrZtwisted._threadsrrrZtwisted.internet._resolverrrrZtwisted.internet.addressrrZtwisted.internet.baserrZtwisted.internet.deferrZtwisted.internet.errorrZtwisted.internet.interfacesrrrrZtwisted.python.threadpoolr Ztwisted.trial.unittestr!ZUnitTestr#r7r?r@rPrZrcrrrrr*r*r*r+s: ,      L'&d