U ~Hjh@sbdZddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddlmZmZmZddlmZddlmZdd lmZdd lmZmZmZmZdd lmZed ZGd ddeZ GdddeZ!Gdddej"Z#dZ$dddddZ%ddddddddZ&GdddeZ'Gd d!d!ej"Z(Gd"d#d#ej"Z)Gd$d%d%ej"Z*dS)&z" Tests for Twisted plugin system. ) annotationsN)invalidate_caches) ModuleType)Callable TypedDictTypeVar) Interface)plugin)FilePath) EventDict addObserverremoveObservertextFromEventDict)unittest_Tc@seZdZdZdS) ITestPluginzS A plugin for use by the plugin system's unit tests. Do not use this. N__name__ __module__ __qualname____doc__rr.wrapped) functoolswraps)rPrRrrQr_withCachenesshs zPluginTests._withCachenesscCst|j}||j}||jd|j|d|jdd|jDd}| |j |||j d||j d||j ttjg|}| |tjd|jjddlm}| ||jdS) 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|jkr|qSr)rprovided.0prrr s z*PluginTests.test_cache..r TestPluginz*A plugin used solely for testing purposes.N)r getCacher3r1 assertEqualrKassertIn descriptionpluginsZassertIsdropinnamestriprVrZIPluginloadr"r%r[Zmypackage.testpluginr!)r4cacherap1Z realPlugintprrr test_cache|s&   zPluginTests.test_cachecCs>t|j|j}tdd|jDd}|t|ddS)zm L{CachedPlugin} has a helpful C{repr} which contains relevant information about it. css|]}|jdkr|VqdS)r[NrbrWrrr s z-PluginTests.test_cacheRepr..rzTN)r r\r3r1listr`r]repr)r4Z cachedDropinZ cachedPluginrrrtest_cacheReprszPluginTests.test_cacheReprcCsLttt|j}|t|dddg}|D]}||j| q.dS)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. ZAnotherTestPluginZThirdTestPluginN) rkr getPluginsrr3r]lenrHrtest)r4r`namesrYrrr test_pluginss  zPluginTests.test_pluginsc Csttd|jdzr| dtj| t tjdddt t t|j}|t|dd d g}|D]}||j|qrW5|tjddXd S) ze Check that L{plugin.getPlugins} is able to detect plugins added at runtime. plugin_extra1.pypluginextra.pymypackage.pluginextraTr pluginextraz&mypackage still has pluginextra modulernr[FourthTestPluginN)r r.r/r0r,r+rMr"r%failIfIn assertFalsehasattrrkr rorr3r]rprHrtest1r4plgsrrrYrrrtest_detectNewFiless   zPluginTests.test_detectNewFilesc Csttd|jdzt t t |j }|t|dttd|jd|tjdt t t |j }|t|ddd d g}|D]}||j|qW5|tjddXd S) z Check that if the content of a plugin change, L{plugin.getPlugins} is able to detect the new plugins added. rtrurvTrnzplugin_extra2.pyr[rxZFifthTestPluginN)r r.r/r0r,r+rMr"r%rkr rorr3r]rprHrr|r}rrrtest_detectFilesChangeds"    z#PluginTests.test_detectFilesChangedc Csnttd|jdzt t t |j W5|tjddXt t t |j }|dt|dS)zs Check that when a dropin file is removed, L{plugin.getPlugins} doesn't return it anymore. rtrurvTN)r r.r/r0r,r+rMr"r%rkr rorr3r]rp)r4r~rrrtest_detectFilesRemoveds z#PluginTests.test_detectFilesRemovedc Csd|}|tj||jj|z&t t t |j}| t|dW5|jj|XdS)zy Test that getCache skips over any entries in a plugin package's C{__path__} which do not exist. rN)r(rzrGr#existsr3__path__appendrHrkr rorr]rp)r4r#r~rrrtest_nonexistentPathEntrysz%PluginTests.test_nonexistentPathEntryc Csxt|}||||dj}|jj |z&t t t|j}|t|dW5|jj |XdS)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. Z test_packagerN)r r(rzrtouchr+r#r3rrrHrkr rorr]rp)r4r#r+r~rrrtest_nonDirectoryChildEntry"s  z'PluginTests.test_nonDirectoryChildEntrycCst|j|jd}ttd|jdt t |jj dt |j d| t j |jj d| t j |j dg}t|j| t|jt|j}|d|||j|d|j tjf}|D]&}t|}|d k st||krq q|d |fd 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. rNrtrui@irw3Unable to write to plugin cache %s: error number %dN;Did not observe unwriteable cache warning in log events: %r)r r\r3r,r+r r.r/r0invalidateImportCachesrGchmodr# addCleanupr rr r^r1errnoEPERMrrCfail)r4Z cachepatheventsreexpectedevent maybeTextrrrtest_deployedMode3s<       zPluginTests.test_deployedModeN)F)rrrrr5r;rMrOrUrhrmrsrrrrrrrrrrr,s. $ rsj from twisted.plugin import pluginPackagePaths __path__.extend(pluginPackagePaths(__name__)) __all__ = [] strbytes)rbrcCsd|dS)Nzfrom zope.interface import provider from twisted.plugin import IPlugin from twisted.test.test_plugin import ITestPlugin @provider(IPlugin, ITestPlugin) class {}: pass ascii)formatencoderirrrpluginFileContentsms  r FilePath[str]r<) entrypath pluginContentreal pluginModulercCsl||d}||r.|dd|d}||rT|dt||d||S)z' Create a plugindummy package. plugindummyrr r`.py)r*r+r-pluginInitFile)rrrrpkgZplugsrrr_createPluginDummy}s  rc@seZdZUded<dS)_HasBoolLegacyKeyr<legacyN)rrr__annotations__rrrrrs rc@seZdZdZddddZddddZdddd Zd dd d Zddd dZddddZ ddddZ ddddZ ddddZ ddddZ dS)DeveloperSetupTestsz These tests verify things about the plugin system without actually interacting with the deployed 'twisted.plugins' package, instead creating a temporary package. rrcCs>tjdd|_tj|_t||_|j |j d|_ |j d|_ |j d|_ t|j tddd|_t|j tddd|_t|j td d d |_tjd d |j |j fD||j d d|_|j d|_t}t|j dj|dfdt|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. NZ system_pathZdevelopment_pathZapplication_pathsystemTZplugindummy_builtindevappFZplugindummy_appcSsg|] }|jqSrr#rXxrrrrZsz-DeveloperSetupTests.setUp..rr`rNzplugindummy_builtin.pyirni)r"r# savedPathr%r&r'r r(ZfakeRootr*r+ systemPathdevPathappPathrrZ systemPackageZ devPackage appPackageextend getAllPluginssysplugsyscachetimerGutime lockSystemresetEnvironment)r4nowrrrr5sD   zDeveloperSetupTests.setUpcCs$t|jjdt|jjddS)zW Lock the system directories, as if they were unwritable by this user. imNrGrrr#rr:rrrrszDeveloperSetupTests.lockSystemcCs$t|jjdt|jjddS)zW Unlock the system directories, as if they were writable by this user. iNrr:rrr unlockSystemsz DeveloperSetupTests.unlockSystemz list[str]cCs(ddl}ttt|j}dd|DS)zl Get all the plugins loadable from our dummy package, and return their short names. rNcSsg|] }|jqSrr)rXZplugrrrrZsz5DeveloperSetupTests.getAllPlugins..)Zplugindummy.pluginsrkr rorr`)r4rrrrrrsz!DeveloperSetupTests.getAllPluginscCs.|tjdd|j|j|jfDdS)zc Change the environment to what it should be just as the test is starting. cSsg|] }|jqSrrrrrrrZsz8DeveloperSetupTests.resetEnvironment..N)unsetEnvironmentr"r#rrrrr:rrrrsz$DeveloperSetupTests.resetEnvironmentcCs2ttjtj|j|jtjdd<dS)zh Change the Python environment back to what it was before the test was started. N)rr"r%r8r9r'rr#r:rrrrs 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)rrr:rrrr;szDeveloperSetupTests.tearDowncCs2tdD]$}|}|||ddgqdS)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. rrrN)rangersortr])r4rrrrrr"test_developmentPluginAvailabilitys z6DeveloperSetupTests.test_developmentPluginAvailabilitycCs|jd}|tdtd}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.pyoneiz stale.pycT)rquietrZtwoN)rr+r-rrrGrr#r/r compileall compile_dirrHrr^rry)r4ZmypathrZpycextrarrrtest_freshPyReplacesStalePyc s     z0DeveloperSetupTests.test_freshPyReplacesStalePyccCs||jdtd|tj|j jg}t |j | t |j |d|d|jjtjf}|D]$}t|}|dk st||krxqqx|d|fdS)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.pyrrNr)rrr+r-rrr"r#rHrr rrr r^rrrrrrCr)r4rrrrrrrtest_newPluginsOnReadOnlyPath,s,   z1DeveloperSetupTests.test_newPluginsOnReadOnlyPathN)rrrrr5rrrrrr;rrrrrrrrs*    rc@s\eZdZdZddddZddddZdd d dd d d Zddd dZddddZdS)AdjacentPackageTestsz Tests for the behavior of the plugin system when there are multiple installed copies of the package containing the plugins being loaded. rrcCs tjdd|_tj|_dS)zS Save the elements of C{sys.path} and the items of C{sys.modules}. N)r"r#r$r%r&r'r:rrrr5[szAdjacentPackageTests.setUpcCs,|jtjdd<tjtj|jdSr6r7r:rrrr;bs zAdjacentPackageTests.tearDownrr)r)rb pluginNamercCsn||}|d}||dd|d}||dt||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. dummyrr r`r)r+makedirsr-rr)r4r)rbr directoryr,r`rrrrcreateDummyPackagejs   z'AdjacentPackageTests.createDummyPackagecCst|}|||dd}||dd}tj|jtj|jddl}tt t |j }| dgdd|DdS)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. firstZ somepluginsecondrNcSsg|] }|jqSrrrWrrrrZszWAdjacentPackageTests.test_hiddenPackageSamePluginModuleNameObscured..r r(rrr"r#rZ dummy.pluginsrkr rorr`r]r4r)ZfirstDirectoryZsecondDirectoryrr`rrr.test_hiddenPackageSamePluginModuleNameObscureds zCAdjacentPackageTests.test_hiddenPackageSamePluginModuleNameObscuredcCst|}|||dd}||dd}tj|jtj|jddl}tt t |j }| dgdd|DdS) 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. rZ thispluginrZ thatpluginrNcSsg|] }|jqSrrrWrrrrZsz\AdjacentPackageTests.test_hiddenPackageDifferentPluginModuleNameObscured..rrrrr3test_hiddenPackageDifferentPluginModuleNameObscureds zHAdjacentPackageTests.test_hiddenPackageDifferentPluginModuleNameObscuredN) rrrrr5r;rrrrrrrrUs !rc@sHeZdZdZddddZddddZdddd Zddd d Zd S) PackagePathTestszg Tests for L{plugin.pluginPackagePaths} which constructs search paths for plugin packages. rrcCstjdd|_dS)z3 Save the elements of C{sys.path}. N)r"r#r$r:rrrr5szPackagePathTests.setUpcCs|jtjdd<dS)z< Restore C{sys.path} to its original value. N)r$r"r#r:rrrr;szPackagePathTests.tearDowncCsTtd}td}|j|jgt_|td|ddj|ddjgdS)z L{plugin.pluginPackagePaths} should return a list containing each directory in C{sys.path} with a suffix based on the supplied package name. foobar dummy.pluginsrr`N)r r#r"r]r pluginPackagePathsr+)r4rrrrrtest_pluginDirectoriessz'PackagePathTests.test_pluginDirectoriescCst|}|ddd}||dd|dj|djgt_|t d|dddjgdS) 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. rrr`rr rrN) r r(r+rr-r#r"r]r r)r4r)rrrrtest_pluginPackagesExcludeds z,PackagePathTests.test_pluginPackagesExcludedN)rrrrr5r;rrrrrrrs r)+r __future__rrrrSrGr"r importlibrrtypesrtypingrrrZzope.interfacerZtwistedr Ztwisted.python.filepathr Ztwisted.python.logr r r rZ twisted.trialrrrrZTestCaserrrrrrrrrrrrs:       <B_