o ¼>h1>ã@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.OpenProcessÚ 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úz/var/www/vedio/testing/chatpythonscript.ninositsolution.com/env/lib/python3.10/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©rr r!r r 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)r2r3rrrÚfakeOpen`r(z6UtilTests.test_readlinkEACCESWindows..fakeOpenÚ_openN)r2r r3r r r) rr+rrr,r.rrr5)rrr6rrrrÚ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)rrrr9rrÚ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}. r9N)r+rÚFilesystemLockrÚlockÚ assertFalse)rÚflrrrÚtest_noKillCallyszUtilTests.test_noKillCallN©r r)Ú__name__Ú __module__Ú __qualname__Ú__doc__rrrÚ isWindowsr-r0r8rÚskipKillÚskipKillReasonr=r?rDrrrrr #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 rcsNd ‡fdd„ }| td|¡| ¡}t |¡}| t|j¡}| |jˆ¡dS) NÚsourcer Údestr rcs tˆdƒ‚r#)r)rOrP©rrrÚ fakeSymlink‡ó z3LockingTests._symlinkErrorTest..fakeSymlinkr)rOr rPr r r) r+rrr@rrrArr)rrrRÚlockfrArrrQrÚ_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)rUrÚ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)rUrr5r%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@Ú assertTruerAÚcleanÚlocked©rrTrArrrÚ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@rYrAÚunlockrBr[rZr\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@rYrArBr[)rrTÚ firstLockÚ 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ÚpidrNÚsignalr rcs,|dkr ttjdƒ‚|ˆkrttjdƒ‚dS)Nr©rrÚEPERMr>©rcrd©ÚownerrrÚfakeKillÖó   ÿz4LockingTests.test_uncleanlyAcquire..fakeKillr9N©rcrNrdrNr r)rr+rrr r@rYrArBrZr[rr.r:r;)rrjrTrArrhrÚ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}. rr r cst ˆ¡ˆ ¡t |¡Sr#)rÚrmlinkÚrestorer.©r©rTÚ readlinkPatchrrÚ fakeReadlinkîs  z?LockingTests.test_lockReleasedBeforeCheck..fakeReadlinkr.rcrNrdrcSó,|dkr ttjdƒ‚|dkrttjdƒ‚dS©Nréu¨rergrrrrj÷rkz;LockingTests.test_lockReleasedBeforeCheck..fakeKillr9rvN)rr r r rl© r+rrr@rr rYrArZr[)rrsrjrArrqrÚ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. rr r!r rcSr"r#r$r&rrrrRs zGLockingTests.test_lockReleasedDuringAcquireSymlink..fakeSymlinkrNr*)r+rrr@rBrAr[)rrRrTrArrrÚ%test_lockReleasedDuringAcquireSymlinks  z2LockingTests.test_lockReleasedDuringAcquireSymlinkr1cCsXd 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}. rr r rcSr"r#r4rprrrrs+s zILockingTests.test_lockReleasedDuringAcquireReadlink..fakeReadlinkr.rvN©rr r r) r+rrr@rr rBrAr[)rrsrTrArrrÚ&test_lockReleasedDuringAcquireReadlink s  z3LockingTests.test_lockReleasedDuringAcquireReadlinkÚ exceptionTypeútype[OSError] | type[IOError]csld ‡‡fdd„ }| td|¡| ¡}t tdƒ|¡t |¡}| ˆ|j¡}| |j ˆ¡|  |j ¡dS) Nrr r rcs ˆˆdƒ‚r#rrp©rr}rrrs<rSz5LockingTests._readlinkErrorTest..fakeReadlinkr.rvr{) r+rrrr r@rrArrrBr[)rr}rrsrTrArrrrÚ_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€rrrVr,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,rrVr5r<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. rr r rcsˆ ¡t ˆ¡t |¡Sr#)rorrnrp©rTÚ rmlinkPatchrrÚ fakeRmlinkis  z?LockingTests.test_lockCleanedUpConcurrently..fakeRmlinkrnrcrNrdcSrtrurergrrrrjrrkz=LockingTests.test_lockCleanedUpConcurrently..fakeKillr9rvN)rr r rrlrw)rr…rjrArrƒrÚtest_lockCleanedUpConcurrentlybryz+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}. rr r rcSr"r#)rrrVrprrrr…‡r(z1LockingTests.test_rmlinkError..fakeRmlinkrnrcrNrdrcSrtrurergrrrrjŒrkz/LockingTests.test_rmlinkError..fakeKillr9rvNr{rl)r+rrrr r@rrrArrrVrBr[)rr…rjrTrArrrrÚ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}. rcrNrdr rcSr"r#)rrrfrgrrrrj¥r(z-LockingTests.test_killError..fakeKillr9rvN)rcrNrdrNr r)r+rrrr r@rrrArrrfrBr[)rrjrTrArrrrÚ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) rrrr r:r;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)rrBrÚisLockedr@rYrAr^r\rrrÚ test_isLocked¾s zLockingTests.test_isLockedN)rrNr rrE)r}r~rrNr r)rFrGrHrUrWrrrJrXr]r_rbrmrxrrzr|r€rr‚r†r‡rˆr‹rrrrrrM…sF  þ   þ þ   þ     rM)rIÚ __future__rrr:ÚunittestrrÚtyping_extensionsrÚtwisted.pythonrÚtwisted.python.reflectrÚtwisted.python.runtimerÚtwisted.trial.unittestr rKrLrJr rMrrrrÚs(        ÿb