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_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_holding_more_than_one(self): lock_a = Lock("a") lock_b = Lock("b") with lock_a, lock_b: assert lock_a.is_held()