U  W[@sTdZddlZddlZddlZddlmZmZddlmZddl m Z ddl m Z m Z ddlmZddlmZdd lmZmZGd d d eZGd d d eZGdddeZGdddeZGdddeZdddejidejejddejejdgZ GdddeZ!Gdddej"Z#Gdd d eZ$Gd!d"d"eZ%Gd#d$d$ejZ&Gd%d&d&eZ'Gd'd(d(e&e(Z)d)d*Z*Gd+d,d,eZ+Gd-d.d.eZ,Gd/d0d0ejZ-Gd1d2d2eZ.Gd3d4d4eZ/Gd5d6d6eZ0Gd7d8d8ejZ1Gd9d:d:eZ2Gd;d<dd>eZ4Gd?d@d@eZ5GdAdBdBeZ6GdCdDdDeZ7dS)Ez+ Tests for L{twisted.words.protocols.irc}. N)protocoltask)FilePath)unicode)StringTransportStringIOWithoutClosing)TestCase)irc) IRCClient attributesc@seZdZddZdS) IRCTestCasecCsN|}t|tr|d}t|tr>t|dtr>dd|D}|||dS)a$ A buffer is always bytes, but sometimes we need to compare it to a utf-8 unicode string @param buf: the buffer @type buf: L{bytes} or L{unicode} or L{list} @param val: the value to compare @type val: L{bytes} or L{unicode} or L{list} utf-8rcSsg|]}|dqS)utf8)decode).0br=/usr/lib/python3/dist-packages/twisted/words/test/test_irc.py &sz6IRCTestCase.assertEqualBufferValue..N) isinstancerrlist assertEqual)selfZbufval bufferValuerrrassertEqualBufferValues    z"IRCTestCase.assertEqualBufferValueN)__name__ __module__ __qualname__rrrrrr sr c@sdeZdZdZdZddZddZddZd d Zd d Z d dZ ddZ ddZ ddZ ddZdS)ModeParsingTestsz> Tests for L{twisted.words.protocols.irc.parseModes}. )ZklbrcCs|tjtjdgdS)zI Parsing an empty mode string raises L{irc.IRCBadModes}. N assertRaisesr IRCBadModes parseModesrrrrtest_emptyModes2sz ModeParsingTests.test_emptyModescCsT|tjtjdg|tjtjdg|tjtjdg|tjtjdgdS)z Parsing a mode string that contains an empty sequence (either a C{+} or C{-} followed directly by another C{+} or C{-}, or not followed by anything at all) raises L{irc.IRCBadModes}. z++kz-+k+-Nr!r%rrrtest_emptyModeSequence9sz'ModeParsingTests.test_emptyModeSequencecCs,|tjtjdg|tjtjdgdS)zp Parsing a mode string that does not start with C{+} or C{-} raises L{irc.IRCBadModes}. foo%Nr!r%rrrtest_malformedModesEsz$ModeParsingTests.test_malformedModescCs,|tjtjdg|tjtjdgdS)zk Parsing a mode string that contains no mode characters raises L{irc.IRCBadModes}. r'r(Nr!r%rrrtest_nullModesNszModeParsingTests.test_nullModescCsXtdg\}}||dg||gtdg\}}||g||dgdS)z Parsing a single mode setting with no parameters results in that mode, with no parameters, in the "added" direction and no modes in the "removed" direction. +ssN-sNr r$rrZaddedZremovedrrrtest_singleModeWs   z ModeParsingTests.test_singleModecCs^tdg\}}||dddg||gtdg\}}||g||ddgdS)z Parsing a single-direction mode setting with multiple modes and no parameters, results in all modes falling into the same direction group. z+stnr/tNnNz-ntNr2r3rrrtest_singleDirectionfs  z%ModeParsingTests.test_singleDirectioncCs4tdg\}}||dddg||dgdS)zL Parsing a multi-direction mode setting with no parameters. z+s-n+tir/r5iNr7Nr2r3rrrtest_multiDirectionws z$ModeParsingTests.test_multiDirectioncCs4tdg\}}||ddddg||gdS)z Parsing a multi-direction mode setting containing two consecutive mode sequences with the same direction results in the same result as if there were only one mode sequence in the same direction. z+sn+tir/r7r5r:Nr2r3rrrtest_consecutiveDirectionsz*ModeParsingTests.test_consecutiveDirectioncCs:|tjtjdg|j|tjtjddddg|jdS)z If the number of mode parameters does not match the number of modes expecting parameters, L{irc.IRCBadModes} is raised. z+kz+klr*Z10Zlulz_extra_paramN)r"r r#r$ paramModesr%rrrtest_mismatchedParamssz&ModeParsingTests.test_mismatchedParamscCstdddddg|j\}}||dddd g||gtd ddg|j\}}||g||d d dd gtd dddg|j\}}||dddd g||gdS)z Modes which require parameters are parsed and paired with their relevant parameter, modes which do not require parameters do not consume any of the parameters. z+klbbsomekey42nick!user@host other!*@*)kr@)lrA)rrB)rrCz-klbb)rDN)rENz+knbbr7N)r r$r>rr3rrrtest_parameterssB   z ModeParsingTests.test_parametersN)rrr__doc__r>r&r)r,r-r4r9r<r=r?rFrrrrr+s    rc@seZdZdZddZdS) MiscTestsz, Tests for miscellaneous functions. c Csb|ttjdddddgddd}|t|gdgdgdgdgggdgdgdgdgd S) z Apply a function of two arguments cumulatively to the items of a sequence, from right to left, so as to reduce the sequence to a single value. rcSs|d||S)Nr)insert)rExrrr insertTops z'MiscTests.test_foldr..insertTopN)rr Z_foldroperatorsub)rrPrrr test_foldrszMiscTests.test_foldrN)rrrrGrSrrrrrHsrHc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&S)'FormattedTextTestsz> Tests for parsing and assembling formatted IRC text. cCst|}|||dS)a+ Assert that C{text} is parsed and assembled to the same value as what C{expectedFormatted} is assembled to. This provides a way to ignore meaningless differences in the formatting structure that would be difficult to detect without rendering the structures. N)r parseFormattedTextassertAssemblesTo)rtextexpectedFormatted formattedrrrassertAssembledEquallys z)FormattedTextTests.assertAssembledEquallyc Cs8t|}t|}|t||d||||fdS)zg Assert that C{formatted} and C{expectedFormatted} assemble to the same value. z$%r (%r) is not equivalent to %r (%r)N)r assembleFormattedTextr)rrYrXrWZ expectedTextrrrrVs  z$FormattedTextTests.assertAssemblesTocCs|dtjdS)zO An empty string parses to a I{normal} attribute with no text. r N)rZAnormalr%rrrtest_parseEmptysz"FormattedTextTests.test_parseEmptycCs0|ttjd|ttjdddS)z An attribute with no text assembles to the empty string. An attribute whose text is the empty string assembles to two control codes: C{off} and that of the attribute. r zN)rr r[r\r]boldr%rrrtest_assembleEmptys z%FormattedTextTests.test_assembleEmptycCs|ttjdddS)zi A I{normal} string assembles to a string prefixed with the I{off} control code. hellozhelloN)rr r[r\r]r%rrrtest_assembleNormals z&FormattedTextTests.test_assembleNormalcCs|ttjdddS)zt A I{bold} string assembles to a string prefixed with the I{off} and I{bold} control codes. razhelloN)rr r[r\r_r%rrrtest_assembleBolds z$FormattedTextTests.test_assembleBoldcCs|ttjdddS)z An I{underline} string assembles to a string prefixed with the I{off} and I{underline} control codes. razhelloN)rr r[r\ underliner%rrrtest_assembleUnderline*s z)FormattedTextTests.test_assembleUnderlinecCs|ttjdddS)z A I{reverse video} string assembles to a string prefixed with the I{off} and I{reverse video} control codes. razhelloN)rr r[r\ reverseVideor%rrrtest_assembleReverseVideo5s z,FormattedTextTests.test_assembleReverseVideocCs|ttjjdddS)z A I{foreground color} string assembles to a string prefixed with the I{off} and I{color} (followed by the relevant foreground color code) control codes. raz 02helloN)rr r[r\fgbluer%rrrtest_assembleForegroundColor@s  z/FormattedTextTests.test_assembleForegroundColorcCs|ttjjdddS)a A I{background color} string assembles to a string prefixed with the I{off} and I{color} (followed by a I{,} to indicate the absence of a foreground color, followed by the relevant background color code) control codes. raz ,02helloN)rr r[r\bgrir%rrrtest_assembleBackgroundColorLs  z/FormattedTextTests.test_assembleBackgroundColorcCs&|ttjjtjjdddS)z A I{foreground} and I{background} color string assembles to a string prefixed with the I{off} and I{color} (followed by the relevant foreground color, I{,} and the relevant background color code) control codes. raz 05,02helloN)rr r[r\rhredrkrir%rrrtest_assembleColorYs z%FormattedTextTests.test_assembleColorcCs\|ttjdtjdfd|ttjtjjtj j ddftj dfddS)zK Nested attributes retain the attributes of their parents. ra worldzhello worldz yayz05,03hello05 world yayN) rr r[r\r_rdr]rhrmrkgreenrfr%rrrtest_assembleNestedfs z&FormattedTextTests.test_assembleNestedcCs|tdtjddS)zk Parsing unformatted text results in text with attributes that constitute a no-op. raN)rr rUr\r]r%rrrtest_parseUnformattedTextwsz,FormattedTextTests.test_parseUnformattedTextcCsf|tdtjjd|tdtjjtjjd|tdtjjdtjjdfdS)z Correctly formatted text with colors uses 2 digits to specify foreground and (optionally) background. z01yayyayz 01,02yayz01yay02yipeeZyipeeN)rr rUr\rhblackrkrir%rrrtest_colorFormattings z'FormattedTextTests.test_colorFormattingcCs|dtjjd|dtjjd|dtjjtjjd|dtjjtjjd|dtjjtjjd |d tjd |d tjd |dtjjd|dtjdS)a Formatted text with colors can use 1 digit for both foreground and background, as long as the text part does not begin with a digit. Foreground and background colors are only processed to a maximum of 2 digits per component, anything else is treated as text. Color sequences must begin with a digit, otherwise processing falls back to unformatted text. z 1kinda validz kinda validz999,999kinda validz9,999kinda validz1,2kinda validz1,999kinda validz 9kinda validz1,242 is a special numberz2 is a special numberz ,02oopsz,02oopszwrongwrongz1,hellorazN) rZr\rhrtrprkriZyellowr]r%rrrtest_weirdColorFormattingsH    z,FormattedTextTests.test_weirdColorFormattingcCsH|dtjtjjddf|dtjtjjtjjddfdS)zb An empty color format specifier clears foreground and background colors. z 01yayresetrsresetz01,02yayresetN)rZr\r]rhrtrkrir%rrrtest_clearColorFormattingsz,FormattedTextTests.test_clearColorFormattingcCsj|dtjtjtjddf|dtjtjjddf|dtjtjjtjjddfdS)zL A reset format specifier clears all formatting attributes. z yayresetrsrxz 01yayresetz01,02yayresetN) rZr\r]r_rdrhrtrkrir%rrrtest_resetFormattingsz'FormattedTextTests.test_resetFormattingc CsB|tttjtjtjtjj tj j ddfddS)zZ Strip formatting codes from formatted text, leaving only the text parts. raroz hello worldN) rr ZstripFormattingr[r\r_rdrfrhrmrkrpr%rrrtest_stripFormattingsz'FormattedTextTests.test_stripFormattingN)rrrrGrZrVr^r`rbrcrergrjrlrnrqrrrurwryrzr{rrrrrTs&         & rTc@seZdZdZddZdS)FormattingStateAttributeTestszD Tests for L{twisted.words.protocols.irc._FormattingState}. c Cs|tt|ttjdd|tjddddtjddtjddddtjdd|tjddtjdddS)z L{irc._FormattingState}s must have matching character attribute values (bold, underline, etc) with the same values to be considered equal. F)offTri)r_rdr}rfZ foreground)r_N)rr Z_FormattingStateZ _IRC_COLORSassertNotEqualr%rrr test_equalitys8   z+FormattingStateAttributeTests.test_equalityN)rrrrGrrrrrr|sr|z3Hello, this is a nice string with no complications.z'xargs%(NUL)smight%(NUL)slike%(NUL)sthisNULz*embedded%(CR)snewline%(CR)s%(NL)sFUN%(NL)s)CRNLz,escape!%(X)s escape!%(M)s %(X)s%(X)sa %(M)s0)XMc@seZdZddZddZdS) QuotingTestsc Cs&tD]}||tt|qdS)z< Testing client-server level quote/dequote. N)stringSubjectsrr Z lowDequoteZlowQuoterr0rrrtest_lowquoteSanity sz QuotingTests.test_lowquoteSanityc Cs&tD]}||tt|qdS)z; Testing CTCP message level quote/dequote. N)rrr Z ctcpDequoteZ ctcpQuoterrrrtest_ctcpquoteSanitysz!QuotingTests.test_ctcpquoteSanityN)rrrrrrrrrr src@s$eZdZdZdZddZddZdS) DispatcherzS A dispatcher that exposes one known command and handles unknown commands. dispcCs||fS)z9 A known command that returns its input. r)rarrrr disp_working$szDispatcher.disp_workingcCs |||fS)zM Handle unknown commands by returning their name and inputs. r)rnamerrrrr disp_unknown+szDispatcher.disp_unknownN)rrrrGprefixrrrrrrrsrc@s(eZdZdZddZddZddZdS) DispatcherTestsz3 Tests for L{irc._CommandDispatcherMixin}. cCs(t}d}|jd|}|||dS)zD Dispatching a command invokes the correct handler. rIrJworkingN)rrdispatchr)rrargsresrrr test_dispatch7szDispatcherTests.test_dispatchcCs4t}d}d}|j|f|}|||f|dS)zM Dispatching an unknown command invokes the default handler. ZmissingrNr)rrrrrrrrtest_dispatchUnknownAs z$DispatcherTests.test_dispatchUnknowncCs"t}d|_|tj|jddS)z Dispatching an unknown command, when no default handler is present, results in an exception being raised. Nbar)rrr"r ZUnhandledCommandr)rrrrrtest_dispatchMissingUnknownLsz+DispatcherTests.test_dispatchMissingUnknownN)rrrrGrrrrrrrr3s  rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ d9ddZ d:ddZ d;ddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8ZdS)<ServerSupportedFeatureTestszE Tests for L{ServerSupportedFeatures} and related functions. cCsr|tdd|tgd|tdd|tddd|tdd|tdddS)zt L{_intOrDefault} converts values to C{int} if possible, otherwise returns a default value. Nr raZ123{)rr _intOrDefaultr%rrrtest_intOrDefault[s z-ServerSupportedFeatureTests.test_intOrDefaultc Csdddgffdddgffdddgffdddddgffd dd gffd dd gffd ddgffdddgffg}tjj}|D]\}}||}|||qt|t|d|t|d|t|d|t|ddS)a L{ServerSupportedFeatures._splitParam} splits ISUPPORT parameters into key and values. Parameters without a separator are split into a key and a list containing only the empty string. Escaped parameters are unescaped. ZFOOr zFOO=zFOO=11z FOO=1,2,323z FOO=A\x20BzA Bz FOO=\x5Cxz\xzFOO=\\zFOO=\nz\nzFOO=\xzFOO=\xNNzFOO=\xNz FOO=\x20\xN)r ServerSupportedFeatures _splitParamrr" ValueError)rZparamsrparamexpectedrrrrtest_splitParamhs"         z+ServerSupportedFeatureTests.test_splitParamcCs,tjddddg}||ddddgd S) z L{ServerSupportedFeatures._splitParamArgs} splits ISUPPORT parameter arguments into key and value. Arguments without a separator are split into a key and an empty string. A:1B:2zC:D)r\r)Br)Cr )rr N)r r_splitParamArgsrrrrrrtest_splitParamArgss z/ServerSupportedFeatureTests.test_splitParamArgscCs,tjdddgtj}||dddgdS)z L{ServerSupportedFeatures._splitParamArgs} uses the argument processor passed to convert ISUPPORT argument values to some more suitable form. rrr)r\rI)rrJ)rNN)r rrrrrrrrtest_splitParamArgsProcessorsz8ServerSupportedFeatureTests.test_splitParamArgsProcessorcCs@tjj}||dd|t|d||dddddS)a  L{ServerSupportedFeatures._parsePrefixParam} parses the ISUPPORT PREFIX parameter into a mapping from modes to prefix symbols, returns L{None} if there is no parseable prefix parameter or raises C{ValueError} if the prefix parameter is malformed. r Nraz(ov)@+@r)r'rI)ov)r r_parsePrefixParamrr"r)rrrrrtest_parsePrefixParams z1ServerSupportedFeatureTests.test_parsePrefixParamc Cstjj}||ddddgddddd||ddddgddddd||ddddgddddd|t|dddd d gd S) aO L{ServerSupportedFeatures._parseChanModesParam} parses the ISUPPORT CHANMODES parameter into a mapping from mode categories to mode characters. Passing fewer than 4 parameters results in the empty string for the relevant categories. Passing more than 4 parameters raises C{ValueError}. r Z addressModesrZsetParamZnoParamrrDrEZimnpstrcdeN)r r_parseChanModesParamrr"r)rrrrrtest_parseChanModesParams< z4ServerSupportedFeatureTests.test_parseChanModesParamcCst}|dddddg||dd||dd d g||dd ||d d ||dd||d|dg||d|dgdS)a L{ServerSupportedFeatures.parse} changes the internal state of the instance to reflect the features indicated by the parsed ISUPPORT parameters, including unknown parameters and unsetting previously set parameters. MODES=4zCHANLIMIT=#:20,&:10INVEXz EXCEPTS=Zz UNKNOWN=A,B,CMODESrLZ CHANLIMIT)#)& IEXCEPTSZZUNKNOWN)r\rrz-INVEXN)r rparser getFeature assertTrue hasFeatureZ assertFalse)r supportedrrr test_parses(  z&ServerSupportedFeatureTests.test_parsecCs$t}dd|D}|||S)z Parse all specified features according to the ISUPPORT specifications. @type features: C{list} of C{(featureName, value)} @param features: Feature names and values to parse @rtype: L{irc.ServerSupportedFeatures} cSs g|]\}}d||pdfqS)z%s=%sr r)rrvaluerrrrsz6ServerSupportedFeatureTests._parse..)r rr)rfeaturesrrrr_parses  z"ServerSupportedFeatureTests._parseNcCs|||fg}||S)z Parse a feature, with the given name and value, according to the ISUPPORT specifications and return the parsed value. )rr)rrrrrrr _parseFeaturesz)ServerSupportedFeatureTests._parseFeaturecCs@|||d||||d||||dddS)zW Perform some common tests on a feature known to use L{_intOrDefault}. NZnotanintrA*rr)rrdefaultrrr_testIntOrDefaultFeatures   z4ServerSupportedFeatureTests._testIntOrDefaultFeaturecCsLtj|}|dkrdg}||}|||||||dS)z Features known to have default values are reported as being present by L{irc.ServerSupportedFeatures.hasFeature}, and their value defaults correctly, when they don't appear in an ISUPPORT message. N)ZDEFINITELY_NOTZ a_feature)r r _featuresrrrrr)rrrrrrrr_testFeatureDefaults  z/ServerSupportedFeatureTests._testFeatureDefaultcCs|d|ddg|ddg||ddddddd||ddddddd||dd dd d d dd S)z The CHANMODES ISUPPORT parameter is parsed into a C{dict} giving the four mode categories, C{'addressModes'}, C{'param'}, C{'setParam'}, and C{'noParam'}. CHANMODES)rzb,,lk,)rz b,,lk,ha,haz,,,r rz,A,,r\z A,Bc,Def,GhijZBcZDefZGhijNrrrr%rrrtest_support_CHANMODES%s6    z2ServerSupportedFeatureTests.test_support_CHANMODEScCs||dddgdS)z The IDCHAN support parameter is parsed into a sequence of two-tuples giving channel prefix and ID length pairs. ZIDCHANz!:5)!5Nrr%rrrtest_support_IDCHANEs z/ServerSupportedFeatureTests.test_support_IDCHANcCsP||ddddg||dddddg||dddddgdS) z~ The MAXLIST support parameter is parsed into a sequence of two-tuples giving modes and their limits. ZMAXLISTz b:25,eI:50)r)ZeI2zb:25,eI:50,a:3.1415)rNzb:25,eI:50,a:notanintNrr%rrrtest_support_MAXLISTOs   z0ServerSupportedFeatureTests.test_support_MAXLISTcCs||ddddS)zr The NETWORK support parameter is parsed as the network name, as specified by the server. ZNETWORKZIRCNetNrr%rrrtest_support_NETWORK`s z0ServerSupportedFeatureTests.test_support_NETWORKcCs||dddS)z The SAFELIST support parameter is parsed into a boolean indicating whether the safe "list" command is supported or not. ZSAFELISTTNrr%rrrtest_support_SAFELISTjsz1ServerSupportedFeatureTests.test_support_SAFELISTcCs||ddddS)z The STATUSMSG support parameter is parsed into a string of channel status that support the exclusive channel notice method. Z STATUSMSGz@+Nrr%rrrtest_support_STATUSMSGts z2ServerSupportedFeatureTests.test_support_STATUSMSGcCsV||ddddd||dddddd||dd dddddS) z The TARGMAX support parameter is parsed into a dictionary, mapping strings to integers, of the maximum number of targets for a particular command. ZTARGMAXzPRIVMSG:4,NOTICE:3rLrK)PRIVMSGNOTICEzPRIVMSG:4,NOTICE:3,KICK:3.1415N)rrZKICKz PRIVMSG:4,NOTICE:3,KICK:notanintrr%rrrtest_support_TARGMAX~s(   z0ServerSupportedFeatureTests.test_support_TARGMAXcCstjd}|d|dS)a The NICKLEN support parameter is parsed into an integer value indicating the maximum length of a nickname the client may use, otherwise, if the parameter is missing or invalid, the default value (as specified by RFC 1459) is used. ZNICKLENNr rrrrrrrrtest_support_NICKLENsz0ServerSupportedFeatureTests.test_support_NICKLENcCstjd}|d|dS)z The CHANNELLEN support parameter is parsed into an integer value indicating the maximum channel name length, otherwise, if the parameter is missing or invalid, the default value (as specified by RFC 1459) is used. Z CHANNELLENNrrrrrtest_support_CHANNELLENsz3ServerSupportedFeatureTests.test_support_CHANNELLENcCs"|d||ddddS)zt The CHANTYPES support parameter is parsed into a tuple of valid channel prefix characters. Z CHANTYPESz#&%)rrr+Nrr%rrrtest_support_CHANTYPESs   z2ServerSupportedFeatureTests.test_support_CHANTYPEScCs|ddS)z The KICKLEN support parameter is parsed into an integer value indicating the maximum length of a kick message a client may use. ZKICKLENNrr%rrrtest_support_KICKLENsz0ServerSupportedFeatureTests.test_support_KICKLENcCsh|d|ddg||ddd||dddddd||dd dddddS) z The PREFIX support parameter is parsed into a dictionary mapping modes to two-tuples of status symbol and priority. PREFIX)rraNz(ohv)@%+r)r+rI)r'rJ)rhrz(hov)@%+rr%rrrtest_support_PREFIXs(    z/ServerSupportedFeatureTests.test_support_PREFIXcCs|ddS)z The TOPICLEN support parameter is parsed into an integer value indicating the maximum length of a topic a client may set. ZTOPICLENNrr%rrrtest_support_TOPICLENsz1ServerSupportedFeatureTests.test_support_TOPICLENcCs|ddS)a_ The MODES support parameter is parsed into an integer value indicating the maximum number of "variable" modes (defined as being modes from C{addressModes}, C{param} or C{setParam} categories for the C{CHANMODES} ISUPPORT parameter) which may by set on a channel by a single MODE command from a client. rNrr%rrrtest_support_MODESsz.ServerSupportedFeatureTests.test_support_MODEScCs*||ddd||dddS)z The EXCEPTS support parameter is parsed into the mode character to be used for "ban exception" modes. If no parameter is specified then the character C{e} is assumed. rrrNrr%rrrtest_support_EXCEPTSs z0ServerSupportedFeatureTests.test_support_EXCEPTScCs*||ddd||dddS)z The INVEX support parameter is parsed into the mode character to be used for "invite exception" modes. If no parameter is specified then the character C{I} is assumed. rrrNrr%rrrtest_support_INVEXs z.ServerSupportedFeatureTests.test_support_INVEX)N)N)N)rrrrGrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrWs8   #           rc@seZdZdZdS)IRCClientWithoutLoginrN)rrr performLoginrrrrrsrc@s@eZdZdZddZddZddZdd Zd d Zd d Z dS) CTCPTestszK Tests for L{twisted.words.protocols.irc.IRCClient} CTCP handling. cCsNt|_t|j|_t|_|j|j||jj ||jj ddSN) rfiler FileWrapper transportrclientmakeConnection addCleanuploseConnectionconnectionLostr%rrrsetUps zCTCPTests.setUpcCsVdtjtjtjd}dtjtjtjd}|j||j}|||dS)zTesting CTCP query ERRMSG. Not because this is this is an especially important case in the field, but it does go through the entire dispatch/decode/encode process. z@:nick!guy@over.there PRIVMSG #theChan :%(X)cERRMSG t%(X)c%(EOL)srEOLz>NOTICE nick :%(X)cERRMSG t :No error has occurred.%(X)c%(EOL)sN) r X_DELIMrLFr dataReceivedrgetvaluer)rZerrQueryZerrReplyreplyrrr test_ERRMSGs    zCTCPTests.test_ERRMSGcCsPd|j_|jddddtjtjtj|jjd}|j}| ||dS)z If attributes for version information on L{IRCClient} are set to L{None}, the parts of the CTCP VERSION response they correspond to are omitted. FrobozzIRCnick!guy@over.there#theChanNz1NOTICE nick :%(X)cVERSION %(vname)s::%(X)c%(EOL)s)rrvname) r versionNamectcpQuery_VERSIONr rrrrr rrZ versionReplyr rrrtest_noNumbersVERSION1s  zCTCPTests.test_noNumbersVERSIONcCsld|j_d|j_d|j_|jddddtjtjtj|jj|jj|jjd}|j }| ||dS) z The response to a CTCP VERSION query includes the version number and environment information, as specified by L{IRCClient.versionNum} and L{IRCClient.versionEnv}. r z1.2gZZorkOSr rNzANOTICE nick :%(X)cVERSION %(vname)s:%(vnum)s:%(venv)s%(X)c%(EOL)s)rrrZvnumvenv) rrZ versionNumZ versionEnvrr rrrrr rrrrrtest_fullVERSIONBs  zCTCPTests.test_fullVERSIONcsZfdd}d_|j_jddddtjigjd jd d S) zL Duplicated CTCP messages are ignored and no reply is made. csjd7_dSNrI)calleduserchanneldatar%rrtestCTCP[sz8CTCPTests.test_noDuplicateCTCPDispatch..testCTCPrfoo!bar@baz.quux#chanz'%(X)sTESTTHIS%(X)sfoo%(X)sTESTTHIS%(X)srr rIN) rrZctcpQuery_TESTTHIS irc_PRIVMSGr rrrr r)rrrr%rtest_noDuplicateCTCPDispatchWs  z&CTCPTests.test_noDuplicateCTCPDispatchcsfdd}d_jd|jddddtjigjd  j d  jd jddd dtjig jd dS)zQ The fallback handler is invoked for unrecognized CTCP messages. cs ||||f_jd7_dSr) calledWithr)rrtagrr%rr unknownQuerymsz6CTCPTests.test_noDefaultDispatch..unknownQueryrZctcpUnknownQueryrrz%(X)sNOTREAL%(X)srr )rrZNOTREALNrIz%%(X)sNOTREAL%(X)sfoo%(X)sNOTREAL%(X)srJN) rpatchrrr rrrr rr!)rr#rr%rtest_noDefaultDispatchis,   z CTCPTests.test_noDefaultDispatchN) rrrrGrr rrr r%rrrrr s rcsdeZdZdddddddddddd d dd d d d ddddddddZddZfddZddZZS)NoticingClientZwheninfo servernameversionZumodesZcmodes)options)channels)ops)motdrrmessage)r)rrsetmodesr)rZsecsr)rkickerr2nick)rr)rrr5r2r)rrZnewTopic)ZoldnameZnewname)createdyourHostmyInfo luserClientbounceisupport luserChannelsluserOpluserMe receivedMOTDprivmsgjoinedleftnoticed modeChangedZpongZsignedOn kickedFromZ nickChanged userJoineduserLeft userKickedaction topicUpdatedZ userRenamedcOs g|_dSr)calls)rrkwrrr__init__szNoticingClient.__init__csr|dr$|dr$tt||Sztt|d|}Wn$tk r`tt||YSX|||SdS)N__methods) startswithendswithsuperr&__getattribute__KeyError makeMethod)rrr __class__rrrUszNoticingClient.__getattribute__csfdd}|S)Ncst|tkr*tdtt|ft|D]*\}}||krVtd|fq4|||<q4t|tkrtdtt|fj|fdS)Nz-TypeError: %s() takes %d arguments (%d given)z=TypeError: %s() got multiple values for keyword argument '%s')len TypeErrorziprMappend)rrNrrrfnamerrrmethods z)NoticingClient.makeMethod..methodr)rr_rr`rr^rrWszNoticingClient.makeMethod)rrrrQrOrUrW __classcell__rrrXrr&s: r&cCs4z ||}Wntk r$|YSX||=|SdSr)rV)dictkeyrrrrrpops   rdc@seZdZddZddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd?d'd(Zd@d)d*ZdAd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Zd=d>Z d&S)BClientImplementationTestscCs@t|_t|_|j|j||jj||jjddSr)rrr&rrrrrr%rrrrs zClientImplementationTests.setUpc Ksvt|dd}t|dd}t|dd}d|d|d|d|d |d }|j|||jj||fgdS) Nhost server.hostr7nicknamerr :  : rdrrrrM) rcodemsgfuncrNrfr7rr2rrr_serverTestImpls:    z)ClientImplementationTests._serverTestImplcCsd}|jd|d|ddS)NzHYour host is some.host[blah.blah/6667], running version server-version-3Z002r9r(rqrrorrr testYourHostsz&ClientImplementationTests.testYourHostcCsd}|jd|d|ddS)Nz=This server was cobbled together Fri Aug 13 18:00:25 UTC 2004Z003r8r'rrrsrrr testCreatedsz%ClientImplementationTests.testCreatedc Cs d}|jd|dddddddS) Nz(server.host server-version abcDEF bcdEHIZ004r:rgzserver-versionZabcDEFZbcdEHIr*rrrsrrr testMyInfos z$ClientImplementationTests.testMyInfocCsd}|jd|d|ddS)Nz4There are 9227 victims and 9542 hiding on 24 serversZ251r;r(rrrsrrrtestLuserClients z)ClientImplementationTests.testLuserClientcCs<d}d}|jd|d|ddddd d d d d dddddgddS)NzMODES=4 CHANLIMIT=#:20 NICKLEN=16 USERLEN=10 HOSTLEN=63 TOPICLEN=450 KICKLEN=450 CHANNELLEN=30 KEYLEN=23 CHANTYPES=# PREFIX=(ov)@+ CASEMAPPING=ascii CAPAB IRCD=dancerare available on this server005r=rzCHANLIMIT=#:20z NICKLEN=16z USERLEN=10z HOSTLEN=63z TOPICLEN=450z KICKLEN=450z CHANNELLEN=30z KEYLEN=23z CHANTYPES=#z PREFIX=(ov)@+zCASEMAPPING=asciiZCAPABz IRCD=dancerrr-rrrrrorrr _sendISUPPORT s& z'ClientImplementationTests._sendISUPPORTcCs |dS)zq The client parses ISUPPORT messages sent by the server and calls L{IRCClient.isupport}. N)r|r%rrr test_ISUPPORT"sz'ClientImplementationTests.test_ISUPPORTcCsd}|jd|d|ddS)NzTry server some.host, port 321Z010r<r(rrrsrrr testBounce*s z$ClientImplementationTests.testBouncecCs$d}d}|jd|d|t|ddS)NZ7116zchannels formedZ254r>)rr.rqintr{rrrtestLuserChannels0s  z+ClientImplementationTests.testLuserChannelscCs$d}d}|jd|d|t|ddS)NZ34zflagged staff membersZ252r?)rr/rr{rrr testLuserOp7s  z%ClientImplementationTests.testLuserOpcCsd}|jd|d|ddS)Nz!I have 1937 clients and 0 serversZ255r@r(rrrsrrr testLuserMe>s z%ClientImplementationTests.testLuserMecCsfdddg}|D]$}||jjg|j|dq||jjddddgifg||jjd d S) z Lines received in I{RPL_MOTDSTART} and I{RPL_MOTD} are delivered to L{IRCClient.receivedMOTD} when I{RPL_ENDOFMOTD} is received. z9:host.name 375 nickname :- host.name Message of the Day -/:host.name 372 nickname :- Welcome to host.name.:host.name 376 nickname :End of /MOTD command.rlrAr0zhost.name Message of the Day -Welcome to host.nameN)rrrMrassertIdenticalr0rlinesLrrrtest_receivedMOTDDsz+ClientImplementationTests.test_receivedMOTDcCsBddg}|D]}|j|dq ||jjdddgifgdS)z If L{IRCClient} receives I{RPL_MOTD} and I{RPL_ENDOFMOTD} without receiving I{RPL_MOTDSTART}, L{IRCClient.receivedMOTD} is still called with a list of MOTD lines. rrrlrAr0rN)rrrrMrrrrtest_withoutMOTDSTARTZsz/ClientImplementationTests.test_withoutMOTDSTARTc Ks~t|dd}t|dd}|d|d|} d| d|d|d|d} |j| ||jj||fgg|j_dS) Nidentrfrrrirjrkrlrm) rsendergrouptyperorprNrrfZ wholeUserr2rrr_clientTestImplls4   z)ClientImplementationTests._clientTestImplc CsDd}|jddd|ddddd|d |jdd d|ddddd |d dS) NzTooty toot toot.rz#grouprrBrrfzsender!ident@host)rrfrrr2Z recipient)rrsrrr testPrivmsg}sz%ClientImplementationTests.testPrivmsgc sttj\}}|ddddddg|ddddgfdd}|d ttj\}}|dddg|dddg|d ttj\}}|g|gjjd d d S) z L{IRCClient.getChannelModeParams} uses ISUPPORT information, either given by the server or defaults, to determine which channel modes require arguments when being added or removed. rrrDrErrcsDd|}d}jd|d||gdjj|dgj_dS)Nr(rxryr=rz)rqrrrrrM)rror%rr removeFeatures zJClientImplementationTests.test_getChannelModeParams..removeFeaturerrN) mapsortedrZgetChannelModeParamsrr|assertNotIdenticalrr)raddremoverrr%rtest_getChannelModeParamss"    z3ClientImplementationTests.test_getChannelModeParamscCs0tt|j\}}||g||gdS)z L{IRCClient.getUserModeParams} returns a list of user modes (modes that the user sets on themself, outside of channel modes) that require parameters when added and removed, respectively. N)rrrgetUserModeParamsr)rrrrrrtest_getUserModeParamss z0ClientImplementationTests.test_getUserModeParamsr NcCs*|dkr d}d|||f}|j|dS)z@ Build a MODE string and send it to the client. Nrz&:Wolf!~wolf@yok.utu.fi MODE %s %s %s )rr)rrortargetr2rrr_sendModeChangesz)ClientImplementationTests._sendModeChangecsp|dkr d}t|D]V\}}|\}||d|dd|d|tfddd D||<q|S) zO Parse the results, do some test and return the data to check. NrrFrWolf!~wolf@yok.utu.fircsg|] }|qSrr)rrcrrrrsz>ClientImplementationTests._parseModeChange..)r3r4r) enumeratertuple)rZresultsrr8resultr`rrr_parseModeChanges z*ClientImplementationTests._parseModeChangecCs(||jj|}|||g|j_dS)zR Compare the expected result with the one returned by the client. N)rrrMr)rrrrrrr_checkModeChanges z*ClientImplementationTests._checkModeChangecCs|d|dgdS)z Mode strings that do not begin with a directional character, C{'+'} or C{'-'}, have C{'+'} automatically prepended. r0)Tr0rNrrr%rrrtest_modeMissingDirections z3ClientImplementationTests.test_modeMissingDirectioncCs0|d|dg|d|dgdS)zx No parameters are passed to L{IRCClient.modeChanged} for modes that don't take any parameters. r1)Fr0rz+n)Tr8rNrr%rrrtest_noModeParameterss   z/ClientImplementationTests.test_noModeParameterscCs4|dd|dg|dd|dgdS)zk Parameters are passed to L{IRCClient.modeChanged} for modes that take parameters. +oa_user)Trrz-o)FrrNrr%rrrtest_oneModeParameters   z/ClientImplementationTests.test_oneModeParametercCs6|dd|dg|dd|ddgdS)z Mixing adding and removing modes that do and don't take parameters invokes L{IRCClient.modeChanged} with mode characters and parameters that match up. z+osvza_user another_user)TZosv)rN another_userz+v-os)Trr)Fos)rNNrr%rrrtest_mixedModess    z)ClientImplementationTests.test_mixedModescCsJ|dd|g|tj}|t|d|d|ddS)z Passing an argument to modes that take no parameters results in L{IRCClient.modeChanged} not being called and an error being logged. r.rvrIzToo many parametersrN rrZflushLoggedErrorsr r#rrZZassertSubstringZgetErrorMessagererrorsrrrtest_tooManyModeParameterss    z4ClientImplementationTests.test_tooManyModeParameterscCsH|d|g|tj}|t|d|d|ddS)z Passing no arguments to modes that do take parameters results in L{IRCClient.modeChange} not being called and an error being logged. rrIzNot enough parametersrNrrrrrtest_tooFewModeParameterss    z3ClientImplementationTests.test_tooFewModeParameterscCsb|jj}|jd|d|jdg|ddd}||jd||jdd|d|jd g|dd S) z A C{MODE} message whose target is our user (the nickname of our user, to be precise), as opposed to a channel, will be parsed according to the modes specified by L{IRCClient.getUserModeParams}. r)r)TrrcSsddgS)Nrr rrrrrr5szBClientImplementationTests.test_userMode..getUserModeParamsrz+Zan_arg)Tr)rN)rrhrrr$)rrrrrr test_userMode)sz'ClientImplementationTests.test_userModecsfdd}t_jj_jd|jjdj dg jjd jj d jdjjj jdjjd tjdjjddS) a When the I{RPL_WELCOME} message is received a heartbeat is started that will send a I{PING} message to the IRC server every L{irc.IRCClient.heartbeatInterval} seconds. When the transport is closed the heartbeat looping call is stopped too. cs}j|_|Sr)_originalCreateHeartbeatclock)Z heartbeatr%rr_createHeartbeatFszBClientImplementationTests.test_heartbeat.._createHeartbeatrNr*r z PING foo r)rZClockrrrrr$r _heartbeatirc_RPL_WELCOMErrhostnamerrrZadvanceheartbeatIntervalrrrZZgetDelayedCalls)rrrr%rtest_heartbeat?s$      z(ClientImplementationTests.test_heartbeatcCs:||jjdd|j_|jdg||jjddS)zo If L{irc.IRCClient.heartbeatInterval} is set to L{None} then no heartbeat is created. Nr*)rrrrrr%rrrtest_heartbeatDisabledasz0ClientImplementationTests.test_heartbeatDisabled)r N)N)N)!rrrrrqrtrurvrwr|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrres<  &        "rec@seZdZddZddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-S).BasicServerFunctionalityTestscCs2t|_t|j|_t|_|j|jdSr) rfrrr6r ZIRCprr%rrrrns z#BasicServerFunctionalityTests.setUpcCs.|j}t|tr|d}|||dS)z Make sure that the internal buffer equals a specified value. @param s: the value to compare against buffer @type s: L{bytes} or L{unicode} r N)rr rrrr)rr0rrrrcheckus   z#BasicServerFunctionalityTests.checkcCs|jddd|ddS)z Passing a command and parameters to L{IRC.sendMessage} results in a query string that consists of the command and parameters, separated by a space, ending with ' '. CMDparam1param2CMD param1 param2 N)r sendMessagerr%rrrtest_sendMessagesz.BasicServerFunctionalityTests.test_sendMessagecCs|jdd|ddS)aF Passing a command and parameters to L{IRC.sendCommand} results in a query string that consists of the command and parameters, separated by a space, ending with ' '. The format is described in more detail in U{RFC 1459 }. rrrrNr sendCommandrr%rrrtest_sendCommands z.BasicServerFunctionalityTests.test_sendCommandcCs|jdd|ddS)zk Passing unicode parameters to L{IRC.sendCommand} encodes the parameters in UTF-8. r)uparam¹uparam²sCMD param¹ param² Nrr%rrrtest_sendUnicodeCommandsz5BasicServerFunctionalityTests.test_sendUnicodeCommandcCs*|t|jjddd}|t|ddS)zf Passing L{None} as the command to L{IRC.sendMessage} raises a C{ValueError}. NrrIRC message requires a command.r"rrrrstrrerrorrrrtest_sendMessageNoCommands z7BasicServerFunctionalityTests.test_sendMessageNoCommandcCs*|t|jjdd}||jdddS)zf Passing L{None} as the command to L{IRC.sendCommand} raises a C{ValueError}. Nrrrr"rrrrrrrrrtest_sendCommandNoCommandsz7BasicServerFunctionalityTests.test_sendCommandNoCommandcCs*|t|jjddd}|t|ddS)zi Passing an invalid string command to L{IRC.sendMessage} raises a C{ValueError}. rjrrzCSomebody screwed up, 'cuz this doesn't look like a command to me: Nrrrrrtest_sendMessageInvalidCommands z}. bbbNZeee)aaaccczexample.com/ddd)aaa=bbbscccsexample.com/ddd=eeerrr rI;rrrrr splitrrrsendTagsZ expectedTagsZoutMsgZ outTagStrZoutLineZoutTagsrrrtest_sendCommandWithTagss    z6BasicServerFunctionalityTests.test_sendCommandWithTagscCs:dddd}|t|jjddd|}||jdd dS) zW Passing empty tag names to L{IRC.sendCommand} raises a C{ValueError}. rNr )rrr rrrrA tag name is required.rrrrrrr!test_sendCommandValidateEmptyTagssz?BasicServerFunctionalityTests.test_sendCommandValidateEmptyTagscCs:dddd}|t|jjddd|}||jdd dS) zb Passing None as a tag name to L{IRC.sendCommand} raises a C{ValueError}. rNZbeep)rrNrrrrrrrrrr test_sendCommandValidateNoneTagssz>BasicServerFunctionalityTests.test_sendCommandValidateNoneTagscCs6ddi}|t|jjddd|}||jdddS) zl Passing a tag name containing spaces to L{IRC.sendCommand} raises a C{ValueError}. zaaa bbbrrrrr Tag contains invalid characters.Nrrrrr&test_sendCommandValidateTagsWithSpacesszDBasicServerFunctionalityTests.test_sendCommandValidateTagsWithSpacescCs6ddi}|t|jjddd|}||jdddS) zx Passing a tag name containing invalid characters to L{IRC.sendCommand} raises a C{ValueError}. zaaa_b^@rrrrrrNrrrrr,test_sendCommandValidateTagsWithInvalidCharsszJBasicServerFunctionalityTests.test_sendCommandValidateTagsWithInvalidCharscCsdddd}d}|jddd||j}|dd \}}|d d d }|t|t|d S) zr Tags with values containing invalid characters passed to L{IRC.sendCommand} are escaped. rz test \;;)rr)rsccc=test\r\n\s\\\:\:rrrrrINrrrrrr(test_sendCommandValidateTagValueEscaping,s  zFBasicServerFunctionalityTests.test_sendCommandValidateTagValueEscapingcCs|jddd|ddS)Nthis-is-sender this-is-recipzthis is messagez8:this-is-sender PRIVMSG this-is-recip :this is message )rrBrr%rrrrBsz)BasicServerFunctionalityTests.testPrivmsgcCs|jddd|ddS)Nrrzthis is noticez6:this-is-sender NOTICE this-is-recip :this is notice )rZnoticerr%rrr testNoticeGsz(BasicServerFunctionalityTests.testNoticecCs|jddd|ddS)Nrrzthis is actionz6:this-is-sender ACTION this-is-recip :this is action )rrKrr%rrr testActionLsz(BasicServerFunctionalityTests.testActioncCs|jdd|ddS)N this-personz #this-channelz!:this-person JOIN #this-channel )rjoinrr%rrrtestJoinQsz&BasicServerFunctionalityTests.testJoincCs|jdd|ddS)Nrz #that-channelz!:this-person PART #that-channel )rpartrr%rrrtestPartVsz&BasicServerFunctionalityTests.testPartcCsxttd}|jj}d}d}|j||dddddd d |d d g d ddddddgt||||d}||dS)zp Verify that a whois by the client receives the right protocol actions from the server. dzrequesting-nickz target-nickrzhost.comz Target Userz irc.host.comz A fake serverF z #fakeusersz #fakemiscrlzA:%(hostname)s 311 %(req)s %(targ)s target host.com * :Target Userz>:%(hostname)s 312 %(req)s %(targ)s irc.host.com :A fake serverzN:%(hostname)s 317 %(req)s %(targ)s 12 %(timestamp)s :seconds idle, signon timez8:%(hostname)s 319 %(req)s %(targ)s :#fakeusers #fakemiscz6:%(hostname)s 318 %(req)s %(targ)s :End of WHOIS list.r )r timestampreqtargN)rtimerrwhoisrrbr)rrrrrrrrr testWhois[s0z'BasicServerFunctionalityTests.testWhoisN)rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrms,           rc@s8eZdZdZddZddZddZdd Zd d Zd S) DummyClientz{ A L{twisted.words.protocols.irc.IRCClient} that stores sent lines in a C{list} rather than transmitting them. cCs g|_dSr)rr%rrrrOwszDummyClient.__init__cCstj|g|_dSr)r r connectionMaderr%rrrr{s zDummyClient.connectionMadecCs|dtjt|jS)zE Truncate an IRC line to the maximum allowed length. N)r MAX_COMMAND_LENGTHrZZ delimiterrlinerrr _truncateLineszDummyClient._truncateLinecCs||}tj||Sr)rr r lineReceivedrrrrrs zDummyClient.lineReceivedcCs|j||dSr)rr]r)rmrrrsendLineszDummyClient.sendLineN) rrrrGrOrrrrrrrrrrs rc@s(eZdZdZddZddZddZdS) ClientInviteTestsz( Tests for L{IRCClient.invite}. cCs t|_dS)zO Create a L{DummyClient} to call C{invite} on in test methods. N)rrr%rrrrszClientInviteTests.setUpcCs$|jdd||jjdgdS)z If the channel name passed to L{IRCClient.invite} does not begin with a channel prefix character, one is prepended to it. r*rINVITE foo #barNrZinviterrr%rrrtest_channelCorrectionsz(ClientInviteTests.test_channelCorrectioncCs$|jdd||jjdgdS)zs L{IRCClient.invite} sends an I{INVITE} message with the specified username and a channel. r*#barr Nr r%rrr test_inviteszClientInviteTests.test_inviteN)rrrrGrr r rrrrrs rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ d'ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&ZdS)(ClientMsgTestszP Tests for messages sent with L{twisted.words.protocols.irc.IRCClient}. cCst|_|jdSr)rrrr%rrrrszClientMsgTests.setUpcCs$|jdd||jjdgdS)zO A message containing no newlines is sent in a single command. r*rPRIVMSG foo :barN)rrorrr%rrrtest_singleLineszClientMsgTests.test_singleLinecCs0|t|jjddd|t|jjddddS)z Specifying a C{length} value to L{IRCClient.msg} that is too short to contain the protocol command to send a message raises C{ValueError}. r*rrrKN)r"rrror%rrrtest_invalidMaxLengthsz$ClientMsgTests.test_invalidMaxLengthcCs:tddd}|jdd|||jjdddgd S) z Messages longer than the C{length} parameter to L{IRCClient.msg} will be split and sent in multiple commands. PRIVMSG foo :rKrJr*barbazborPRIVMSG foo :bazzPRIVMSG foo :boNrZrrorr)rmaxLenrrrtest_multipleLinesz ClientMsgTests.test_multipleLinecCsd}td|fd}|jd||||jjd|fgg|j_|jd||d|dt|jjg|j_|jd||d|dt|jjdS)z Messages exactly equal in length to the C{length} parameter to L{IRCClient.msg} are sent in a single command. rzPRIVMSG foo :%srJr*rINr)rrorrrrtest_sufficientWidthsz#ClientMsgTests.test_sufficientWidthcCs,g|j_|jdd||jjdgdS)zC An LF at the beginning of the message is ignored. r*z barrNrrrorr%rrrtest_newlinesAtStartsz#ClientMsgTests.test_newlinesAtStartcCs,g|j_|jdd||jjdgdS)z= An LF at the end of the message is ignored. r*zbar rNrr%rrrtest_newlinesAtEndsz!ClientMsgTests.test_newlinesAtEndcCs.g|j_|jdd||jjddgdS)z; An LF within a message causes a new line. r*zbar bazrrNrr%rrrtest_newlinesWithinMessagesz)ClientMsgTests.test_newlinesWithinMessagecCs.g|j_|jdd||jjddgdS)z< Consecutive LFs do not cause a blank line. r*zbar bazrrNrr%rrrtest_consecutiveNewlinessz'ClientMsgTests.test_consecutiveNewlinesNcsd|jj|jj|jjf}|jjd||dg||jdfdd|jjD]}|j||qP|t |d dd D}|||d S) z Assert that messages sent by L{IRCClient.msg} are split into an expected number of commands and the original message is transmitted in its entirety over those commands. z :%s!%s@%s r*lengthrBcs |Sr)r])rrBrr"z;ClientMsgTests.assertLongMessageSplitting..r css|]\}}}|VqdSrr)rrrr2rrr (sz.N) rrhrealnamerror$rrrrZr)rr2ZexpectedNumCommandsrZresponsePrefixrZreceivedMessagerr rassertLongMessageSplittings  z)ClientMsgTests.assertLongMessageSplittingcCsdtjd}||ddS)a] If a maximum message length is not provided to L{IRCClient.msg} a best-guess effort is made to determine a safe maximum, messages longer than this are split into multiple commands with the intent of delivering long messages without losing data due to message truncation when the server relays them. rrJNr rr%rr2rrr!test_splitLongMessagesWithDefault/sz0ClientMsgTests.test_splitLongMessagesWithDefaultcCs(dtjd}|j|dtjdddS)a The maximum message length can be specified to L{IRCClient.msg}, messages longer than this are split into multiple commands with the intent of delivering long messages without losing data due to message truncation when the server relays them. rrJrKrNr&r'rrr"test_splitLongMessagesWithOverride;s z1ClientMsgTests.test_splitLongMessagesWithOverridecCsDdtjd}|jd|d|||jjd|d|gdS)zK IRCClient breaks on newlines before it breaks long lines. rrJr* rNr rrrorrrZlonglinerrrtest_newlinesBeforeLineBreakingGsz.ClientMsgTests.test_newlinesBeforeLineBreakingcCsDdtjd}|jd|d|||jjd|d|gdS)zK IRCClient prefers to break long lines at word boundaries. rrJr*rjrNr+r,rrrtest_lineBreakOnWordBoundariesVsz-ClientMsgTests.test_lineBreakOnWordBoundariescCsN|ttjdd|ttjdd|gtdd|gtddS)z L{twisted.words.protocols.irc.split} raises C{ValueError} if given a length less than or equal to C{0} and returns C{[]} when splitting C{''}. r*rr rIN)r"rr rrr%rrrtest_splitSanityeszClientMsgTests.test_splitSanitycCs@tdd}|dddg|tdd}|dddg|dS)z L{twisted.words.protocols.irc.split} skips any delimiter (space or newline) that it finds at the very beginning of the string segment it is operating on. Nothing should be added to the output list because of it. zxx yyzrJZxxZyyzzxx yyzN)r rr)rrrrrtest_splitDelimitersrs  z#ClientMsgTests.test_splitDelimiterscCs(|ttjdd|ttjdddS)z L{twisted.words.protocols.irc.split} raises C{ValueError} if given a length less than or equal to C{0}. r*rr/N)r"rr rr%rrrtest_splitValidatesLengthsz(ClientMsgTests.test_splitValidatesLengthcCs$|jdd||jjdgdS)z L{IRCClient.say} prepends the channel prefix C{"#"} if necessary and then sends the message to the server for delivery to that channel. Z thechannelz the messagez PRIVMSG #thechannel :the messageN)rZsayrrr%rrrtest_says zClientMsgTests.test_say)N)rrrrGrrrrrrrrrr%r(r)r-r.r0r3r4r5rrrrrs(          rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd S)! ClientTestszs Tests for the protocol-level behavior of IRCClient methods intended to be called by application code. cCsZt|_t|_d|j_|j|j||jd||jj ||jj ddS)zT Create and connect a new L{IRCClient} to a new L{StringTransport}. Fr N) rrr rrrrrrrrr%rrrrszClientTests.setUpcCs2|}ttkr$t|tr$|d}|ddS)zF Return the last IRC message in the transport buffer. r rlrM)rbytesrrrr)rrrrrr getLastLines zClientTests.getLastLinecCs:d}|j|d|fdg}||jd|dS)zU L{IRCClient.away} sends an AWAY command with the specified message. zSorry, I'm not here.zAWAY :%sr  N)rZawayrrrr)rr2rrrr test_aways  zClientTests.test_awaycCs.|jddg}||jd|dS)zP L{IRCClient.back} sends an AWAY command with an empty message. zAWAY :r r9N)rZbackrrrr)rrrrr test_backs  zClientTests.test_backcCs,|jd||jdddgdS)z; L{IRCClient.whois} sends a WHOIS message. alicer9z WHOIS alicer Nrrrrrrr%rrr test_whoiss  zClientTests.test_whoiscCs.|jdd||jdddgdS)z L{IRCClient.whois} sends a WHOIS message with a server name if a value is passed for the C{server} parameter. r<z example.orgr9zWHOIS example.org alicer Nr=r%rrrtest_whoisWithServers z ClientTests.test_whoisWithServercCshd}d}d}d|j_d|j_|j|||d|fd||||jjfdg}||jd |dS) z L{IRCClient.register} sends NICK and USER commands with the username, name, hostname, server name, and real name specified. testusertesthost testservertestnameNNICK %sUSER %s %s %s :%sr r9rr$passwordregisterrrrrrusernamerr+rrrr test_registers zClientTests.test_registercCstd}d}d}d|j_d|j_|j|||d|jjfd|fd||||jjfd g}||jd |d S) z If the C{password} attribute of L{IRCClient} is not L{None}, the C{register} method also sends a PASS command with it as the argument. r@rArBrCtestpasszPASS %srDrEr r9NrFrIrrrtest_registerWithPasswords" z%ClientTests.test_registerWithPasswordcCsd}d}d}d|j_d|j_|j||||jddg||j}||d|f|jddg||j}||d|d fd S) z Verify that the client repeats the L{IRCClient.setNick} method with a new value when presented with an C{ERR_NICKNAMEINUSE} while trying to register. r@rArBrCrLrrrDrPN) rr$rGrHirc_ERR_NICKNAMEINUSEr8rr~r)rrJrr+lastLinerrrtest_registerWithTakenNick s  z&ClientTests.test_registerWithTakenNickcCsRd}dd|j_|j||jddg||j}||d|dfdS) z L{IRCClient.alterCollidedNick} determines how a nickname is altered upon collision while a user is trying to change to that nickname. r*cSs|dS)N***rr6rrrr!% r"z.rrrDrQN)rZalterCollidedNickrHrNr8rr)rr7rOrrrtest_overrideAlterCollidedNick s    z*ClientTests.test_overrideAlterCollidedNickcCsjd}d}|j||jddg|j|||jj||jd|f|g||jj|dS)z When a NICK command is sent after signon, C{IRCClient.nickname} is set to the new nickname I{after} the server sends an acknowledgement. r*rrrz %s!quux@quxN)rrHrsetNickrrhZirc_NICK)roldnickZnewnickrrrtest_nickChange- s  zClientTests.test_nickChangecCsd}||jjd|j||jddg||j}||d|jjf|jddg||jjd|j |jj||jj |jj|jj }|j ||jddg||j}||d|f||jj |dS)z Trying to register an illegal nickname results in the default legal nickname being set, and trying to change a nickname to an illegal nickname results in the old nickname being kept. r*FrrrDTN) rr _registeredrHZirc_ERR_ERRONEUSNICKNAMEr8rZerroneousNickFallbackrrSrh)rZbadnickrOrTrrrtest_erroneousNick< s2     zClientTests.test_erroneousNickcCs^d}d}d}|j|||j||d||fd||fdg}||jd|dS)zd L{IRCClient.desrcibe} sends a CTCP ACTION message to the target specified. r*r ZwaveszPRIVMSG %s :ACTION %sr r9N)rZdescriberrrr)rrrrKrrrr test_describe[ s  zClientTests.test_describecs*fdd}|j_jdddgdS)zh The default implementation of L{IRCClient.noticed} doesn't invoke C{privmsg()} csddS)Nz%privmsg() should not have been called)Zfailr1r%rrrBq sz6ClientTests.test_noticedDoesntPrivmsg..privmsgZspamz#greasyspooncafezI don't want any spam!N)rrB irc_NOTICE)rrBrr%rtest_noticedDoesntPrivmsgl s  z%ClientTests.test_noticedDoesntPrivmsgcCs|jd||jd|j|jdd||jd|ji|j_t |jj dD] }t ||jjdt |f<qn|t |jj|jj d|jdd|t |jj|jj ||jddS) z# L{IRCClient.ping} Z otherusersPRIVMSG otheruser :PINGz are you theres)PRIVMSG otheruser :PING are you there rKzI sent a lot of pingss1PRIVMSG otheruser :PING I sent a lot of pings N)rZpingrrrrRclearrZ_pingsrangeZ _MAX_PINGRINGrrrZ)rZpingNumrrr test_pingx s(      zClientTests.test_pingN)rrrrGrr8r:r;r>r?rKrMrPrRrUrWrXrZr]rrrrr6s       r6c@seZdZdZddZdS)CollectorClientzQ A client that saves in a list the names of the methods that got called. cs8g_d_|D]"}|ffdd }t||qdS)zx @param methodsList: list of methods' names that should be replaced. @type methodsList: C{list} Wolfcsfdd}|S)z6 Collects C{method}s. csj|fdSr)rQr])r)r`rrrinner sz.fake_method..innerr)r`r`r%)r`r fake_method sz-CollectorClient.__init__..fake_methodN)rQrhsetattr)rZ methodsListr`rarr%rrO s zCollectorClient.__init__N)rrrrGrOrrrrr^ sr^c@sxeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZdS)DccTestsz% Tests for C{dcc_*} methods. cCs&ddddg}d|_d|_t||_dS)N dccDoSenddccDoAcceptResume dccDoResume dccDoChatr#twistedrrr^rrrQrrrr s zDccTests.setUpc CsB|j|j|jd||jjd|jdddddddgffgdS) zO L{irc.IRCClient.dcc_SEND} invokes L{irc.IRCClient.dccDoSend}. foo.txt 127.0.0.1 1025rd 127.0.0.1foo.txtr/1025N)rdcc_SENDrrrrQr%rrr test_dccSend s  zDccTests.test_dccSendcCst}|t|jdddS)zM L{irc.IRCClient.dccDoSend} is raises C{NotImplementedError} rJN)r r r"NotImplementedErrorZdccSend)rrrrrtest_dccSendNotImplemented s z#DccTests.test_dccSendNotImplementedcCs0|tj|jj|j|jd}|t|ddS)z{ L{irc.IRCClient.dcc_SEND} raises L{irc.IRCBadMessage} when it is passed a malformed query string. r*z#malformed DCC SEND request: ['foo']N r"r IRCBadMessagerrprrrrrrrrrtest_dccSendMalformedRequest s z%DccTests.test_dccSendMalformedRequestcCs0|tj|jj|j|jd}|t|ddS)z L{irc.IRCClient.dcc_SEND} raises L{irc.IRCBadMessage} when it is passed a query string that doesn't contain a valid address. zfoo.txt #23 sd@dzIndecipherable address '#23'Nrtrvrrr!test_dccSendIndecipherableAddress s z*DccTests.test_dccSendIndecipherableAddresscCs0|tj|jj|j|jd}|t|ddS)z L{irc.IRCClient.dcc_SEND} raises L{irc.IRCBadMessage} when it is passed a query string that doesn't contain a valid port number. foo.txt 127.0.0.1 sd@dIndecipherable port 'sd@d'Nrtrvrrrtest_dccSendIndecipherablePort s z'DccTests.test_dccSendIndecipherablePortcCs8|j|j|jd||jjd|jdddffgdS)zY L{irc.IRCClient.dcc_ACCEPT} invokes L{irc.IRCClient.dccDoAcceptResume}. foo.txt 1025 2rernrmrJN)r dcc_ACCEPTrrrrQr%rrrtest_dccAccept s zDccTests.test_dccAcceptcCs0|tj|jj|j|jd}|t|ddS)z} L{irc.IRCClient.dcc_ACCEPT} raises L{irc.IRCBadMessage} when it is passed a malformed query string. r*z*malformed DCC SEND ACCEPT request: ['foo']N) r"r rurr}rrrrrvrrrtest_dccAcceptMalformedRequest s z'DccTests.test_dccAcceptMalformedRequestcCs8|j|j|jd||jjd|jdddffgdS)zS L{irc.IRCClient.dcc_RESUME} invokes L{irc.IRCClient.dccDoResume}. r|rfrnrmrJN)r dcc_RESUMErrrrQr%rrrtest_dccResume s zDccTests.test_dccResumecCs0|tj|jj|j|jd}|t|ddS)z} L{irc.IRCClient.dcc_RESUME} raises L{irc.IRCBadMessage} when it is passed a malformed query string. r*z*malformed DCC SEND RESUME request: ['foo']N) r"r rurrrrrrrvrrrtest_dccResumeMalformedRequest s z'DccTests.test_dccResumeMalformedRequestc CsB|j|j|jd||jjd|j|jdddddgffgdS)zO L{irc.IRCClient.dcc_CHAT} invokes L{irc.IRCClient.dccDoChat}. rkrgrlrmrnroN)rdcc_CHATrrrrQr%rrr test_dccChat s  zDccTests.test_dccChatcCs0|tj|jj|j|jd}|t|ddS)z{ L{irc.IRCClient.dcc_CHAT} raises L{irc.IRCBadMessage} when it is passed a malformed query string. r*z#malformed DCC CHAT request: ['foo']N r"r rurrrrrrrvrrrtest_dccChatMalformedRequest s z%DccTests.test_dccChatMalformedRequestcCs0|tj|jj|j|jd}|t|ddS)z L{irc.IRCClient.dcc_CHAT} raises L{irc.IRCBadMessage} when it is passed a query string that doesn't contain a valid port number. ryrzNrrvrrrtest_dccChatIndecipherablePort* s z'DccTests.test_dccChatIndecipherablePortN)rrrrGrrqrsrwrxr{r~rrrrrrrrrrrc s           rcc@sXeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ dS)ServerToClientTestszL Tests for the C{irc_*} methods sent from the server to the client. c Cs0d|_d|_ddddddd d d g }t||_dS) NrrhrCrHrDrIuserQuitrErGrJrLrirjrrrr9 s zServerToClientTests.setUpcCsD|j|j|jg|jddg||jjd|jffdgdS)z L{IRCClient.joined} is called when I join a channel; L{IRCClient.userJoined} is called when someone else joins. Svadilfari!~svadi@yok.utu.fi#pythonrC)rH SvadilfarirN)rZirc_JOINrrrrQr%rrr test_irc_JOINA s  z!ServerToClientTests.test_irc_JOINcCsD|j|j|jg|jddg||jjd|jffdgdS)z L{IRCClient.left} is called when I part the channel; L{IRCClient.userLeft} is called when someone else parts. rrrD)rIrN)rZirc_PARTrrrrQr%rrr test_irc_PARTM s  z!ServerToClientTests.test_irc_PARTcCs:|jddg|j|jdg||jjddgdS)zo L{IRCClient.userQuit} is called whenever someone quits the channel (myself included). rAdios. Farewell.)r)rr)r)r_rN)rZirc_QUITrrrQr%rrr test_irc_QUITY s z!ServerToClientTests.test_irc_QUITcCsPdtjtjtjd}|j|j|j|g||jj d|jddffgdS)zK L{IRCClient.noticed} is called when a notice is received. z:%(X)cextended%(X)cdata1%(X)cextended%(X)cdata2%(X)c%(EOL)srrErhz data1 data2N) r rrrrrYrrrrQrsrrrtest_irc_NOTICEe s z#ServerToClientTests.test_irc_NOTICEc CsR|jddddg|j|j|jddg||jjddd|jd dffgd S) z L{IRCClient.kickedFrom} is called when I get kicked from the channel; L{IRCClient.userKicked} is called when someone else gets kicked. rrZWOLF shoryuken!rz hadouken!)rG)rrrrJr_N)rZirc_KICKrrrrQr%rrr test_irc_KICKp s    z!ServerToClientTests.test_irc_KICKcCs8|j|j|jdg||jjdd|jdffgdS)zR L{IRCClient.topicUpdated} is called when someone sets the topic. new topic is newrLr_N)rZ irc_TOPICrrrrQr%rrrtest_irc_TOPIC s   z"ServerToClientTests.test_irc_TOPICcCs:|j|jd|jdg||jjdd|jdffgdS)zc L{IRCClient.topicUpdated} is called when the topic is initially reported. ?rrLr_N)rZ irc_RPL_TOPICrrrrQr%rrrtest_irc_RPL_TOPIC s    z&ServerToClientTests.test_irc_RPL_TOPICcCs8|j|jd|jg||jjdd|jdffgdS)zP L{IRCClient.topicUpdated} is called when the topic is removed. rrLr_r N)rZirc_RPL_NOTOPICrrrrQr%rrrtest_irc_RPL_NOTOPIC s z(ServerToClientTests.test_irc_RPL_NOTOPICN) rrrrGrrrrrrrrrrrrrr5 s      rc@sPeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ dS)CTCPQueryTestsz/ Tests for the C{ctcpQuery_*} methods. cCsd|_d|_tdg|_dS)Nrrh ctcpMakeReplyrir%rrrr szCTCPQueryTests.setUpcCs4|j|j|jd||jjdddgffgdS)zm L{IRCClient.ctcpQuery_PING} calls L{IRCClient.ctcpMakeReply} with the correct args. rrr_)ZPINGrN)rZctcpQuery_PINGrrrrQr%rrrtest_ctcpQuery_PING s z"CTCPQueryTests.test_ctcpQuery_PINGcCs<d|j_|j|j|jd||jjdddgffgdS)zo L{IRCClient.ctcpQuery_FINGER} calls L{IRCClient.ctcpMakeReply} with the correct args. r rrr_)ZFINGERr N)rZ fingerReplyZctcpQuery_FINGERrrrrQr%rrrtest_ctcpQuery_FINGER s  z$CTCPQueryTests.test_ctcpQuery_FINGERcCs>d|j_|j|j|jd||jjddddgffgdS)zo L{IRCClient.ctcpQuery_SOURCE} calls L{IRCClient.ctcpMakeReply} with the correct args. urlrrr_)SOURCEr)rNN)rZ sourceURLZctcpQuery_SOURCErrrrQr%rrrtest_ctcpQuery_SOURCE s z$CTCPQueryTests.test_ctcpQuery_SOURCEcCs<d|j_|j|j|jd||jjdddgffgdS)zq L{IRCClient.ctcpQuery_USERINFO} calls L{IRCClient.ctcpMakeReply} with the correct args. r)rrr_)ZUSERINFOr)N)rZuserinfoZctcpQuery_USERINFOrrrrQr%rrrtest_ctcpQuery_USERINFO s  z&CTCPQueryTests.test_ctcpQuery_USERINFOcCs\|j|j|jd|j|j|jdd}||jjddd|fgffdddgffgdS) zs L{IRCClient.ctcpQuery_CLIENTINFO} calls L{IRCClient.ctcpMakeReply} with the correct args. r z PING PONGzEACTION CLIENTINFO DCC ERRMSG FINGER PING SOURCE TIME USERINFO VERSIONrr_ CLIENTINFO)rNN)rZctcpQuery_CLIENTINFOrrrrQ)rr)rrrtest_ctcpQuery_CLIENTINFO s  z(CTCPQueryTests.test_ctcpQuery_CLIENTINFOcCs4|j|j|jd||jjdddddS)zm L{IRCClient.ctcpQuery_TIME} calls L{IRCClient.ctcpMakeReply} with the correct args. rrrIr_N)rZctcpQuery_TIMErrrrQr%rrrtest_ctcpQuery_TIME sz"CTCPQueryTests.test_ctcpQuery_TIMEcCs4|j|j|jd||jjdddgffgdS)zl L{IRCClient.ctcpQuery_DCC} calls L{IRCClient.ctcpMakeReply} with the correct args. rrr_)ZERRMSGz!DCC data :Unknown DCC type 'DATA'N)rZ ctcpQuery_DCCrrrrQr%rrrtest_ctcpQuery_DCC s  z!CTCPQueryTests.test_ctcpQuery_DCCN) rrrrGrrrrrrrrrrrrr s     rc@seZdZdZddZdS)DccChatFactoryTestsz& Tests for L{DccChatFactory}. cCs:d}td|}|d}||tj||j|dS)z An instance of the L{irc.DccChat} protocol is returned, which has the factory property set to the factory which created it. )ZfromUserNNNrl)r ZDccChatFactoryZ buildProtocolZassertIsInstanceZDccChatrfactory)rZ queryDatarrrrrtest_buildProtocol s   z&DccChatFactoryTests.test_buildProtocolN)rrrrGrrrrrr src@seZdZdZddZdS)DccDescribeTestsz# Tests for L{dccDescribe}. cCstd}||ddS)z@ L{irc.dccDescribe} supports long IP addresses. zCHAT arg 3232235522 6666z$CHAT for host 192.168.0.2, port 6666N)r Z dccDescriberrvrrr test_address s zDccDescribeTests.test_addressN)rrrrGrrrrrr src@sZeZdZdZdddZddZdd Zd d Zd d ZddZ ddZ ddZ ddZ dS)DccFileReceiveTestsz& Tests for L{DccFileReceive}. rNcCs0tj||d}|r|dt}|||S)a Factory helper that returns a L{DccFileReceive} instance for a specific test case. @param filename: Path to the local file where received data is stored. @type filename: L{str} @param resumeOffset: An integer representing the amount of bytes from where the transfer of data should be resumed. @type resumeOffset: L{int} @param overwrite: A boolean specifying whether the file to write to should be overwritten by calling L{DccFileReceive.set_overwrite} or not. @type overwrite: L{bool} @return: An instance of L{DccFileReceive}. @rtype: L{DccFileReceive}  resumeOffsetT)r ZDccFileReceiveZ set_overwriterr)rfilenamer overwriterrrrrmakeConnectedDccFileReceive s   z/DccFileReceiveTests.makeConnectedDccFileReceivecCs|||ddS)z Arrange the protocol so that it received all data. @param protocol: The protocol which will receive the data. @type: L{DccFileReceive} @param data: The received data. @type data: L{bytest} N)rr)rrrrrrallDataReceivedForProtocol; s z.DccFileReceiveTests.allDataReceivedForProtocolcCsFt|}|d|j|jdd}||d||ddS)z If given a resumeOffset argument, L{DccFileReceive} will attempt to resume from that number of bytes if the file exists. sTwisted is awesome! rsamazing!Twisted is amazing!NrmktempZ setContentrpathrr getContentrfprrrrtest_resumeFromResumeOffsetI s    z/DccFileReceiveTests.test_resumeFromResumeOffsetcCsFt|}|d|j|jdd}||d||ddS)aG When resuming from an offset somewhere in the middle of the file, for example, if there are 50 bytes in a file, and L{DccFileReceive} is given a resumeOffset of 25, and after that 15 more bytes are written to the file, then the resultant file should have just 40 bytes of data. rrrscool!sTwisted is cool!Nrrrrr:test_resumeFromResumeOffsetInTheMiddleOfAlreadyWrittenDataW s    zNDccFileReceiveTests.test_resumeFromResumeOffsetInTheMiddleOfAlreadyWrittenDatacCsFt|}|d|j|jdd}||d||ddS)z When local file already exists it can be overwritten using the L{DccFileReceive.set_overwrite} method. sI love contributing to Twisted!T)rsTwisted rocks!Nrrrrrtest_setOverwriteh s    z%DccFileReceiveTests.test_setOverwritecCs8t|}||j}||d||ddS)z~ If the file does not already exist, then L{DccFileReceive} will create one and write the data to it. s I <3 TwistedN)rrrrrrrrrrrtest_fileDoesNotExistv s   z)DccFileReceiveTests.test_fileDoesNotExistcCs6t|}|jt|j|jdd}|tj|jdS)z If given a resumeOffset to resume writing to a file that does not exist, L{DccFileReceive} will raise L{OSError}. rIrN) rrr"OSErrorrrrerrnoZENOENT)rrrrrrtest_resumeWhenFileDoesNotExist s z3DccFileReceiveTests.test_resumeWhenFileDoesNotExistcCs*t|}||t|j|jdS)zn If the file already exists and overwrite action was not asked, L{OSError} is raised. N)rrZtouchr"rrrrrrrr!test_fileAlreadyExistsNoOverwrite s z5DccFileReceiveTests.test_fileAlreadyExistsNoOverwritecCs(t|d}|t|j|jdS)zO L{IOError} is raised when failing to open the requested path. zchild-with-no-existing-parentN)rrZchildr"IOErrorrrrrrrtest_failToOpenLocalFile sz,DccFileReceiveTests.test_failToOpenLocalFile)rN) rrrrGrrrrrrrrrrrrrr s   r)8rGrrQrZtwisted.internetrrZtwisted.python.filepathrZtwisted.python.compatrZtwisted.test.proto_helpersrrZtwisted.trial.unittestrZtwisted.words.protocolsr Ztwisted.words.protocols.ircr r r\r rrHrTr|rrrZX_QUOTEZM_QUOTErrZ_CommandDispatcherMixinrrrrrobjectr&rdrerrrrr6r^rcrrrrrrrrrsx    !  $2|E  dmZ