o ¯b(cã@sdZddlZddlZddlZddlZddlZddlZddlmZ ddl m Z ddl m Z ddlmZddlmZddlmZmZmZdd lmZGd d „d e ƒZGd d „d e ƒZGdd„dejƒZdZdd„Zdd„ZGdd„dejƒZGdd„dejƒZ Gdd„dejƒZ!dS)z" Tests for Twisted plugin system. éN)Úinvalidate_caches)ÚCallable)Ú Interface)Úplugin)ÚFilePath)Ú addObserverÚremoveObserverÚtextFromEventDict)Úunittestc@óeZdZdZdS)Ú ITestPluginzS A plugin for use by the plugin system's unit tests. Do not use this. N©Ú__name__Ú __module__Ú __qualname__Ú__doc__©rrú:/usr/lib/python3/dist-packages/twisted/test/test_plugin.pyr ór c@r )Ú ITestPlugin2z See L{ITestPlugin}. Nr rrrrr#rrc@s¤eZdZdZdd„Zdd„Zd!dd„Zd d „Zd efd d „Z e dd„ƒZ dd„Z e dd„ƒZ e dd„ƒZ e dd„ƒZe dd„ƒZe dd„ƒZe dd„ƒZdd„Zd S)"Ú PluginTestsz_ Tests which verify the behavior of the current, active Twisted plugins directory. cCs¤tjdd…|_tj ¡|_t| ¡ƒ|_|j  ¡|j  d¡|_ |j   ¡|j   d¡  d¡tt ƒ d¡ |j   d¡¡d|_tj d|jj¡ddl}||_dS) zV Save C{sys.path} and C{sys.modules}, and create a package for tests. NÚ mypackageú __init__.pyózplugin_basic.pyz testplugin.pyÚ testpluginr)ÚsysÚpathÚ originalPathÚmodulesÚcopyÚ savedModulesrÚmktempÚrootÚcreateDirectoryÚchildÚpackageÚ setContentÚ__file__ÚsiblingÚcopyToÚoriginalPluginÚinsertrÚmodule)ÚselfrrrrÚsetUp/s    ÿ zPluginTests.setUpcCó,|jtjdd…<tj ¡tj |j¡dS©zR Restore C{sys.path} and C{sys.modules} to their original values. N©rrrrÚclearÚupdater ©r-rrrÚtearDownGó zPluginTests.tearDownFc Cs¦|j d¡}d |dd…¡}|d}ttj||ƒtj|j=ddg|r(dgp)gD]%}z t |j|¡Wq+t yP}z |j t j krF‚WYd}~q+d}~wwdS)NÚ.éÿÿÿÿÚcÚoÚ) rÚsplitÚjoinÚdelattrrrÚosÚremover'ÚOSErrorÚerrnoÚENOENT)r-r,Ú deleteSourceÚ modulePathÚ packageNameÚ moduleNameÚextÚoserrrÚ_unimportPythonModuleOs    ÿ€ÿýz!PluginTests._unimportPythonModulecCs|j d¡ ¡dS)z; Remove the plugins B{droping.cache} file. ú dropin.cacheN)r%r$r@r4rrrÚ _clearCache]ózPluginTests._clearCacheÚmethcst ˆ¡‡fdd„ƒ}|S)zþ This is a paranoid test wrapper, that calls C{meth} 2 times, clear the cache, and calls it 2 other times. It's supposed to ensure that the plugin system behaves correctly no matter what the state of the cache is. cs,ˆ|ƒˆ|ƒ| ¡ˆ|ƒˆ|ƒdS)N)rLr4©rNrrÚwrappedks  z+PluginTests._withCacheness..wrapped)Ú functoolsÚwraps)rNrPrrOrÚ_withCachenesscszPluginTests._withCachenesscCsÒt |j¡}||j}| |jd|j›¡| d|j¡dd„|jDƒd}|  |j |¡| |j d¡| |j  ¡d¡| |j ttjg¡| ¡}|  |tjd|j›j¡ddlm}|  ||j¡dS) a  Check that the cache returned by L{plugin.getCache} hold the plugin B{testplugin}, and that this plugin has the properties we expect: provide L{TestPlugin}, has the good name and description, and can be loaded successfully. z mypackage.zI'm a test drop-in.cSsg|] }t|jvr|‘qSr)r Úprovided©Ú.0ÚprrrÚ „sz*PluginTests.test_cache..rÚ TestPluginz*A plugin used solely for testing purposes.N)rÚgetCacher,r*Ú assertEqualrGÚassertInÚ descriptionÚpluginsÚassertIsÚdropinÚnameÚstriprTr ÚIPluginÚloadrrrYÚmypackage.testpluginr)r-Úcacher`Úp1Ú realPluginÚtprrrÚ test_cacheus$   ÿþ zPluginTests.test_cachecCs>t |j¡|j}tdd„|jDƒƒd}| t|ƒd¡dS)zm L{CachedPlugin} has a helpful C{repr} which contains relevant information about it. css|] }|jdkr|VqdS)rYN©rarUrrrÚ  s€z-PluginTests.test_cacheRepr..rzTN)rrZr,r*Úlistr^r[Úrepr)r-Ú cachedDropinÚ cachedPluginrrrÚtest_cacheRepršsÿþzPluginTests.test_cacheReprcCsLtt t|j¡ƒ}| t|ƒd¡ddg}|D] }| |j¡|  ¡qdS)a L{plugin.getPlugins} should return the list of plugins matching the specified interface (here, L{ITestPlugin2}), and these plugins should be instances of classes with a C{test} method, to be sure L{plugin.getPlugins} load classes correctly. éÚAnotherTestPluginÚThirdTestPluginN) rmrÚ getPluginsrr,r[Úlenr@rÚtest)r-r^ÚnamesrWrrrÚ test_plugins©s  þzPluginTests.test_pluginsc Cs¸ttƒ d¡ |j d¡¡zC| dtj¡|  t tjddƒd¡t t   t|j¡ƒ}| t|ƒd¡dd g}|D] }| |j¡| ¡q9W| tjdd ¡d S| tjdd ¡w) ze Check that L{plugin.getPlugins} is able to detect plugins added at runtime. úplugin_extra1.pyúpluginextra.pyúmypackage.pluginextrarÚ pluginextraz&mypackage still has pluginextra modulerrrYÚFourthTestPluginTN)rr'r(r)r%r$ÚfailIfInrrÚ assertFalseÚhasattrrmrrur r,r[rvr@rÚtest1rJ©r-ÚplgsrxrWrrrÚtest_detectNewFilesºs" ÿþ  þ*zPluginTests.test_detectNewFilesc Csàttƒ d¡ |j d¡¡zWtt t |j ¡ƒ}|  t |ƒd¡ttƒ d¡ |j d¡¡|  tjd¡tt t |j ¡ƒ}|  t |ƒd¡gd¢}|D] }| |j¡| ¡qMW|  tjdd¡d S|  tjdd¡w) z… Check that if the content of a plugin change, L{plugin.getPlugins} is able to detect the new plugins added. rzr{rrzplugin_extra2.pyr|é)rYr~ÚFifthTestPluginTN)rr'r(r)r%r$rmrrur r,r[rvrJrrr@rr‚rƒrrrÚtest_detectFilesChangedØs$ ÿ ÿ  þ*z#PluginTests.test_detectFilesChangedc Cs€ttƒ d¡ |j d¡¡ztt t |j ¡ƒW|  t j dd¡n |  t j dd¡wtt t |j ¡ƒ}| dt|ƒ¡dS)zs Check that when a dropin file is removed, L{plugin.getPlugins} doesn't return it anymore. rzr{r|TéN)rr'r(r)r%r$rmrrur r,rJrrr[rv)r-r„rrrÚtest_detectFilesRemovedùs ÿ(z#PluginTests.test_detectFilesRemovedc Csp| ¡}| tj |¡¡|jj |¡ztt   t |j¡ƒ}|  t |ƒd¡W|jj |¡dS|jj |¡w)zy Test that getCache skips over any entries in a plugin package's C{__path__} which do not exist. r‰N)r!r€r?rÚexistsr,Ú__path__Úappendrmrrur r[rvr@)r-rr„rrrÚtest_nonexistentPathEntry s"z%PluginTests.test_nonexistentPathEntryc Cs„t| ¡ƒ}| | ¡¡| ¡| d¡j}|jj  |¡zt t   t |j¡ƒ}| t|ƒd¡W|jj |¡dS|jj |¡w)z¡ Test that getCache skips over any entries in a plugin package's C{__path__} which refer to children of paths which are not directories. Ú test_packager‰N)rr!r€r‹Útouchr$rr,rŒrrmrrur r[rvr@)r-rr$r„rrrÚtest_nonDirectoryChildEntrys  "z'PluginTests.test_nonDirectoryChildEntrycCst |j¡|j d¡}ttƒ d¡ |j d¡¡t ƒt   |jj d¡t   |j d¡|  t j |jj d¡|  t j |j d¡g}t|jƒ|  t|j¡t |j¡}| d|¡| |j|¡d|j tjf}|D] }|t|ƒvrud Sqj| d |f¡d S) z¿ The C{dropin.cache} file may not be writable: the cache should still be attainable, but an error should be logged to show that the cache couldn't be updated. rKrzr{i@éiÀr}ú3Unable to write to plugin cache %s: error number %dú;Did not observe unwriteable cache warning in log events: %rN)rrZr,r%r$rr'r(r)ÚinvalidateImportCachesr?ÚchmodrÚ addCleanuprrrr\r*rBÚEPERMr Úfail)r-Ú cachepathÚeventsrfÚexpectedÚeventrrrÚtest_deployedMode,s:   ÿ   þ ÿÿÿzPluginTests.test_deployedModeN)F)rrrrr.r5rJrLrrSrjrqryr…rˆrŠrŽr‘ržrrrrr)s.  $       rsj from twisted.plugin import pluginPackagePaths __path__.extend(pluginPackagePaths(__name__)) __all__ = [] cCsd |¡ d¡S)Nz¬from zope.interface import provider from twisted.plugin import IPlugin from twisted.test.test_plugin import ITestPlugin @provider(IPlugin, ITestPlugin) class {}: pass Úascii)ÚformatÚencoderkrrrÚpluginFileContentsdsõr¢cCsl| ¡| d¡}| ¡|r| d¡ d¡| d¡}| ¡|r*| d¡ t¡| |d¡ |¡|S)z' Create a plugindummy package. Ú plugindummyrrr^ú.py)r#r$r&ÚpluginInitFile)Ú entrypathÚ pluginContentÚrealÚ pluginModuleÚpkgÚplugsrrrÚ_createPluginDummyts  r¬c@s`eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dS)ÚDeveloperSetupTestsz³ These tests verify things about the plugin system without actually interacting with the deployed 'twisted.plugins' package, instead creating a temporary package. cCs>tjdd…|_tj ¡|_t| ¡ƒ|_|j  ¡|j  d¡|_ |j  d¡|_ |j  d¡|_ t|j tdƒddƒ|_t|j tdƒddƒ|_t|j td ƒd d ƒ|_tj d d „|j |j fDƒ¡| ¡|j   d¡  d¡|_|j  d¡|_t ¡}t |j  d¡j|dfd¡t |jj|dfd¡| ¡| ¡dS)a7 Create a complex environment with multiple entries on sys.path, akin to a developer's environment who has a development (trunk) checkout of Twisted, a system installed version of Twisted (for their operating system's tools) and a project which provides Twisted plugins. NÚ system_pathÚdevelopment_pathÚapplication_pathÚsystemTÚplugindummy_builtinÚdevÚappFÚplugindummy_appcSóg|]}|j‘qSr©r©rVÚxrrrrX¥óz-DeveloperSetupTests.setUp..r£r^rKzplugindummy_builtin.pyiˆrriÐ)rrÚ savedPathrrr rr!ÚfakeRootr#r$Ú systemPathÚdevPathÚappPathr¬r¢Ú systemPackageÚ devPackageÚ appPackageÚextendÚ getAllPluginsÚsysplugÚsyscacheÚtimer?ÚutimeÚ lockSystemÚresetEnvironment)r-Únowrrrr.Œs2  ÿÿÿ  zDeveloperSetupTests.setUpcCó$t |jjd¡t |jjd¡dS)zW Lock the system directories, as if they were unwritable by this user. imN©r?r–rÅrrÆr4rrrrɶózDeveloperSetupTests.lockSystemcCrÌ)zW Unlock the system directories, as if they were writable by this user. iÿNrÍr4rrrÚ unlockSystem½rÎz DeveloperSetupTests.unlockSystemcCs(ddl}tt t|j¡ƒ}dd„|DƒS)zl Get all the plugins loadable from our dummy package, and return their short names. rNcSr¶r©r)rVÚplugrrrrXÎrºz5DeveloperSetupTests.getAllPlugins..)Úplugindummy.pluginsrmrrur r^)r-r£r¹rrrrÄÄsz!DeveloperSetupTests.getAllPluginscCs.| ¡tj dd„|j|j|jfDƒ¡dS)zc Change the environment to what it should be just as the test is starting. cSr¶rr·r¸rrrrXÖrºz8DeveloperSetupTests.resetEnvironment..N)ÚunsetEnvironmentrrrÃr¾r½r¿r4rrrrÊÐs&z$DeveloperSetupTests.resetEnvironmentcCs2tƒtj ¡tj |j¡|jtjdd…<dS)zh Change the Python environment back to what it was before the test was started. N)r•rrr2r3r r»rr4rrrrÓØs z$DeveloperSetupTests.unsetEnvironmentcCs| ¡| ¡dS)zÑ Reset the Python environment to what it was before this test ran, and restore permissions on files which were marked read-only so that the directory may be cleanly cleaned up. N)rÓrÏr4rrrr5âs zDeveloperSetupTests.tearDowncCs2tdƒD]}| ¡}| ¡| |ddg¡qdS)a Plugins added in the development path should be loadable, even when the (now non-importable) system path contains its own idea of the list of plugins for a package. Inversely, plugins added in the system path should not be available. r†r´r³N)ÚrangerÄÚsortr[)r-r¹rxrrrÚ"test_developmentPluginAvailabilityïs ýz6DeveloperSetupTests.test_developmentPluginAvailabilitycCsâ|j d¡}| tdƒ¡t ¡d}t |j||f¡| d¡}t dd}t j |jjfddi|¤Žt |j||f¡|  ¡|  ¡| d| ¡¡| d | ¡¡|  ¡| td ƒ¡| d| ¡¡| d | ¡¡d S) zÜ Verify that if a stale .pyc file on the PYTHONPATH is replaced by a fresh .py file, the plugins in the new .py are picked up rather than the stale .pyc, even if the .pyc is still around. zstale.pyÚoneièz stale.pycT)ÚlegacyÚquietr‰ÚtwoN)rÂr$r&r¢rÇr?rÈrr(ÚdictÚ compileallÚ compile_dirr@rÊr\rÄr)r-Úmypathr¹ÚpycÚextrarrrÚtest_freshPyReplacesStalePycýs    z0DeveloperSetupTests.test_freshPyReplacesStalePyccCs¤| ¡|j d¡ tdƒ¡| ¡tj |j j¡g}t |j ƒ|  t |j ¡| d| ¡¡d|jjtjf}|D] }|t|ƒvrGdSq<| d|f¡dS)aF Verify that a failure to write the dropin.cache file on a read-only path will not affect the list of plugins returned. Note: this test should pass on both Linux and Windows, but may not provide useful coverage on Windows due to the different meaning of "read-only directory". z newstuff.pyr×r“r”N)rÏrÅr$r&r¢rÉrrr@r¾rrr—rr\rÄrÆrBr˜r r™)r-r›rœrrrrÚtest_newPluginsOnReadOnlyPaths*  þ ÿÿÿz1DeveloperSetupTests.test_newPluginsOnReadOnlyPathN)rrrrr.rÉrÏrÄrÊrÓr5rÖrárârrrrr­…s*    r­c@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd S) ÚAdjacentPackageTestsz– Tests for the behavior of the plugin system when there are multiple installed copies of the package containing the plugins being loaded. cCs tjdd…|_tj ¡|_dS)zS Save the elements of C{sys.path} and the items of C{sys.modules}. N)rrrrrr r4rrrr.JszAdjacentPackageTests.setUpcCr/r0r1r4rrrr5Qr6zAdjacentPackageTests.tearDowncCsn| |¡}| d¡}| ¡| d¡ d¡| d¡}| ¡| d¡ t¡| |d¡}| t|ƒ¡|S)a` Create a directory containing a Python package named I{dummy} with a I{plugins} subpackage. @type root: L{FilePath} @param root: The directory in which to create the hierarchy. @type name: C{str} @param name: The name of the directory to create which will contain the package. @type pluginName: C{str} @param pluginName: The name of a module to create in the I{dummy.plugins} package. @rtype: L{FilePath} @return: The directory which was created to contain the I{dummy} package. Údummyrrr^r¤)r$Úmakedirsr&r¥r¢)r-r"raÚ pluginNameÚ directoryr%r^r©rrrÚcreateDummyPackageYs   z'AdjacentPackageTests.createDummyPackagecCs‚t| ¡ƒ}| ¡| |dd¡}| |dd¡}tj |j¡tj |j¡ddl}tt   t |j ¡ƒ}|  dgdd„|Dƒ¡dS)zê Only plugins from the first package in sys.path should be returned by getPlugins in the case where there are two Python packages by the same name installed, each with a plugin module by a single name. ÚfirstÚ somepluginÚsecondrNcSr¶rrÐrUrrrrXŠrºzWAdjacentPackageTests.test_hiddenPackageSamePluginModuleNameObscured..©rr!rårèrrrÚ dummy.pluginsrmrrur r^r[©r-r"ÚfirstDirectoryÚsecondDirectoryrär^rrrÚ.test_hiddenPackageSamePluginModuleNameObscuredxó zCAdjacentPackageTests.test_hiddenPackageSamePluginModuleNameObscuredcCs‚t| ¡ƒ}| ¡| |dd¡}| |dd¡}tj |j¡tj |j¡ddl}tt   t |j ¡ƒ}|  dgdd„|Dƒ¡dS) zè Plugins from the first package in sys.path should be returned by getPlugins in the case where there are two Python packages by the same name installed, each with a plugin module by a different name. réÚ thispluginrëÚ thatpluginrNcSr¶rrÐrUrrrrXžrºz\AdjacentPackageTests.test_hiddenPackageDifferentPluginModuleNameObscured..rìrîrrrÚ3test_hiddenPackageDifferentPluginModuleNameObscuredŒròzHAdjacentPackageTests.test_hiddenPackageDifferentPluginModuleNameObscuredN) rrrrr.r5rèrñrõrrrrrãDs rãc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S) ÚPackagePathTestszg Tests for L{plugin.pluginPackagePaths} which constructs search paths for plugin packages. cCstjdd…|_dS)z3 Save the elements of C{sys.path}. N)rrrr4rrrr.§rMzPackagePathTests.setUpcCs|jtjdd…<dS)z< Restore C{sys.path} to its original value. N)rrrr4rrrr5­rMzPackagePathTests.tearDowncCsTtdƒ}tdƒ}|j|jgt_| t d¡| d¡ d¡j| d¡ d¡jg¡dS)z® L{plugin.pluginPackagePaths} should return a list containing each directory in C{sys.path} with a suffix based on the supplied package name. ÚfooÚbarú dummy.pluginsrär^N)rrrr[rÚpluginPackagePathsr$)r-r÷rørrrÚtest_pluginDirectories³sþþz'PackagePathTests.test_pluginDirectoriescCs€t| ¡ƒ}| d¡ d¡ d¡}| ¡| d¡ d¡| d¡j| d¡jgt_| t  d¡| d¡ d¡ d¡jg¡dS) a™ L{plugin.pluginPackagePaths} should exclude directories which are Python packages. The only allowed plugin package (the only one associated with a I{dummy} package which Python will allow to be imported) will already be known to the caller of L{plugin.pluginPackagePaths} and will most commonly already be in the C{__path__} they are about to mutate. r÷rär^rrrørùN) rr!r$rår&rrr[rrú)r-r"r÷rrrÚtest_pluginPackagesExcludedÄs þz,PackagePathTests.test_pluginPackagesExcludedN)rrrrr.r5rûrürrrrrö¡s  rö)"rrÜrBrQr?rrÇÚ importlibrr•ÚtypingrÚzope.interfacerÚtwistedrÚtwisted.python.filepathrÚtwisted.python.logrrr Ú twisted.trialr r rÚTestCaserr¥r¢r¬r­rãrörrrrÚs4      6@]