U  W[’<ã@s¤dZddlmZmZddlZddlZddlmZddlm Z ddl m Z ddl m Z dZe  ¡r|e dƒdkr|e d ƒdkr|d ZGd d „d ejƒZGd d„dejƒZdS)z' Tests for L{twisted.python.lockfile}. é)Úabsolute_importÚdivisionN)Úunittest)Úlockfile)Ú requireModule)Úplatformzwin32api.OpenProcessZ pywintypeszZOn windows, lockfile.kill is not implemented in the absence of win32api and/or pywintypes.c@speZdZdZdd„Zdd„Ze ¡s*de_dd„Z d d „Z e ¡sHd e _d d „Z e e _dd„Z e e _dd„ZdS)Ú UtilTestszM Tests for the helper functions used to implement L{FilesystemLock}. cCs:| ¡}t d|¡| ttjd|¡}| |jtj¡dS)z  L{lockfile.symlink} raises L{OSError} with C{errno} set to L{EEXIST} when an attempt is made to create a symlink which already exists. ÚfooN)ÚmktemprÚsymlinkÚ assertRaisesÚOSErrorÚ assertEqualÚerrnoZEEXIST©ÚselfÚnameÚexc©rú.fakeRenameÚrenamer N) r Úpatchrr rr rrr)rrrrrrrÚtest_symlinkEIOWindows*s z UtilTests.test_symlinkEIOWindowsúBspecial rename EIO handling only necessary and correct on Windows.cCs,| ¡}| ttj|¡}| |jtj¡dS)zŸ L{lockfile.readlink} raises L{OSError} with C{errno} set to L{ENOENT} when an attempt is made to read a symlink which does not exist. N)r r r rÚreadlinkrrZENOENTrrrrÚtest_readlinkENOENT?szUtilTests.test_readlinkENOENTcCsB| ¡}dd„}| td|¡| ttj|¡}| |jtj¡dS)a\ L{lockfile.readlink} raises L{OSError} with C{errno} set to L{EACCES} on Windows when the underlying file open attempt fails with C{EACCES}. Opening a file on Windows may fail if the path is inside a directory which is in the process of being deleted (directory deletion appears not to be atomic). cSsttjdƒ‚dSr©rrÚEACCES)ÚpathÚmoderrrÚfakeOpenSsz6UtilTests.test_readlinkEACCESWindows..fakeOpenZ_openN) r rrr rr!rrr$)rrr'rrrrÚtest_readlinkEACCESWindowsIs z$UtilTests.test_readlinkEACCESWindowsúGspecial readlink EACCES handling only necessary and correct on Windows.cCst t ¡d¡dS)z} L{lockfile.kill} returns without error if passed the PID of a process which exists and signal C{0}. rN)rÚkillÚosÚgetpid©rrrrÚ test_kill^szUtilTests.test_killcCs&| ttjdd¡}| |jtj¡dS)z L{lockfile.kill} raises L{OSError} with errno of L{ESRCH} if passed a PID which does not correspond to any process. iÿÿÿrN)r r rr*rrÚESRCH)rrrrrÚtest_killESRCHgszUtilTests.test_killESRCHcCs6| tdd¡t | ¡¡}| ¡| | ¡¡dS)zµ Verify that when L{lockfile.kill} does end up as None (e.g. on Windows without pywin32), it doesn't end up being called and raising a L{TypeError}. r*N)rrÚFilesystemLockr ÚlockÚ assertFalse)rZflrrrÚtest_noKillCallrszUtilTests.test_noKillCallN)Ú__name__Ú __module__Ú __qualname__Ú__doc__rrrÚ isWindowsÚskipr"r(r.ÚskipKillr0r4rrrrrs  ÿ ÿrc@sÔeZdZdd„Zdd„Zdd„Ze ¡r.de_dd „Z d d „Z d d „Z dd„Z dd„Z dd„Ze ¡slde_dd„Ze ¡s‚de_dd„Zdd„Zdd„Ze ¡r¨de_dd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(S))Ú LockingTestscsL‡fdd„}| td|¡| ¡}t |¡}| t|j¡}| |jˆ¡dS)Ncstˆdƒ‚dSr)r )ÚsourceÚdest©rrrÚ fakeSymlinksz3LockingTests._symlinkErrorTest..fakeSymlinkr ) rrr r1r r r2rr)rrr@Úlockfr2rrr?rÚ_symlinkErrorTest€s   zLockingTests._symlinkErrorTestcCs| tj¡dS)z† An exception raised by C{symlink} other than C{EEXIST} is passed up to the caller of L{FilesystemLock.lock}. N)rBrÚENOSYSr-rrrÚtest_symlinkError‹szLockingTests.test_symlinkErrorcCs| tj¡| tj¡dS)a  An L{OSError} raised by C{symlink} on a POSIX platform with an errno of C{EACCES} or C{EIO} is passed to the caller of L{FilesystemLock.lock}. On POSIX, unlike on Windows, these are unexpected errors which cannot be handled by L{FilesystemLock}. N)rBrr$rr-rrrÚtest_symlinkErrorPOSIX“s z#LockingTests.test_symlinkErrorPOSIXz9POSIX-specific error propagation not expected on Windows.cCs<| ¡}t |¡}| | ¡¡| |j¡| |j¡dS)z‹ If the lock has never been held, it can be acquired and the C{clean} and C{locked} attributes are set to C{True}. N)r rr1Ú assertTruer2ÚcleanÚlocked©rrAr2rrrÚtest_cleanlyAcquire¢s   z LockingTests.test_cleanlyAcquirecCsh| ¡}t |¡}| | ¡¡| ¡| |j¡t |¡}| | ¡¡| |j¡| |j¡dS)zŒ If a lock is released cleanly, it can be re-acquired and the C{clean} and C{locked} attributes are set to C{True}. N) r rr1rFr2Úunlockr3rHrGrIrrrÚtest_cleanlyRelease®s    z LockingTests.test_cleanlyReleasecCsH| ¡}t |¡}| | ¡¡t |¡}| | ¡¡| |j¡dS)zK If a lock is currently locked, it cannot be locked again. N)r rr1rFr2r3rH)rrAZ firstLockZ secondLockrrrÚtest_cannotLockLocked¿s   z"LockingTests.test_cannotLockLockedcs„d‰‡fdd„}| ¡}| td|¡t tˆƒ|¡t |¡}| | ¡¡| |j ¡| |j ¡|  t  |¡tt  ¡ƒ¡dS)zÇ If a lock was held by a process which no longer exists, it can be acquired, the C{clean} attribute is set to C{False}, and the C{locked} attribute is set to C{True}. i90cs,|dkrttjdƒ‚|ˆkr(ttjdƒ‚dS)Nr©r rÚEPERMr/©ÚpidÚsignal©ÚownerrrÚfakeKillÔs z4LockingTests.test_uncleanlyAcquire..fakeKillr*N)r rrr Ústrr1rFr2r3rGrHrr!r+r,)rrUrAr2rrSrÚtest_uncleanlyAcquireÌs    z"LockingTests.test_uncleanlyAcquirecs~‡‡fdd„}| td|¡‰dd„}| td|¡| ¡‰t ˆ¡}t tdƒˆ¡| | ¡¡| |j¡| |j ¡dS) zð If the lock is initially held but then released before it can be examined to determine if the process which held it still exists, it is acquired and the C{clean} and C{locked} attributes are set to C{True}. cst ˆ¡ˆ ¡t |¡Sr)rÚrmlinkÚrestorer!©r©rAZ readlinkPatchrrÚ fakeReadlinkìs z?LockingTests.test_lockReleasedBeforeCheck..fakeReadlinkr!cSs,|dkrttjdƒ‚|dkr(ttjdƒ‚dS©Nréu¨rNrPrrrrUôs z;LockingTests.test_lockReleasedBeforeCheck..fakeKillr*r^N© rrr r1r rVrFr2rGrH)rr\rUr2rr[rÚtest_lockReleasedBeforeCheckæs  z)LockingTests.test_lockReleasedBeforeCheckcCsFdd„}| td|¡| ¡}t |¡}| | ¡¡| |j¡dS)a“ If the lock is released while an attempt is made to acquire it, the lock attempt fails and C{FilesystemLock.lock} returns C{False}. This can happen on Windows when L{lockfile.symlink} fails with L{IOError} of C{EIO} because another process is in the middle of a call to L{os.rmdir} (implemented in terms of RemoveDirectory) which is not atomic. cSsttjdƒ‚dSr)r rrrrrrr@ szGLockingTests.test_lockReleasedDuringAcquireSymlink..fakeSymlinkr N)rrr r1r3r2rH)rr@rAr2rrrÚ%test_lockReleasedDuringAcquireSymlinks  z2LockingTests.test_lockReleasedDuringAcquireSymlinkr cCsVdd„}| td|¡| ¡}t |¡}t tdƒ|¡| | ¡¡| |j¡dS)z» If the lock is initially held but is released while an attempt is made to acquire it, the lock attempt fails and L{FilesystemLock.lock} returns C{False}. cSsttjdƒ‚dSrr#rZrrrr\#szILockingTests.test_lockReleasedDuringAcquireReadlink..fakeReadlinkr!r^N) rrr r1r rVr3r2rH)rr\rAr2rrrÚ&test_lockReleasedDuringAcquireReadlinks z3LockingTests.test_lockReleasedDuringAcquireReadlinkr)csj‡‡fdd„}| td|¡| ¡}t tdƒ|¡t |¡}| ˆ|j¡}| |j ˆ¡|  |j ¡dS)Ncsˆˆdƒ‚dSrrrZ©rÚ exceptionTyperrr\6sz5LockingTests._readlinkErrorTest..fakeReadlinkr!r^) rrr r rVr1r r2rrr3rH)rrdrr\rAr2rrrcrÚ_readlinkErrorTest5s zLockingTests._readlinkErrorTestcCs | ttj¡| ttj¡dS)z‡ An exception raised by C{readlink} other than C{ENOENT} is passed up to the caller of L{FilesystemLock.lock}. N)rer rrCrr-rrrÚtest_readlinkErrorEszLockingTests.test_readlinkErrorcCs | ttj¡| ttj¡dS)zú Any L{IOError} raised by C{readlink} on a POSIX platform passed to the caller of L{FilesystemLock.lock}. On POSIX, unlike on Windows, these are unexpected errors which cannot be handled by L{FilesystemLock}. N)rerrrCr$r-rrrÚtest_readlinkErrorPOSIXNsz$LockingTests.test_readlinkErrorPOSIXcs~‡‡fdd„}| td|¡‰dd„}| td|¡| ¡‰t ˆ¡}t tdƒˆ¡| | ¡¡| |j¡| |j ¡dS) z× If a second process cleans up the lock after a first one checks the lock and finds that no process is holding it, the first process does not fail when it tries to clean up the lock. csˆ ¡t ˆ¡t |¡Sr)rYrrXrZ©rAZ rmlinkPatchrrÚ fakeRmlinkcs z?LockingTests.test_lockCleanedUpConcurrently..fakeRmlinkrXcSs,|dkrttjdƒ‚|dkr(ttjdƒ‚dSr]rNrPrrrrUks z=LockingTests.test_lockCleanedUpConcurrently..fakeKillr*r^Nr_)rrirUr2rrhrÚtest_lockCleanedUpConcurrently]s  z+LockingTests.test_lockCleanedUpConcurrentlycCs|dd„}| td|¡dd„}| td|¡| ¡}t tdƒ|¡t |¡}| t|j¡}|  |j t j ¡|  |j ¡dS) z… An exception raised by L{rmlink} other than C{ENOENT} is passed up to the caller of L{FilesystemLock.lock}. cSsttjdƒ‚dSr)r rrCrZrrrrisz1LockingTests.test_rmlinkError..fakeRmlinkrXcSs,|dkrttjdƒ‚|dkr(ttjdƒ‚dSr]rNrPrrrrUƒs z/LockingTests.test_rmlinkError..fakeKillr*r^N)rrr r rVr1r r r2rrrCr3rH)rrirUrAr2rrrrÚtest_rmlinkErrorzs zLockingTests.test_rmlinkErrorcCsfdd„}| td|¡| ¡}t tdƒ|¡t |¡}| t|j¡}|  |j t j ¡|  |j ¡dS)z¶ If L{kill} raises an exception other than L{OSError} with errno set to C{ESRCH}, the exception is passed up to the caller of L{FilesystemLock.lock}. cSsttjdƒ‚dSr)r rrOrPrrrrU›sz-LockingTests.test_killError..fakeKillr*r^N)rrr r rVr1r r r2rrrOr3rH)rrUrAr2rrrrÚtest_killError•s zLockingTests.test_killErrorcCs<| ¡}t tt ¡dƒ|¡t |¡}| t|j ¡dS)z‚ L{FilesystemLock.unlock} raises L{ValueError} if called for a lock which is held by a different process. éN) r rr rVr+r,r1r Ú ValueErrorrKrIrrrÚtest_unlockOtherªs zLockingTests.test_unlockOthercCs\| ¡}| t |¡¡t |¡}| | ¡¡| t |¡¡| ¡| t |¡¡dS)zp L{isLocked} returns C{True} if the named lock is currently locked, C{False} otherwise. N)r r3rZisLockedr1rFr2rKrIrrrÚ test_isLockedµs zLockingTests.test_isLockedN)r5r6r7rBrDrErr9r:rJrLrMrWr`rarbrerfrgrjrkrlrorprrrrr<s<  ÿ  ÿÿ  ÿ r<)r8Z __future__rrrr+Z twisted.trialrZtwisted.pythonrZtwisted.python.reflectrZtwisted.python.runtimerr;r9ZTestCaserr<rrrrÚs      ÿd