def test_multi_connection(self):
lock_a = Lock("a")
lock_b = Lock("b", using='other')
with lock_a, lock_b:
# Different connections = can hold > 1!
assert lock_a.is_held()
assert lock_b.is_held()
def test_multi_connection(self):
lock_a = Lock("a")
lock_b = Lock("b", using="other")
with lock_a, lock_b:
# Different connections = can hold > 1!
assert lock_a.is_held()
assert lock_b.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_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_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_holding_more_than_one(self):
is_mariadb = connection_is_mariadb(connection)
supports_multiple_locks = (
is_mariadb and connection.mysql_version >= (10, 0, 2)
) or (not is_mariadb and connection.mysql_version >= (5, 7))
if not supports_multiple_locks:
self.skipTest(
"Only MySQL 5.7+ and MariaDB 10.0.2+ have the ability to hold "
"more than one named lock"
)
lock_a = Lock("a")
lock_b = Lock("b")
with lock_a, lock_b:
assert lock_a.is_held()
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
def test_holding_more_than_one(self):
conn = connection
supports_multiple_locks = (
(conn.is_mariadb and conn.mysql_version >= (10, 0, 2)) or
(not conn.is_mariadb and conn.mysql_version >= (5, 7))
)
if not supports_multiple_locks:
self.skipTest(
"Only MySQL 5.7+ and MariaDB 10.0.2+ have the ability to hold "
"more than one named lock"
)
lock_a = Lock("a")
lock_b = Lock("b")
with lock_a, lock_b:
assert lock_a.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_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_error_on_unneeded_exit(self):
mylock = Lock("mylock")
assert not mylock.is_held()
with pytest.raises(ValueError) as excinfo:
mylock.__exit__(None, None, None)
assert "unheld lock" in str(excinfo.value)
def test_error_on_unneeded_exit(self):
mylock = Lock("mylock")
assert not mylock.is_held()
with pytest.raises(ValueError) as excinfo:
mylock.__exit__(None, None, None)
assert "unheld lock" in str(excinfo.value)
def test_holding_more_than_one(self):
lock_a = Lock("a")
lock_b = Lock("b")
with lock_a, lock_b:
assert lock_a.is_held()
