def test_simple(self):
mylock = Lock("mylock")
assert not mylock.is_held()
with mylock:
assert mylock.is_held()
assert Lock("mylock").is_held()
cursor = connection.cursor()
cursor.execute("SELECT CONNECTION_ID();")
own_connection_id = cursor.fetchone()[0]
assert mylock.holding_connection_id() == own_connection_id
assert not mylock.is_held()
assert not Lock("mylock").is_held()
def test_simple(self):
mylock = Lock("mylock")
assert not mylock.is_held()
with mylock:
assert mylock.is_held()
assert Lock("mylock").is_held()
cursor = connection.cursor()
cursor.execute("SELECT CONNECTION_ID();")
own_connection_id = cursor.fetchone()[0]
assert mylock.holding_connection_id() == own_connection_id
assert not mylock.is_held()
assert not Lock("mylock").is_held()
def test_threads_concurrent_access(self):
"""
Test that the same lock object can be used in multiple threads, allows
the definition of a lock upfront in a module.
"""
if TYPE_CHECKING: # pragma: no branch
to_me: queue.Queue[str]
to_you: queue.Queue[str]
to_me = queue.Queue()
to_you = queue.Queue()
the_lock = Lock("THElock", 0.05)
def check_it_lock_it():
assert not the_lock.is_held()
with the_lock:
to_me.put("Locked")
to_you.get(True)
other_thread = Thread(target=check_it_lock_it)
other_thread.start()
try:
item = to_me.get(True)
assert item == "Locked"
cursor = connection.cursor()
cursor.execute("SELECT CONNECTION_ID()")
own_connection_id = cursor.fetchone()[0]
assert the_lock.is_held()
assert the_lock.holding_connection_id() != own_connection_id
with pytest.raises(TimeoutError):
with the_lock:
pass
to_you.put("Stop")
finally:
other_thread.join()
with the_lock:
pass
def test_timeout_with_threads(self):
if TYPE_CHECKING: # pragma: no cover
to_me: queue.Queue[str]
to_you: queue.Queue[str]
to_me = queue.Queue()
to_you = queue.Queue()
def lock_until_told():
with Lock("threading_test"):
to_me.put("Locked")
to_you.get(True)
threading_test = Lock("threading_test", 0.05)
assert not threading_test.is_held()
other_thread = Thread(target=lock_until_told)
other_thread.start()
try:
item = to_me.get(True)
assert item == "Locked"
cursor = connection.cursor()
cursor.execute("SELECT CONNECTION_ID();")
own_connection_id = cursor.fetchone()[0]
assert threading_test.is_held()
assert threading_test.holding_connection_id() != own_connection_id
with pytest.raises(TimeoutError):
with threading_test:
pass
to_you.put("Stop")
finally:
other_thread.join()
assert not threading_test.is_held()
with threading_test:
pass
def test_threads_concurrent_access(self):
"""
Test that the same lock object can be used in multiple threads, allows
the definition of a lock upfront in a module.
"""
to_me = queue.Queue()
to_you = queue.Queue()
the_lock = Lock('THElock', 0.05)
def check_it_lock_it():
assert not the_lock.is_held()
with the_lock:
to_me.put("Locked")
to_you.get(True)
other_thread = Thread(target=check_it_lock_it)
other_thread.start()
try:
item = to_me.get(True)
assert item == "Locked"
cursor = connection.cursor()
cursor.execute("SELECT CONNECTION_ID()")
own_connection_id = cursor.fetchone()[0]
assert the_lock.is_held()
assert the_lock.holding_connection_id() != own_connection_id
with pytest.raises(TimeoutError):
with the_lock:
pass
to_you.put("Stop")
finally:
other_thread.join()
with the_lock:
pass
def test_timeout_with_threads(self):
to_me = queue.Queue()
to_you = queue.Queue()
def lock_until_told():
with Lock('threading_test'):
to_me.put("Locked")
to_you.get(True)
threading_test = Lock('threading_test', 0.05)
assert not threading_test.is_held()
other_thread = Thread(target=lock_until_told)
other_thread.start()
try:
item = to_me.get(True)
assert item == "Locked"
cursor = connection.cursor()
cursor.execute("SELECT CONNECTION_ID();")
own_connection_id = cursor.fetchone()[0]
assert threading_test.is_held()
assert threading_test.holding_connection_id() != own_connection_id
with pytest.raises(TimeoutError):
with threading_test:
pass
to_you.put("Stop")
finally:
other_thread.join()
assert not threading_test.is_held()
with threading_test:
pass
