o ¯b\ã@s¨dZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZddlmZddlmZmZddlmZddlZddlZddlZddlZddlZddlZddlZddlZddl Zddlm!Z!m"Z"ddl#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)dd l*m+Z+dd l,m-Z-m.Z.m/Z/m0Z0dd l1m2Z2m3Z3dd l m4Z4dd l5m6Z6ddl7m8Z8m9Z9m:Z:ddl;mZ>m?Z?ddl@mAZAddlBmCZCddlDmEZEmFZFmGZGddlHmIZIeeCdkdƒGdd„deIƒƒZJeeCdkdƒGdd„deIƒƒZKeeCdkdƒGdd„deIƒƒZLeeCdkdƒGdd„deIƒƒZMeeCdkdƒGdd „d eIƒƒZNeeCdkdƒGd!d"„d"eIƒƒZOeeCdkdƒGd#d$„d$e"jPjQƒƒZRGd%d&„d&ƒZSeeCdkdƒGd'd(„d(eIeSƒƒZTeeCdkdƒGd)d*„d*eIeSƒƒZUeeCdkdƒGd+d,„d,eIƒƒZVeeCdkdƒGd-d.„d.eIƒƒZWeeCdkdƒGd/d0„d0eIƒƒZXee"j"jYƒGd1d2„d2ƒƒZZeeCdkdƒGd3d4„d4eIƒƒZ[eeCdkdƒGd5d6„d6eIƒƒZ\Gd7d8„d8e3j]ƒZ^eeCdkdƒGd9d:„d:eIƒƒZ_eeCdkdƒGd;d<„d„d>ƒZaeeCdkdƒGd?d@„d@eIƒƒZbeeCdkdƒGdAdB„dBeIƒƒZcddCl5mdZdmeZemfZfGdDdE„dEeejgƒZhdFdG„ZidHdI„ZjeeCdkdƒGdJdK„dKeIƒƒZkeeCdkdƒGdLdM„dMeIƒƒZlGdNdO„dOƒZmeeCdkdƒGdPdQ„dQeIƒƒZnGdRdS„dSƒZoeeCdkdƒGdTdU„dUeIƒƒZpGdVdW„dWƒZqGdXdY„dYe"jrjsƒZtGdZd[„d[e"jrjuƒZvGd\d]„d]ƒZweeCdkdƒGd^d_„d_eIƒƒZxGd`da„daƒZyGdbdc„dcƒZzGddde„deƒZ{eeCdkdƒGdfdg„dgeIƒƒZ|dS)hz. Tests for large portions of L{twisted.mail}. éN)Úmd5)ÚskipIf)Ú InterfaceÚ implementer)Ú verifyClass)ÚcredÚmail)ÚaddressÚdeferÚ interfacesÚprotocolÚreactorÚtask)ÚDeferred)ÚCannotListenErrorÚDNSLookupErrorÚ ProcessDoneÚProcessTerminated)Úpop3Úsmtp)Ú_AttemptManager)Údns)Ú Record_CNAMEÚ Record_MXÚRRHeader)Ú DNSNameError)ÚfailureÚlog)ÚFilePath)Ú platformType)ÚLineSendingProtocolÚMemoryReactorClockÚStringTransport)ÚTestCaseÚposixz twisted.mail only works on posixc@sDeZdZeejdkdƒdd„ƒZdd„Zdd„Zd d „Z d d „Z d S)ÚDomainWithDefaultsTests©éúnot ported to Python 3cCs‚dd„tdƒDƒ}tj |d¡}| t|ƒd¡| tt|ƒƒttdƒƒ¡| t| ¡ƒtt|ƒƒ¡t| ¡ƒ}|  ¡| |dd„tdƒDƒ¡t|  ¡ƒ}|  ¡| |ttddƒƒ¡|  ¡}|  ¡| |dd„tdƒDƒ¡|  ¡}|  ¡| |ttddƒƒ¡tdƒD]}| |||d¡| |  |¡|d¡| ||v¡qŒ|d =|d =|d =| t|ƒd ¡| |d d¡| |d d¡| |d d¡| dd ddœ¡| t|ƒd¡| |dd¡| |dd ¡| |dd¡| ¡| t|ƒd¡| | dd¡d¡| |dd¡| | ¡d¡| t|ƒd¡| ¡}| |j|j¡| |j|j¡dS)NcSsi|]}||d“qS©é ©©Ú.0Úxr+r+ú=/usr/lib/python3/dist-packages/twisted/mail/test/test_mail.pyÚ @óz7DomainWithDefaultsTests.testMethods..r*ÚDefaultcSóg|]}||df‘qSr)r+r,r+r+r/Ú Ióz7DomainWithDefaultsTests.testMethods..écSr3r)r+r,r+r+r/r4Qr5éééér+Ú*)ÚaÚbÚcr<r=r>rÚkeyÚvalue)r?r@)ÚrangerÚDomainWithDefaultDictÚ assertEqualÚlenÚlistÚiterÚiterkeysÚ iteritemsÚsortÚ itervaluesÚitemsÚvaluesÚgetÚ assertTrueÚupdateÚclearÚ setdefaultÚpopitemÚcopyÚdomainsÚdefault)ÚselfÚdrKrLr.Údcopyr+r+r/Ú testMethods>sP   z#DomainWithDefaultsTests.testMethodscCsFtj id¡}| |jj||ƒ¡d|d<| tddiƒ||ƒ¡dS)a™ Assert that the class name of a L{mail.mail.DomainWithDefaultDict} instance and the string-formatted underlying domain dictionary both appear in the string produced by the given string-returning function. @type stringifier: one-argument callable @param stringifier: either C{str} or C{repr}, to be used to get a string to make assertions against. r2r@r?N)rrBÚassertInÚ __class__Ú__name__Ústr)rVÚ stringifierÚdomainr+r+r/Ú_stringificationTestvs z,DomainWithDefaultsTests._stringificationTestcCó| t¡dS)z— L{DomainWithDefaultDict.__str__} should return a string including the class name and the domain mapping held by the instance. N)r`r]©rVr+r+r/Útest_str…óz DomainWithDefaultsTests.test_strcCra)z˜ L{DomainWithDefaultDict.__repr__} should return a string including the class name and the domain mapping held by the instance. N)r`Úreprrbr+r+r/Ú test_reprŒrdz!DomainWithDefaultsTests.test_reprcCsftj id¡}| d¡d}| |jg¡}| dt|ƒ¡| t|dd¡| ||dd¡dS) z, has_key is now deprecated. r2Úanythingzotwisted.mail.mail.DomainWithDefaultDict.has_key was deprecated in Twisted 16.3.0. Use the `in` keyword instead.érÚcategoryÚmessageN)rrBÚhas_keyÚ flushWarningsÚtest_has_keyDeprecationrCrDÚDeprecationWarning)rVÚsutrjÚwarningsr+r+r/rm“s ÿz/DomainWithDefaultsTests.test_has_keyDeprecationN) r\Ú __module__Ú __qualname__rÚsysÚ version_inforYr`rcrfrmr+r+r+r/r%<s 7 r%c@ó,eZdZdd„Zdd„Zdd„Zdd„Zd S) Ú BounceTestscCótj ¡|_dS©N)rÚ BounceDomainr_rbr+r+r/ÚsetUp§ózBounceTests.setUpcCs| tj|jjd¡dS)Nzany user)Ú assertRaisesrÚ AddressErrorr_Úexistsrbr+r+r/Ú testExistsªszBounceTests.testExistscCs| |j dd¡d¡dS)Nzrandom q emailerr F)rCr_Ú willRelayrbr+r+r/Ú testRelay­szBounceTests.testRelaycCs&|j dd¡| tj|jjd¡dS)NÚbobÚpassword)r_ÚaddUserr|rÚ SMTPBadRcptr~rbr+r+r/Ú testAddUser°szBounceTests.testAddUserN)r\rqrrrzrrr†r+r+r+r/rv¥s  rvc@óeZdZdZdd„ZdS)ÚBounceWithSMTPServerTestsz_ Tests for L{twisted.mail.mail.BounceDomain} with L{twisted.mail.smtp.SMTPServer}. cCs¼tj ¡}tj ¡}| d|¡tj |¡}| d¡}tj |dd¡}||_t ƒ}|  |¡|  d¡|  d¡|  d¡|  d¡|  |j ¡| d¡| | ¡ ¡ d¡dd ¡dS) zo Incoming emails to a SMTP server with L{twisted.mail.mail.BounceDomain} are rejected. sfoo.comNs HELO baz.netsMAIL FROM:sRCPT TO:sQUITs éþÿÿÿs(550 Cannot receive for specified address)rÚ MailServiceryÚ addDomainÚ protocolsÚ SMTPFactoryÚ buildProtocolÚSMTPDomainDeliveryÚdeliveryr"ÚmakeConnectionÚ lineReceivedrNÚ disconnectingÚconnectionLostrCr@ÚstripÚsplit)rVÚservicer_Úfactoryr Ú delivererÚ transportr+r+r/Ú test_rejected¼s&            þz'BounceWithSMTPServerTests.test_rejectedN)r\rqrrÚ__doc__r›r+r+r+r/rˆµs rˆc@s\eZdZdd„Zdd„Zdd„Zdd„Zeej d kd ƒd d „ƒZ eej d kd ƒd d„ƒZ dS)ÚFileMessageTestscCs6d|_d|_t|jdƒ|_tj |j|j|j¡|_dS)NzfileMessage.testFilezfinal.fileMessage.testFileÚw)ÚnameÚfinalÚopenÚfrÚ FileMessageÚfprbr+r+r/rzÞszFileMessageTests.setUpcCsnz|j ¡Wn tyYnwzt |j¡Wn ty"Ynwz t |j¡WdSty6YdSwrx)r¢ÚcloseÚ BaseExceptionÚosÚremoverŸr rbr+r+r/ÚtearDownäs ÿ ÿ ÿzFileMessageTests.tearDowncCs|j ¡ |j¡Srx)r¤Ú eomReceivedÚ addCallbackÚ _cbFinalNamerbr+r+r/Ú testFinalNameòózFileMessageTests.testFinalNamecCs4| ||j¡| |jj¡| tj |j ¡¡dSrx) rCr rNr¢ÚclosedÚ assertFalser§Úpathr~rŸ©rVÚresultr+r+r/r¬õszFileMessageTests._cbFinalNamer&r(cCshd}| ¡D]}|j |¡q|j ¡t|jƒ}| | ¡|¡WdƒdS1s-wYdS)Nz"first line second line third line )Ú splitlinesr¤r’rªr¡r rCÚread)rVÚcontentsÚliner¢r+r+r/Ú testContentsús   "ÿzFileMessageTests.testContentscCsTd}| ¡D]}|j |¡q|j ¡| tj |j¡¡| tj |j ¡¡dS)Nzfirst line second line ) r´r¤r’r”r°r§r±r~rŸr )rVr¶r·r+r+r/ÚtestInterrupteds   z FileMessageTests.testInterruptedN) r\rqrrrzr©r­r¬rrsrtr¸r¹r+r+r+r/rÜs rc@s$eZdZdd„Zdd„Zdd„ZdS)ÚMailServiceTestscCrwrx)rrŠr—rbr+r+r/rzr{zMailServiceTests.setUpcCs”|j ¡}| t|tjƒ¡| | d¡tj¡|j  ¡}| t|tjƒ¡| | d¡t j ¡|j  ¡}| t|tjƒ¡| | d¡t j ¡dS)N)ú 127.0.0.1é90)r—ÚgetPOP3FactoryrNÚ isinstancer Ú ServerFactoryrŽrÚPOP3ÚgetSMTPFactoryrÚSMTPÚgetESMTPFactoryÚESMTP)rVr¢r+r+r/Ú testFactoriess   zMailServiceTests.testFactoriescCsRtƒ}tƒ}||jjd<||jjd<| |j d¡|u¡| |j ¡|u¡dS)Nr_Ú)Úobjectr—ÚportalsrNÚ lookupPortalÚ defaultPortal)rVÚo1Úo2r+r+r/Ú testPortalss   zMailServiceTests.testPortalsN)r\rqrrrzrÅrÍr+r+r+r/rº s rºc@sheZdZdZdd„Zdd„Zeejdkdƒdd „ƒZ eejdkdƒd d „ƒZ d d „Z dd„Z dd„Z dS)ÚStringListMailboxTestszc Tests for L{StringListMailbox}, an in-memory only implementation of L{pop3.IMailbox}. cCsJtj gd¢¡}| | d¡d¡| | d¡d¡| | d¡d¡dS)zŠ L{StringListMailbox.listMessages} returns the length of the message at the offset into the mailbox passed to it. )ÚabcÚabr<rr'rhr7N©rÚmaildirÚStringListMailboxrCÚ listMessages©rVÚmailboxr+r+r/Útest_listOneMessage0sz*StringListMailboxTests.test_listOneMessagecCs(tj gd¢¡}| | ¡gd¢¡dS)z L{StringListMailbox.listMessages} returns a list of the lengths of all messages if not passed an index. )r<rÏrÐ)rhr'r7NrÑrÕr+r+r/Útest_listAllMessages:sz+StringListMailboxTests.test_listAllMessagesr&r(cCs*tj ddg¡}| | d¡ ¡d¡dS)zµ L{StringListMailbox.getMessage} returns a file-like object from which the contents of the message at the given offset into the mailbox can be read. Úfooz real contentsrhN)rrÒrÓrCÚ getMessagerµrÕr+r+r/Útest_getMessageBsz&StringListMailboxTests.test_getMessagecCs,tj ddg¡}| | d¡| d¡¡dS)zˆ L{StringListMailbox.getUidl} returns a unique identifier for the message at the given offset into the mailbox. rÙÚbarrrhN)rrÒrÓÚassertNotEqualÚgetUidlrÕr+r+r/Ú test_getUidlLsz#StringListMailboxTests.test_getUidlcCs@tj dg¡}| d¡| | d¡d¡| | ¡dg¡dS)zŽ L{StringListMailbox.deleteMessage} marks a message for deletion causing further requests for its length to return 0. rÙrN)rrÒrÓÚ deleteMessagerCrÔrÕr+r+r/Útest_deleteMessageUs z)StringListMailboxTests.test_deleteMessagecCsHtj dg¡}| d¡| ¡| | d¡d¡| | ¡dg¡dS)z L{StringListMailbox.undeleteMessages} causes any messages marked for deletion to be returned to their original state. rÙrr'N)rrÒrÓràÚundeleteMessagesrCrÔrÕr+r+r/Útest_undeleteMessages_s  z,StringListMailboxTests.test_undeleteMessagescCsPtj dg¡}| d¡| ¡| ¡| | d¡d¡| | ¡dg¡dS)zy L{StringListMailbox.sync} causes any messages as marked for deletion to be permanently deleted. rÙrN)rrÒrÓràÚsyncrârCrÔrÕr+r+r/Ú test_syncjs  z StringListMailboxTests.test_syncN)r\rqrrrœr×rØrrsrtrÛrßrárãrår+r+r+r/rÎ)s    rÎc@s0eZdZdZdZdZdd„Zdd„Zdd„ZdS) Ú&FailingMaildirMailboxAppendMessageTaskTcCs |jr t |||¡Sttjdƒ‚©NzFaked Permission Problem)Ú _openstater§r¡ÚOSErrorÚerrnoÚEPERM)rVÚfnÚattrÚmoder+r+r/Úosopens z-FailingMaildirMailboxAppendMessageTask.osopencCó|jr t ||¡Sttjdƒ‚)NzFaked Space problem)Ú _writestater§ÚwriterérêÚENOSPC)rVÚfhÚdatar+r+r/Úoswrite…ó  z.FailingMaildirMailboxAppendMessageTask.oswritecCrðrç)Ú _renamestater§Úrenamerérêrë)rVÚoldnameÚnewnamer+r+r/Úosrename‹r÷z/FailingMaildirMailboxAppendMessageTask.osrenameN) r\rqrrrèrñrørïrörür+r+r+r/ræws ræc@r‡)Ú_AppendTestMixinz Mixin for L{MaildirMailbox.appendMessage} test cases which defines a helper for serially appending multiple messages to a mailbox. cs:g‰‡‡‡fdd„}t |ƒ¡ ¡}| ‡fdd„¡|S)zì Deliver the given messages one at a time. Delivery is serialized to guarantee a predictable order in the mailbox (overlapped message deliver makes no guarantees about which message which appear first). c3s,ˆD]}ˆ |¡}| ˆj¡|VqdSrx)Ú appendMessager«Úappend)ÚmrW©ÚmboxÚmessagesÚresultsr+r/rÿ s €  ýz0_AppendTestMixin._appendMessages..appendcóˆSrxr+©Úignored)rr+r/Ú§óz2_AppendTestMixin._appendMessages..)rÚ cooperateÚwhenDoner«)rVrrrÿrWr+rr/Ú_appendMessages˜s z _AppendTestMixin._appendMessagesN)r\rqrrrœr r+r+r+r/rý’s rýc@sJeZdZdZdd„Zdd„Zddd„Zeej d kd ƒd d „ƒZ d d„Z dS)ÚMaildirAppendStringTestsúO Tests for L{MaildirMailbox.appendMessage} when invoked with a C{str}. cCó| ¡|_tj |j¡dSrx©ÚmktemprWrrÒÚinitializeMaildirrbr+r+r/rz±ó zMaildirAppendStringTests.setUpcCs| d¡}| |t¡S)NÚTEST)rþÚ assertFailureÚ Exception©rVrrrWr+r+r/Ú_appendµs  z MaildirAppendStringTests._appendNcCsz|dur| t|jd|jj¡||j_|dur&| t|jd|jj¡||j_|dur;| t|jd|jj¡||j_dSdS)aÞ Change the behavior of future C{rename}, C{write}, or C{open} calls made by the mailbox C{mbox}. @param rename: If not L{None}, a new value for the C{_renamestate} attribute of the mailbox's append factory. The original value will be restored at the end of the test. @param write: Like C{rename}, but for the C{_writestate} attribute. @param open: Like C{rename}, but for the C{_openstate} attribute. Nrørñrè)Ú addCleanupÚsetattrÚ AppendFactoryrørñrè)rVrrrùròr¡r+r+r/Ú _setState¹s, üüÿ üz"MaildirAppendStringTests._setStater&r(cCsVtj |j¡}t|_| |dd„tddƒDƒ¡}| |j dgd¡| |j |¡|S)ú– L{MaildirMailbox.appendMessage} returns a L{Deferred} which fires when the message has been added to the end of the mailbox. cSsg|]}d|‘qS)ÚXr+©r-Úir+r+r/r4åsz8MaildirAppendStringTests.test_append..rhé Nr*) rrÒÚMaildirMailboxrWrærr rAr«rCÚ _cbTestAppend)rVrrWr+r+r/Ú test_appendÜs z$MaildirAppendStringTests.test_appendcs²| tˆ ¡ƒd¡| ‡fdd„tdƒDƒttddƒƒ¡|jdˆdd| dˆ¡}|j|jˆd dd | |jˆ¡|j|jˆd dd | |jˆ¡|j|jˆd d |S) úÛ Check that the mailbox has the expected number (ten) of messages in it, and that each has the expected contents, and that they are in the same order as that in which they were appended. r*cóg|] }tˆ |¡ ¡ƒ‘qSr+©rDrÚrµr©rr+r/r4òóz:MaildirAppendStringTests._cbTestAppend..rhr!NF)rùT)rùrò)ròr¡)r¡)rCrDrÔrArErrr«rr+r(r/r#ês ÿ z&MaildirAppendStringTests._cbTestAppend)NNN) r\rqrrrœrzrrrrsrtr$r#r+r+r+r/r «s #  r c@s8eZdZdZdd„Zeejdkdƒdd„ƒZdd „Z d S) ÚMaildirAppendFileTestsrcCrrxrrbr+r+r/rzrzMaildirAppendFileTests.setUpr&r(cCsxtj |j¡}g}tddƒD]}t ¡}| d|¡| dd¡|  |¡|  |j ¡q|  ||¡}|  |j|¡|S)rrhr!rr)rrÒr"rWrAÚtempfileÚ TemporaryFileròÚseekrÿrr¥r r«r#)rVrrr ÚtemprWr+r+r/r$ s   z"MaildirAppendFileTests.test_appendcs@| tˆ ¡ƒd¡| ‡fdd„tdƒDƒttddƒƒ¡dS)r%r*cr&r+r'rr(r+r/r4$r)z8MaildirAppendFileTests._cbTestAppend..rhr!N)rCrDrÔrArE)rVr³rr+r(r/r#s ÿz$MaildirAppendFileTests._cbTestAppendN) r\rqrrrœrzrrsrtr$r#r+r+r+r/r*ÿs   r*c@sDeZdZdd„Zdd„Zdd„Zdd„Zeej d kd ƒd d „ƒZ d S)Ú MaildirTestscCrrxrrbr+r+r/rz*rzMaildirTests.setUpcCót |j¡dSrx)ÚshutilÚrmtreerWrbr+r+r/r©.r{zMaildirTests.tearDowncCs†|j}tj |d¡}| tj |¡otj |¡¡| tj tj |d¡¡¡| tj tj |d¡¡¡| tj tj |d¡¡¡| tj tj |d¡¡¡| tj tj |d¡¡¡| tj tj |d¡¡¡| tj tj |d¡¡¡| tj tj |d¡¡¡| tj tj |d¡¡¡| tj tj |d¡¡¡| tj tj |d¡¡¡| tj tj |d¡¡¡dS)Nú.TrashÚnewÚcurÚtmp)rWr§r±ÚjoinrNr~Úisdir)rVrWÚtrashr+r+r/ÚtestInitializer1s zMaildirTests.testInitializercCsJt ¡}| d¡tj |¡}| ¡}| d¡| ¡}| ||k¡dS)a Each call to L{_MaildirNameGenerator.generate} returns a unique string suitable for use as the basename of a new message file. The names are ordered such that those generated earlier sort less than those generated later. gš™™™™™©?N)rÚClockÚadvancerrÒÚ_MaildirNameGeneratorÚgeneraterN)rVÚclockÚ generatorÚ firstNameÚ secondNamer+r+r/Útest_nameGeneratorDs   zMaildirTests.test_nameGeneratorr&r(c sêtjj‰tjj‰‡‡fdd„dDƒ}d}|D]&}tˆ|j|ƒdƒ}| d|¡Wdƒn1s3wY|d}qtj  |j¡}|  |  ¡t t ddƒƒ¡|  |  d¡d ¡|  |  d ¡d ¡|  | d ¡ ¡d ¡|  | d¡ ¡d ¡i}t dƒD]}| |¡}| ||v¡d||<qtj |d ¡\}}| d ¡|  |  d ¡d¡| tj ˆ|jdd|ƒ¡¡| tj ˆ|j|d ƒ¡¡| ¡|  |  d ¡d ¡| tj ˆ|jdd|ƒ¡¡| tj ˆ|j|d ƒ¡¡dS)zb Exercise the methods of L{IMailbox} as implemented by L{MaildirMailbox}. cs&g|]}tdƒD]}ˆ|ˆƒƒ‘qqS)é)rA)r-r=r.©ÚjÚnr+r/r4]s&z-MaildirTests.test_mailbox..)r5r4rhržr.Nr!r7rDr9ÚxxxxxxxÚxxr*rr3r5)r§r±r7rrÒÚ_generateMaildirNamer¡rWròr"rCrÔrErArÚrµrÞr°r–ràrNr~râ) rVÚmsgsr r¢ÚfObjÚmbrWÚuÚpr+rEr/Ú test_mailboxUs:ÿ     "zMaildirTests.test_mailboxN) r\rqrrrzr©r:rCrrsrtrPr+r+r+r/r/(sr/c@r‡)ÚAbstractMaildirDomainTestszB Tests for L{twisted.mail.maildir.AbstractMaildirDomain}. cCsttjjtjjƒdS)zW L{maildir.AbstractMaildirDomain} implements L{mail.IAliasableDomain}. N)rrÚIAliasableDomainrÒÚAbstractMaildirDomainrbr+r+r/Útest_interface‡óz)AbstractMaildirDomainTests.test_interfaceN)r\rqrrrœrTr+r+r+r/rQs rQc@sˆeZdZdZdd„Zdd„Zeejdkdƒdd „ƒZ d d „Z eejdkdƒd d „ƒZ eejdkdƒdd„ƒZ eejdkdƒdd„ƒZ dS)ÚMaildirDirdbmDomainTestsz+ Tests for L{MaildirDirdbmDomain}. cCs.| ¡|_tj ¡|_tj |j|j¡|_dS)zw Create a temporary L{MaildirDirdbmDomain} and parent L{MailService} before running each test. N)rÚPrrŠÚSrÒÚMaildirDirdbmDomainÚDrbr+r+r/rz”s  zMaildirDirdbmDomainTests.setUpcCst |j¡dS)z_ Remove the temporary C{maildir} directory when the test has finished. N)r1r2rWrbr+r+r/r©sz!MaildirDirdbmDomainTests.tearDownr&r(c Csvd}|D] \}}|j ||¡q|D]&\}}| ||jjv¡| |jj||¡| tj tj |j |¡¡¡qdS)z¾ L{MaildirDirdbmDomain.addUser} accepts a user and password argument. It stores those in a C{dbm} dictionary attribute and creates a directory for each user. ))Úuser1Úpwd1)Úuser2Úpwd2)Úuser3Úpwd3N) rZr„rNÚdbmrCr§r±r~r7rW)rVÚtoAddrNrOr+r+r/Ú test_addUser¤s   ýz%MaildirDirdbmDomainTests.test_addUsercCsN|j ¡}| t|ƒd¡| tjj |d¡¡| tj j |dj v¡dS)zŽ L{MaildirDirdbmDomain.getCredentialsCheckers} initializes and returns one L{ICredentialsChecker} checker by default. rhrN) rZÚgetCredentialsCheckersrCrDrNrÚcheckersÚICredentialsCheckerÚ providedByÚ credentialsÚIUsernamePasswordÚcredentialInterfaces)rVÚcredsr+r+r/Útest_credentials´s ÿz)MaildirDirdbmDomainTests.test_credentialscCsŽGdd„dtƒ}|j dd¡| t|jjdd|¡|j ddtj¡}| t |ƒd¡|  |dtju¡|  tj  |d¡¡|d ƒdS) a? L{MaildirDirdbmDomain.requestAvatar} raises L{NotImplementedError} unless it is supplied with an L{pop3.IMailbox} interface. When called with an L{pop3.IMailbox}, it returns a 3-tuple containing L{pop3.IMailbox}, an implementation of that interface and a NOOP callable. c@s eZdZdS)z?MaildirDirdbmDomainTests.test_requestAvatar..ISomethingN)r\rqrrr+r+r+r/Ú ISomethingËsrmÚuserrƒNr'rrhr7) rrZr„r|ÚNotImplementedErrorÚ requestAvatarrÚIMailboxrCrDrNrg)rVrmÚtr+r+r/Útest_requestAvatarÁs ÿz+MaildirDirdbmDomainTests.test_requestAvatarcCsb|j dd¡|j ¡d}tj dd¡}| tjj|j |¡tj dd¡}|  |  |¡d¡dS)a L{DirdbmDatabase.requestAvatarId} raises L{UnauthorizedLogin} if supplied with invalid user credentials. When called with valid credentials, L{requestAvatarId} returns the username associated with the supplied credentials. rnrƒrúwrong passwordN) rZr„rdrrhÚUsernamePasswordr|ÚerrorÚUnauthorizedLoginÚrequestAvatarIdrC)rVÚdatabaserkr+r+r/Útest_requestAvatarIdÚs z-MaildirDirdbmDomainTests.test_requestAvatarIdcCsz|j dd¡| |j d¡tj |jjd¡¡d|j_|  |j d¡d¡d|j_| |j d¡tj |jjd¡¡dS)a] L{MaildirDirdbmDomain.userDirectory} is supplied with a user name and returns the path to that user's maildir subdirectory. Calling L{MaildirDirdbmDomain.userDirectory} with a non-existent user returns the 'postmaster' directory if there is a postmaster or returns L{None} if there is no postmaster. rnrƒFÚnouserNTÚ postmaster) rZr„rCÚ userDirectoryr§r±r7Úrootr|ÚassertIdenticalrbr+r+r/Útest_userDirectoryës ÿÿz+MaildirDirdbmDomainTests.test_userDirectoryN)r\rqrrrœrzr©rrsrtrcrlrsrzr€r+r+r+r/rVŽs    rVc@s2eZdZdZd dd„Zdd„Zdd„Zd d „ZdS) ÚStubAliasableDomainz> Minimal testable implementation of IAliasableDomain. NcCótƒ‚©z{ No test coverage for invocations of this method on domain objects, so we just won't implement it. ©ro©rVrnÚmemor+r+r/r~ózStubAliasableDomain.existscCr‚rƒr„)rVrnrƒr+r+r/r„r‡zStubAliasableDomain.addUsercCsgS)a! This needs to succeed in order for other tests to complete successfully, but we don't actually assert anything about its behavior. Return an empty list. Sometime later we should return something else and assert that a portal got set up properly. r+rbr+r+r/rdóz*StubAliasableDomain.getCredentialsCheckerscCó ||_dS)zG Just record the value so the test can check it later. N)Ú aliasGroup)rVÚaliasesr+r+r/Ú setAliasGroups z!StubAliasableDomain.setAliasGrouprx)r\rqrrrœr~r„rdrŒr+r+r+r/rs   rc@steZdZdd„Zdd„Zdd„Zeejdkdƒd d „ƒZ eejdkdƒd d „ƒZ d d„Z dd„Z dd„Z dd„ZdS)ÚServiceDomainTestscCsrtj ¡|_tj |jd¡|_|j|j_d|j_d|j_|  ¡|_ tj   |j|j ¡}|  dd¡|j d|¡dS)NrÚhostnameóuserópasswordú test.domain)rrŠrXrŒÚDomainDeliveryBaserZr—Ú protocolNameÚhostrÚtmpdirrÒrYr„r‹©rVr_r+r+r/rz(s    zServiceDomainTests.setUpcCr0rx©r1r2r•rbr+r+r/r©4r{zServiceDomainTests.tearDowncCs4tƒ}tƒ}||j_|j d|¡| |j|¡dS)z‚ Test that adding an IAliasableDomain to a mail service properly sets up alias group references and such. ú example.comN)rÇrrXr‹r‹rrŠ)rVr‹r_r+r+r/ÚtestAddAliasableDomain7s z)ServiceDomainTests.testAddAliasableDomainr&r(cCsZ|j dt d¡dg¡}t |¡}tj ¡}|  |¡}|  t |  ¡ƒd¡|  d|¡dS)N)Ú remotehostz123.232.101.234zzuser@host.namerhÚReceived)rZÚreceivedHeaderrÚAddressÚioÚBytesIOÚemailÚparserÚParserÚparserCrDrKrZ)rVÚhdrr¤Ú emailParserrr+r+r/ÚtestReceivedHeaderBsý   z%ServiceDomainTests.testReceivedHeadercCs(t dddd¡}t |jj|¡ |j¡S)Nzuser@test.domainÚheloúwherever@whatever)rÚUserr Ú maybeDeferredrZÚ validateTor«Ú _cbValidateTo©rVrnr+r+r/ÚtestValidateToOsÿz!ServiceDomainTests.testValidateTocCs| t|ƒ¡dSrx)rNÚcallabler²r+r+r/r¬Vr®z ServiceDomainTests._cbValidateTocCó*t dddd¡}| t |jj|¡tj¡S)Nzresu@test.domainr§r¨©rr©rr rªrZr«r…r­r+r+r/ÚtestValidateToBadUsernameYóÿz,ServiceDomainTests.testValidateToBadUsernamecCr°)Nzuser@domain.testr§r¨r±r­r+r+r/ÚtestValidateToBadDomain_r³z*ServiceDomainTests.testValidateToBadDomaincCsŒd}t d¡}| |j ||¡|u¡d}t d¡}| |j ||¡|u¡d}t d¡}| |j ||¡|u¡| tj|jjd|¡dS)N)rŽr»z)rŽú1.2.3.4z<>)rrrNrZÚ validateFromr|Ú SMTPBadSender)rVr§Úoriginr+r+r/ÚtestValidateFromes   z#ServiceDomainTests.testValidateFromN)r\rqrrrzr©r™rrsrtr¦r®r¬r²r´r¹r+r+r+r/r&s    rc@s¼eZdZdd„Zdd„Zeejdkdƒdd„ƒZd d „Z eejdkdƒd d „ƒZ eejdkdƒd d„ƒZ eejdkdƒdd„ƒZ dd„Z eejdkdƒdd„ƒZeejdkdƒdd„ƒZdS)ÚVirtualPOP3TestscCs¢| ¡|_tj ¡|_tj |j|j¡|_|j dd¡|j  d|j¡t j   |j¡}t |j|j ¡ƒ||jjd<|jjd<tj ¡|_|j|j_d|j_dS)Nrrr‘rÆz)rr•rrŠrXrÒrYrZr„r‹rÚportalÚPortalÚmapÚregisterCheckerrdrÈrŒÚ VirtualPOP3rWr—Úmagic)rVr»r+r+r/rzws     zVirtualPOP3Tests.setUpcCr0rxr—rbr+r+r/r©†r{zVirtualPOP3Tests.tearDownr&r(cCs*t|jjdƒ ¡}|j d|¡ |j¡S)Nrƒrn)rrWrÀÚ hexdigestÚauthenticateUserAPOPr«Ú_cbAuthenticateAPOP©rVÚrespr+r+r/ÚtestAuthenticateAPOP‰sÿz%VirtualPOP3Tests.testAuthenticateAPOPcCóF| t|ƒd¡| |dtj¡| tj |d¡¡|dƒdS©Nr'rrhr7©rCrDrrqrNrgr²r+r+r/rÃóz$VirtualPOP3Tests._cbAuthenticateAPOPcCs.t|jjdƒ ¡}| |j d|¡tjj¡S)NrƒÚresu) rrWrÀrÁrrÂrrvrwrÄr+r+r/Ú!testAuthenticateIncorrectUserAPOP–sÿz2VirtualPOP3Tests.testAuthenticateIncorrectUserAPOPcCs&tdƒ ¡}| |j d|¡tjj¡S)Nz wrong digestrn)rrÁrrWrÂrrvrwrÄr+r+r/Ú%testAuthenticateIncorrectResponseAPOPs ÿz6VirtualPOP3Tests.testAuthenticateIncorrectResponseAPOPcCs|j dd¡ |j¡S)Nrnrƒ)rWÚauthenticateUserPASSr«Ú_cbAuthenticatePASSrbr+r+r/ÚtestAuthenticatePASS¤sÿz%VirtualPOP3Tests.testAuthenticatePASScCrÇrÈrÉr²r+r+r/rϪrÊz$VirtualPOP3Tests._cbAuthenticatePASScCó| |j dd¡tjj¡S)NrËrƒ©rrWrÎrrvrwrbr+r+r/ÚtestAuthenticateBadUserPASS°ó þz,VirtualPOP3Tests.testAuthenticateBadUserPASScCrÑ)NrnrtrÒrbr+r+r/ÚtestAuthenticateBadPasswordPASS·rÔz0VirtualPOP3Tests.testAuthenticateBadPasswordPASSN)r\rqrrrzr©rrsrtrÆrÃrÌrÍrÐrÏrÓrÕr+r+r+r/rºus"     rºc@seZdZdd„ZdS)ÚemptycCsdSrxr+rbr+r+r/Ú__init__Àszempty.__init__N)r\rqrrr×r+r+r+r/rÖ¿s rÖc@s$eZdZeejdkdƒdd„ƒZdS)Ú RelayTestsr&r(csôtj ¡}tj |¡}t d¡t ddd¡g}t ddd¡t ddd¡g}|D]'‰tƒ}d |_d |_ tƒ|_ tƒ|j _ ‡fd d „|j j _ |  t| |¡ƒ¡q'|D]&‰tƒ}d |_tƒ|_ tƒ|j _ ‡fdd „|j j _ d|_ | tj|j|¡qQdS)Nz/var/run/mail-relayÚTCPr»r¼z 192.168.2.1é>rµi—z user@hostz tsoh@resucrrxr+r+©Úpeerr+r/rÛr z'RelayTests.testExists..z some@placecrrxr+r+rÛr+r/rär z who@cares)rrŠÚrelayÚ DomainQueuerr Ú UNIXAddressÚ IPv4AddressrÖÚorigÚdestr ršÚgetPeerrNr¯r~r|rr…)rVr—r_ÚdoRelayÚ dontRelayrnr+rÛr/rÆs2   þ  þ  øzRelayTests.testExistsN)r\rqrrrrsrtrr+r+r+r/rØÄsrØc@s4eZdZdd„Zdd„Zdd„Zdd„Zd d „Zd S) Ú RelayerTestsc CsØ| ¡|_t |j¡g|_tdƒD]J}tj |jd|f¡}t|ddƒ}t   d|fd|fg|¡Wdƒn1s?wYt|ddƒ}|  |¡|  d d ¡|j  |¡qtj ¡|_|j |j¡dS) Nr*úbody-%dú-HÚwbúfrom-%dúto-%dú-Držr)rr•r§ÚmkdirÚ messageFilesrAr±r7r¡ÚpickleÚdumpròr-rÿrrÝÚ RelayerMixinÚRÚ loadMessages)rVr rŸr¢r+r+r/rzìs   ÿ   zRelayerTests.setUpcCr0rxr—rbr+r+r/r©ýr{zRelayerTests.tearDowncCsPtdƒD]}| |j ¡d|f¡|j ddddd¡q| |j ¡d¡dS)Nr*rêéú)rArCròÚ getMailFromÚsentMail©rVr r+r+r/Ú testMailFroms zRelayerTests.testMailFromcCsRtdƒD]}| |j ¡d|fg¡|j ddddd¡q| |j ¡d¡dS)Nr*rërô)rArCròÚ getMailTorör÷r+r+r/Ú testMailTos zRelayerTests.testMailTocCsdtdƒD]"}tj |jd|f¡}| |j ¡ ¡|¡|j  ddddd¡q| |j ¡d¡dS)Nr*rçrô) rAr§r±r7r•rCròÚ getMailDatarµrö)rVr rŸr+r+r/Ú testMailData s zRelayerTests.testMailDataN)r\rqrrrzr©rørúrür+r+r+r/ræês  ræc@ru) ÚManagercCsg|_g|_g|_dSrx)ÚsuccessrÚdonerbr+r+r/r×ó zManager.__init__cCó|j ||f¡dSrx)rþrÿ©rVr˜rjr+r+r/Ú notifySuccessózManager.notifySuccesscCrrx)rrÿrr+r+r/Ú notifyFailurerzManager.notifyFailurecCó|j |¡dSrx)rÿrÿ)rVr˜r+r+r/Ú notifyDone r{zManager.notifyDoneN)r\rqrrr×rrrr+r+r+r/rýs  rýc@ru) ÚManagedRelayerTestscCsdtƒ|_ttdddƒƒ|_tƒ|_tj  |j¡|_ |jdd…|j _|jdd…|j _ |j|j _dS)Nrr6r7) rýÚmanagerrErArrÇr˜rÚ relaymanagerÚManagedRelayerMixinrÝÚnamesrbr+r+r/rz&szManagedRelayerTests.setUpcóDˆjD] }ˆj ddddd¡qˆ ˆjj‡fdd„ˆjDƒ¡dS)Nrôcóg|]}ˆj|f‘qSr+©r˜©r-rrbr+r/r44r1z>ManagedRelayerTests.testSuccessfulSentMail..)rrÝrörCr rþr÷r+rbr/ÚtestSuccessfulSentMail/ó ÿz*ManagedRelayerTests.testSuccessfulSentMailcr )Ni&crr+rrrbr+r/r4<r1z:ManagedRelayerTests.testFailedSentMail..)rrÝrörCr rr÷r+rbr/ÚtestFailedSentMail7rz&ManagedRelayerTests.testFailedSentMailcCs,|j t tƒ¡¡| |jj|jg¡dSrx) rÝr”rÚFailurerrCr rÿr˜rbr+r+r/ÚtestConnectionLost?sz&ManagedRelayerTests.testConnectionLostN)r\rqrrrzrrrr+r+r+r/r$s   rc@sleZdZdd„Zdd„Zeejdkdƒdd„ƒZeejdkdƒd d „ƒZ eejdkdƒd d „ƒZ d d„Z dS)ÚDirectoryQueueTestsc Cs¤| ¡|_t |j¡tj |j¡|_d|j_t dƒD]/}|j  ¡\}}|t   d|g|¡Wdƒn1s9wY|  d|f¡| ¡q|j ¡dS)NFéÚheadersbody: %d)rr•r§rírr ÚQueueÚqueueÚnoisyrAÚcreateNewMessagerïrðr’rªÚ readDirectory)rVrÚhdrFÚmsgFr+r+r/rzFs   ÿ zDirectoryQueueTests.setUpcCr0rxr—rbr+r+r/r©Tr{zDirectoryQueueTests.tearDownr&r(cCs€| |j ¡¡| t|j ¡ƒd¡|j ¡}|j |d¡| t|j ¡ƒd¡|j |d¡| t|j ¡ƒd¡dS)Nrré)rNrÚ hasWaitingrCrDÚ getWaitingÚ setRelayingÚ setWaiting)rVÚwaitingr+r+r/Ú testWaitingWs zDirectoryQueueTests.testWaitingcCsš|j ¡D]}|j |¡| t|j ¡ƒdt|j ¡ƒ¡q| |j ¡¡|j ¡}|j |d¡| t|j ¡ƒd¡| t|j ¡ƒd¡dS)Nrrrhr ) rr"r#rCrDÚ getRelayedr°r!r$)rVrÚrelayedr+r+r/Ú testRelayingcs ÿ z DirectoryQueueTests.testRelayingcCs~|j ¡d}|j |¡|j |¡| t|j ¡ƒd¡| t|j ¡ƒd¡| ||j ¡v¡| ||j ¡v¡dS)Nrr )rr"r#rÿrCrDr'r°)rVÚmsgr+r+r/ÚtestDoners  zDirectoryQueueTests.testDonecCsVg}|j ¡D] }| |j |¡¡q| ¡tdƒD] }| | d¡d|g¡qdS)Nrrr)rr"rÿÚ getEnveloperIrArCÚpop)rVÚ envelopesr*r r+r+r/Ú testEnvelope~s ÿz DirectoryQueueTests.testEnvelopeN) r\rqrrrzr©rrsrtr&r)r+r/r+r+r+r/rDs    r)ÚclientÚcommonÚserverc@óeZdZdd„Zddd„ZdS)Ú TestAuthoritycCstj |¡i|_dSrx)r1Ú ResolverBaser×Ú addressesrbr+r+r/r×s  zTestAuthority.__init__Nc Csv||jvr0|tjkr0g}|j|D]}t |tjtjdt d|¡¡}| |¡qt |ggf¡St  t   t  |¡¡¡S)Né<r) r6rÚMXrÚINrrÿr ÚsucceedÚfailrrÚ DomainError)rVrŸÚclsÚtypeÚtimeoutrr<r¤r+r+r/Ú_lookup‘s zTestAuthority._lookuprx)r\rqrrr×r@r+r+r+r/r4Œór4cCstƒ|_t |jg¡}t |¡} tjd|dd|_|j  ¡j}z tj ||dd|_ Wnt y9|j  ¡Ynwnqtjd|fgd|_dS)Nrhrr»©Ú interface)Úservers)r4Úauthr2ÚDNSServerFactoryrÚDNSDatagramProtocolr Ú listenTCPÚportÚgetHostÚ listenUDPÚudpPortrÚ stopListeningr0ÚResolverÚresolver)rVr˜r Ú portNumberr+r+r/ÚsetUpDNS›s    ÿ ÿõ rQcCsZg}| t |jj¡¡| t |jj¡¡z|jj ¡Wn t y'Ynwt  |¡Srx) rÿr rªrIrMrLrOÚ _parseCallÚcancelr¦Ú DeferredList)rVÚdlr+r+r/Ú tearDownDNS®s ÿ rVc@sðeZdZdZdd„Zdd„Zdd„Zeej dkd ƒd d „ƒZ d d „Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zeej dkd ƒd*d+„ƒZd,d-„Zd.d/„Zd0d1„Zd2d3„Zd4S)5ÚMXTestsz6 Tests for L{mail.relaymanager.MXCalculator}. cCs*t|ƒt ¡|_tj |j|j¡|_dSrx) rQrr;r?rr Ú MXCalculatorrOÚmxrbr+r+r/rz¿s z MXTests.setUpcCst|ƒSrx)rVrbr+r+r/r©ÄszMXTests.tearDowncCs| tj |j¡jt¡dS)zQ L{MXCalculator}'s default clock is C{twisted.internet.reactor}. N)rrr rXrOr?r rbr+r+r/Útest_defaultClockÇsÿzMXTests.test_defaultClockr&r(cCs"dg|jjd<|j d¡ |j¡S)Núthe.email.test.domainr‘)rEr6rYÚgetMXr«Ú_cbSimpleSuccessrbr+r+r/ÚtestSimpleSuccessÏszMXTests.testSimpleSuccesscCs$| |jd¡| t|jƒd¡dS)Nrr[)rCÚ preferencer]rŸ©rVrYr+r+r/r]ÔszMXTests._cbSimpleSuccesscCsd|j_| |j d¡t¡S)NFr‘)rYÚfallbackToDomainrr\ÚIOErrorrbr+r+r/ÚtestSimpleFailureØszMXTests.testSimpleFailurecCs| |j d¡t¡S©Nr‘)rrYr\rrbr+r+r/ÚtestSimpleFailureWithFallbackÜrz%MXTests.testSimpleFailureWithFallbackcsFG‡‡fdd„dƒ}|ƒˆj_ˆj ˆ¡}‡‡fdd„}| |¡|S)aZ Issue an MX request for the given domain and arrange for it to be responded to with the given records. Verify that the resulting mail exchange is the indicated host. @type domain: C{str} @type records: C{list} of L{RRHeader} @type correctMailExchange: C{str} @rtype: L{Deferred} cóeZdZ‡‡fdd„ZdS)z,MXTests._exchangeTest..DummyResolvercs&|ˆkr t ˆggf¡St tˆƒ¡Srx)r r:r;r)rVrŸ©r_Úrecordsr+r/ÚlookupMailExchangeìsz?MXTests._exchangeTest..DummyResolver.lookupMailExchangeN©r\rqrrrir+rgr+r/Ú DummyResolverëórkcsˆ t|jƒˆ¡dSrx©rCr]rŸ)Úrecord)ÚcorrectMailExchangerVr+r/ÚgotMailExchangeôsz.MXTests._exchangeTest..gotMailExchange)rYrOr\r«)rVr_rhrorkrWrpr+)ror_rhrVr/Ú _exchangeTestßs    zMXTests._exchangeTestcCsZd}d}d}t|tjtd|ƒdt|tjtd|ƒdt|tjtd|ƒdg}| |||¡S)zh The MX record with the lowest preference is returned by L{MXCalculator.getMX}. r˜úgood.example.comúbad.example.comrh©rŸr>Úpayloadrr7)rrÚTYPErq©rVr_ÚgoodÚbadrhr+r+r/Útest_mailExchangePreferenceúsýz#MXTests.test_mailExchangePreferencecCsRd}d}d}t|tjtd|ƒdt|tjtd|ƒdg}|j |¡| |||¡S)z L{MXCalculator.getMX} returns the MX record with the lowest preference which is not also marked as bad. r˜rrrsrrtrh©rrrvrYÚmarkBadrqrwr+r+r/Útest_badExchangeExcluded sþ z MXTests.test_badExchangeExcludedcCs^d}d}d}t|tjtd|ƒdt|tjtd|ƒdg}|j |¡|j |¡| |||¡S)zœ L{MXCalculator.getMX} returns the MX record with the lowest preference if all the MX records in the response have been marked bad. r˜rszworse.example.comrrtrhr{)rVr_ryÚworserhr+r+r/Útest_fallbackForAllBadExchangessþ  z'MXTests.test_fallbackForAllBadExchangescCsbd}d}d}t|tjtd|ƒdt|tjtd|ƒdg}|j |¡|j |jj¡| |||¡S)z¸ L{MXCalculator.getMX} returns the MX record with the lowest preference if it was last marked bad longer than L{MXCalculator.timeOutBadMX} seconds ago. r˜rrrsrrtrh) rrrvrYr|r?r<Ú timeOutBadMXrq©rVr_rxÚ previouslyBadrhr+r+r/Útest_badExchangeExpires+sÿü zMXTests.test_badExchangeExpirescCsnd}d}d}t|tjtd|ƒdt|tjtd|ƒdg}|j |¡|j |¡|j |jj¡|  |||¡S)z L{MXCalculator.getMX} returns the MX record with the lowest preference if it was marked good after it was marked bad. r˜rrrsrrtrh) rrrvrYr|ÚmarkGoodr?r<r€rqrr+r+r/Útest_goodExchangeUsed?sÿü  zMXTests.test_goodExchangeUsedcsJd‰d‰G‡‡fdd„dƒ}|ƒ|j_|j ˆ¡}| |jtˆd¡|S)zè If an MX lookup succeeds but the result set is empty, L{MXCalculator.getMX} should try to look up an I{A} record for the requested name and call back its returned Deferred with that address. rµz example.orgcs6eZdZdZ”gggfiZ””iZdd„Zdd„ZdS)z9MXTests.test_successWithoutResults..DummyResolverah Fake resolver which will respond to an MX lookup with an empty result set. @ivar mx: A dictionary mapping hostnames to three-tuples of results to be returned from I{MX} lookups. @ivar a: A dictionary mapping hostnames to addresses to be returned from I{A} lookups. cSót |j|¡Srx)r r:rYr–r+r+r/rilr{zLMXTests.test_successWithoutResults..DummyResolver.lookupMailExchangecSr†rx)r r:r<r–r+r+r/Ú getHostByNameor{zGMXTests.test_successWithoutResults..DummyResolver.getHostByNameN)r\rqrrrœrYr<rir‡r+©r_Úipr+r/rk]s   rk©rŸ©rYrOr\r«rCr©rVrkrWr+rˆr/Útest_successWithoutResultsSs  z"MXTests.test_successWithoutResultscCs<Gdd„dƒ}|ƒ|j_|j d¡}| |jtdd¡|S)a' Test that if the MX record lookup fails, fallback is enabled, and an A record is available for the name, then the Deferred returned by L{MXCalculator.getMX} ultimately fires with a Record_MX instance which gives the address in the A record for the name. c@s eZdZdZdd„Zdd„ZdS)zAMXTests.test_failureWithSuccessfulFallback..DummyResolverzw Fake resolver which will fail an MX lookup but then succeed a getHostByName call. cSs t tƒ¡Srx)r r;rr–r+r+r/ri…s zTMXTests.test_failureWithSuccessfulFallback..DummyResolver.lookupMailExchangecSs t d¡S)Nrµ)r r:r–r+r+r/r‡ˆó zOMXTests.test_failureWithSuccessfulFallback..DummyResolver.getHostByNameN)r\rqrrrœrir‡r+r+r+r/rks rkr_rµrŠr‹rŒr+r+r/Ú"test_failureWithSuccessfulFallbackws  z*MXTests.test_failureWithSuccessfulFallbackcsPd‰d‰d‰G‡‡‡fdd„dƒ}|ƒ|j_|j ˆ¡}| |jtˆd¡|S)zÌ If an MX lookup returns a single CNAME record as a result, MXCalculator will perform an MX lookup for the canonical name indicated and return the MX record which results. úalias.example.comúcanonical.example.comúmail.example.comcs eZdZdZ‡‡‡fdd„ZdS)z;MXTests.test_cnameWithoutGlueRecords..DummyResolverz¬ Fake resolver which will return a CNAME for an MX lookup of a name which is an alias and an MX for an MX lookup of the canonical name. csd|ˆkrt t|tjtˆƒdgggf¡S|ˆkr+t t|tjtdˆƒdgggf¡St t|ƒ¡S)Nrtr)r r:rrrvrr;rr–©ÚaliasÚ canonicalÚexchanger+r/ri s2ýÿ÷ÿ ýÿ÷ÿzNMXTests.test_cnameWithoutGlueRecords..DummyResolver.lookupMailExchangeN)r\rqrrrœrir+r“r+r/rkšsrkrŠr‹rŒr+r“r/Útest_cnameWithoutGlueRecordss & z$MXTests.test_cnameWithoutGlueRecordscsXGdd„dƒ}d‰|ƒˆj_ˆj dˆ¡}ˆ |tjjj¡‡‡fdd„}| |¡|S)zÉ If L{MXCalculator.getMX} encounters a CNAME chain which is longer than the length specified, the returned L{Deferred} should errback with L{CanonicalNameChainTooLong}. c@seZdZdZdZdd„ZdS)z.MXTests.test_cnameChain..DummyResolverz Fake resolver which generates a CNAME chain of infinite length in response to MX lookups. rcSs<|jd7_d|jf}t t|tjt|ƒdgggf¡S)Nrhúx-%d.example.comrt)Ú chainCounterr r:rrrv)rVr_rŸr+r+r/riÔs ýÿ÷ÿzAMXTests.test_cnameChain..DummyResolver.lookupMailExchangeN)r\rqrrrœr™rir+r+r+r/rkÌs rkr'r’cs:ˆ |jdtdˆdfƒ¡ˆ ˆjjjˆd¡dS)Nrr˜rh)rCÚargsrrYrOr™)rv©Ú cnameLimitrVr+r/ÚcbChainTooLongêsÿz/MXTests.test_cnameChain..cbChainTooLong) rYrOr\rÚtwistedrr ÚCanonicalNameChainTooLongr«)rVrkrWrr+r›r/Útest_cnameChainÅs  zMXTests.test_cnameChaincsVg‰d‰d‰d‰G‡‡‡‡fdd„dƒ}|ƒ|j_|j ˆ¡}| |jtˆd¡|S)zü If an MX lookup returns a CNAME and the MX record for the CNAME, the L{Deferred} returned by L{MXCalculator.getMX} should be called back with the name from the MX record without further lookups being attempted. rr‘r’cseZdZ‡‡‡‡fdd„ZdS)z8MXTests.test_cnameWithGlueRecords..DummyResolverc sL|ˆksˆr gggfSt tˆtjtˆƒdtˆtjtˆddgggf¡S)NrtrŠ)r r:rrrvrr–©r”r•r–ÚlookedUpr+r/ris$  ýýú òÿzKMXTests.test_cnameWithGlueRecords..DummyResolver.lookupMailExchangeNrjr+r¡r+r/rkÿsrkrŠr‹rŒr+r¡r/Útest_cnameWithGlueRecordsós  z!MXTests.test_cnameWithGlueRecordscsHd‰d‰G‡‡fdd„dƒ}|ƒ|j_|j ˆ¡}| |tjjj¡|S)zç If an MX lookup returns two CNAME records which point to each other, the loop should be detected and the L{Deferred} returned by L{MXCalculator.getMX} should be errbacked with L{CanonicalNameLoop}. zcname1.example.comzcname2.example.comcrf)z.DummyResolvercs4t tˆtjtˆƒdtˆtjtˆƒdgggf¡S)Nrt)r r:rrrvr–©Ú firstAliasÚ secondAliasr+r/ri's ýýú òÿzOMXTests.test_cnameLoopWithGlueRecords..DummyResolver.lookupMailExchangeNrjr+r¤r+r/rk&rlrk)rYrOr\rržrr ÚCanonicalNameLooprŒr+r¤r/Útest_cnameLoopWithGlueRecordss  z%MXTests.test_cnameLoopWithGlueRecordscCs$gd¢|jjd<|j d¡ |j¡S)N)zmx1.test.domainzmx2.test.domainzmx3.test.domainr‘)rEr6rYr\r«Ú_cbManyRecordsSuccessfulLookuprbr+r+r/ÚtestManyRecords@s ÿzMXTests.testManyRecordscCsH| t|jƒ dd¡ddv¡|j t|jƒ¡|j d¡ |j|¡S)NÚ.rhr)Úmx1Úmx2Úmx3r‘) rNr]rŸr–rYr|r\r«Ú_cbManyRecordsDifferentResultr`r+r+r/r©Ks  ÿz&MXTests._cbManyRecordsSuccessfulLookupcCsB| t|jƒt|jƒ¡|j t|jƒ¡|j d¡ |j||¡Srd)rÝr]rŸrYr|r\r«Ú_cbManyRecordsLastResult)rVÚnextMXrYr+r+r/r¯Rs  ÿz%MXTests._cbManyRecordsDifferentResultcCsj| t|jƒt|jƒ¡| t|jƒt|jƒ¡|j t|jƒ¡|j t|jƒ¡|j d¡ |j|¡Srd) rÝr]rŸrYr|r„r\r«Ú"_cbManyRecordsRepeatSpecificResult)rVÚlastMXrYr±r+r+r/r°Zs ÿz MXTests._cbManyRecordsLastResultcCs| t|jƒt|jƒ¡dSrxrm)rVÚagainMXr±r+r+r/r²esz*MXTests._cbManyRecordsRepeatSpecificResultN)r\rqrrrœrzr©rZrrsrtr^r]rcrerqrzr}rrƒr…rrr—r r£r¨rªr©r¯r°r²r+r+r+r/rW¹s8 $5.*#   rWc@s`eZdZe ed¡durdZdd„Zdd„Ze e j dkdƒd d „ƒZ e e j dkdƒd d „ƒZ dS) ÚLiveFireExerciseTestsNz1UDP support is required to determining MX recordscCst|ƒgd¢|_dS)N)Ú domainDirÚinsertionDomainÚinsertionQueueÚdestinationDomainÚdestinationQueue)rQÚtmpdirsrbr+r+r/rznszLiveFireExerciseTests.setUpcCs*|jD] }tj |¡rt |¡qt|ƒSrx)r»r§r±r~r1r2rV)rVrWr+r+r/r©xs   €zLiveFireExerciseTests.tearDownr&r(csütj ¡}|j tj ¡¡tj |d¡‰ˆ  dd¡|  dˆ¡|j d|j d<t |j djˆ  ¡ƒ| tj |¡¡| ¡}tjd|ddˆ_tgd ¢ƒ‰tƒ‰t ¡}‡fd d „|_‡fd d „|_t dˆj ¡j|¡‡‡fd d„}ˆ |¡ˆS)Nr¶rnrƒr‘rÆrr»rB)ú HELO mesonzMAIL FROM: zRCPT TO: ÚDATAúThis is the messager«ÚQUITcrrxr+r+©r0r+r/rœr z9LiveFireExerciseTests.testLocalDelivery..có ˆ d¡Srx©Úcallback©rš©rÿr+r/ró cs>ˆ ddtj¡d}| d¡ ¡}ˆ | d¡d¡ˆj ¡S©Nrnrhrr¾éÿÿÿÿ) rprrqrÚrµrÝÚfindÚ smtpServerrM©Úignrr*)r_rVr+r/Úfinished s z9LiveFireExerciseTests.testLocalDelivery..finished)rrŠÚ smtpPortalr¾rreÚAllowAnonymousAccessrÒrYr„r‹rÈr½rdÚsetQueuerÝrÞrÁr rHrÊr rr Ú ClientFactoryÚclientConnectionLostÚ connectTCPrJrIr«)rVr—r¢rÍr+)r0r_rÿrVr/ÚtestLocalDelivery~s*   ÿ  z'LiveFireExerciseTests.testLocalDeliverycsÐtj ¡}|j tj ¡¡tj |d¡‰|  dˆ¡t   d¡|  tj  d¡¡|j tj |¡¡tj  |j¡‰ˆjd7_tj  ˆd¡‰tj  ˆj¡ˆ_dgˆjjd<| ¡}tjd|dd ˆ_tj ¡}|j tj ¡¡tj |d ¡‰ˆ  d d ¡|  dˆ¡t   d ¡|  tj  d ¡¡tj  ˆd¡‰ˆ !¡| ¡}tjd|dd ˆ_"ˆj" #¡j$ˆ_%t&gd¢ƒ‰t'ƒ‰t( )¡}‡fdd„|_(‡fdd„|_*t +dˆj #¡j$|¡‡‡‡‡fdd„}ˆ ,|¡ˆS)Nr·zinsertion.domainr¸)ztest.identity.hostnamerhr»zdestination.domainrrBr¹rnrƒrº)r¼zMAIL FROM: z"RCPT TO: r½r¾r«r¿crrxr+r+rÀr+r/ràr z9LiveFireExerciseTests.testRelayDelivery..crÁrxrÂrÄrÅr+r/rárÆcs&ˆ ¡}‡‡‡fdd„}| |¡|S)NcsTˆ ddtj¡d}| d¡ ¡}ˆ | d¡d¡ˆj ¡ˆj  ¡ˆ  ¡dSrÇ) rprrqrÚrµrÝrÉÚ insServerrMÚ destServerÚ stopServicerË)r_ÚhelperrVr+r/Ú deliveredés    zLLiveFireExerciseTests.testRelayDelivery..finished..delivered)Ú checkStater«)rÌrrÙ)r_rØr rVr+r/rÍäs z9LiveFireExerciseTests.testRelayDelivery..finished)-rrŠrÎr¾rrerÏrÒrYr‹r§rírÐr rrTÚsetDefaultDomainrÝrÞÚSmartHostSMTPRelayingManagerrÚfArgsÚRelayStateHelperrXrOÚmxcalcrEr6rÁr rHrÕr„Ú startServicerÖrJrIÚPORTr rr rÑrÒrÓr«)rVÚinsServr¢ÚdestServrÍr+)r0r_rÿrØr rVr/ÚtestRelayDeliveryªsJ       ÿ  z'LiveFireExerciseTests.testRelayDelivery)r\rqrrr Ú IReactorUDPr Úskiprzr©rrsrtrÔrär+r+r+r/rµis  +rµc@ru) ÚLineBufferMessagecCsg|_d|_d|_dS)NF)ÚlinesÚeomÚlostrbr+r+r/r×úrzLineBufferMessage.__init__cCrrx)rèrÿ)rVr·r+r+r/r’ÿr{zLineBufferMessage.lineReceivedcCsd|_t d¡S)NTz )rér r:rbr+r+r/rªó zLineBufferMessage.eomReceivedcCs d|_dS)NT)rêrbr+r+r/r”rŽz LineBufferMessage.connectionLostN)r\rqrrr×r’rªr”r+r+r+r/rçùs  rçc@sdeZdZgd¢Zdd„Zeejdkdƒdd„ƒZdd „Z d d „Z eejdkdƒd d „ƒZ dd„Z dS)Ú AliasTests©z First linez Next linerÆzAfter a blank linez Last linecCsxi}gd¢}|D] }tj ||dd¡q| |dddg¡| |ddg¡| |dd g¡| |d gd ¢¡dS) N)zuser: another@host znextuser: |/bin/program zuser: me@again z"moreusers: :/etc/include/filename z3multiuser: first@host, second@host,last@anotherhostr#rnz another@hostzme@againÚnextuserz |/bin/programÚ moreusersz:/etc/include/filenameÚ multiuser)z first@hostz second@hostzlast@anotherhost)rr”ÚhandlerC)rVr³rèÚlr+r+r/Ú testHandles ÿzAliasTests.testHandler&r(cCs dtƒi}tjj|t t d¡ ¡¡d}|  t |ƒd¡|d}t |ƒ}dD] }|  |  |¡d¡q'|  t |ƒd¡|d }t |ƒ}d D] }|  |  |¡d¡qE|  t |ƒd¡|d }t |ƒ}|  |  d ¡d¡d D]}|  |  |¡dd|¡ql|  t |ƒd¡dS)NrÆa… # Here's a comment # woop another one testuser: address1,address2, address3, continuation@address, |/bin/process/this usertwo:thisaddress,thataddress, lastaddress lastuser: :/includable, /filename, |/program, address )r¤r'Útestuser)Úaddress1Úaddress2Úaddress3zcontinuation@addressz/bin/process/thisrÈrDÚusertwo)Ú thisaddressÚ thataddressÚ lastaddressÚlastuserz /includable)z /filenameÚprogramr z %s not found)rÇrr”Ú loadAliasFileržrŸÚtextwrapÚdedentÚencoderCrDr]rÝrÉ)rVrTr³ÚgroupÚsr<r+r+r/ÚtestFileLoader"s6 ÿ õþzAliasTests.testFileLoadercCsDtƒtƒtƒf}tj |¡}|jD]}| |¡q| ¡ |j|¡Srx) rçrr”Ú MultiWrapperrèr’rªr«Ú_cbMultiWrapper)rVrKr*ÚLr+r+r/ÚtestMultiWrapperQs    zAliasTests.testMultiWrappercCs6|D]}| |j¡| |j¡| |j|j¡qdSrx)rNrér°rêrCrè)rVrrKrr+r+r/rYs   ýzAliasTests._cbMultiWrappercCsH| ¡}tj |dd¡}| ¡}|jD]}| |¡q| ¡ |j |¡Srx) rrr”Ú FileAliasÚcreateMessageReceiverrèr’rªr«Ú_cbTestFileAlias)rVÚtmpfiler<rròr+r+r/Ú testFileAlias_s   zAliasTests.testFileAliascCsLt|ƒ }| ¡}Wdƒn1swY| dd„|Dƒ|j¡dS)NcSóg|]}|dd…‘qS©NrÈr+©r-rr+r+r/r4lr5z/AliasTests._cbTestFileAlias..©r¡Ú readlinesrCrè)rVrr r¢rèr+r+r/r ió  ÿzAliasTests._cbTestFileAliasN) r\rqrrrèrórrsrtrrrr r r+r+r+r/rì s .  rìc@s"eZdZdZdd„Zddd„ZdS)Ú DummyDomainz/ Test domain for L{AddressAliasTests}. cCs ||_dSrx)r )rVr r+r+r/r×trŽzDummyDomain.__init__Ncs|rtj d¡‚‡‡fdd„S)a  @returns: When a C{memo} is passed in this will raise a L{smtp.SMTPBadRcpt} exception, otherwise a boolean indicating if the C{user} and string version of L{self.address} are equal or not. @rtype: C{bool} ÚhamcsˆtˆjƒkSrx)r]r r+r­r+r/r‚sz$DummyDomain.exists..)rrr…r…r+r­r/r~ws zDummyDomain.existsrx)r\rqrrrœr×r~r+r+r+r/rosrc@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd S) ÚAddressAliasTestsz7 Tests for L{twisted.mail.alias.AddressAlias}. cCs:tj d¡|_|jjt|jƒi}tj |j||j¡|_dS)z+ Setup an L{AddressAlias}. zfoo@barN)rrrr r_rr”Ú AddressAlias)rVrTr+r+r/rz‹szAddressAliasTests.setUpcCs| |j ¡¡dS)z” L{createMessageReceiever} calls C{exists()} on the domain object which key matches the C{alias} passed to L{AddressAlias}. N)rNr”r rbr+r+r/Útest_createMessageReceiver“sz,AddressAliasTests.test_createMessageReceivercCs| t|jƒd¡dS)zP The string presentation of L{AddressAlias} includes the alias. z
N)rCr]r”rbr+r+r/rcšrUzAddressAliasTests.test_strcCs| |j |jdi¡d¡dS)z— L{resolve} will look for additional aliases when an C{aliasmap} dictionary is passed, and returns L{None} if none were found. rÜN)rCr”Úresolver rbr+r+r/Ú test_resolve szAddressAliasTests.test_resolvecCs| |j i¡d¡dS)z¡ L{resolve} returns L{None} when the alias could not be found in the C{aliasmap} and no L{mail.smtp.User} with this alias exists either. N)rCr”rrbr+r+r/Útest_resolveWithoutAliasmap§sz-AddressAliasTests.test_resolveWithoutAliasmapN) r\rqrrrœrzrrcrrr+r+r+r/r…s rc@seZdZdgZdS)Ú DummyProcessÚonEndN)r\rqrrÚ __slots__r+r+r+r/r¯s rc@r‡)ÚMockProcessAliaszD An alias processor that doesn't actually launch processes. cCódS)z( Don't spawn a process. Nr+)rVÚprotorýr±r+r+r/Ú spawnProcess¸r zMockProcessAlias.spawnProcessN)r\rqrrrœr"r+r+r+r/r³s rc@seZdZdZeZdS)ÚMockAliasGroupz3 An alias group using C{MockProcessAlias}. N)r\rqrrrœrÚprocessAliasFactoryr+r+r+r/r#¾sr#c@s(eZdZdZdd„Zdd„Zdd„ZdS) Ú StubProcessz— Fake implementation of L{IProcessTransport}. @ivar signals: A list of all the signals which have been sent to this fake process. cCs g|_dSrx)Úsignalsrbr+r+r/r×ÎrŽzStubProcess.__init__cCr )z8 No-op implementation of disconnection. Nr+rbr+r+r/ÚloseConnectionÑr zStubProcess.loseConnectioncCs|j |¡dS)zL Record a signal sent to this process for later inspection. N)r&rÿ)rVÚsignalr+r+r/Ú signalProcessÖszStubProcess.signalProcessN)r\rqrrrœr×r'r)r+r+r+r/r%Æs  r%c@s¼eZdZdZe ed¡durdZgd¢Zdd„Z dd„Z d d „Z d d „Z e ejd kdƒdd„ƒZdd„Zdd„Zdd„Zdd„Zdd„Ze ejd kdƒdd„ƒZe ejd kdƒdd„ƒZdS)ÚProcessAliasTestsz% Tests for alias resolution. NzIReactorProcess not supportedrícCsB|d>dB}| t |¡¡| t |¡|¡| t |¡¡|S)a Construct a status from the given exit code. @type code: L{int} between 0 and 255 inclusive. @param code: The exit status which the code will represent. @rtype: L{int} @return: A status integer for the given exit code. ér)rNr§Ú WIFEXITEDrCÚ WEXITSTATUSr°Ú WIFSIGNALED)rVÚcodeÚstatusr+r+r/Ú exitStatusès zProcessAliasTests.exitStatuscCs:|}| t |¡¡| t |¡|¡| t |¡¡|S)a Construct a status from the given signal. @type signal: L{int} between 0 and 255 inclusive. @param signal: The signal number which the status will represent. @rtype: L{int} @return: A status integer for the given signal. )rNr§r.rCÚWTERMSIGr°r,)rVr(r0r+r+r/Ú signalStatusýs zProcessAliasTests.signalStatuscCstj|_dt_dS)zB Replace L{smtp.DNSNAME} with a well-known value. rÆN)rÚDNSNAMErbr+r+r/rzs zProcessAliasTests.setUpcCs |jt_dS)z@ Restore the original value of L{smtp.DNSNAME}. N)r4rrbr+r+r/r©s zProcessAliasTests.tearDownr&r(csntˆ ¡ƒ}| d¡t |jd¡tj |jdd¡}|  ¡}ˆj D]}|  |¡q"‡fdd„}|  ¡  |¡S)z¤ Standard call to C{mail.alias.ProcessAlias}: check that the specified script is called, and that the input is correctly transferred to it. zX#!/bin/sh rm -f process.alias.out while read i; do echo $i >> process.alias.out doneiÀNcsLtdƒ }| ¡}Wdƒn1swYˆ dd„|Dƒˆj¡dS)Nzprocess.alias.outcSrrr+rr+r+r/r4;r5zPProcessAliasTests.test_processAlias.._cbProcessAlias..r)rr¢rèrbr+r/Ú_cbProcessAlias8rz._cbProcessAlias)rrÚ setContentr§Úchmodr±rr”Ú ProcessAliasr rèr’rªr«)rVÚshr<rròr5r+rbr/Útest_processAlias"s ÿ   z#ProcessAliasTests.test_processAliascstt ¡}tƒ‰tj ¡‰ˆ ˆ¡tj ˆd|¡}| ¡}|  |j ¡‡‡‡fdd„}ˆ  |tjj ¡|  |¡|S)a  If the alias child process does not exit within a particular period of time, the L{Deferred} returned by L{MessageWrapper.eomReceived} should fail with L{ProcessAliasTimeout} and send the I{KILL} signal to the child process.. Ncs*ˆ ˆjdg¡ˆ tˆ tj¡ƒ¡dS)NÚKILL)rCr&Ú processEndedrr3r(ÚSIGKILLr©r!rVršr+r/ÚtimedOutOsz.timedOut)rr;r%rr”ÚProcessAliasProtocolr‘ÚMessageWrapperrªr<ÚcompletionTimeoutrÚProcessAliasTimeoutr«)rVr ÚreceiverrWr?r+r>r/Útest_processAliasTimeout?s    z*ProcessAliasTests.test_processAliasTimeoutcCsNtƒ}tj ¡}| |¡tj |dd¡}| t t dƒ¡¡|  |  ¡t ¡S)z¿ If the process associated with an L{mail.alias.MessageWrapper} exits before I{eomReceived} is called, the L{Deferred} returned by I{eomReceived} should fail. Nr) r%rr”r@r‘rAr<rrrrrª)rVršr rDr+r+r/Útest_earlyProcessTerminationYó   z.ProcessAliasTests.test_earlyProcessTerminationcCsNtƒ}tj ¡}| |¡tj |dd¡}| t t |ƒ¡¡|  |  ¡t ¡S)zÕ Verify that if the process associated with an L{mail.alias.MessageWrapper} exits with the given status, the L{Deferred} returned by I{eomReceived} fails with L{ProcessTerminated}. N) r%rr”r@r‘rAr<rrrrrª)rVr0ršr rDr+r+r/Ú_terminationTestfrGz"ProcessAliasTests._terminationTestcCs| | d¡¡S)z¹ If the process associated with an L{mail.alias.MessageWrapper} exits with a non-zero exit code, the L{Deferred} returned by I{eomReceived} should fail. rh)rHr1rbr+r+r/Útest_errorProcessTerminationssz.ProcessAliasTests.test_errorProcessTerminationcCs| | tj¡¡S)z¼ If the process associated with an L{mail.alias.MessageWrapper} exits because it received a signal, the L{Deferred} returned by I{eomReceived} should fail. )rHr3r(ÚSIGHUPrbr+r+r/Útest_signalProcessTermination{sz/ProcessAliasTests.test_signalProcessTerminationc Csxi}dt|gd¢ƒi}tgd¢|dƒ}tddg|dƒ}tj d|d¡}| |||d œ¡| |¡}tt|j ƒ}|  ¡tttj d d d ¡tj  t ƒd ¡tj  d ¡gƒ}|  ¡| ||¡| |¡} tt| j ƒ} |   ¡tttj dd d ¡tj dd d ¡gƒ}|  ¡| | |¡| |¡} tt| j ƒ} |   ¡tttj d d d ¡tj  t ƒd ¡tj  d ¡gƒ}|  ¡| | |¡d S)aÅ Check that the C{resolve} method of alias processors produce the correct set of objects: - direct alias with L{mail.alias.AddressAlias} if a simple input is passed - aliases in a file with L{mail.alias.FileWrapper} if an input in the format '/file' is given - aliases resulting of a process call wrapped by L{mail.alias.MessageWrapper} if the format is '|process' rÆ)r[r]r_)r[ú|echoú/fileÚalias1r]r_Úalias2Úalias3©rNrOrPr[NÚechorM)Ú TestDomainr#rr”rrOrr½r]ÚobjsrIrArÚ FileWrapperrC) rVr‹r_ÚA1ÚA2ÚA3Úres1Úr1ÚexpectedÚres2Úr2Úres3Úr3r+r+r/Útest_aliasResolutionƒs\ ýÿ   ýþ   þþ    ýþz&ProcessAliasTests.test_aliasResolutionc Csüi}dt|gƒi}tj d|d¡}tj d|d¡}tj d|d¡}| |||dœ¡| |d |¡d¡| |d |¡d¡| |d |¡d¡tddg|dƒ}||d<| |¡}tt |j ƒ}|  ¡tt tj  t ƒd ¡gƒ} |   ¡| || ¡dS) zN Check that a cycle in alias resolution is correctly handled. rÆrOrNrPrQNrLÚalias4rR)rSrr”rrOrCrr#r½r]rTrIrAr) rVr‹r_rVrWrXÚA4ÚresÚrr[r+r+r/Útest_cyclicAliasÄs"  z"ProcessAliasTests.test_cyclicAlias)r\rqrrrœr ÚIReactorProcessr rærèr1r3rzr©rrsrtr:rErFrHrIrKr`rer+r+r+r/r*Ýs(    @r*c@r3)rScCs||_||_dSrx)r‹Úusers)rVr‹rgr+r+r/r×àrëzTestDomain.__init__Ncsnˆjj‰ˆ|jvr‡fdd„Sz|jˆ}Wn ty"t ˆ¡‚w| |j|¡‰ˆr2‡fdd„St ˆ¡‚)Ncstj ˆdd¡Srx)rr”rr+)rnr+r/rçsz#TestDomain.exists..crrxr+r+)r‹r+r/rïr )râÚlocalrgr‹r¦rr…r)rVrnr†r<r+)r‹rnr/r~äs    ÿ  zTestDomain.existsrx)r\rqrrr×r~r+r+r+r/rSßrArSc@s@eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dS)Ú DummyQueuezÒ A fake relay queue to use for testing. This queue doesn't keep track of which messages are waiting to be relayed or are in the process of being relayed. @ivar directory: See L{__init__}. cCr‰)zŽ @type directory: L{bytes} @param directory: The pathname of the directory holding messages in the queue. N)Ú directory)rVrjr+r+r/r×ýs zDummyQueue.__init__cCs8tj |¡}t | |¡d¡t | |¡d¡dS)z‹ Remove a message from the queue. @type message: L{bytes} @param message: The base filename of a message. rìrèN)r§r±Úbasenamer¨ÚgetPath©rVrjr+r+r/rÿ s zDummyQueue.donecCsttj |j|d¡dƒS)zé Get the envelope file for a message in the queue. @type message: L{bytes} @param message: The base filename of a message. @rtype: L{file} @return: The envelope file for the message. rèÚrb)r¡r§r±r7rjrmr+r+r/ÚgetEnvelopeFile s zDummyQueue.getEnvelopeFilecCstj |j|¡S)zõ Return the full base pathname of a message in the queue. @type message: L{bytes} @param message: The base filename of a message. @rtype: L{bytes} @return: The full base pathname of the message. )r§r±r7rjrmr+r+r/rl s zDummyQueue.getPathcCsvt ¡›dt|ƒ›}ttj |j|d¡dƒ}tj |j|d¡}tj |j|d¡}t|dƒ}|tj |||¡fS)zß Create a new message in the queue. @rtype: 2-L{tuple} of (E{1}) L{file}, (E{2}) L{FileMessage} @return: The envelope file and a message receiver for a new message in the queue. Ú_rèréz-Crì) ÚtimeÚidr¡r§r±r7rjrr£)rVÚfnameÚ headerFileÚ tempFilenameÚ finalFilenameÚ messageFiler+r+r/r( s ÿzDummyQueue.createNewMessagecCr )z© Ignore the request to mark a message as waiting to be relayed. @type message: L{bytes} @param message: The base filename of a message. Nr+rmr+r+r/r$: rˆzDummyQueue.setWaitingN) r\rqrrrœr×rÿrorlrr$r+r+r+r/riós    ric@r‡)Ú!DummySmartHostSMTPRelayingManagera4 A fake smart host to use for testing. @type managed: L{dict} of L{bytes} -> L{list} of L{list} of L{bytes} @ivar managed: A mapping of a string identifying a managed relayer to filenames of messages the managed relayer is responsible for. @ivar queue: See L{__init__}. cCsi|_||_dS)z´ Initialize the minimum necessary members of a smart host. @type queue: L{DummyQueue} @param queue: A queue that can be used for testing purposes. N)Úmanagedr)rVrr+r+r/r×P s z*DummySmartHostSMTPRelayingManager.__init__N)r\rqrrrœr×r+r+r+r/rxD s rxc@s°eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z eejdkdƒdd„ƒZeejdkdƒdd„ƒZdd„Zdd„Zd d!„Zd"d#„Zd$S)%Ú_AttemptManagerTestsa Test the behavior of L{_AttemptManager}. @type tmpdir: L{bytes} @ivar tmpdir: The path to a temporary directory holding the message files. @type reactor: L{MemoryReactorClock} @ivar reactor: The reactor used for test purposes. @type eventLog: L{None} or L{dict} of L{bytes} -> L{object} @ivar eventLog: Information about the last informational log message generated or none if no log message has been generated. @type noisyAttemptMgr: L{_AttemptManager} @ivar noisyAttemptMgr: An attempt manager which generates informational log messages. @type quietAttemptMgr: L{_AttemptManager} @ivar quietAttemptMgr: An attempt manager which does not generate informational log messages. @type noisyMessage: L{bytes} @ivar noisyMessage: The full base pathname of the message to be used with the noisy attempt manager. @type quietMessage: L{bytes} @ivar quietMessage: The full base pathname of the message to be used with the quiet. cCs^| ¡|_t |j¡tƒ|_d|_t |j ¡t t t |jƒƒd|jƒ|_ t t t |jƒƒd|jƒ|_d}d}tj |j|¡|_tj |j|¡|_t|jddƒ ¡t|jddƒ ¡|g|j jjd<|g|jjjd <t|jd d ƒ}t d d g|¡Wdƒn1s‡wYt|jd d ƒ}t ddg|¡WdƒdS1s¨wYdS)a Set up a temporary directory for the queue, attempt managers with the noisy flag on and off, message files for use with each attempt manager, and a reactor. Also, register to be notified when log messages are generated. NTFÚ noisyMessageÚ quietMessagerìržÚ noisyRelayerÚ quietRelayerrèrézfrom-noisy@domainzto-noisy@domainzfrom-quiet@domainzto-quiet@domain)rr•r§rír!r ÚeventLogrÚ addObserverÚ _logObserverrrxriÚnoisyAttemptMgrÚquietAttemptMgrr±r7r{r|r¡r¥r ryrïrð)rVÚ noisyBaseNameÚ quietBaseNameÚenveloper+r+r/rz{ s:    ý ýÿ"ÿz_AttemptManagerTests.setUpcCst |j¡t |j¡dS)zO Unregister for log events and remove the temporary directory. N)rÚremoveObserverrr1r2r•rbr+r+r/r©¨ s z_AttemptManagerTests.tearDowncCr‰)z A log observer. @type eventDict: L{dict} of L{bytes} -> L{object} @param eventDict: Information about the last informational log message generated. N)r)rVÚ eventDictr+r+r/r¯ s z!_AttemptManagerTests._logObservercCs"ttt|jƒƒƒ}| |j¡dS)z When an attempt manager is created without the noisy parameter, the noisy instance variable should default to true. N)rrxrir•rNr©rVÚamr+r+r/Útest_initNoisyDefault¹ sz*_AttemptManagerTests.test_initNoisyDefaultcCó| |jj¡dS)z• When an attempt manager is created with the noisy parameter set to true, the noisy instance variable should be set to true. N)rNr‚rrbr+r+r/Útest_initNoisyÁ óz#_AttemptManagerTests.test_initNoisycCrŒ)z— When an attempt manager is created with the noisy parameter set to false, the noisy instance variable should be set to false. N)r°rƒrrbr+r+r/Útest_initQuietÈ rŽz#_AttemptManagerTests.test_initQuietcCs$ttt|jƒƒƒ}| |jt¡dS)zŸ When an attempt manager is created without the reactor parameter, the reactor instance variable should default to the global reactor. N)rrxrir•rCr r‰r+r+r/Útest_initReactorDefaultÏ sz,_AttemptManagerTests.test_initReactorDefaultcCs| |jj|j¡dS)z“ When an attempt manager is created with a reactor provided, the reactor instance variable should default to that reactor. N)rCr‚r rbr+r+r/Útest_initReactor× sz%_AttemptManagerTests.test_initReactorcCó |j d|j¡| |j¡dS)zw For an attempt manager with the noisy flag set, notifySuccess should result in a log message. r}N)r‚rr{rNrrbr+r+r/Útest_notifySuccessNoisyÞ óz,_AttemptManagerTests.test_notifySuccessNoisycCr’)z| For an attempt manager with the noisy flag not set, notifySuccess should result in no log message. r~N)rƒrr|r°rrbr+r+r/Útest_notifySuccessQuietæ r”z,_AttemptManagerTests.test_notifySuccessQuietr&r(cCr’)zw For an attempt manager with the noisy flag set, notifyFailure should result in a log message. r}N)r‚rr{rNrrbr+r+r/Útest_notifyFailureNoisyî óz,_AttemptManagerTests.test_notifyFailureNoisycCr’)z| For an attempt manager with the noisy flag not set, notifyFailure should result in no log message. r~N)rƒrr|r°rrbr+r+r/Útest_notifyFailureQuiet÷ r—z,_AttemptManagerTests.test_notifyFailureQuietcCó|j d¡| |j¡dS)zt For an attempt manager with the noisy flag set, notifyDone should result in a log message. r}N)r‚rrNrrbr+r+r/Útest_notifyDoneNoisy ó z)_AttemptManagerTests.test_notifyDoneNoisycCr™)zy For an attempt manager with the noisy flag not set, notifyDone should result in no log message. r~N)rƒrr°rrbr+r+r/Útest_notifyDoneQuiet r›z)_AttemptManagerTests.test_notifyDoneQuietcCó(|j d¡| |j¡|j d¡dS)z| For an attempt manager with the noisy flag set, notifyNoConnection should result in a log message. r}r7N)r‚ÚnotifyNoConnectionrNrr r<rbr+r+r/Útest_notifyNoConnectionNoisy ó  z1_AttemptManagerTests.test_notifyNoConnectionNoisycCr)z For an attempt manager with the noisy flag not set, notifyNoConnection should result in no log message. r~r7N)rƒržr°rr r<rbr+r+r/Útest_notifyNoConnectionQuiet r z1_AttemptManagerTests.test_notifyNoConnectionQuietN)r\rqrrrœrzr©rr‹rrrr‘r“r•rrsrtr–r˜ršrœrŸr¡r+r+r+r/rz[ s(-    rz)}rœÚ email.messager Ú email.parserrêržr§rïr1r(rsr+rÿrqÚhashlibrÚunittestrÚzope.interfacerrÚzope.interface.verifyrÚtwisted.cred.checkersržÚtwisted.cred.credentialsÚtwisted.cred.portalÚtwisted.mail.aliasÚtwisted.mail.mailÚtwisted.mail.maildirÚtwisted.mail.protocolsÚtwisted.mail.relayÚtwisted.mail.relaymanagerrrÚtwisted.internetr r r r r rÚtwisted.internet.deferrÚtwisted.internet.errorrrrrÚ twisted.mailrrrÚ twisted.namesrÚtwisted.names.dnsrrrÚtwisted.names.errorrÚtwisted.pythonrrÚtwisted.python.filepathrÚtwisted.python.runtimerÚtwisted.test.proto_helpersr r!r"Útwisted.trial.unittestr#r%rvrˆrrºrÎrÒÚ _MaildirMailboxAppendMessageTaskrærýr r*r/rQrVrRrrrºr©rÖrØrærýrrr0r1r2r5r4rQrVrWrµrçrìrrrr”r8rÚ AliasGroupr#r%r*rSrirxrzr+r+r+r/Úsä             h  & 0  M ÿ  S ( X  s # NI  %)  D  2 d )  Q