def test_acquire(self, tmpdir):
"""
Test lock acquisition using direct methods.
* Create a LockFile, and acquire the lock.
* Create a second LockFile and try to acquire the lock. It should fail.
* Release the first lock and try acquiring the lock with the second
one. It should now succeed.
"""
# Use a lock file inside the testing tempdir
lock_file_path = tmpdir.join("test_lockfile1")
# Acquire the first lock, should succeed
first_lock_file = LockFile(lock_file_path.strpath,
raise_if_fail=False,
wait=False)
assert first_lock_file.acquire()
# Try to acquire the lock using a second object, must fail
second_lock_file = LockFile(lock_file_path.strpath,
raise_if_fail=False,
wait=False)
assert not second_lock_file.acquire()
# Release the lock with the first LockFile
first_lock_file.release()
# The second LockFile is now able to acquire the lock
assert second_lock_file.acquire()
second_lock_file.release()
def test_release(self, fcntl_mock, tmpdir):
"""
Try to release an already released LockFile object
"""
# Use a lock file inside the testing tempdir
lock_file_path = tmpdir.join("test_lock_file1")
# set flock to not raise
_prepare_fnctl_mock(fcntl_mock)
lock_file = LockFile(lock_file_path.strpath,
raise_if_fail=False,
wait=False)
assert lock_file.acquire()
# set flock to not raise
_prepare_fnctl_mock(fcntl_mock)
# Release the lock
lock_file.release()
# Check that the fcntl.flock() have been called using the flag LOCK_UN
fcntl_mock.flock.assert_called_once_with(ANY, fcntl.LOCK_UN)
# set flock to not raise
_prepare_fnctl_mock(fcntl_mock)
# Try to release the lock again
lock_file.release()
# The release method should not have called fcntl.flock()
assert not fcntl_mock.flock.called
def test_wait(self, fcntl_mock, tmpdir):
"""
Test wait parameter override using method acquire.
Test different method behaviour
"""
# Use a lock file inside the testing tempdir
lock_file_path = tmpdir.join("test_lock_file1")
# set flock to not raise
_prepare_fnctl_mock(fcntl_mock)
lock_file = LockFile(lock_file_path.strpath,
raise_if_fail=False,
wait=False)
# should succeed
assert lock_file.acquire(wait=True)
# if the wait flag is set to true we expect a lock_ex flag, that
# has a numeric value of 2
fcntl_mock.flock.assert_called_once_with(ANY, fcntl.LOCK_EX)
# release the lock
lock_file.release()
# set flock to not raise
_prepare_fnctl_mock(fcntl_mock)
# acquire it again with wait flag set to False
assert lock_file.acquire(wait=False)
# with the wait flag not set flock bust be called with
# LOCK_EX and LOCK_NB flags
fcntl_mock.flock.assert_called_once_with(
ANY, fcntl.LOCK_EX | fcntl.LOCK_NB)
def test_release(self, fcntl_mock, tmpdir):
"""
Tests for release method
"""
# Test 1: normal release
# Use a lock file inside the testing tempdir
lock_file_path = tmpdir.join("test_lock_file1")
# set flock to not raise
_prepare_fnctl_mock(fcntl_mock)
lock_file = LockFile(lock_file_path.strpath,
raise_if_fail=False,
wait=False)
assert lock_file.acquire()
# set flock to not raise
_prepare_fnctl_mock(fcntl_mock)
# Release the lock
lock_file.release()
# Check that the fcntl.flock() have been called using the flag LOCK_UN
fcntl_mock.flock.assert_called_once_with(ANY, fcntl.LOCK_UN)
# Test 2: release an already released lock
# set flock to not raise
_prepare_fnctl_mock(fcntl_mock)
# Try to release the lock again
lock_file.release()
# The release method should not have called fcntl.flock()
assert not fcntl_mock.flock.called
# Test 3: exceptions during release
# set flock to not raise
_prepare_fnctl_mock(fcntl_mock)
lock_file = LockFile(lock_file_path.strpath,
raise_if_fail=False,
wait=False)
assert lock_file.acquire()
# set flock to raise an OSError (no matter what)
_prepare_fnctl_mock(fcntl_mock, OSError(errno.EBADF, '', ''))
# Release the lock (should not raise any error)
lock_file.release()
# Check that the fcntl.flock() have been called using the flag LOCK_UN
fcntl_mock.flock.assert_called_once_with(ANY, fcntl.LOCK_UN)
def test_release(self, fcntl_mock, tmpdir):
"""
Tests for release method
"""
# Test 1: normal release
# Use a lock file inside the testing tempdir
lock_file_path = tmpdir.join("test_lock_file1")
# set flock to not raise
_prepare_fcntl_mock(fcntl_mock)
lock_file = LockFile(lock_file_path.strpath, raise_if_fail=False, wait=False)
assert lock_file.acquire()
# set flock to not raise
_prepare_fcntl_mock(fcntl_mock)
# Release the lock
lock_file.release()
# Check that the fcntl.flock() have been called using the flag LOCK_UN
fcntl_mock.flock.assert_called_once_with(ANY, fcntl.LOCK_UN)
# Test 2: release an already released lock
# set flock to not raise
_prepare_fcntl_mock(fcntl_mock)
# Try to release the lock again
lock_file.release()
# The release method should not have called fcntl.flock()
assert not fcntl_mock.flock.called
# Test 3: exceptions during release
# set flock to not raise
_prepare_fcntl_mock(fcntl_mock)
lock_file = LockFile(lock_file_path.strpath, raise_if_fail=False, wait=False)
assert lock_file.acquire()
# set flock to raise an OSError (no matter what)
_prepare_fcntl_mock(fcntl_mock, OSError(errno.EBADF, "", ""))
# Release the lock (should not raise any error)
lock_file.release()
# Check that the fcntl.flock() have been called using the flag LOCK_UN
fcntl_mock.flock.assert_called_once_with(ANY, fcntl.LOCK_UN)
