o ¯bè;ã@s¨dZddlZddlZddlmZmZddlmZddlm Z ddl m Z ddl m Z dZd Ze  ¡rBe d ƒdurBe d ƒdurBd Zd ZGdd„de ƒZGdd„de ƒZdS)z' Tests for L{twisted.python.lockfile}. éN)ÚskipIfÚ skipUnless)Úlockfile)Ú requireModule)Úplatform)ÚTestCaseFÚzwin32api.OpenProcessÚ pywintypesTzZOn windows, lockfile.kill is not implemented in the absence of win32api and/or pywintypes.c@sxeZdZdZdd„Zee ¡dƒdd„ƒZdd„Z ee ¡d ƒd d „ƒZ e e e ƒd d „ƒZe e e ƒdd„ƒZdd„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ÚerrnoÚEEXIST©ÚselfÚnameÚexc©rú.fakeRenameÚrenamer N) r ÚpatchrrÚIOErrorr rrr)rrr"rrrrÚtest_symlinkEIOWindows0s  z UtilTests.test_symlinkEIOWindowscCs,| ¡}| 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 rrrÚreadlinkrrÚENOENTrrrrÚtest_readlinkENOENTFszUtilTests.test_readlinkENOENTúGspecial readlink EACCES handling only necessary and correct on Windows.cCsB| ¡}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). cSrr©rrÚEACCES)ÚpathÚmoderrrÚfakeOpen^r#z6UtilTests.test_readlinkEACCESWindows..fakeOpenÚ_openN) r r%rrr&r(rrr-)rrr0rrrrÚtest_readlinkEACCESWindowsOs  z$UtilTests.test_readlinkEACCESWindowscCst 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_killeszUtilTests.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)rrrr3rrÚESRCH)rrrrrÚtest_killESRCHmszUtilTests.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}. r3N)r%rÚFilesystemLockr ÚlockÚ assertFalse)rÚflrrrÚtest_noKillCallwszUtilTests.test_noKillCallN)Ú__name__Ú __module__Ú __qualname__Ú__doc__rrrÚ isWindowsr'r*r2rÚskipKillÚskipKillReasonr7r9r>rrrrr !s& þ  þ    r c@sÔeZdZdd„Zdd„Zee ¡dƒdd„ƒZdd „Z d d „Z d d „Z dd„Z dd„Z ee ¡dƒdd„ƒZee ¡dƒdd„ƒZdd„Zdd„Zee ¡dƒdd„ƒZdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(S))Ú LockingTestscsL‡fdd„}| td|¡| ¡}t |¡}| t|j¡}| |jˆ¡dS)Ncs tˆdƒ‚r)r)ÚsourceÚdest©rrrÚ fakeSymlink…ó z3LockingTests._symlinkErrorTest..fakeSymlinkr ) r%rr r:rrr;rr)rrrJÚlockfr;rrrIrÚ_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)rMrÚENOSYSr6rrrÚtest_symlinkErrorszLockingTests.test_symlinkErrorz9POSIX-specific error propagation not expected on Windows.cCs| 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)rMrr-rr6rrrÚtest_symlinkErrorPOSIX–s z#LockingTests.test_symlinkErrorPOSIXcCs<| ¡}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 rr:Ú assertTruer;ÚcleanÚlocked©rrLr;rrrÚ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 rr:rQr;Úunlockr<rSrRrTrrrÚ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 rr:rQr;r<rS)rrLÚ firstLockÚ 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,|dkr ttjdƒ‚|ˆkrttjdƒ‚dS)Nr©rrÚEPERMr8©ÚpidÚsignal©ÚownerrrÚfakeKillÔó   ÿz4LockingTests.test_uncleanlyAcquire..fakeKillr3N)r r%rr Ústrr:rQr;r<rRrSrr(r4r5)rrbrLr;rr`rÚtest_uncleanlyAcquireÌs    z"LockingTests.test_uncleanlyAcquirecó~‡‡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©rLÚ readlinkPatchrrÚ fakeReadlinkìs  z?LockingTests.test_lockReleasedBeforeCheck..fakeReadlinkr(cSó,|dkr ttjdƒ‚|dkrttjdƒ‚dS©Nréu¨r[r]rrrrbõrcz;LockingTests.test_lockReleasedBeforeCheck..fakeKillr3roN© r%rr r:r rdrQr;rRrS)rrlrbr;rrjrÚtest_lockReleasedBeforeCheckåó  z)LockingTests.test_lockReleasedBeforeCheckrcCsFdd„}| 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. cSrrrrrrrrJs zGLockingTests.test_lockReleasedDuringAcquireSymlink..fakeSymlinkr N)r%rr r:r<r;rS)rrJrLr;rrrÚ%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}. cSrrr,rirrrrl)s zILockingTests.test_lockReleasedDuringAcquireReadlink..fakeReadlinkr(roN) r%rr r:r rdr<r;rS)rrlrLr;rrrÚ&test_lockReleasedDuringAcquireReadlinks  z3LockingTests.test_lockReleasedDuringAcquireReadlinkcsj‡‡fdd„}| td|¡| ¡}t tdƒ|¡t |¡}| ˆ|j¡}| |j ˆ¡|  |j ¡dS)Ncs ˆˆdƒ‚rrri©rÚ exceptionTyperrrl8rKz5LockingTests._readlinkErrorTest..fakeReadlinkr(ro) r%rr r rdr:rr;rrr<rS)rrvrrlrLr;rrrurÚ_readlinkErrorTest7s 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)rwrrrNr&r6rrrÚtest_readlinkErrorGszLockingTests.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)rwr&rrNr-r6rrrÚtest_readlinkErrorPOSIXOs z$LockingTests.test_readlinkErrorPOSIXcrf) 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)rhrrgri©rLÚ rmlinkPatchrrÚ fakeRmlinkes  z?LockingTests.test_lockCleanedUpConcurrently..fakeRmlinkrgcSrmrnr[r]rrrrbnrcz=LockingTests.test_lockCleanedUpConcurrently..fakeKillr3roNrp)rr|rbr;rrzrÚtest_lockCleanedUpConcurrently^rrz+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}. cSrr)rrrNrirrrr|ƒr#z1LockingTests.test_rmlinkError..fakeRmlinkrgcSrmrnr[r]rrrrbˆrcz/LockingTests.test_rmlinkError..fakeKillr3roN)r%rr r rdr:rrr;rrrNr<rS)rr|rbrLr;rrrrÚtest_rmlinkError}s 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}. cSrr)rrr\r]rrrrb¡r#z-LockingTests.test_killError..fakeKillr3roN)r%rr r rdr:rrr;rrr\r<rS)rrbrLr;rrrrÚ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 rdr4r5r:rÚ ValueErrorrVrTrrrÚ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 r<rÚisLockedr:rQr;rVrTrrrÚ test_isLockedºs zLockingTests.test_isLockedN)r?r@rArMrOrrrCrPrUrWrZrerqrrsrtrwrxryr}r~rr‚r„rrrrrFƒsF þ    þ þ þ   rF)rBrr4ÚunittestrrÚtwisted.pythonrÚtwisted.python.reflectrÚtwisted.python.runtimerÚtwisted.trial.unittestrrDrErCr rFrrrrÚs$      ÿb