\d;dZddlZddlZddlmZmZddlmZddlm Z ddl m Z ddl m Z dZd Ze jre d e d d Zd ZGdde ZGdde ZdS)z' Tests for L{twisted.python.lockfile}. N)skipIf skipUnless)lockfile) requireModule)platform)TestCaseFzwin32api.OpenProcess pywintypesTzZOn windows, lockfile.kill is not implemented in the absence of win32api and/or pywintypes.ceZdZdZdZeejddZdZ eejddZ e e e dZe e e d Zd Zd S) UtilTestszM Tests for the helper functions used to implement L{FilesystemLock}. c|}tjd||ttjd|}||jt jdS)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)mktemprsymlink assertRaisesOSError assertEqualerrnoEEXISTselfnameexcs :lib/python3.11/site-packages/twisted/test/test_lockfile.pytest_symlinkEEXISTzUtilTests.test_symlinkEEXIST&s` {{}}%%%)95$GG EL11111Bspecial rename EIO handling only necessary and correct on Windows.c|}d}|td||ttj|d}||jtjdS)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). c6ttjdNrrEIOsrcdsts r fakeRenamez4UtilTests.test_symlinkEIOWindows..fakeRename?s%)T** *rrenamerN) rpatchrrIOErrorrrrr")rrr&rs rtest_symlinkEIOWindowsz UtilTests.test_symlinkEIOWindows0st{{}} + + + 8Xz222)94GG EI.....rc|}|ttj|}||jt jdS)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)rrrrreadlinkrrENOENTrs rtest_readlinkENOENTzUtilTests.test_readlinkENOENTFsK {{}}):DAA EL11111rGspecial readlink EACCES handling only necessary and correct on Windows.c|}d}|td||ttj|}||jtjdS)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). c6ttjdr rrEACCES)pathmodes rfakeOpenz6UtilTests.test_readlinkEACCESWindows..fakeOpen^%,-- -r_openN) rr(rrr)r,rrr3)rrr6rs rtest_readlinkEACCESWindowsz$UtilTests.test_readlinkEACCESWindowsOsr{{}} . . . 8Wh///):DAA EL11111rcRtjtjddS)z} L{lockfile.kill} returns without error if passed the PID of a process which exists and signal C{0}. rN)rkillosgetpidrs r test_killzUtilTests.test_killes"  bikk1%%%%%rc|ttjdd}||jt jdS)z L{lockfile.kill} raises L{OSError} with errno of L{ESRCH} if passed a PID which does not correspond to any process. irN)rrrr;rrESRCH)rrs rtest_killESRCHzUtilTests.test_killESRCHms? QGG EK00000rc|tddtj|}|||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)r(rFilesystemLockrlock assertFalse)rfls rtest_noKillCallzUtilTests.test_noKillCallwsa 8VT***  $T[[]] 3 3   #####rN)__name__ __module__ __qualname____doc__rrr isWindowsr*r.r9rskipKillskipKillReasonr?rBrHrrr r !s222ZO// /$222ZT22 2$ VHn%%&&&%& VHn%%11&%1 $ $ $ $ $rr creZdZdZdZeejddZdZ dZ dZ dZ d Z eejd d Zeejd d ZdZdZeejddZdZdZdZdZdZdS) LockingTestscfd}|td||}tj|}|t |j}||jdS)Nc$tdr )r)sourcedestrs r fakeSymlinkz3LockingTests._symlinkErrorTest..fakeSymlinks%&& &rr) r(rrrDrrrErr)rrrWlockfrErs ` r_symlinkErrorTestzLockingTests._symlinkErrorTests ' ' ' ' ' 8Y 444 &u--33 E*****rcD|tjdS)z An exception raised by C{symlink} other than C{EEXIST} is passed up to the caller of L{FilesystemLock.lock}. N)rYrENOSYSr>s rtest_symlinkErrorzLockingTests.test_symlinkErrors u|,,,,,rz9POSIX-specific error propagation not expected on Windows.c|tj|tjdS)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)rYrr3r"r>s rtest_symlinkErrorPOSIXz#LockingTests.test_symlinkErrorPOSIXs6 u|,,, uy)))))rc |}tj|}||||j||jdS)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)rrrD assertTruerEcleanlockedrrXrEs rtest_cleanlyAcquirez LockingTests.test_cleanlyAcquiresi  &u--  $$$  ###  $$$$$rc|}tj|}|||||jtj|}||||j||jdS)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) rrrDr`rEunlockrFrbrarcs rtest_cleanlyReleasez LockingTests.test_cleanlyReleases  &u--  $$$  %%%&u--  $$$  ###  $$$$$rcN|}tj|}||tj|}||||jdS)zK If a lock is currently locked, it cannot be locked again. N)rrrDr`rErFrb)rrX firstLock secondLocks rtest_cannotLockLockedz"LockingTests.test_cannotLockLockeds +E22   (())),U33  **+++ *+++++rc$dfd}|}|td|tjt |tj|}||||j ||j | tj |t tjdS)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}. i90c|dkrttjd|krttjddS)NrrrEPERMrA)pidsignalowners rfakeKillz4LockingTests.test_uncleanlyAcquire..fakeKills@{{ek4000e||ek4000|rr;N)rr(rrstrrDr`rErFrarbrr,r<r=)rrsrXrErrs @rtest_uncleanlyAcquirez"LockingTests.test_uncleanlyAcquires  1 1 1 1 1   8VX...UU+++&u--  $$$ $$$  $$$ *5113ry{{3C3CDDDDDrcfd}|td|d}|td||tj}tjt d||||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}. c|tjtj|Sr )rrmlinkrestorer,)rrX readlinkPatchs r fakeReadlinkz?LockingTests.test_lockReleasedBeforeCheck..fakeReadlinks6 OE " " "  ! ! # # #$T** *rr,c|dkrttjd|dkrttjddSNrurnrprqs rrsz;LockingTests.test_lockReleasedBeforeCheck..fakeKill?{{ek4000e||ek4000|rr;r~N r(rrrDrrtr`rErarb)rr{rsrErXrzs @@rtest_lockReleasedBeforeCheckz)LockingTests.test_lockReleasedBeforeChecks + + + + + + 8ZFF  1 1 1 8VX... &u--UU+++  $$$  ###  $$$$$rrcd}|td||}tj|}||||jdS)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. c6ttjdr r!r#s rrWzGLockingTests.test_lockReleasedDuringAcquireSymlink..fakeSymlinks%)T** *rrN)r(rrrDrFrErb)rrWrXrEs r%test_lockReleasedDuringAcquireSymlinkz2LockingTests.test_lockReleasedDuringAcquireSymlinks~ + + + 8Y 444 &u-- %%% %%%%%rr/cZd}|td||}tj|}tjt d|||||jdS)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}. c6ttjdr r2rs rr{zILockingTests.test_lockReleasedDuringAcquireReadlink..fakeReadlink)s%,-- -rr,r~N) r(rrrDrrtrFrErb)rr{rXrEs r&test_lockReleasedDuringAcquireReadlinkz3LockingTests.test_lockReleasedDuringAcquireReadlinks . . . 8Z666 &u--UU+++ %%% %%%%%rcfd}|td||}tjt d|tj|}||j}||j | |j dS)Ncdr rP)rr exceptionTypes rr{z5LockingTests._readlinkErrorTest..fakeReadlink8s-t,, ,rr,r~) r(rrrrtrDrrErrrFrb)rrrr{rXrErs `` r_readlinkErrorTestzLockingTests._readlinkErrorTest7s - - - - - - 8Z666  UU+++&u-- ty99 E*** %%%%%rc|ttj|ttjdS)z An exception raised by C{readlink} other than C{ENOENT} is passed up to the caller of L{FilesystemLock.lock}. N)rrrr[r)r>s rtest_readlinkErrorzLockingTests.test_readlinkErrorGs: 666 66666rc|ttj|ttjdS)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)rr)rr[r3r>s rtest_readlinkErrorPOSIXz$LockingTests.test_readlinkErrorPOSIXOs: 666 66666rcfd}|td|d}|td||tj}tjt d||||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. c|tjtj|Sr )ryrrx)rrX rmlinkPatchs r fakeRmlinkz?LockingTests.test_lockCleanedUpConcurrently..fakeRmlinkes5    ! ! ! OE " " "?4(( (rrxc|dkrttjd|dkrttjddSr}rnrs rrsz=LockingTests.test_lockCleanedUpConcurrently..fakeKillnrrr;r~Nr)rrrsrErXrs @@rtest_lockCleanedUpConcurrentlyz+LockingTests.test_lockCleanedUpConcurrently^s ) ) ) ) ) )jj8Z@@  1 1 1 8VX... &u--UU+++  $$$  ###  $$$$$rcd}|td|d}|td||}tjt d|tj|}|t|j}| |j tj | |j dS)z An exception raised by L{rmlink} other than C{ENOENT} is passed up to the caller of L{FilesystemLock.lock}. c6ttjdr )rrr[rs rrz1LockingTests.test_rmlinkError..fakeRmlinkr7rrxc|dkrttjd|dkrttjddSr}rnrs rrsz/LockingTests.test_rmlinkError..fakeKillrrr;r~N)r(rrrrtrDrrrErrr[rFrb)rrrsrXrErs rtest_rmlinkErrorzLockingTests.test_rmlinkError}s  . . . 8Xz222 1 1 1 8VX...  UU+++&u--33 EL111 %%%%%rcd}|td||}tjt d|tj|}|t|j}| |j tj | |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}. c6ttjdr )rrrors rrsz-LockingTests.test_killError..fakeKills%+t,, ,rr;r~N)r(rrrrtrDrrrErrrorFrb)rrsrXrErs rtest_killErrorzLockingTests.test_killErrors - - - 8VX...  UU+++&u--33 EK000 %%%%%rc|}tjtt jdz|tj|}|t|j dS)z L{FilesystemLock.unlock} raises L{ValueError} if called for a lock which is held by a different process. N) rrrrtr<r=rDr ValueErrorrfrcs rtest_unlockOtherzLockingTests.test_unlockOthersd  RY[[1_--u555&u-- *dk22222rc|}|tj|tj|}|||tj|||tj|dS)zp L{isLocked} returns C{True} if the named lock is currently locked, C{False} otherwise. N)rrFrisLockedrDr`rErfrcs r test_isLockedzLockingTests.test_isLockeds   *511222&u--  $$$ )%00111  *51122222rN)rIrJrKrYr\rrrMr^rdrgrkrurrrrrrrrrrrrrPrrrRrRs + + +--- VC * *  * % % %%%% , , ,EEE2%%%>ZO&& &,ZT&& &*&&& 777 VC 7 7  7%%%>&&&:&&&,333 3 3 3 3 3rrR)rLrr<unittestrrtwisted.pythonrtwisted.python.reflectrtwisted.python.runtimertwisted.trial.unittestrrNrOrMr rRrPrrrsA   ''''''''######000000++++++++++++ 8   ,--5 M, ' ' / <  _$_$_$_$_$_$_$_$DB3B3B3B3B38B3B3B3B3B3r