U .Wj1>ã@sÀdZddlmZddlZddlZddlmZmZddlm Z ddl m Z ddl m Z ddlmZdd lmZd Zd Ze ¡rœe d ƒdkrœe d ƒdkrœdZdZGdd„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¢eZdZdZddœdd„Zee ¡dƒddœdd„ƒZddœd d „Z ee ¡d ƒddœd d „ƒZ e e e ƒddœdd„ƒZe e e ƒddœdd„ƒZddœdd„ZdS)Ú UtilTestszM Tests for the helper functions used to implement L{FilesystemLock}. ÚNone©ÚreturncCs:| ¡}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úec:\users\psant\downloads\hotstarbackend\school\venv38\Lib\site-packages\twisted/test/test_lockfile.pyÚtest_symlinkEEXIST(s zUtilTests.test_symlinkEEXISTúBspecial rename EIO handling only necessary and correct on Windows.cCsN| ¡}ddddœdd„}| td|¡| ttj|d¡}| |jtj¡dS) 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). Ústrr©ÚsrcÚdstrcSsttjdƒ‚dS©N©rrÚEIO©r!r"rrrÚ fakeRenameAsz4UtilTests.test_symlinkEIOWindows..fakeRenameÚrenamerN) 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.cCsL| ¡}ddddœ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). rr)ÚpathÚmodercSsttjdƒ‚dSr#©rrÚEACCES)r0r1rrrÚfakeOpen`sz6UtilTests.test_readlinkEACCESWindows..fakeOpenÚ_openN) rr)rrr*r,rrr3)rrr4rrrrÚ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)rrrr7rrÚ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}. r7N)r)rÚFilesystemLockrÚlockÚ assertFalse)rÚflrrrÚtest_noKillCallyszUtilTests.test_noKillCallN)Ú__name__Ú __module__Ú __qualname__Ú__doc__rrrÚ isWindowsr+r.r6rÚskipKillÚskipKillReasonr;r=rBrrrrr #s$ þ þ r c@sFeZdZdddœdd„Zddœdd„Zee ¡d ƒddœd d „ƒZddœd d „Z ddœdd„Z ddœdd„Z ddœdd„Z ddœdd„Z ee ¡dƒddœdd„ƒZee ¡dƒddœdd„ƒZddddœdd„Zddœd d!„Zee ¡d ƒddœd"d#„ƒZddœd$d%„Zddœd&d'„Zddœd(d)„Zddœd*d+„Zddœd,d-„Zd.S)/Ú LockingTestsÚintr )rrcsVddddœ‡fdd„ }| td|¡| ¡}t |¡}| t|j¡}| |jˆ¡dS)Nrr)ÚsourceÚdestrcstˆdƒ‚dSr#)r)rLrM©rrrÚ fakeSymlink‡sz3LockingTests._symlinkErrorTest..fakeSymlinkr) r)rrr>rrr?rr)rrrOÚlockfr?rrrNrÚ_symlinkErrorTest†s  zLockingTests._symlinkErrorTestr cCs| tj¡dS)z† An exception raised by C{symlink} other than C{EEXIST} is passed up to the caller of L{FilesystemLock.lock}. N)rQrÚ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)rQrr3r%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©rrPr?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>rUr?Úunlockr@rWrVrXrrrÚ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>rUr?r@rW)rrPZ firstLockZ secondLockrrrÚtest_cannotLockLockedÂs   z"LockingTests.test_cannotLockLockedcsŽd‰ddddœ‡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}. i90rKr ©ÚpidÚsignalrcs,|dkrttjdƒ‚|ˆkr(ttjdƒ‚dS)Nr©rrÚEPERMr<©r^r_©ÚownerrrÚfakeKillÖs z4LockingTests.test_uncleanlyAcquire..fakeKillr7N)rr)rrrr>rUr?r@rVrWrr,r8r9)rrerPr?rrcrÚtest_uncleanlyAcquireÎs   z"LockingTests.test_uncleanlyAcquirecsdddœ‡‡fdd„ }| td|¡‰ddddœd d „}| td |¡| ¡‰t ˆ¡}t td ƒˆ¡| | ¡¡| |j¡| |j ¡d S)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}. r©rrcst ˆ¡ˆ ¡t |¡Sr#)rÚrmlinkÚrestorer,©r©rPZ readlinkPatchrrÚ fakeReadlinkîs z?LockingTests.test_lockReleasedBeforeCheck..fakeReadlinkr,rKr r]cSs,|dkrttjdƒ‚|dkr(ttjdƒ‚dS©Nréu¨r`rbrrrre÷s z;LockingTests.test_lockReleasedBeforeCheck..fakeKillr7rnN© r)rrr>rrrUr?rVrW)rrlrer?rrkrÚtest_lockReleasedBeforeCheckçs  z)LockingTests.test_lockReleasedBeforeCheckrcCsPddddœdd„}| 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. rrr cSsttjdƒ‚dSr#r$r&rrrrOszGLockingTests.test_lockReleasedDuringAcquireSymlink..fakeSymlinkrN)r)rrr>r@r?rW)rrOrPr?rrrÚ%test_lockReleasedDuringAcquireSymlinks  z2LockingTests.test_lockReleasedDuringAcquireSymlinkr/cCs^dddœdd„}| 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}. rrrgcSsttjdƒ‚dSr#r2rjrrrrl+szILockingTests.test_lockReleasedDuringAcquireReadlink..fakeReadlinkr,rnN) r)rrr>rrr@r?rW)rrlrPr?rrrÚ&test_lockReleasedDuringAcquireReadlink s  z3LockingTests.test_lockReleasedDuringAcquireReadlinkztype[OSError] | type[IOError])Ú exceptionTyperrcsrdddœ‡‡fdd„ }| td|¡| ¡}t tdƒ|¡t |¡}| ˆ|j¡}| |j ˆ¡|  |j ¡dS)Nrrrgcsˆˆdƒ‚dSr#rrj©rrsrrrl<sz5LockingTests._readlinkErrorTest..fakeReadlinkr,rn) r)rrrrr>rr?rrr@rW)rrsrrlrPr?rrrtrÚ_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)rurrrRr*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)rur*rrRr3r:rrrÚtest_readlinkErrorPOSIXSs z$LockingTests.test_readlinkErrorPOSIXcsdddœ‡‡fdd„ }| td|¡‰ddddœd d „}| td |¡| ¡‰t ˆ¡}t td ƒˆ¡| | ¡¡| |j¡| |j ¡d S)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 rgcsˆ ¡t ˆ¡t |¡Sr#)rirrhrj©rPZ rmlinkPatchrrÚ fakeRmlinkis z?LockingTests.test_lockCleanedUpConcurrently..fakeRmlinkrhrKr]cSs,|dkrttjdƒ‚|dkr(ttjdƒ‚dSrmr`rbrrrrers z=LockingTests.test_lockCleanedUpConcurrently..fakeKillr7rnNro)rryrer?rrxrÚtest_lockCleanedUpConcurrentlybs  z+LockingTests.test_lockCleanedUpConcurrentlycCsŽdddœdd„}| td|¡dddd œd 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}. rrrgcSsttjdƒ‚dSr#)rrrRrjrrrry‡sz1LockingTests.test_rmlinkError..fakeRmlinkrhrKr r]cSs,|dkrttjdƒ‚|dkr(ttjdƒ‚dSrmr`rbrrrreŒs z/LockingTests.test_rmlinkError..fakeKillr7rnN)r)rrrrr>rrr?rrrRr@rW)rryrerPr?rrrrÚtest_rmlinkErrors zLockingTests.test_rmlinkErrorcCspddddœdd„}| 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}. rKrr]cSsttjdƒ‚dSr#)rrrarbrrrre¥sz-LockingTests.test_killError..fakeKillr7rnN)r)rrrrr>rrr?rrrar@rW)rrerPr?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) rrrrr8r9r>rÚ ValueErrorrZrXrrrÚ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)rr@rZisLockedr>rUr?rZrXrrrÚ test_isLocked¾s zLockingTests.test_isLockedN)rCrDrErQrSrrrGrTrYr[r\rfrprrqrrrurvrwrzr{r|rr€rrrrrJ…sD þ   þþþ  rJ)rFÚ __future__rrr8ZunittestrrZtyping_extensionsrZtwisted.pythonrZtwisted.python.reflectrZtwisted.python.runtimerZtwisted.trial.unittestr rHrIrGr rJrrrrÚs*       ÿ þÿb