o Óó·i1>ã@sÀdZddlmZddlZddlZddlmZmZddlm Z ddl m Z ddl m Z ddlmZdd lmZd Zd Ze ¡rNe d ƒdurNe d ƒdurNdZdZGdd„deƒZGdd„deƒZdS)z' Tests for L{twisted.python.lockfile}. é)Ú annotationsN)ÚskipIfÚ skipUnless)ÚNoReturn)Úlockfile)Ú requireModule)Úplatform)ÚTestCaseFÚzwin32api.OpenProcessZ pywintypesTzZOn windows, lockfile.kill is not implemented in the absence of win32api and/or pywintypes.c@s†eZdZdZddd„Zee ¡dƒddd„ƒZdd d „Z ee ¡d ƒdd d „ƒZ e e e ƒddd„ƒZe e e ƒddd„ƒZddd„ZdS)Ú UtilTestszM Tests for the helper functions used to implement L{FilesystemLock}. ÚreturnÚNonecCs:| ¡}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ú`C:\Users\psant\Downloads\PAF backend\school\venv\Lib\site-packages\twisted/test/test_lockfile.pyÚtest_symlinkEEXIST(s zUtilTests.test_symlinkEEXISTúBspecial rename EIO handling only necessary and correct on Windows.cCsF| ¡}d dd„}| td|¡| ttj|d ¡}| |jtj¡d S) a< L{lockfile.symlink} raises L{OSError} with C{errno} set to L{EIO} when the underlying L{rename} call fails with L{EIO}. Renaming a file on Windows may fail if the target of the rename is in the process of being deleted (directory deletion appears not to be atomic). ÚsrcÚstrÚdstr rcSó ttjdƒ‚©N©rrÚEIO©rr rrrÚ fakeRenameAó z4UtilTests.test_symlinkEIOWindows..fakeRenameÚrenamerN©rrr rr r) rÚpatchrrÚIOErrorrrrr$)rrr&rrrrÚtest_symlinkEIOWindows2s  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)rrrrÚreadlinkrrÚENOENTrrrrÚtest_readlinkENOENTHszUtilTests.test_readlinkENOENTúGspecial readlink EACCES handling only necessary and correct on Windows.cCsD| ¡}d dd„}| td|¡| ttj|¡}| |jtj¡d S) 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). ÚpathrÚmoder rcSr!r"©rrÚEACCES)r1r2rrrÚfakeOpen`r'z6UtilTests.test_readlinkEACCESWindows..fakeOpenÚ_openN)r1rr2rr r) rr*rrr+r-rrr4)rrr5rrrrÚtest_readlinkEACCESWindowsQs  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_killgszUtilTests.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)rrrr8rrÚESRCH)rrrrrÚtest_killESRCHoszUtilTests.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}. r8N)r*rÚFilesystemLockrÚlockÚ assertFalse)rÚflrrrÚtest_noKillCallyszUtilTests.test_noKillCallN©r r )Ú__name__Ú __module__Ú __qualname__Ú__doc__rrrÚ isWindowsr,r/r7rÚskipKillÚskipKillReasonr<r>rCrrrrr #s&  þ   þ    r c@søeZdZd/dd„Zd0dd„Zee ¡d ƒd0d d „ƒZd0d d „Z d0dd„Z d0dd„Z d0dd„Z d0dd„Z ee ¡dƒd0dd„ƒZee ¡dƒd0dd„ƒZd1dd„Zd0d d!„Zee ¡d ƒd0d"d#„ƒZd0d$d%„Zd0d&d'„Zd0d(d)„Zd0d*d+„Zd0d,d-„Zd.S)2Ú LockingTestsrÚintr r csNd ‡fdd„ }| td|¡| ¡}t |¡}| t|j¡}| |jˆ¡dS) NÚsourcerÚdestr rcs tˆdƒ‚r")r)rNrO©rrrÚ fakeSymlink‡ó z3LockingTests._symlinkErrorTest..fakeSymlinkr)rNrrOrr r) r*rrr?rrr@rr)rrrQÚlockfr@rrrPrÚ_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)rTrÚENOSYSr;rrrÚtest_symlinkError‘szLockingTests.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)rTrr4r$r;rrrÚ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)rrr?Ú assertTruer@ÚcleanÚlocked©rrSr@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) rrr?rXr@ÚunlockrArZrYr[rrrÚtest_cleanlyRelease²s    z LockingTests.test_cleanlyReleasecCsH| ¡}t |¡}| | ¡¡t |¡}| | ¡¡| |j¡dS)zK If a lock is currently locked, it cannot be locked again. N)rrr?rXr@rArZ)rrSZ firstLockZ secondLockrrrÚtest_cannotLockLockedÂs   z"LockingTests.test_cannotLockLockedcs†d‰d ‡fdd„ }| ¡}| td |¡t tˆƒ|¡t |¡}| | ¡¡| |j ¡| |j ¡|  t  |¡tt  ¡ƒ¡d S) 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}. i90ÚpidrMÚsignalr r cs,|dkr ttjdƒ‚|ˆkrttjdƒ‚dS)Nr©rrÚEPERMr=©r`ra©ÚownerrrÚfakeKillÖó   ÿz4LockingTests.test_uncleanlyAcquire..fakeKillr8N©r`rMrarMr r )rr*rrrr?rXr@rArYrZrr-r9r:)rrgrSr@rrerÚtest_uncleanlyAcquireÎs   z"LockingTests.test_uncleanlyAcquirecs‚d‡‡fdd„ }| td|¡‰dd d „}| 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}. rrr cst ˆ¡ˆ ¡t |¡Sr")rÚrmlinkÚrestorer-©r©rSZ readlinkPatchrrÚ fakeReadlinkîs  z?LockingTests.test_lockReleasedBeforeCheck..fakeReadlinkr-r`rMrar cSó,|dkr ttjdƒ‚|dkrttjdƒ‚dS©Nréu¨rbrdrrrrg÷rhz;LockingTests.test_lockReleasedBeforeCheck..fakeKillr8rrN)rrr rri© r*rrr?rrrXr@rYrZ)rrorgr@rrnrÚtest_lockReleasedBeforeCheckçó   z)LockingTests.test_lockReleasedBeforeCheckrcCsHd dd„}| td|¡| ¡}t |¡}| | ¡¡| |j¡d S) 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. rrr r rcSr!r"r#r%rrrrQs zGLockingTests.test_lockReleasedDuringAcquireSymlink..fakeSymlinkrNr))r*rrr?rAr@rZ)rrQrSr@rrrÚ%test_lockReleasedDuringAcquireSymlinks  z2LockingTests.test_lockReleasedDuringAcquireSymlinkr0cCsXd dd„}| td|¡| ¡}t |¡}t tdƒ|¡| | ¡¡| |j¡d S) 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}. rrr rcSr!r"r3rmrrrro+s zILockingTests.test_lockReleasedDuringAcquireReadlink..fakeReadlinkr-rrN©rrr r) r*rrr?rrrAr@rZ)rrorSr@rrrÚ&test_lockReleasedDuringAcquireReadlink s  z3LockingTests.test_lockReleasedDuringAcquireReadlinkÚ exceptionTypeútype[OSError] | type[IOError]csld ‡‡fdd„ }| td|¡| ¡}t tdƒ|¡t |¡}| ˆ|j¡}| |j ˆ¡|  |j ¡dS) Nrrr rcs ˆˆdƒ‚r"rrm©rryrrro<rRz5LockingTests._readlinkErrorTest..fakeReadlinkr-rrrw) r*rrrrr?rr@rrrArZ)rryrrorSr@rrr{rÚ_readlinkErrorTest9s 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)r|rrrUr+r;rrrÚtest_readlinkErrorKszLockingTests.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)r|r+rrUr4r;rrrÚtest_readlinkErrorPOSIXSs z$LockingTests.test_readlinkErrorPOSIXcs‚d‡‡fdd„ }| td|¡‰dd d „}| 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. rrr r csˆ ¡t ˆ¡t |¡Sr")rlrrkrm©rSZ rmlinkPatchrrÚ fakeRmlinkis  z?LockingTests.test_lockCleanedUpConcurrently..fakeRmlinkrkr`rMracSrprqrbrdrrrrgrrhz=LockingTests.test_lockCleanedUpConcurrently..fakeKillr8rrN)rrr r rirs)rr€rgr@rrrÚtest_lockCleanedUpConcurrentlybruz+LockingTests.test_lockCleanedUpConcurrentlycCs€ddd„}| td|¡dd d „}| 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}. rrr rcSr!r")rrrUrmrrrr€‡r'z1LockingTests.test_rmlinkError..fakeRmlinkrkr`rMrar cSrprqrbrdrrrrgŒrhz/LockingTests.test_rmlinkError..fakeKillr8rrNrwri)r*rrrrr?rrr@rrrUrArZ)rr€rgrSr@rrrrÚtest_rmlinkErrors   zLockingTests.test_rmlinkErrorcCshd dd„}| td|¡| ¡}t td ƒ|¡t |¡}| t|j¡}|  |j t j ¡|  |j ¡d S) 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}. r`rMrar rcSr!r")rrrcrdrrrrg¥r'z-LockingTests.test_killError..fakeKillr8rrN)r`rMrarMr r)r*rrrrr?rrr@rrrcrArZ)rrgrSr@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) rrrrr9r:r?rÚ ValueErrorr]r[rrrÚ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)rrArZisLockedr?rXr@r]r[rrrÚ test_isLocked¾s zLockingTests.test_isLockedN)rrMr r rD)ryrzrrMr r )rErFrGrTrVrrrIrWr\r^r_rjrtrrvrxr|r}r~rr‚rƒr†r‡rrrrrL…sF  þ   þ þ   þ     rL)rHÚ __future__rrr9ZunittestrrZtyping_extensionsrZtwisted.pythonrZtwisted.python.reflectrZtwisted.python.runtimerZtwisted.trial.unittestr rJrKrIr rLrrrrÚs,       ÿ þÿb