File: //usr/lib/python3/dist-packages/twisted/test/__pycache__/test_lockfile.cpython-38.pyc
U
W[�< � @ s� d Z ddlmZmZ ddlZddlZddlmZ ddlm Z ddl
m Z ddl m
Z
dZe
�� r|e d�dkr|e d �dkr|d
ZG d d � d ej�ZG d
d� dej�ZdS )z'
Tests for L{twisted.python.lockfile}.
� )�absolute_import�divisionN)�unittest)�lockfile)�
requireModule)�platformzwin32api.OpenProcessZ
pywintypeszZOn windows, lockfile.kill is not implemented in the absence of win32api and/or pywintypes.c @ sp e Zd ZdZdd� Zdd� Ze�� s*de_dd� Z d d
� Z
e�� sHd e
_d d
� Z e e _dd� Z
e e
_dd� ZdS )� UtilTestszM
Tests for the helper functions used to implement L{FilesystemLock}.
c C s: | � � }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�errnoZEEXIST��self�name�exc� r �</usr/lib/python3/dist-packages/twisted/test/test_lockfile.py�test_symlinkEEXIST s z UtilTests.test_symlinkEEXISTc C sD | � � }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).
c S s t tjd ��d S �N)�IOErrorr �EIO��srcZdstr r r �
fakeRename4 s z4UtilTests.test_symlinkEIOWindows.<locals>.fakeRename�renamer N) r
�patchr r r r r r r )r r r r r r r �test_symlinkEIOWindows* s
z UtilTests.test_symlinkEIOWindows�Bspecial rename EIO handling only necessary and correct on Windows.c C s, | � � }| �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
r r
r �readlinkr r ZENOENTr r r r �test_readlinkENOENT? s z UtilTests.test_readlinkENOENTc C sB | � � }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).
c S s t tjd ��d S r �r r �EACCES)�path�moder r r �fakeOpenS s z6UtilTests.test_readlinkEACCESWindows.<locals>.fakeOpenZ_openN) r
r r r r r! r r r$ )r r r' r r r r �test_readlinkEACCESWindowsI s
z$UtilTests.test_readlinkEACCESWindows�Gspecial readlink EACCES handling only necessary and correct on Windows.c C s t �t�� d� dS )z}
L{lockfile.kill} returns without error if passed the PID of a
process which exists and signal C{0}.
r N)r �kill�os�getpid�r r r r � test_kill^ s zUtilTests.test_killc C s& | � 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���r N)r r
r r* r r �ESRCH)r r r r r �test_killESRCHg s zUtilTests.test_killESRCHc C s6 | � 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}.
r* N)r r �FilesystemLockr
�lock� assertFalse)r Zflr r r �test_noKillCallr s zUtilTests.test_noKillCallN)�__name__�
__module__� __qualname__�__doc__r r r � isWindows�skipr" r( r. �skipKillr0 r4 r r r r r s �
�r c @ s� e Zd Zdd� Zdd� Zdd� Ze�� r.de_dd � Z d
d � Z
d d
� Z dd� Z dd� Z
dd� Ze�� slde_dd� Ze�� s�de_dd� Zdd� Zd d � Ze�� r�de_d d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(S ))� LockingTestsc sL � fdd�}| � td|� | �� }t�|�}| �t|j�}| �|j� � d S )Nc s t � d ��d S r )r
)�source�dest�r r r � fakeSymlink� s z3LockingTests._symlinkErrorTest.<locals>.fakeSymlinkr ) r r r
r1 r r
r2 r r )r r r@ �lockfr2 r r r? r �_symlinkErrorTest� s
z LockingTests._symlinkErrorTestc C s | � tj� dS )z�
An exception raised by C{symlink} other than C{EEXIST} is passed up to
the caller of L{FilesystemLock.lock}.
N)rB r �ENOSYSr- r r r �test_symlinkError� s z LockingTests.test_symlinkErrorc C s | � 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)rB r r$ r r- r r r �test_symlinkErrorPOSIX� s z#LockingTests.test_symlinkErrorPOSIXz9POSIX-specific error propagation not expected on Windows.c C s< | � � }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
r r1 �
assertTruer2 �clean�locked�r rA r2 r r r �test_cleanlyAcquire� s
z LockingTests.test_cleanlyAcquirec C sh | � � }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
r r1 rF r2 �unlockr3 rH rG rI r r r �test_cleanlyRelease� s
z LockingTests.test_cleanlyReleasec C sH | � � }t�|�}| �|�� � t�|�}| �|�� � | �|j� dS )zK
If a lock is currently locked, it cannot be locked again.
N)r
r r1 rF r2 r3 rH )r rA Z firstLockZ
secondLockr r r �test_cannotLockLocked� s
z"LockingTests.test_cannotLockLockedc s� 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}.
i90 c s, |dkrt tjd ��| � kr(t tjd ��d S )Nr �r
r �EPERMr/ ��pid�signal��ownerr r �fakeKill� s z4LockingTests.test_uncleanlyAcquire.<locals>.fakeKillr* N)r
r r r �strr1 rF r2 r3 rG rH r r! r+ r, )r rU rA r2 r rS r �test_uncleanlyAcquire� s
z"LockingTests.test_uncleanlyAcquirec s~ � �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}.
c s t �� � ��� t �| �S r )r �rmlink�restorer! �r �rA Z
readlinkPatchr r � fakeReadlink� s
z?LockingTests.test_lockReleasedBeforeCheck.<locals>.fakeReadlinkr! c S s, |dkrt tjd ��| dkr(t tjd ��d S �Nr �u� rN rP r r r rU � s z;LockingTests.test_lockReleasedBeforeCheck.<locals>.fakeKillr* r^ N�
r r r
r1 r rV rF r2 rG rH )r r\ rU r2 r r[ r � test_lockReleasedBeforeCheck� s
z)LockingTests.test_lockReleasedBeforeCheckc C sF 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.
c S s t tjd ��d S r )r
r r r r r r r@ s zGLockingTests.test_lockReleasedDuringAcquireSymlink.<locals>.fakeSymlinkr N)r r r
r1 r3 r2 rH )r r@ rA r2 r r r �%test_lockReleasedDuringAcquireSymlink s
z2LockingTests.test_lockReleasedDuringAcquireSymlinkr c C sV 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}.
c S s t tjd ��d S r r# rZ r r r r\ # s zILockingTests.test_lockReleasedDuringAcquireReadlink.<locals>.fakeReadlinkr! r^ N) r r r
r1 r rV r3 r2 rH )r r\ rA r2 r r r �&test_lockReleasedDuringAcquireReadlink s
z3LockingTests.test_lockReleasedDuringAcquireReadlinkr) c sj � �fdd�}| � td|� | �� }t�td�|� t�|�}| ��|j�}| �|j � � | �
|j � d S )Nc s �� d ��d S r r rZ �r �
exceptionTyper r r\ 6 s z5LockingTests._readlinkErrorTest.<locals>.fakeReadlinkr! r^ ) r r r
r rV r1 r r2 r r r3 rH )r rd r r\ rA r2 r r rc r �_readlinkErrorTest5 s
z LockingTests._readlinkErrorTestc C s | � 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)re r
r rC r r- r r r �test_readlinkErrorE s z LockingTests.test_readlinkErrorc C s | � 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)re r r rC r$ r- r r r �test_readlinkErrorPOSIXN s z$LockingTests.test_readlinkErrorPOSIXc s~ � �fdd�}| � td|��dd� }| � 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.
c s �� � t�� � t�| �S r )rY r rX rZ �rA Z rmlinkPatchr r �
fakeRmlinkc s
z?LockingTests.test_lockCleanedUpConcurrently.<locals>.fakeRmlinkrX c S s, |dkrt tjd ��| dkr(t tjd ��d S r] rN rP r r r rU k s z=LockingTests.test_lockCleanedUpConcurrently.<locals>.fakeKillr* r^ Nr_ )r ri rU r2 r rh r � test_lockCleanedUpConcurrently] s
z+LockingTests.test_lockCleanedUpConcurrentlyc C s| 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}.
c S s t tjd ��d S r )r
r rC rZ r r r ri s z1LockingTests.test_rmlinkError.<locals>.fakeRmlinkrX c S s, |dkrt tjd ��| dkr(t tjd ��d S r] rN rP r r r rU � s z/LockingTests.test_rmlinkError.<locals>.fakeKillr* r^ N)r r r
r rV r1 r r
r2 r r rC r3 rH )r ri rU rA r2 r r r r �test_rmlinkErrorz s
z LockingTests.test_rmlinkErrorc C sf 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}.
c S s t tjd ��d S r )r
r rO rP r r r rU � s z-LockingTests.test_killError.<locals>.fakeKillr* r^ N)r r r
r rV r1 r r
r2 r r rO r3 rH )r rU rA r2 r r r r �test_killError� s
zLockingTests.test_killErrorc C s< | � � }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
r r rV r+ r, r1 r �
ValueErrorrK rI r r r �test_unlockOther� s
z LockingTests.test_unlockOtherc C s\ | � � }| �t�|�� t�|�}| �|�� � | �t�|�� |�� | �t�|�� dS )zp
L{isLocked} returns C{True} if the named lock is currently locked,
C{False} otherwise.
N)r
r3 r ZisLockedr1 rF r2 rK rI r r r �
test_isLocked� s
zLockingTests.test_isLockedN)r5 r6 r7 rB rD rE r r9 r: rJ rL rM rW r` ra rb re rf rg rj rk rl ro rp r r r r r< s<
�
��
� r< )r8 Z
__future__r r r r+ Z
twisted.trialr Ztwisted.pythonr Ztwisted.python.reflectr Ztwisted.python.runtimer r; r9 ZTestCaser r< r r r r �<module> s
�d