o ¯b( ã@s¼dZddlZddlZddlZddlZddlZddlZz ddlZddl Z Wn e y1dZ dZYnwe Z eZddl m Z ddlmZddlmZddlmZddlmZmZmZddlmZmZmZdd lmZdd lmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z&ddl'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0ddl1m(Z2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?ddl@mAZAe5dƒZBeBràddlCmDZDmEZEmFZFe5dƒZGe5dƒZHe5dƒZIe5dƒZJd d!„ZKGd"d#„d#ƒZLGd$d%„d%ejMƒZNGd&d'„d'e;jOƒZPGd(d)„d)eAƒZQeeB d*ƒGd+d,„d,eAƒƒZRGd-d.„d.eAƒZSGd/d0„d0ƒZTGd1d2„d2ejUƒZVGd3d4„d4eAƒZWeeB d*ƒGd5d6„d6eAƒƒZXeeB d*ƒGd7d8„d8eAƒƒZYeeB d*ƒGd9d:„d:eAƒƒZZGd;d<„d<ƒZ[ee#ƒGd=d>„d>e[ƒƒZ\Gd?d@„d@ƒZ]GdAdB„dBeAƒZ^dCdD„Z_dEdF„Z`GdGdH„dHeAƒZaeeB d*ƒGdIdJ„dJeAƒƒZbeeB dKƒGdLdM„dMeAƒƒZcee$ƒGdNdO„dOe=ƒƒZdGdPdQ„dQe;jOƒZedRdS„ZfGdTdU„dUeAƒZgdS)VzE Tests for L{twisted.application.app} and L{twisted.scripts.twistd}. éN)ÚStringIO)ÚskipIf)Ú implementer)Ú verifyObject)ÚinternetÚloggerÚplugin)ÚappÚreactorsÚservice)Ú IServiceMaker)Ú ReactorBase)ÚDeferred)ÚIReactorDaemonizeÚ_ISupportsExitSignalCapturing)ÚAlternateReactor)Ú ILogObserverÚglobalLogBeginnerÚglobalLogPublisher)Úutil)Ú Componentized)Ú UserDatabase)rÚtextFromEventDict)Ú requireModule)Ú platformType)Ú UsageError)Útwistd)Ú MemoryReactor)ÚMockOS)ÚTestCaseztwistd.scripts._twistd_unix)ÚUnixApplicationRunnerÚ UnixAppLoggerÚcheckPIDztwistd.python.syslogÚprofileÚpstatsÚcProfilec s|t t ¡¡}t t ¡¡‰tƒ}| ||j |ˆ|j |j |j ¡‡‡‡fdd„}|td|j ƒ|td|ƒ|td|jƒdS)au Patch L{pwd.getpwnam} so that it behaves as though only one user exists and patch L{grp.getgrnam} so that it behaves as though only one group exists. @param patch: A function like L{TestCase.patch} which will be used to install the fake implementations. @type user: C{str} @param user: The name of the single user which will exist. @type uid: C{int} @param uid: The UID of the single user which will exist. @type group: C{str} @param group: The name of the single user which will exist. @type gid: C{int} @param gid: The GID of the single group which will exist. cs<tˆƒ}ˆ|| ˆj¡<ˆ|| ˆj¡<t|ƒ}ˆ|i|S©N)ÚlistÚindexÚgr_nameÚgr_gidÚtuple)ÚnameÚresult©ÚgidÚgrentÚgroup©ú:/usr/lib/python3/dist-packages/twisted/test/test_twistd.pyÚgetgrnamds  z#patchUserDatabase..getgrnamÚgetpwnamr4ÚgetpwuidN)Úpwdr6ÚosÚgetuidÚgrpÚgetgrgidÚgetgidrÚaddUserÚ pw_passwdÚpw_gecosÚpw_dirÚpw_shellr5)ÚpatchÚuserÚuidr1r/ÚpwentÚdatabaser4r2r.r3ÚpatchUserDatabaseCsÿ rGc@óeZdZdZdZdd„ZdS)ÚMockServiceMakerzO A non-implementation of L{twisted.application.service.IServiceMaker}. ÚueoacCs||_t ¡|_|jS)ze Take a L{usage.Options} instance and return a L{service.IService} provider. )Úoptionsr ÚService©ÚselfrKr2r2r3Ú makeServicews zMockServiceMaker.makeServiceN)Ú__name__Ú __module__Ú __qualname__Ú__doc__ÚtapnamerOr2r2r2r3rIps rIc@seZdZdZdd„ZdS)ÚCrippledAppLoggerz* @see: CrippledApplicationRunner. cCódSr&r2©rNÚ applicationr2r2r3Ústart†ózCrippledAppLogger.startN)rPrQrRrSrYr2r2r2r3rUs rUc@s$eZdZdZeZdd„Zdd„ZdS)ÚCrippledApplicationRunnerzà An application runner that cripples the platform-specific runner and nasty side-effect-having code so that we can use it without actually running any environment-affecting code. cCrVr&r2©rNr2r2r3ÚpreApplication“rZz(CrippledApplicationRunner.preApplicationcCrVr&r2r\r2r2r3ÚpostApplication–rZz)CrippledApplicationRunner.postApplicationN)rPrQrRrSrUÚ loggerFactoryr]r^r2r2r2r3r[Šs  r[c@s”eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Ze e d ƒd d„ƒZ e e d ƒdd„ƒZ e e d ƒdd„ƒZ dd„Zdd„Zdd„Zdd„ZdS)ÚServerOptionsTestszT Non-platform-specific tests for the platform-specific ServerOptions class. c sÎGdd„dƒ}|dƒ‰|dƒ‰|dƒ‰|dƒ‰‡‡‡‡‡fdd„}t ¡}ˆ |jtj¡||_|j}ˆˆˆˆg}t||ƒD]&\}}|\}} } } ˆ ||j¡ˆ  | ¡ˆ | ƒ|j ¡fˆ | |j ¡q>d S) zh subCommands is built from IServiceMaker plugins, and is sorted alphabetically. c@seZdZdd„Zdd„ZdS)z7ServerOptionsTests.test_subCommands..FakePlugincSs||_d||_d||_dS)Nz options for údescription of )rTÚ_optionsÚ description©rNr,r2r2r3Ú__init__¦s z@ServerOptionsTests.test_subCommands..FakePlugin.__init__cSó|jSr&)rbr\r2r2r3rK«sz?ServerOptionsTests.test_subCommands..FakePlugin.optionsN)rPrQrRrerKr2r2r2r3Ú FakePlugin¥s rgÚappleÚbananaÚcoconutÚdonutc3s*ˆ |t¡ˆVˆVˆVˆVdSr&)Ú assertEqualr )Ú interface©rhrirjrkrNr2r3Ú getPlugins³s €  z7ServerOptionsTests.test_subCommands..getPluginsN) rÚ ServerOptionsrlÚ _getPluginsrroÚ subCommandsÚziprTÚ assertIsNonerbrc) rNrgroÚconfigrrÚ expectedOrderÚ subCommandÚexpectedCommandr,ÚshortcutÚ parserClassÚ documentationr2rnr3Útest_subCommandsŸs$    ûz#ServerOptionsTests.test_subCommandscsØGdd„dƒ}|dƒ‰|dƒ‰|dƒ‰|dƒ‰‡‡‡‡fdd„}t ¡}ˆ |jtj¡||_tƒ|_ˆ t |j d g¡|j  ¡‰g‰ˆˆˆˆfD]}‡‡‡fd d „}||j ƒ||j ƒqIˆ ˆtˆƒd  ˆ¡¡d S)zP Reactor names are listed alphabetically by I{--help-reactors}. c@óeZdZdd„ZdS)zGServerOptionsTests.test_sortedReactorHelp..FakeReactorInstallercSsd||_d||_d|_dS)Nzname of raztwisted.internet.default)Ú shortNamercÚ moduleNamerdr2r2r3reÐs   zPServerOptionsTests.test_sortedReactorHelp..FakeReactorInstaller.__init__N)rPrQrRrer2r2r2r3ÚFakeReactorInstallerÏó r€rhrirjrkc3sˆVˆVˆVˆVdSr&r2r2)rhrirjrkr2r3ÚgetReactorTypesÚs € zBServerOptionsTests.test_sortedReactorHelp..getReactorTypesz--help-reactorscs ˆ |ˆ¡ˆ ˆ |¡¡dSr&)ÚassertInÚappendr()Ús)Ú helpOutputÚindexesrNr2r3ÚgetIndexês z;ServerOptionsTests.test_sortedReactorHelp..getIndexz9reactor descriptions were not in alphabetical order: {!r}N)rrprlÚ_getReactorTypesr r‚rÚ messageOutputÚ assertRaisesÚ SystemExitÚ parseOptionsÚgetvaluer~rcÚsortedÚformat)rNr€r‚ruÚreactorrˆr2)rhrirjrkr†r‡rNr3Útest_sortedReactorHelpÊs0   ÿýz)ServerOptionsTests.test_sortedReactorHelpcCs(t ¡}d|_| ¡| |d¡dS)zS postOptions should set no_save to True when a subcommand is used. rJÚno_saveN)rrprwÚ postOptionsÚ assertTrue©rNrur2r2r3Ú&test_postOptionsSubCommandCausesNoSaveùsz9ServerOptionsTests.test_postOptionsSubCommandCausesNoSavecCs"t ¡}| ¡| |d¡dS)zR If no sub command is used, postOptions should not touch no_save. r“N)rrpr”Ú assertFalser–r2r2r3Ú(test_postOptionsNoSubCommandSavesAsUsualsz;ServerOptionsTests.test_postOptionsNoSubCommandSavesAsUsualcCs.t ¡}t|ƒ}tjjD]}| ||¡q dS)zq All the profilers that can be used in L{app.AppProfiler} are listed in the help output. N)rrpÚstrr Ú AppProfilerÚ profilersrƒ)rNrur†Úprofilerr2r2r3Útest_listAllProfilers s  ÿz(ServerOptionsTests.test_listAllProfilersútwistd unix not availablecCst ¡}| |d¡dS)zG The default value for the C{umask} option is L{None}. ÚumaskN)rrprtr–r2r2r3Útest_defaultUmasksz$ServerOptionsTests.test_defaultUmaskcCsHt ¡}| ddg¡| |dd¡| ddg¡| |dd¡dS)zh The value given for the C{umask} option is parsed as an octal integer literal. ú--umaskÚ123r éSÚ0123N)rrprrlr–r2r2r3Ú test_umasks zServerOptionsTests.test_umaskcCs t ¡}| t|jddg¡dS)z¥ If a value is given for the C{umask} option which cannot be parsed as an integer, L{UsageError} is raised by L{ServerOptions.parseOptions}. r¢ÚabcdefN)rrpr‹rrr–r2r2r3Útest_invalidUmask(sz$ServerOptionsTests.test_invalidUmaskcCóHt ¡}| t|jddg¡}| |jd d¡¡| d|jd¡dS)zQ C{--logger} with an unimportable module raises a L{UsageError}. ú--loggerzno.such.module.I.hoperzeLogger 'no.such.module.I.hope' could not be imported: 'no.such.module.I.hope' does not name an objectÚ N© rrpr‹rrr•ÚargsÚ startswithÚ assertNotIn©rNruÚer2r2r3Ú&test_unimportableConfiguredLogObserver1s ÿ ÿÿz9ServerOptionsTests.test_unimportableConfiguredLogObservercCr©)zP C{--logger} with a non-existent object raises a L{UsageError}. rªztwisted.test.test_twistd.FOOBARrz{Logger 'twisted.test.test_twistd.FOOBAR' could not be imported: module 'twisted.test.test_twistd' has no attribute 'FOOBAR'r«Nr¬r°r2r2r3Ú*test_badAttributeWithConfiguredLogObserverAsý ÿÿz=ServerOptionsTests.test_badAttributeWithConfiguredLogObservercCsvddlm}tdkr d}nd}d ||j|j¡}tƒ}tj|d}| t |j dg¡}|  |j d ¡|  | ¡|¡d S) z2 C{--version} prints the version. r)Ú copyrightÚwin32z(the Twisted Windows runner)z(the Twisted daemon)ztwistd {} {} {} ©Ústdoutz --versionN)Útwistedr´rrÚversionrrrpr‹rŒrÚassertIsÚcoderlrŽ)rNr´r,ÚexpectedOutputr·rur±r2r2r3Ú test_versionTs  ÿ zServerOptionsTests.test_versioncCs(tƒ}tj|d}| t|jdg¡dS)zI Command is printed when an invalid option is requested. r¶z web --fooN)rrrpr‹rr)rNr·rur2r2r3Ú!test_printSubCommandForUsageErrorhs z4ServerOptionsTests.test_printSubCommandForUsageErrorN)rPrQrRrSr|r’r—r™ržrÚ _twistd_unixr¡r¦r¨r²r³r½r¾r2r2r2r3r`šs"+/      r`rŸc@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd S) Ú CheckPIDTestsz Tests for L{checkPID}. cCs | tjddd„¡tdƒdS)z7 Nonexistent PID file is not an error. ÚexistscSódS©NFr2)Ú_r2r2r3Ú|óz.CheckPIDTests.test_notExists..znon-existent PID fileN)rBr8Úpathr"r\r2r2r3Útest_notExistsxs zCheckPIDTests.test_notExistscCs\| ¡}t|dƒ }| d¡Wdƒn1swY| tt|¡}| d|j¡dS)zI Non-numeric content in a PID file causes a system exit. Úwz non-numericNznon-numeric value)ÚmktempÚopenÚwriter‹rŒr"rƒr»)rNÚpidfileÚfr±r2r2r3Útest_nonNumerics   ÿzCheckPIDTests.test_nonNumericcCsr| ¡}t|dƒ }| d¡Wdƒn1swYdd„}| td|¡| tt|¡}| d|j ¡dS)zE Another running twistd server causes a system exit. rÉÚ42NcSrVr&r2©ÚpidÚsigr2r2r3Úkill‘rZz/CheckPIDTests.test_anotherRunning..killrÔzAnother twistd server) rÊrËrÌrBr8r‹rŒr"rƒr»©rNrÍrÎrÔr±r2r2r3Útest_anotherRunning‰s  ÿz!CheckPIDTests.test_anotherRunningcCs|| ¡}t|dƒ}| tt ¡dƒ¡Wdƒn1swYdd„}| td|¡t|ƒ| tj   |¡¡dS)zJ Stale PID file is removed without causing a system exit. rÉéNcSó ttjdƒ‚©NÚfake)ÚOSErrorÚerrnoÚESRCHrÑr2r2r3rÔ ó z&CheckPIDTests.test_stale..killrÔ) rÊrËrÌršr8ÚgetpidrBr"r˜rÇrÁ)rNrÍrÎrÔr2r2r3Ú test_stale˜s ÿzCheckPIDTests.test_stalecCsˆ| ¡}t|dƒ }| d¡Wdƒn1swYdd„}| td|¡| tt|¡}| |j d¡|  |j d  d¡¡dS) z An unexpected L{OSError} when checking the validity of a PID in a C{pidfile} terminates the process via L{SystemExit}. rÉÚ3581NcSrØrÙ©rÛrÜÚEBADFrÑr2r2r3rÔ°rÞz2CheckPIDTests.test_unexpectedOSError..killrÔrzCan't check status of PID) rÊrËrÌrBr8r‹rŒr"Ú assertIsNotr»r•r­r®rÕr2r2r3Útest_unexpectedOSError§s  ÿz$CheckPIDTests.test_unexpectedOSErrorN) rPrQrRrSrÈrÏrÖràrår2r2r2r3rÀrs  rÀc@ó eZdZdZdd„Zdd„ZdS)Ú TapFileTestszM Test twistd-related functionality that requires a tap file on disk. cCsN| ¡|_t|jdƒ}t t d¡|¡WdƒdS1s wYdS)zP Create a trivial Application and put it in a tap file on disk. ÚwbúHi!N)rÊÚtapfilerËÚpickleÚdumpr Ú Application)rNrÎr2r2r3ÚsetUp¾s "ÿzTapFileTests.setUpcCs<t ¡}| d|jg¡t|ƒ ¡}| t |¡j d¡dS)zŽ Ensure that the createOrGetApplication call that 'twistd -f foo.tap' makes will load the Application out of foo.tap. z-fréN) rrprrêr[ÚcreateOrGetApplicationrlr ÚIServicer,)rNrurXr2r2r3Ú&test_createOrGetApplicationWithTapFileÆs z3TapFileTests.test_createOrGetApplicationWithTapFileN)rPrQrRrSrîrñr2r2r2r3rç¹s rçc@ó(eZdZdZdd„Zdd„Zdd„ZdS) ÚTestLoggerFactoryz8 A logger factory for L{TestApplicationRunner}. cCó ||_dSr&)Úrunner)rNrõr2r2r3reÖó zTestLoggerFactory.__init__cCs"|jj d¡t|jdƒ|j_dS)zC Save the logging start on the C{runner} instance. ÚlogrXN)rõÚorderr„ÚhasattrÚhadApplicationLogObserverrWr2r2r3rYÙszTestLoggerFactory.startcCrÂ)z% Don't log anything. Nr2r\r2r2r3ÚstopàrÆzTestLoggerFactory.stopN)rPrQrRrSrerYrûr2r2r2r3róÑs  róc@rò) ÚTestApplicationRunnerz` An ApplicationRunner which tracks the environment in which its methods are called. cCs"tj ||¡g|_t|ƒ|_dSr&)r ÚApplicationRunnerrerørórrMr2r2r3reìszTestApplicationRunner.__init__cCó|j d¡t|dƒ|_dS)NÚprerX)rør„rùÚhadApplicationPreApplicationr\r2r2r3r]ñó z$TestApplicationRunner.preApplicationcCrþ)NÚpostrX)rør„rùÚhadApplicationPostApplicationr\r2r2r3r^õrz%TestApplicationRunner.postApplicationN)rPrQrRrSrer]r^r2r2r2r3rüæs  rüc@sˆeZdZdZdd„Zdd„Zdd„Zdd „Zee e d d ƒ d ƒd d„ƒZ ee e d d ƒ d ƒdd„ƒZ dd„Z dd„Zdd„Zdd„Zd S)ÚApplicationRunnerTestszR Non-platform-specific tests for the platform-specific ApplicationRunner. cCs4t ¡}tƒ|_d|ji|_tƒ|_d|_||_dS)NÚ test_command) rrprIÚ serviceMakerÚ loadedPluginsÚobjectÚ subOptionsrwrur–r2r2r3rîÿs   zApplicationRunnerTests.setUpcCsLt|jƒ}| ¡| |jj|jjd¡| |jjt |j ¡j dd¡dS)z· Ensure that a twistd plugin gets used in appropriate ways: it is passed its Options instance, and the service it returns is added to the application. zKServiceMaker.makeService needs to be passed the correct sub Command object.rzPServiceMaker.makeService's result needs to be set as a child of the Application.N) r[ruÚrunrºrrKr r rðrXÚservices)rNÚarunnerr2r2r3Ú,test_applicationRunnerGetsCorrectApplications ýýzCApplicationRunnerTests.test_applicationRunnerGetsCorrectApplicationcCsLt|jƒ}| ¡| |j¡| |j¡| |j¡| |j gd¢¡dS)z† Test thet preApplication and postApplication methods are called by ApplicationRunner.run() when appropriate. )rÿr÷rN) rürur r˜rr•rrúrlrø)rNr…r2r2r3Útest_preAndPostApplications    z1ApplicationRunnerTests.test_preAndPostApplicationc s¦|j |¡g‰G‡fdd„dtjƒ}ttjtjƒG‡fdd„dƒƒ}|ƒ}ttj|ƒttj|ƒ||jƒ}|  ¡||_ |  ¡|  ˆdddd||fd d g¡d S) a. Assert that given a particular command line, an application is started as a particular UID/GID. @param argv: A list of strings giving the options to parse. @param uid: An integer giving the expected UID. @param gid: An integer giving the expected GID. cs8eZdZ‡fdd„Z‡fdd„Z‡fdd„Zdd„Zd S) z\ApplicationRunnerTests._applicationStartsWithConfiguredID..FakeUnixApplicationRunnercóˆ d¡dS)NÚ environment©r„©rNÚchrootÚrundirÚnodaemonr rÍ©Úeventsr2r3ÚsetupEnvironment8ózmApplicationRunnerTests._applicationStartsWithConfiguredID..FakeUnixApplicationRunner.setupEnvironmentcsˆ d|||f¡dS)NÚ privilegesr)rNÚeuidrDr/rr2r3ÚshedPrivileges;szkApplicationRunnerTests._applicationStartsWithConfiguredID..FakeUnixApplicationRunner.shedPrivilegescr)Nr‘r)rNr‘Ú oldstdoutÚ oldstderrrr2r3Ú startReactor>rziApplicationRunnerTests._applicationStartsWithConfiguredID..FakeUnixApplicationRunner.startReactorcSrVr&r2)rNrÍr2r2r3Ú removePIDArZzfApplicationRunnerTests._applicationStartsWithConfiguredID..FakeUnixApplicationRunner.removePIDN)rPrQrRrrrr r2rr2r3ÚFakeUnixApplicationRunner7s     r!cs\eZdZdZdZdZdZdZdZdd„Z dd„Z dd„Z ‡fdd „Z ‡fd d „Z d d „ZdS)zNApplicationRunnerTests._applicationStartsWithConfiguredID..FakeServiceNcSrVr&r2rdr2r2r3ÚsetNameNrZzVApplicationRunnerTests._applicationStartsWithConfiguredID..FakeService.setNamecSrVr&r2)rNÚparentr2r2r3ÚsetServiceParentQrZz_ApplicationRunnerTests._applicationStartsWithConfiguredID..FakeService.setServiceParentcSrVr&r2r\r2r2r3ÚdisownServiceParentTrZzbApplicationRunnerTests._applicationStartsWithConfiguredID..FakeService.disownServiceParentcr)NÚprivilegedStartServicerr\rr2r3r&WrzeApplicationRunnerTests._applicationStartsWithConfiguredID..FakeService.privilegedStartServicecr)NÚ startServicerr\rr2r3r'Zrz[ApplicationRunnerTests._applicationStartsWithConfiguredID..FakeService.startServicecSrVr&r2r\r2r2r3Ú stopService]rZzZApplicationRunnerTests._applicationStartsWithConfiguredID..FakeService.stopService)rPrQrRr#Úrunningr,Ú processNamerDr/r"r$r%r&r'r(r2rr2r3Ú FakeServiceDs   r+rr&rFr'r‘N) rurrÚ_SomeApplicationRunnerrr rðÚIProcessrr]rXr^rl)rNÚargvrDr/r!r+rXrõr2rr3Ú"_applicationStartsWithConfiguredID*s*      ûþz9ApplicationRunnerTests._applicationStartsWithConfiguredIDÚsetuidNz5Platform does not support --uid/--gid twistd options.cCs*d}d}| dt|ƒdt|ƒg||¡dS)a L{postApplication} should change the UID and GID to the values specified as numeric strings by the configuration after running L{service.IService.privilegedStartService} and before running L{service.IService.startService}. éÒéáú--uidú--gidN)r/rš)rNrDr/r2r2r3Ú.test_applicationStartsWithConfiguredNumericIDsts  ÿzEApplicationRunnerTests.test_applicationStartsWithConfiguredNumericIDscCs<d}d}d}d}t|j||||ƒ| d|d|g||¡dS)a  L{postApplication} should change the UID and GID to the values specified as user and group names by the configuration after running L{service.IService.privilegedStartService} and before running L{service.IService.startService}. Úfoor1Úbarr2r3r4N)rGrBr/)rNrCrDr1r/r2r2r3Ú+test_applicationStartsWithConfiguredNameIDs…s ÿzBApplicationRunnerTests.test_applicationStartsWithConfiguredNameIDscCs8tƒ}t ddddœ¡}| |dd¡| |jd¡dS)z7 L{startReactor} calls L{reactor.run}. Fr#©r#rÚdebugNz'startReactor did not call reactor.run())Ú DummyReactorr rýrr•Úcalled©rNr‘rõr2r2r3Útest_startReactorRunsTheReactor™s  ÿz6ApplicationRunnerTests.test_startReactorRunsTheReactorcCsDtƒ}| td|¡t ddddœ¡}| ddd¡| |j¡dS)zN L{ApplicationRunner} chooses a reactor if none is specified. r‘Fr#r9N)r;rBrr rýrr•r<r=r2r2r3Ú*test_applicationRunnerChoosesReactorIfNone¤s ÿzAApplicationRunnerTests.test_applicationRunnerChoosesReactorIfNonecCsHGdd„dtƒ}|ƒ}t ddddœ¡}| |dd¡| d|j¡dS)zg If the reactor exits with a signal, the application runner caches the signal. c@ræ)z[ApplicationRunnerTests.test_applicationRunnerCapturesSignal..DummyReactorWithSignalú‹ A dummy reactor, providing a C{run} method, and setting the _exitSignal attribute to a nonzero value. cSr©z= Dummy method, does nothing. Nr2r\r2r2r3Ú installWaker¼rÆzhApplicationRunnerTests.test_applicationRunnerCapturesSignal..DummyReactorWithSignal.installWakercSó d|_dS)zZ A fake run method setting _exitSignal to a nonzero value éN©Ú _exitSignalr\r2r2r3r Ás z_ApplicationRunnerTests.test_applicationRunnerCapturesSignal..DummyReactorWithSignal.runN©rPrQrRrSrBr r2r2r2r3ÚDummyReactorWithSignal¶ó rHFr#r9NrD)r r rýrÚ assertEqualsrF)rNrHr‘rõr2r2r3Ú$test_applicationRunnerCapturesSignal°s ÿz;ApplicationRunnerTests.test_applicationRunnerCapturesSignalcCsFGdd„dƒ}|ƒ}t ddddœ¡}| |dd¡| d|j¡dS)z˜ The runner sets its _exitSignal instance attribute to None if the reactor does not implement L{_ISupportsExitSignalCapturing}. c@ræ)ziApplicationRunnerTests.test_applicationRunnerIgnoresNoSignal..DummyReactorWithExitSignalAttributer@cSrÂrAr2r\r2r2r3rBÚrÆzvApplicationRunnerTests.test_applicationRunnerIgnoresNoSignal..DummyReactorWithExitSignalAttribute.installWakercSrC)z‚ A fake run method setting _exitSignal to a nonzero value that should be ignored. rDNrEr\r2r2r3r ßs zmApplicationRunnerTests.test_applicationRunnerIgnoresNoSignal..DummyReactorWithExitSignalAttribute.runNrGr2r2r2r3Ú#DummyReactorWithExitSignalAttributeÔrIrLFr#r9N)r rýrrJrF)rNrLr‘rõr2r2r3Ú%test_applicationRunnerIgnoresNoSignalÎs ÿzr?rKrMr2r2r2r3rús(  J þ  þ   rc@sveZdZdZeƒZdd„Zdd„Zdd„Zdd „Z d d „Z d d „Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„ZdS)Ú*UnixApplicationRunnerSetupEnvironmentTestsaº Tests for L{UnixApplicationRunner.setupEnvironment}. @ivar root: The root of the filesystem, or C{unset} if none has been specified with a call to L{os.chroot} (patched for this TestCase with L{UnixApplicationRunnerSetupEnvironmentTests.chroot}). @ivar cwd: The current working directory of the process, or C{unset} if none has been specified with a call to L{os.chdir} (patched for this TestCase with L{UnixApplicationRunnerSetupEnvironmentTests.chdir}). @ivar mask: The current file creation mask of the process, or C{unset} if none has been specified with a call to L{os.umask} (patched for this TestCase with L{UnixApplicationRunnerSetupEnvironmentTests.umask}). @ivar daemon: A boolean indicating whether daemonization has been performed by a call to L{_twistd_unix.daemonize} (patched for this TestCase with L{UnixApplicationRunnerSetupEnvironmentTests}. cs†ˆjˆ_ˆjˆ_ˆjˆ_dˆ_t ¡ˆ_ˆ td‡fdd„¡ˆ td‡fdd„¡ˆ td‡fdd„¡t t   ¡ƒˆ_ ˆj ˆj _ dS) NFrcó tˆd|ƒS)NÚroot©Úsetattr©rÇr\r2r3rÅ ó zBUnixApplicationRunnerSetupEnvironmentTests.setUp..ÚchdircrP)NÚcwdrRrTr\r2r3rÅ rUr crP)NÚmaskrR)rXr\r2r3rÅrU)ÚunsetrQrWrXÚdaemonr8rßrÒrBr rrprõÚ daemonizer\r2r\r3rîs z0UnixApplicationRunnerSetupEnvironmentTests.setUpcs dˆ_ˆ td‡fdd„¡dS)z§ Indicate that daemonization has happened and change the PID so that the value written to the pidfile can be tested in the daemonization case. Trßcs ˆjdS©Nr×)rÒr2r\r2r3rÅs zFUnixApplicationRunnerSetupEnvironmentTests.daemonize..N)rZrBr8©rNr‘r2r\r3r[sz4UnixApplicationRunnerSetupEnvironmentTests.daemonizecCs&|j ddddd¡| |jd¡dS)z¡ L{UnixApplicationRunner.setupEnvironment} changes the root of the filesystem if passed a non-L{None} value for the C{chroot} parameter. ú/foo/barÚ.TN)rõrrlrQr\r2r2r3Ú test_chrootóz6UnixApplicationRunnerSetupEnvironmentTests.test_chrootcCó(|j ddddd¡| |j|j¡dS)z L{UnixApplicationRunner.setupEnvironment} does not change the root of the filesystem if passed L{None} for the C{chroot} parameter. Nr_T)rõrrºrQrYr\r2r2r3Ú test_noChroot"sz8UnixApplicationRunnerSetupEnvironmentTests.test_noChrootcCs&|j ddddd¡| |jd¡dS)zŸ L{UnixApplicationRunner.setupEnvironment} changes the working directory of the process to the path given for the C{rundir} parameter. Nr^T)rõrrlrWr\r2r2r3Útest_changeWorkingDirectory*razFUnixApplicationRunnerSetupEnvironmentTests.test_changeWorkingDirectorycCsNttƒƒ|j ddddd¡Wdƒn1swY| |j¡dS)z L{UnixApplicationRunner.setupEnvironment} daemonizes the process if C{False} is passed for the C{nodaemon} parameter. Nr_F)rÚFakeDaemonizingReactorrõrr•rZr\r2r2r3Útest_daemonize2s ÿz9UnixApplicationRunnerSetupEnvironmentTests.test_daemonizecCs$|j ddddd¡| |j¡dS)z– L{UnixApplicationRunner.setupEnvironment} does not daemonize the process if C{True} is passed for the C{nodaemon} parameter. Nr_T)rõrr˜rZr\r2r2r3Útest_noDaemonize;sz;UnixApplicationRunnerSetupEnvironmentTests.test_noDaemonizecCsd| ¡}|j dddd|¡t|dƒ}t| ¡ƒ}Wdƒn1s$wY| ||j¡dS)z L{UnixApplicationRunner.setupEnvironment} writes the process's PID to the file specified by the C{pidfile} parameter. Nr_TÚrb)rÊrõrrËÚintÚreadrlrÒ©rNrÍrÎrÒr2r2r3Útest_nonDaemonPIDFileCs  ÿz@UnixApplicationRunnerSetupEnvironmentTests.test_nonDaemonPIDFilecCs’| ¡}ttƒƒ|j dddd|¡Wdƒn1swYt|dƒ}t| ¡ƒ}Wdƒn1s9wY| ||j d¡dS)z½ L{UnixApplicationRunner.setupEnvironment} writes the daemonized process's PID to the file specified by the C{pidfile} parameter if C{nodaemon} is C{False}. Nr_Frhr×) rÊrrerõrrËrirjrlrÒrkr2r2r3Útest_daemonPIDFileNs ÿ ÿz=UnixApplicationRunnerSetupEnvironmentTests.test_daemonPIDFilecCsPttƒƒ|j ddddd¡Wdƒn1swY| |jd¡dS)z L{UnixApplicationRunner.setupEnvironment} changes the process umask to the value specified by the C{umask} parameter. Nr_Fé{©rrerõrrlrXr\r2r2r3r¦[s ÿz5UnixApplicationRunnerSetupEnvironmentTests.test_umaskcCrb)zÑ L{UnixApplicationRunner.setupEnvironment} doesn't change the process umask if L{None} is passed for the C{umask} parameter and C{True} is passed for the C{nodaemon} parameter. Nr_T)rõrrºrXrYr\r2r2r3Útest_noDaemonizeNoUmaskdszBUnixApplicationRunnerSetupEnvironmentTests.test_noDaemonizeNoUmaskcCsPttƒƒ|j ddddd¡Wdƒn1swY| |jd¡dS)zÖ L{UnixApplicationRunner.setupEnvironment} changes the process umask to C{0077} if L{None} is passed for the C{umask} parameter and C{False} is passed for the C{nodaemon} parameter. Nr_Fé?ror\r2r2r3Útest_daemonizedNoUmaskms ÿzAUnixApplicationRunnerSetupEnvironmentTests.test_daemonizedNoUmaskN)rPrQrRrSrrYrîr[r`rcrdrfrgrlrmr¦rprrr2r2r2r3rOîs     rOc@s@eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dS)Ú*UnixApplicationRunnerStartApplicationTestsz> Tests for L{UnixApplicationRunner.startApplication}. csÆt ¡}| gd¢¡t d¡}t|ƒ|_g‰‡fdd„}t |jj ¡j }t |¡j }|  ¡}|  d¡|  ||¡| td|¡| tddd „¡| td d d „¡|j |¡|  ˆgd ¢¡d S)zó L{UnixApplicationRunner.startApplication} calls L{UnixApplicationRunner.setupEnvironment} with the chroot, rundir, nodaemon, umask, and pidfile parameters from the configuration it is constructed with. ) ú --nodaemonr¢Ú0070z--chrootú /foo/chrootz--rundirú /foo/rundirz --pidfileú /foo/pidfileÚtest_setupEnvironmentcsˆ |||||f¡dSr&)Úextendr©r­r2r3ÚfakeSetupEnvironment˜sz^UnixApplicationRunnerStartApplicationTests.test_setupEnvironment..fakeSetupEnvironmentrNrrc_rVr&r2©ÚaÚkwr2r2r3rŬrÆzRUnixApplicationRunnerStartApplicationTests.test_setupEnvironment..ÚstartApplicationc_rVr&r2r}r2r2r3rÅ­rÆ)rvrwTé8rxN)rrprr rír rõÚinspectÚ signaturerÚ parametersÚcopyÚpoprlrBr r€)rNrKrXr|ÚsetupEnvironmentParametersÚfakeSetupEnvironmentParametersr2r{r3ry~s4ÿ  ÿþÿþ   z@UnixApplicationRunnerStartApplicationTests.test_setupEnvironmentcs4‡fdd„}ˆ td|¡tiƒ}| ddd¡dS)zf L{UnixApplicationRunner.shedPrivileges} switches the user ID of the process. cs(ˆ |d¡ˆ |d¡ˆ |d¡dS)NéÈé6é#©rl©rDr/rr\r2r3Ú switchUIDPass¸s  zUUnixApplicationRunnerStartApplicationTests.test_shedPrivileges..switchUIDPassÚ switchUIDr‹r‰rŠN)rBr¿r r)rNrŽrõr2r\r3Útest_shedPrivileges²s z>UnixApplicationRunnerStartApplicationTests.test_shedPrivilegescCsDdd„}tiƒ}| td|¡| t|jddd¡}| |jd¡dS)z  An unexpected L{OSError} when calling L{twisted.scripts._twistd_unix.shedPrivileges} terminates the process via L{SystemExit}. cSrØrÙrârr2r2r3Ú switchUIDFailÈrÞzZUnixApplicationRunnerStartApplicationTests.test_shedPrivilegesError..switchUIDFailrr‹r‰Nr×)r rBr¿r‹rŒrrlr»)rNr‘rõÚexcr2r2r3Útest_shedPrivilegesErrorÁs zCUnixApplicationRunnerStartApplicationTests.test_shedPrivilegesErrorc s®tˆj|ˆ|ˆƒ‡‡‡fdd„}‡‡fdd„}‡‡fdd„}ˆ td|¡ˆ td|¡ˆ td |¡t ¡}| d d tˆƒg¡t  d ¡} t |ƒˆ_ t |ƒ} |   | ¡d S)zj Common code for tests which try to pass the the UID to L{UnixApplicationRunner}. csˆ |ˆ¡ˆ |ˆ¡dSr&rŒ)rDr/©rNÚ wantedGidÚ wantedUidr2r3Ú initgroups×rzFUnixApplicationRunnerStartApplicationTests._setUID..initgroupscóˆ |ˆ¡dSr&rŒ)rD)rNr–r2r3r0ÛózBUnixApplicationRunnerStartApplicationTests._setUID..setuidcr˜r&rŒ)r/)rNr•r2r3ÚsetgidÞr™zBUnixApplicationRunnerStartApplicationTests._setUID..setgidr—r0ršrtr3ryN) rGrBrr8rrprršr rír rõr€) rNÚ wantedUserr–Ú wantedGroupr•r—r0ršrKrXrõr2r”r3Ú_setUIDÐs  z2UnixApplicationRunnerStartApplicationTests._setUIDcCs| dddd¡dS)z½ Starting an application with L{UnixApplicationRunner} configured with a UID and no GUID will result in the GUID being set to the default GUID for that UID. r6ir7i’N)rr\r2r2r3Útest_setUidWithoutGidìsz@UnixApplicationRunnerStartApplicationTests.test_setUidWithoutGidcCsTt ¡}| d|dd¡| ¡}| dt|ƒ¡d ||¡}| ||dd¡dS) zz If the specified UID is the same as the current UID of the process, then a warning is displayed. ÚmorefooÚmorebari÷r×z\tried to drop privileges and setuid {} but uid is already {}; should we be root? Continuing.rÚmessageN)r8r9rÚ flushWarningsrlÚlenr)rNÚ currentUidÚ warningsShownÚexpectedWarningr2r2r3Útest_setUidSameAsCurrentUidôsþzFUnixApplicationRunnerStartApplicationTests.test_setUidSameAsCurrentUidN) rPrQrRrSryrr“rržr§r2r2r2r3rsxs4 rsc@ræ)Ú#UnixApplicationRunnerRemovePIDTestsz7 Tests for L{UnixApplicationRunner.removePID}. cCsVtiƒ}| ¡}t |¡tj |d¡}t|dƒ ¡| |¡|  tj  |¡¡dS)zp L{UnixApplicationRunner.removePID} deletes the file the name of which is passed to it. zfoo.pidrÉN) r rÊr8ÚmakedirsrÇÚjoinrËÚcloser r˜rÁ)rNrõrÇrÍr2r2r3Útest_removePID s  z2UnixApplicationRunnerRemovePIDTests.test_removePIDcCsFtiƒ}| d¡| t¡}| t|ƒd¡| |djjtj¡dS)zr Calling L{UnixApplicationRunner.removePID} with a non-existent filename logs an OSError. Úfakepidr×rN) r r ÚflushLoggedErrorsrÛrlr£ÚvaluerÜÚENOENT)rNrõÚerrorsr2r2r3Útest_removePIDErrorss   z8UnixApplicationRunnerRemovePIDTests.test_removePIDErrorsN)rPrQrRrSr¬r²r2r2r2r3r¨s r¨c@ó0eZdZdZdd„Zdd„Zdd„Zdd „Zd S) ÚFakeNonDaemonizingReactora› A dummy reactor, providing C{beforeDaemonize} and C{afterDaemonize} methods, but not announcing this, and logging whether the methods have been called. @ivar _beforeDaemonizeCalled: if C{beforeDaemonize} has been called or not. @type _beforeDaemonizeCalled: C{bool} @ivar _afterDaemonizeCalled: if C{afterDaemonize} has been called or not. @type _afterDaemonizeCalled: C{bool} cCsd|_d|_dSrÃ)Ú_beforeDaemonizeCalledÚ_afterDaemonizeCalledr\r2r2r3re0s z"FakeNonDaemonizingReactor.__init__cCó d|_dS©NT)rµr\r2r2r3ÚbeforeDaemonize4röz)FakeNonDaemonizingReactor.beforeDaemonizecCr·r¸)r¶r\r2r2r3ÚafterDaemonize7röz(FakeNonDaemonizingReactor.afterDaemonizecOrÂ)z* Skip event registration. Nr2)rNr­rr2r2r3ÚaddSystemEventTrigger:rÆz/FakeNonDaemonizingReactor.addSystemEventTriggerN)rPrQrRrSrer¹rºr»r2r2r2r3r´$s   r´c@seZdZdZdS)rez A dummy reactor, providing C{beforeDaemonize} and C{afterDaemonize} methods, announcing this, and logging whether the methods have been called. N)rPrQrRrSr2r2r2r3re@srec@rH)r;z² A dummy reactor, only providing a C{run} method and checking that it has been called. @ivar called: if C{run} has been called or not. @type called: C{bool} FcCs|jrtdƒ‚d|_dS)zV A fake run method, checking that it's been called one and only time. zAlready calledTN)r<Ú RuntimeErrorr\r2r2r3r Ss úDummyReactor.runN)rPrQrRrSr<r r2r2r2r3r;Hs r;c@s¤eZdZdZee dƒdd„ƒZdd„Zee dƒdd„ƒZd d „Z ee dƒd d „ƒZ ee d ƒdd„ƒZ ee d ƒdd„ƒZ dd„Zdd„Zdd„Zdd„ZdS)ÚAppProfilingTestsz' Tests for L{app.AppProfiler}. zprofile module not availablecCs’t ¡}| ¡|d<d|d<t |¡}tƒ}| |¡| |j¡t |dƒ }|  ¡}Wdƒn1s6wY|  d|¡|  d|¡dS)zŒ L{app.ProfileRunner.run} should call the C{run} method of the reactor and save profile data in the specified file. r#rNr½úfunction calls© rrprÊr r›r;r r•r<rËrjrƒ©rNrurr‘rÎÚdatar2r2r3Ú test_profileaó     ÿ zAppProfilingTests.test_profilecCsPtƒ}| td|¡}||ƒ}| ¡| ¡| ¡}| d|¡| d|¡dS)Nr·r¿z(run))rrBÚsysÚ print_statsÚrestorerŽrƒ)rNÚ statsClassr#Úoutr·ÚstatsrÂr2r2r3Ú _testStatsus zAppProfilingTests._testStatscCs`t ¡}| ¡|d<d|d<d|d<t |¡}tƒ}| |¡| |j¡|  t j |d¡dS)z˜ With the C{savestats} option specified, L{app.ProfileRunner.run} should save the raw stats object instead of a summary output. r#rTÚ savestatsN© rrprÊr r›r;r r•r<rËr$ÚStats©rNrurr‘r2r2r3Útest_profileSaveStats†s    z'AppProfilingTests.test_profileSaveStatsc Csttj ¡}t ¡}d|d<t |¡}dtjd<z| t|j d¡Wtj  ¡tj  |¡dStj  ¡tj  |¡w)z† When the C{profile} module is not present, L{app.ProfilerRunner.run} should raise a C{SystemExit} exception. r#rN© rÅÚmodulesr…rrpr r›r‹rŒr ÚclearÚupdate©rNÚ savedModulesrurr2r2r3Útest_withoutProfile˜s     ÿz%AppProfilingTests.test_withoutProfilecCstGdd„dtjƒ}| td|¡t ¡}| ¡|d<d|d<t |¡}tƒ}t j }|  t |j |¡| t j |¡dS)z… When an error happens during the print of the stats, C{sys.stdout} should be restored to its initial value. c@r})zGAppProfilingTests.test_profilePrintStatsError..ErroneousProfilecSstdƒ‚)NÚBoom©r¼r\r2r2r3rƲózSAppProfilingTests.test_profilePrintStatsError..ErroneousProfile.print_statsN)rPrQrRrÆr2r2r2r3ÚErroneousProfile±rrÛÚProfiler#rN)r#rÜrBrrprÊr r›r;rÅr·r‹r¼r rº)rNrÛrurr‘Ú oldStdoutr2r2r3Útest_profilePrintStatsErrorªs  z-AppProfilingTests.test_profilePrintStatsErrorzcProfile module not availablecCs’t ¡}| ¡|d<d|d<t |¡}tƒ}| |¡| |j¡t |dƒ }|  ¡}Wdƒn1s6wY|  d|¡|  d|¡dS)z L{app.CProfileRunner.run} should call the C{run} method of the reactor and save profile data in the specified file. r#r%rNr r¿rÀrÁr2r2r3Ú test_cProfileÁrÄzAppProfilingTests.test_cProfilecCs`t ¡}| ¡|d<d|d<d|d<t |¡}tƒ}| |¡| |j¡|  t j |d¡dS)z¡ With the C{savestats} option specified, L{app.CProfileRunner.run} should save the raw stats object instead of a summary output. r#r%rTrÌNrÍrÏr2r2r3Útest_cProfileSaveStatsÕs    z(AppProfilingTests.test_cProfileSaveStatsc Csttj ¡}dtjd<t ¡}d|d<t |¡}z| t|j d¡Wtj  ¡tj  |¡dStj  ¡tj  |¡w)zª When the C{cProfile} module is not present, L{app.CProfileRunner.run} should raise a C{SystemExit} exception and log the C{ImportError}. Nr%rrÑrÕr2r2r3Útest_withoutCProfileès     ÿz&AppProfilingTests.test_withoutCProfilecCs@t ¡}| ¡|d<d|d<| ttj|¡}| t|ƒd¡dS)zq Check that L{app.AppProfiler} raises L{SystemExit} when given an unknown profiler name. r#Úfoobarrz!Unsupported profiler name: foobarN) rrprÊr‹rŒr r›rlrš)rNruÚerrorr2r2r3Útest_unknownProfilerús  z&AppProfilingTests.test_unknownProfilercCst i¡}| |jd¡dS)zU L{app.Profiler} defaults to the cprofile profiler if not specified. ÚcprofileN©r r›rlr©rNrr2r2r3Útest_defaultProfilers z&AppProfilingTests.test_defaultProfilercCs t ddi¡}| |jd¡dS)ze The case of the profiler name passed to L{app.AppProfiler} is not relevant. rÚCprOfileråNrærçr2r2r3Útest_profilerNameCaseInsentive sz0AppProfilingTests.test_profilerNameCaseInsentiveN)rPrQrRrSrr#rÃrËrÐr×rÞr%rßràrárärèrêr2r2r2r3r¾\s$           r¾cs(g‰tj‰‡‡fdd„}|td|ƒˆS)a Patch L{logger.textFileLogObserver} to record every call and keep a reference to the passed log file for tests. @param patch: a callback for patching (usually L{TestCase.patch}). @return: the list that keeps track of the log files. @rtype: C{list} cs ˆ |¡ˆ|g|¢Ri|¤ŽSr&r)ÚlogFiler­Úkwargs©ÚlogFilesÚoldFileLogObserverr2r3Úobserver#s z+_patchTextFileLogObserver..observerÚtextFileLogObserver)rrñ)rBrðr2rír3Ú_patchTextFileLogObservers   ròcs(g‰G‡fdd„dƒ}| td|¡ˆS)zu Make fake syslog, and return list to which prefix and then log messages will be appended if it is used. cs$eZdZ‡fdd„Z‡fdd„ZdS)z(_setupSyslog..fakesyslogobservercóˆ |¡dSr&r)rNÚprefix©Ú logMessagesr2r3re3rz1_setupSyslog..fakesyslogobserver.__init__crór&r)rNÚ eventDictrõr2r3Úemit6rz-_setupSyslog..fakesyslogobserver.emitN)rPrQrRrerør2rõr2r3Úfakesyslogobserver2s rùÚSyslogObserver)rBÚsyslog)ÚtestCaserùr2rõr3Ú _setupSyslog+srýc@sÀeZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z ie j fdd„Z dd„Z dd„Zdd„Zdd„Zee dƒee dƒdd„ƒƒZdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(S))ÚAppLoggerTestsz† Tests for L{app.AppLogger}. @ivar observers: list of observers installed during the tests. @type observers: C{list} có$gˆ_‡fdd„}ˆ td|¡dS)zˆ Override L{globaLogBeginner.beginLoggingTo} so that we can trace the observers installed in C{self.observers}. cs$|D] }ˆj |¡t |¡qdSr&)Ú observersr„rÚ addObserver)rrðr\r2r3ÚbeginLoggingToLs  þz,AppLoggerTests.setUp..beginLoggingTorN)rrBr)rNrr2r\r3rîEs zAppLoggerTests.setUpcCs|jD]}t |¡qdS)z1 Remove all installed observers. N)rrÚremoveObserver©rNrðr2r2r3ÚtearDownSs  ÿzAppLoggerTests.tearDowncCsttƒGdd„dƒƒ}|ƒS)z Make a new observer which captures all logs sent to it. @return: An observer that stores all logs sent to it. @rtype: Callable that implements L{ILogObserver}. c@seZdZgZdd„ZdS)z2AppLoggerTests._makeObserver..TestObservercSs|j |¡dSr&)Ú_logsr„)rNÚeventr2r2r3Ú__call__fr™z;AppLoggerTests._makeObserver..TestObserver.__call__N)rPrQrRrrr2r2r2r3Ú TestObserverbs r )rr)rNr r2r2r3Ú _makeObserverZszAppLoggerTests._makeObservercCs@| |j|g¡| d|jdd¡| d|jdd¡dS)z Ensure that initial C{twistd} logs are written to logs. @param observer: The observer made by L{self._makeObserver). ú starting uprÚ log_formatz reactor classr×N)rlrrƒrrr2r2r3Ú_checkObserverkszAppLoggerTests._checkObservercs:t i¡}| ¡‰‡fdd„|_| tƒ¡| ˆ¡dS)z” L{app.AppLogger.start} calls L{globalLogBeginner.addObserver}, and then writes some messages about twistd and the reactor. cóˆSr&r2r2©rðr2r3rÅ|rÆz+AppLoggerTests.test_start..N)r Ú AppLoggerr Ú_getLogObserverrYrr )rNrr2rr3Ú test_startus  zAppLoggerTests.test_startcCs<tƒ}| ¡}| t|¡t i¡}| |¡| |¡dS)zµ When the L{ILogObserver} component is available on the application, that object will be used as the log observer instead of constructing a new one. N)rr Ú setComponentrr rrYr )rNrXrðrr2r2r3Ú$test_startUsesApplicationLogObserver€s    z3AppLoggerTests.test_startUsesApplicationLogObservercs8| ¡‰d‡fdd„i}| |¡||ƒ}| |¡ˆS)a Set up an AppLogger which exercises the C{logger} configuration option. @type application: L{Componentized} @param application: The L{Application} object to pass to L{app.AppLogger.start}. @type extraLogArgs: C{dict} @param extraLogArgs: extra values to pass to AppLogger. @type appLogger: L{AppLogger} class, or a subclass @param appLogger: factory for L{AppLogger} instances. @rtype: C{list} @return: The logs accumulated by the log observer. rcrr&r2r2rr2r3rÅŸrÆz7AppLoggerTests._setupConfiguredLogger..)r rÔrY)rNrXÚ extraLogArgsÚ appLoggerÚlogArgsrr2rr3Ú_setupConfiguredLoggers   z%AppLoggerTests._setupConfiguredLoggercCstƒ}| | |¡¡dS)a When the C{logger} key is specified in the configuration dictionary (i.e., when C{--logger} is passed to twistd), the initial log observer will be the log observer returned from the callable which the value refers to in FQPN form. N)rr rrWr2r2r3Ú#test_startUsesConfiguredLogObserver¥sz2AppLoggerTests.test_startUsesConfiguredLogObservercCs<| ¡}tƒ}| t|¡| | |¡¡| |jg¡dS)zk C{--logger} takes precedence over a L{ILogObserver} component set on Application. N)r rrrr rrlr)rNrðrXr2r2r3Ú(test_configuredLogObserverBeatsComponent¯s  z7AppLoggerTests.test_configuredLogObserverBeatsComponentcCs8g}tƒ}| t|j¡| | |¡¡| |g¡dS)zq C{--logger} takes precedence over a L{LegacyILogObserver} component set on Application. N)rrÚLegacyILogObserverr„r rrl)rNÚnonlogsrXr2r2r3Ú.test_configuredLogObserverBeatsLegacyComponentºs z=AppLoggerTests.test_configuredLogObserverBeatsLegacyComponentcCsZg}| ¡}tƒ}| t|¡| t|j¡t i¡}| |¡|  |¡|  |g¡dS)zw A L{ILogObserver} takes precedence over a L{LegacyILogObserver} component set on Application. N) r rrrrr„r rrYr rl)rNrrðrXrr2r2r3Ú.test_loggerComponentBeatsLegacyLoggerComponentÅs    z=AppLoggerTests.test_loggerComponentBeatsLegacyLoggerComponentrŸzsyslog not availablecCs6t|ƒ}tƒ}| | |ddit¡¡| |g¡dS)z` C{--logger} takes precedence over a C{--syslog} command line argument. rûTN)rýrr rr!rl)rNÚlogsrXr2r2r3Ú%test_configuredLogObserverBeatsSyslogÖs ÿz4AppLoggerTests.test_configuredLogObserverBeatsSyslogcCs:tƒ}| ¡}| | |ddi¡¡| tj |¡¡dS)za C{--logger} takes precedence over a C{--logfile} command line argument. ÚlogfilerÇN)rrÊr rr˜r8rÇrÁ)rNrXrÇr2r2r3Ú&test_configuredLogObserverBeatsLogfileäs ÿz5AppLoggerTests.test_configuredLogObserverBeatsLogfilecCs~t ddi¡}t|jƒ}| ¡| t|ƒd¡| |dtj ¡t ddi¡}| ¡| t|ƒd¡| |dtj ¡dS)z’ When logfile is empty or set to C{-}, L{app.AppLogger._getLogObserver} returns a log observer pointing at C{sys.stdout}. r!ú-r×rÚrDN) r rròrBrrlr£rºrÅr·)rNrrîr2r2r3Útest_getLogObserverStdoutðs z(AppLoggerTests.test_getLogObserverStdoutcCsdt|jƒ}| ¡}t d|i¡}| ¡}| |jj¡|  t |ƒd¡|  |dj t j   |¡¡dS)z• When passing the C{logfile} option, L{app.AppLogger._getLogObserver} returns a log observer pointing at the specified path. r!r×rN)ròrBrÊr rrÚ addCleanupÚ_outFiler«rlr£rÇr8Úabspath)rNrîÚfilenameÚsutrðr2r2r3Útest_getLogObserverFiles z&AppLoggerTests.test_getLogObserverFilecspg‰tƒ}‡fdd„}| td|¡t i¡}||_| ¡| ˆ|g¡| ¡| ˆ|g¡| |j¡dS)zÀ L{app.AppLogger.stop} removes the observer created in C{start}, and reinitialize its C{_observer} so that if C{stop} is called several times it doesn't break. csˆ |¡dSr&rr©Úremovedr2r3Úremoverz(AppLoggerTests.test_stop..removerN) rrBrr rÚ _observerrûrlrt)rNrðr.rr2r,r3Ú test_stops  zAppLoggerTests.test_stopcszg‰t i¡}ttƒG‡fdd„dƒƒ‰‡fdd„|_| tƒ¡| dtˆdƒ¡|  |j g¡}|  t |ƒd|¡dS)zt L{app.AppLogger} using a legacy logger observer still works, wrapping it in a compat shim. cseZdZdZ‡fdd„ZdS)z;AppLoggerTests.test_legacyObservers..LoggerObserverzX An observer which implements the legacy L{LegacyILogObserver}. csˆ |¡dS)z< Add C{x} to the logs list. Nr)rNÚx©rr2r3r5szDAppLoggerTests.test_legacyObservers..LoggerObserver.__call__N)rPrQrRrSrr2r2r2r3ÚLoggerObserver/sr3csˆƒSr&r2r2)r3r2r3rÅ;óz5AppLoggerTests.test_legacyObservers..r rN) r rrrÚ_observerFactoryrYrrƒrr¢Útest_legacyObserversrlr£©rNrÚwarningsr2)r3rr3r6's  z#AppLoggerTests.test_legacyObserverscstg‰t i¡}‡fdd„|_| tƒ¡| dtˆdƒ¡| |jg¡}|  t |ƒd|¡|  |ddd¡dS) zÐ L{app.AppLogger} using a logger observer which does not implement L{ILogObserver} or L{LegacyILogObserver} will be wrapped in a compat shim and raise a L{DeprecationWarning}. csˆjSr&rr2r2r2r3rÅJr4zAAppLoggerTests.test_unmarkedObserversDeprecated..r rr×r¡aZPassing a logger factory which makes log observers which do not implement twisted.logger.ILogObserver or twisted.python.log.ILogObserver to twisted.application.app.AppLogger was deprecated in Twisted 16.2. Please use a factory that produces twisted.logger.ILogObserver (or the legacy twisted.python.log.ILogObserver) implementing objects instead.N) r rrrYrrƒrr¢Ú test_unmarkedObserversDeprecatedrlr£r7r2r2r3r9Bs   ýz/AppLoggerTests.test_unmarkedObserversDeprecatedN)rPrQrRrSrîrr r rrr rrrrrrrr¿rûr r"r%r+r0r6r9r2r2r2r3rþ=s.   ÿ        rþc@sTeZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z e e dƒdd„ƒZ dS)ÚUnixAppLoggerTestszw Tests for L{UnixAppLogger}. @ivar signals: list of signal handlers installed. @type signals: C{list} crÿ)zs Fake C{signal.signal} for not installing the handlers but saving them in C{self.signals}. csˆj ||f¡dSr&)Úsignalsr„)rÓrÎr\r2r3Ú fakeSignalpsz,UnixAppLoggerTests.setUp..fakeSignalÚsignalN)r;rBr=)rNr<r2r\r3rîis zUnixAppLoggerTests.setUpcCs~t|jƒ}tdddœƒ}| ¡| t|ƒd¡| |dtj¡tdddœƒ}| ¡| t|ƒd¡| |dtj¡dS) z° When non-daemonized and C{logfile} is empty or set to C{-}, L{UnixAppLogger._getLogObserver} returns a log observer pointing at C{sys.stdout}. r#T©r!rr×rr$rDN) ròrBr!rrlr£rºrÅr·©rNrîrr2r2r3r%us z,UnixAppLoggerTests.test_getLogObserverStdoutcCs0tdddœƒ}| t|j¡}| t|ƒd¡dS)z When daemonized and C{logfile} is set to C{-}, L{UnixAppLogger._getLogObserver} raises C{SystemExit}. r#Fr>z&Daemons cannot log to stdout, exiting!N)r!r‹rŒrrlrš)rNrrãr2r2r3Útest_getLogObserverStdoutDaemon‡sz2UnixAppLoggerTests.test_getLogObserverStdoutDaemoncsÀt|jƒ}| ¡}td|iƒ}| ¡}| |jj¡| t |ƒd¡| |dj t j   |¡¡| t |j ƒd¡| |j ddtj¡tƒ‰‡fdd„}||d_|j dd}|ddƒˆS)zÓ When C{logfile} contains a file name, L{app.AppLogger._getLogObserver} returns a log observer pointing at the specified path, and a signal handler rotating the log is installed. r!r×rcsˆ d¡dSr&)Úcallbackr2©Údr2r3Úrotate¥rz:UnixAppLoggerTests.test_getLogObserverFile..rotateN)ròrBrÊr!rr&r'r«rlr£rÇr8r(r;r=ÚSIGUSR1rrD)rNrîr)r*rðrDÚ rotateLogr2rBr3r+s     z*UnixAppLoggerTests.test_getLogObserverFilecsV‡fdd„}ˆ td|¡ˆ ¡}td|iƒ}| ¡}ˆ |jj¡ˆ ˆj g¡dS)zy If a signal handler is already installed, L{UnixAppLogger._getLogObserver} doesn't override it. csˆ |tj¡tƒSr&)rlr=rEr)rÓr\r2r3Ú fakeGetSignal´szVUnixAppLoggerTests.test_getLogObserverDontOverrideSignalHandler..fakeGetSignalÚ getsignalr!N) rBr=rÊr!rr&r'r«rlr;)rNrGr)r*rðr2r\r3Ú,test_getLogObserverDontOverrideSignalHandler®s  z?UnixAppLoggerTests.test_getLogObserverDontOverrideSignalHandlercCsNt|jƒ}tdddœƒ}| ¡| t|ƒd¡| |djtj d¡¡dS)z¶ When daemonized and C{logfile} is empty, the observer returned by L{UnixAppLogger._getLogObserver} points at C{twistd.log} in the current directory. r$Fr>r×rz twistd.logN) ròrBr!rrlr£rÇr8r(r?r2r2r3Útest_getLogObserverDefaultFileÁs z1UnixAppLoggerTests.test_getLogObserverDefaultFilerŸcCsPt|ƒ}tdddœƒ}| ¡}| |dg¡|ddiƒ| |dddig¡dS)z’ If C{syslog} is set to C{True}, L{UnixAppLogger._getLogObserver} starts a L{syslog.SyslogObserver} with given C{prefix}. Tz test-prefix)rûrôr~ÚbN)rýr!rrl)rNrrrðr2r2r3Útest_getLogObserverSyslogÎs  z,UnixAppLoggerTests.test_getLogObserverSyslogN) rPrQrRrSrîr%r@r+rIrJrr¿rLr2r2r2r3r:`s   r:z!twistd unix support not availablec@seZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zd d!„Zd"S)#ÚDaemonizeTestszH Tests for L{_twistd_unix.UnixApplicationRunner} daemonization. cCsbtƒ|_t ¡|_| td|j¡t |j¡|_t   d¡|j_ t j |j_t j|j_dd„|j_dS)Nr8récWrVr&r2r{r2r2r3rÅêrÆz&DaemonizeTests.setUp..)rÚmockosrrprurBr¿r rõr rírXrÅr·rÚstderrrrr\r2r2r3rîâs   zDaemonizeTests.setUpcCs`ttƒƒ |j ¡Wdƒn1swY| |jjgd¢¡| |jjddg¡dS)zw When double fork succeeded in C{daemonize}, the child process writes B{0} to the status pipe. N)©rVr_©r rq©ÚforkTÚsetsidrR)rÌéþÿÿÿó0©Úunlinkz twistd.pidéýÿÿÿrU)rrerõr^rlrNÚactionsÚclosedr\r2r2r3Ú test_successìs  ÿþ zDaemonizeTests.test_successcCstd|j_d|j_ttƒƒ| t|jj¡Wdƒn1s wY|  |jj gd¢¡|  |jj dg¡dS)zˆ The parent process initiating the C{daemonize} call reads data from the status pipe and then exit the process. FrVN)rPrQrR©rjéÿÿÿÿéd©ÚexitrrWr^) rNÚchildÚreadDatarrer‹Ú SystemErrorrõr^rlrZr[r\r2r2r3Útest_successInParents ÿþ z#DaemonizeTests.test_successInParentcsˆg‰‡fdd„}||j_ttƒƒ |j ¡Wdƒn1s!wY| |jjgd¢¡| |jjddg¡| ddgˆ¡dS)z‚ If the C{os.write} call to the status pipe raises an B{EINTR} error, the process child retries to write. cs(ˆ ||f¡tˆƒdkrttjƒ‚dSr\©r„r£rÛrÜÚEINTR)Úfdr©Úwrittenr2r3Ú raisingWrites  ÿz6DaemonizeTests.test_successEINTR..raisingWriteN)rPrQrRrTrRrWrYrU)rUrV) rNrÌrrerõr^rlrZr[)rNrkr2rir3Útest_successEINTRs   ÿþ z DaemonizeTests.test_successEINTRcs”g‰‡fdd„}||j_d|j_ttƒƒ| t|jj¡Wdƒn1s(wY|  |jj gd¢¡|  |jj dg¡|  ddgˆ¡dS)z If the C{os.read} call on the status pipe raises an B{EINTR} error, the parent child retries to read. cs(ˆ ||f¡tˆƒdkrttjƒ‚dS)Nr×rVrf)rhÚsize©rjr2r3Ú raisingRead;s  z=DaemonizeTests.test_successInParentEINTR..raisingReadFN)rPrQrRr`rWr^)r^r_) rNrjrbrrer‹rdrõr^rlrZr[)rNror2rnr3Útest_successInParentEINTR4s  ÿþ z(DaemonizeTests.test_successInParentEINTRc s G‡fdd„dtjƒ}|ƒ}| |jj¡ttƒƒ| t|jj ¡Wdƒn1s-wY|  |j j ddddddd |fd g¡|  |j j d d g¡dS) z¶ Assert L{UnixApplicationRunner.postApplication} writes C{reported} to its status pipe if the service raises an exception whose message is C{raised}. cseZdZ‡fdd„ZdS)z6DaemonizeTests.assertErrorWritten..FakeServicecstˆƒ‚r&rÙr\©Úraisedr2r3r'ZrÚzCDaemonizeTests.assertErrorWritten..FakeService.startServiceN)rPrQrRr'r2rqr2r3r+Ysr+NrPrQrRrTrÌrUrWrY)r rLr$rõrXrrer‹r¼r^rlrNrZr[)rNrrÚreportedr+Ú errorServicer2rqr3ÚassertErrorWrittenRs$ ÿùþ z!DaemonizeTests.assertErrorWrittencCó|jddddS)z„ If an error happens during daemonization, the child process writes the exception error to the status pipe. zSomething is wrongs"1 RuntimeError: Something is wrong©rrrsN©rur\r2r2r3Ú test_errorpó ÿzDaemonizeTests.test_errorcCrv)z» If an error happens during daemonization, and that error's message is Unicode, the child encodes the message as ascii with backslash Unicode code points. u•s1 RuntimeError: \u2022rwNrxr\r2r2r3Útest_unicodeErrorysz DaemonizeTests.test_unicodeErrorcCs”d|j_||j_tƒ}| td|¡ttƒƒ| t |j j ¡Wdƒn1s*wY|  |  ¡|¡|  |jj|¡|  |jjdg¡dS)a Make L{os.read} appear to return C{readData}, and assert that L{UnixApplicationRunner.postApplication} writes C{errorMessage} to standard error and executes the calls against L{os} functions specified in C{mockOSActions}. FÚ __stderr__Nr^)rNrbrcrrBrÅrrer‹rdrõr^rlrŽrZr[)rNrcÚ errorMessageÚ mockOSActionsÚerrorIOr2r2r3ÚassertErrorInParentBehaviors ÿz*DaemonizeTests.assertErrorInParentBehaviorcCó|jddgd¢ddS)zÍ When the child writes an error message to the status pipe during daemonization, the parent writes the repr of the message to C{stderr} and exits with non-zero status code. s 1 Exception: An identified errorzgAn error has occurred: b'Exception: An identified error' Please look at log file for more information. ©rPrQrRr])rar×rW©rcr}r~N©r€r\r2r2r3Útest_errorInParent’ó  úz!DaemonizeTests.test_errorInParentcCr)zØ When the child writes a non-ASCII error message to the status pipe during daemonization, the parent writes the repr of the message to C{stderr} and exits with a non-zero status code. s1 Exception: ÿzXAn error has occurred: b'Exception: \xff' Please look at log file for more information. r‚rƒNr„r\r2r2r3Útest_nonASCIIErrorInParent¨r†z)DaemonizeTests.test_nonASCIIErrorInParentcCs,d}d d¡}|j|d |¡gd¢ddS)a  When the child writes a non-ASCII error message to the status pipe during daemonization, and that message is too longer, the parent writes the repr of the truncated message to C{stderr} and exits with a non-zero status code. ód1 RuntimeError: \u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022zb'RuntimeError: {}'zb\\u2022\\u2022\\u2022\\u2022\\u2022\\u2022\\u2022\\u2022\\u2022\\u2022\\u2022\\u2022\\u2022\\u2022zHAn error has occurred: {} Please look at log file for more information. r‚rƒN)rr€)rNÚtruncatedMessageÚreportedMessager2r2r3Ú&test_errorInParentWithTruncatedUnicode¾s ÿ øz5DaemonizeTests.test_errorInParentWithTruncatedUnicodecCrv)z{ If an error occurs during daemonization and its message is too long, it's truncated by the child. ÚÈxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxsd1 RuntimeError: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxrwNrxr\r2r2r3Útest_errorMessageTruncatedÛrzz)DaemonizeTests.test_errorMessageTruncatedcCrv)z¾ If an error occurs during daemonization and its message is unicode and too long, it's truncated by the child, even if this splits a unicode escape sequence. uZ••••••••••••••••••••••••••••••rˆrwNrxr\r2r2r3Ú!test_unicodeErrorMessageTruncatedäs þz0DaemonizeTests.test_unicodeErrorMessageTruncatedcCó.tƒ}|j |¡| |j¡| |j¡dS)z¸ C{daemonize} indeed calls L{IReactorDaemonize.beforeDaemonize} and L{IReactorDaemonize.afterDaemonize} if the reactor implements L{IReactorDaemonize}. N)rerõr[r•rµr¶r]r2r2r3Útest_hooksCalledïó  zDaemonizeTests.test_hooksCalledcCr)zÀ C{daemonize} does NOT call L{IReactorDaemonize.beforeDaemonize} or L{IReactorDaemonize.afterDaemonize} if the reactor does NOT implement L{IReactorDaemonize}. N)r´rõr[r˜rµr¶r]r2r2r3Útest_hooksNotCalledúr‘z"DaemonizeTests.test_hooksNotCalledN)rPrQrRrSrîr\rerlrpruryr{r€r…r‡r‹rrŽrr’r2r2r2r3rMÜs$    rMc@s*eZdZdZedd„ƒZejdd„ƒZdS)ÚSignalCapturingMemoryReactorz‰ MemoryReactor that implements the _ISupportsExitSignalCapturing interface, all other operations identical to MemoryReactor. cCrfr&©Ú_valr\r2r2r3rF sz(SignalCapturingMemoryReactor._exitSignalcCrôr&r”)rNÚvalr2r2r3rFs N)rPrQrRrSÚpropertyrFÚsetterr2r2r2r3r“s  r“cs4eZdZdZeZ‡fdd„Zdd„Zdd„Z‡Z S)ÚStubApplicationRunnerWithSignalzï An application runner that uses a SignalCapturingMemoryReactor and has a _signalValue attribute that it will set in the reactor. @ivar _signalValue: The signal value to set on the reactor's _exitSignal attribute. cstƒ |¡d|_dSr&)ÚsuperreÚ _signalValuer–©Ú __class__r2r3re!s  z(StubApplicationRunnerWithSignal.__init__cCrÂ)z Does nothing. Nr2r\r2r2r3r]%rÆz.StubApplicationRunnerWithSignal.preApplicationcCs$tƒ}|j|_| |tjtj¡dS)z` Instantiate a SignalCapturingMemoryReactor and start it in the runner. N)r“r›rFrrÅr·rOr]r2r2r3r^*sz/StubApplicationRunnerWithSignal.postApplication) rPrQrRrSrUr_rer]r^Ú __classcell__r2r2rœr3r™s  r™cs‡fdd„}|S)aI Create a factory function to instantiate a StubApplicationRunnerWithSignal that will report signum as the captured signal.. @param signum: The integer signal number or None @type signum: C{int} or C{None} @return: A factory function to create stub runners. @rtype: stubApplicationRunnerFactory cst|ƒ}ˆ|_|S)a· Create a StubApplicationRunnerWithSignal using a reactor that implements _ISupportsExitSignalCapturing and whose _exitSignal attribute is set to signum. @param config: The runner configuration, platform dependent. @type config: L{twisted.scripts.twistd.ServerOptions} @return: A runner to use for the test. @rtype: twisted.test.test_twistd.StubApplicationRunnerWithSignal )r™r›)rurõ©Úsignumr2r3ÚstubApplicationRunnerFactoryAs zIstubApplicationRunnerFactoryCreator..stubApplicationRunnerFactoryr2)r r¡r2rŸr3Ú#stubApplicationRunnerFactoryCreator4s r¢c@r³) ÚExitWithSignalTestsz? Tests for L{twisted.application.app._exitWithSignal}. csRt ¡ˆ_dtƒiˆj_tƒˆj_dˆj_ddgˆ_‡fdd„}ˆ  t d|¡dS)zM Set up the server options and a fake for use by test cases. rNcs|ˆjd<|ˆjd<dS)zÄ Fake method to capture arguments passed to os.kill. @param pid: The pid of the process being killed. @param sig: The signal sent to the process. rr×N)Ú fakeKillArgsrÑr\r2r3ÚfakeKillds z+ExitWithSignalTests.setUp..fakeKillrÔ) rrprurIrrr rwr¤rBr8)rNr¥r2r\r3rîZs     zExitWithSignalTests.setUpcs€ddg‰‡fdd„}| td|¡t tj¡| ˆdtj¡| ˆdtj¡| |jdt  ¡¡| |jdtj¡dS)zœ exitWithSignal replaces the existing signal handler with the default handler and sends the replaced signal to the current process. Ncs|ˆd<|ˆd<dS)Nrr×r2)rÓÚhandler©ÚfakeSignalArgsr2r3Ú fake_signalys z.fake_signalr=rr×) rBr=r Ú_exitWithSignalÚSIGINTrJÚSIG_DFLr¤r8rß)rNr©r2r§r3Útest_exitWithSignalqs  z'ExitWithSignalTests.test_exitWithSignalcCsB| tdtdƒ¡t |j¡| |jd¡| |jd¡dS)zb _exitWithSignal is not called if the runner does not exit with a signal. r,Nrr×)rBrr¢ÚrunApprurtr¤r\r2r2r3Útest_normalExit…s  ÿ z#ExitWithSignalTests.test_normalExitcCsN| tdttjƒ¡t |j¡| |jdt   ¡¡| |jdtj¡dS)zP _exitWithSignal is called when the runner exits with a signal. r,rr×N) rBrr¢r=r«r®rurJr¤r8rßr\r2r2r3Útest_runnerExitsWithSignal‘sý z.ExitWithSignalTests.test_runnerExitsWithSignalN)rPrQrRrSrîr­r¯r°r2r2r2r3r£Ts  r£)hrSrÜr‚r8rër=rÅr:Ú_grpr7Ú_pwdÚ ImportErrorÚiorÚunittestrÚzope.interfacerÚzope.interface.verifyrr¸rrrÚtwisted.applicationr r r Útwisted.application.servicer Útwisted.internet.baser Útwisted.internet.deferrÚtwisted.internet.interfacesrrÚ#twisted.internet.test.modulehelpersrÚtwisted.loggerrrrÚtwisted.pythonrÚtwisted.python.componentsrÚtwisted.python.fakepwdrÚtwisted.python.logrrÚtwisted.python.reflectrÚtwisted.python.runtimerÚtwisted.python.usagerÚtwisted.scriptsrÚtwisted.test.proto_helpersrÚtwisted.test.test_processrÚtwisted.trial.unittestrr¿Útwisted.scripts._twistd_unixr r!r"rûr#r$r%rGrIrrUr,r[r`rÀrçrórýrürrOrsr¨r´rer;r¾ròrýrþr:rMr“r™r¢r£r2r2r2r3Ús²  þ                  -  YF u  ; % {+