Ported lock test to pytest.

lib/spack/spack/test/lock.py

@@ -27,29 +27,32 @@
 """
 import os
 import shutil
+import functools
 import tempfile
-import unittest
+import traceback
 from multiprocessing import Process
 
-from llnl.util.filesystem import join_path, touch
+import pytest
+
+from llnl.util.filesystem import join_path, touch, mkdirp
 from llnl.util.lock import *
 from spack.util.multiproc import Barrier
 
+
 # This is the longest a failed test will take, as the barriers will
 # time out and raise an exception.
 barrier_timeout = 5
 
 
-class LockTest(unittest.TestCase):
+@pytest.fixture()
+def lock_path():
+    tempdir = tempfile.mkdtemp()
+    lock_file = join_path(tempdir, 'lockfile')
+    yield lock_file
+    shutil.rmtree(tempdir)
 
-    def setUp(self):
-        self.tempdir = tempfile.mkdtemp()
-        self.lock_path = join_path(self.tempdir, 'lockfile')
 
-    def tearDown(self):
+def multiproc_test(*functions):
-        shutil.rmtree(self.tempdir, ignore_errors=True)
-
-    def multiproc_test(self, *functions):
     """Order some processes using simple barrier synchronization."""
     b = Barrier(len(functions), timeout=barrier_timeout)
     procs = [Process(target=f, args=(b,)) for f in functions]
@@ -59,250 +62,340 @@ def multiproc_test(self, *functions):
 
     for p in procs:
         p.join()
-            self.assertEqual(p.exitcode, 0)
+        assert p.exitcode == 0
 
-    #
+
-    # Process snippets below can be composed into tests.
+#
-    #
+# Process snippets below can be composed into tests.
-    def acquire_write(self, start=0, length=0):
+#
+def acquire_write(lock_path, start=0, length=0):
     def fn(barrier):
-            lock = Lock(self.lock_path, start, length)
+        lock = Lock(lock_path, start, length)
         lock.acquire_write()  # grab exclusive lock
         barrier.wait()
         barrier.wait()  # hold the lock until timeout in other procs.
     return fn
 
-    def acquire_read(self, start=0, length=0):
+
+def acquire_read(lock_path, start=0, length=0):
     def fn(barrier):
-            lock = Lock(self.lock_path, start, length)
+        lock = Lock(lock_path, start, length)
         lock.acquire_read()  # grab shared lock
         barrier.wait()
         barrier.wait()  # hold the lock until timeout in other procs.
     return fn
 
-    def timeout_write(self, start=0, length=0):
+
+def timeout_write(lock_path, start=0, length=0):
     def fn(barrier):
-            lock = Lock(self.lock_path, start, length)
+        lock = Lock(lock_path, start, length)
         barrier.wait()  # wait for lock acquire in first process
-            self.assertRaises(LockError, lock.acquire_write, 0.1)
+        with pytest.raises(LockError):
+            lock.acquire_write(0.1)
         barrier.wait()
     return fn
 
-    def timeout_read(self, start=0, length=0):
+
+def timeout_read(lock_path, start=0, length=0):
     def fn(barrier):
-            lock = Lock(self.lock_path, start, length)
+        lock = Lock(lock_path, start, length)
         barrier.wait()  # wait for lock acquire in first process
-            self.assertRaises(LockError, lock.acquire_read, 0.1)
+        with pytest.raises(LockError):
+            lock.acquire_read(0.1)
         barrier.wait()
     return fn
 
-    #
-    # Test that exclusive locks on other processes time out when an
-    # exclusive lock is held.
-    #
-    def test_write_lock_timeout_on_write(self):
-        self.multiproc_test(self.acquire_write(), self.timeout_write())
 
-    def test_write_lock_timeout_on_write_2(self):
+#
-        self.multiproc_test(
+# Test that exclusive locks on other processes time out when an
-            self.acquire_write(), self.timeout_write(), self.timeout_write())
+# exclusive lock is held.
+#
+def test_write_lock_timeout_on_write(lock_path):
+    multiproc_test(acquire_write(lock_path), timeout_write(lock_path))
 
-    def test_write_lock_timeout_on_write_3(self):
-        self.multiproc_test(
-            self.acquire_write(), self.timeout_write(), self.timeout_write(),
-            self.timeout_write())
 
-    def test_write_lock_timeout_on_write_ranges(self):
+def test_write_lock_timeout_on_write_2(lock_path):
-        self.multiproc_test(
+    multiproc_test(
-            self.acquire_write(0, 1), self.timeout_write(0, 1))
+        acquire_write(lock_path),
+        timeout_write(lock_path),
+        timeout_write(lock_path))
 
-    def test_write_lock_timeout_on_write_ranges_2(self):
-        self.multiproc_test(
-            self.acquire_write(0, 64), self.acquire_write(65, 1),
-            self.timeout_write(0, 1), self.timeout_write(63, 1))
 
-    def test_write_lock_timeout_on_write_ranges_3(self):
+def test_write_lock_timeout_on_write_3(lock_path):
-        self.multiproc_test(
+    multiproc_test(
-            self.acquire_write(0, 1), self.acquire_write(1, 1),
+        acquire_write(lock_path),
-            self.timeout_write(), self.timeout_write(), self.timeout_write())
+        timeout_write(lock_path),
+        timeout_write(lock_path),
+        timeout_write(lock_path))
 
-    def test_write_lock_timeout_on_write_ranges_4(self):
-        self.multiproc_test(
-            self.acquire_write(0, 1), self.acquire_write(1, 1),
-            self.acquire_write(2, 456), self.acquire_write(500, 64),
-            self.timeout_write(), self.timeout_write(), self.timeout_write())
 
-    #
+def test_write_lock_timeout_on_write_ranges(lock_path):
-    # Test that shared locks on other processes time out when an
+    multiproc_test(
-    # exclusive lock is held.
+        acquire_write(lock_path, 0, 1),
-    #
+        timeout_write(lock_path, 0, 1))
-    def test_read_lock_timeout_on_write(self):
-        self.multiproc_test(self.acquire_write(), self.timeout_read())
 
-    def test_read_lock_timeout_on_write_2(self):
-        self.multiproc_test(
-            self.acquire_write(), self.timeout_read(), self.timeout_read())
 
-    def test_read_lock_timeout_on_write_3(self):
+def test_write_lock_timeout_on_write_ranges_2(lock_path):
-        self.multiproc_test(
+    multiproc_test(
-            self.acquire_write(), self.timeout_read(), self.timeout_read(),
+        acquire_write(lock_path, 0, 64),
-            self.timeout_read())
+        acquire_write(lock_path, 65, 1),
+        timeout_write(lock_path, 0, 1),
+        timeout_write(lock_path, 63, 1))
 
-    def test_read_lock_timeout_on_write_ranges(self):
+
+def test_write_lock_timeout_on_write_ranges_3(lock_path):
+    multiproc_test(
+        acquire_write(lock_path, 0, 1),
+        acquire_write(lock_path, 1, 1),
+        timeout_write(lock_path),
+        timeout_write(lock_path),
+        timeout_write(lock_path))
+
+
+def test_write_lock_timeout_on_write_ranges_4(lock_path):
+    multiproc_test(
+        acquire_write(lock_path, 0, 1),
+        acquire_write(lock_path, 1, 1),
+        acquire_write(lock_path, 2, 456),
+        acquire_write(lock_path, 500, 64),
+        timeout_write(lock_path),
+        timeout_write(lock_path),
+        timeout_write(lock_path))
+
+
+#
+# Test that shared locks on other processes time out when an
+# exclusive lock is held.
+#
+def test_read_lock_timeout_on_write(lock_path):
+    multiproc_test(
+        acquire_write(lock_path),
+        timeout_read(lock_path))
+
+
+def test_read_lock_timeout_on_write_2(lock_path):
+    multiproc_test(
+        acquire_write(lock_path),
+        timeout_read(lock_path),
+        timeout_read(lock_path))
+
+
+def test_read_lock_timeout_on_write_3(lock_path):
+    multiproc_test(
+        acquire_write(lock_path),
+        timeout_read(lock_path),
+        timeout_read(lock_path),
+        timeout_read(lock_path))
+
+
+def test_read_lock_timeout_on_write_ranges(lock_path):
     """small write lock, read whole file."""
-        self.multiproc_test(self.acquire_write(0, 1), self.timeout_read())
+    multiproc_test(
+        acquire_write(lock_path, 0, 1),
+        timeout_read(lock_path))
 
-    def test_read_lock_timeout_on_write_ranges_2(self):
+
+def test_read_lock_timeout_on_write_ranges_2(lock_path):
     """small write lock, small read lock"""
-        self.multiproc_test(self.acquire_write(0, 1), self.timeout_read(0, 1))
+    multiproc_test(
+        acquire_write(lock_path, 0, 1),
+        timeout_read(lock_path, 0, 1))
 
-    def test_read_lock_timeout_on_write_ranges_3(self):
+
+def test_read_lock_timeout_on_write_ranges_3(lock_path):
     """two write locks, overlapping read locks"""
-        self.multiproc_test(
+    multiproc_test(
-            self.acquire_write(0, 1), self.acquire_write(64, 128),
+        acquire_write(lock_path, 0, 1),
-            self.timeout_read(0, 1), self.timeout_read(128, 256))
+        acquire_write(lock_path, 64, 128),
+        timeout_read(lock_path, 0, 1),
+        timeout_read(lock_path, 128, 256))
 
-    #
-    # Test that exclusive locks time out when shared locks are held.
-    #
-    def test_write_lock_timeout_on_read(self):
-        self.multiproc_test(self.acquire_read(), self.timeout_write())
 
-    def test_write_lock_timeout_on_read_2(self):
+#
-        self.multiproc_test(
+# Test that exclusive locks time out when shared locks are held.
-            self.acquire_read(), self.timeout_write(), self.timeout_write())
+#
+def test_write_lock_timeout_on_read(lock_path):
+    multiproc_test(
+        acquire_read(lock_path),
+        timeout_write(lock_path))
 
-    def test_write_lock_timeout_on_read_3(self):
-        self.multiproc_test(
-            self.acquire_read(), self.timeout_write(), self.timeout_write(),
-            self.timeout_write())
 
-    def test_write_lock_timeout_on_read_ranges(self):
+def test_write_lock_timeout_on_read_2(lock_path):
-        self.multiproc_test(self.acquire_read(0, 1), self.timeout_write())
+    multiproc_test(
+        acquire_read(lock_path),
+        timeout_write(lock_path),
+        timeout_write(lock_path))
 
-    def test_write_lock_timeout_on_read_ranges_2(self):
-        self.multiproc_test(self.acquire_read(0, 1), self.timeout_write(0, 1))
 
-    def test_write_lock_timeout_on_read_ranges_3(self):
+def test_write_lock_timeout_on_read_3(lock_path):
-        self.multiproc_test(
+    multiproc_test(
-            self.acquire_read(0, 1), self.acquire_read(10, 1),
+        acquire_read(lock_path),
-            self.timeout_write(0, 1), self.timeout_write(10, 1))
+        timeout_write(lock_path),
+        timeout_write(lock_path),
+        timeout_write(lock_path))
 
-    def test_write_lock_timeout_on_read_ranges_4(self):
-        self.multiproc_test(
-            self.acquire_read(0, 64),
-            self.timeout_write(10, 1), self.timeout_write(32, 1))
 
-    def test_write_lock_timeout_on_read_ranges_5(self):
+def test_write_lock_timeout_on_read_ranges(lock_path):
-        self.multiproc_test(
+    multiproc_test(
-            self.acquire_read(64, 128),
+        acquire_read(lock_path, 0, 1),
-            self.timeout_write(65, 1), self.timeout_write(127, 1),
+        timeout_write(lock_path))
-            self.timeout_write(90, 10))
 
-    #
-    # Test that exclusive locks time while lots of shared locks are held.
-    #
-    def test_write_lock_timeout_with_multiple_readers_2_1(self):
-        self.multiproc_test(
-            self.acquire_read(), self.acquire_read(), self.timeout_write())
 
-    def test_write_lock_timeout_with_multiple_readers_2_2(self):
+def test_write_lock_timeout_on_read_ranges_2(lock_path):
-        self.multiproc_test(
+    multiproc_test(
-            self.acquire_read(), self.acquire_read(), self.timeout_write(),
+        acquire_read(lock_path, 0, 1),
-            self.timeout_write())
+        timeout_write(lock_path, 0, 1))
 
-    def test_write_lock_timeout_with_multiple_readers_3_1(self):
-        self.multiproc_test(
-            self.acquire_read(), self.acquire_read(), self.acquire_read(),
-            self.timeout_write())
 
-    def test_write_lock_timeout_with_multiple_readers_3_2(self):
+def test_write_lock_timeout_on_read_ranges_3(lock_path):
-        self.multiproc_test(
+    multiproc_test(
-            self.acquire_read(), self.acquire_read(), self.acquire_read(),
+        acquire_read(lock_path, 0, 1),
-            self.timeout_write(), self.timeout_write())
+        acquire_read(lock_path, 10, 1),
+        timeout_write(lock_path, 0, 1),
+        timeout_write(lock_path, 10, 1))
 
-    def test_write_lock_timeout_with_multiple_readers_2_1_ranges(self):
-        self.multiproc_test(
-            self.acquire_read(0, 10), self.acquire_read(5, 10),
-            self.timeout_write(5, 5))
 
-    def test_write_lock_timeout_with_multiple_readers_2_3_ranges(self):
+def test_write_lock_timeout_on_read_ranges_4(lock_path):
-        self.multiproc_test(
+    multiproc_test(
-            self.acquire_read(0, 10), self.acquire_read(5, 15),
+        acquire_read(lock_path, 0, 64),
-            self.timeout_write(0, 1), self.timeout_write(11, 3),
+        timeout_write(lock_path, 10, 1), timeout_write(lock_path, 32, 1))
-            self.timeout_write(7, 1))
 
-    def test_write_lock_timeout_with_multiple_readers_3_1_ranges(self):
-        self.multiproc_test(
-            self.acquire_read(0, 5), self.acquire_read(5, 5),
-            self.acquire_read(10, 5),
-            self.timeout_write(0, 15))
 
-    def test_write_lock_timeout_with_multiple_readers_3_2_ranges(self):
+def test_write_lock_timeout_on_read_ranges_5(lock_path):
-        self.multiproc_test(
+    multiproc_test(
-            self.acquire_read(0, 5), self.acquire_read(5, 5),
+        acquire_read(lock_path, 64, 128),
-            self.acquire_read(10, 5),
+        timeout_write(lock_path, 65, 1),
-            self.timeout_write(3, 10), self.timeout_write(5, 1))
+        timeout_write(lock_path, 127, 1),
+        timeout_write(lock_path, 90, 10))
 
-    #
+#
-    # Test that read can be upgraded to write.
+# Test that exclusive locks time while lots of shared locks are held.
-    #
+#
-    def test_upgrade_read_to_write(self):
+def test_write_lock_timeout_with_multiple_readers_2_1(lock_path):
+    multiproc_test(
+        acquire_read(lock_path),
+        acquire_read(lock_path),
+        timeout_write(lock_path))
+
+
+def test_write_lock_timeout_with_multiple_readers_2_2(lock_path):
+    multiproc_test(
+        acquire_read(lock_path),
+        acquire_read(lock_path),
+        timeout_write(lock_path),
+        timeout_write(lock_path))
+
+
+def test_write_lock_timeout_with_multiple_readers_3_1(lock_path):
+    multiproc_test(
+        acquire_read(lock_path),
+        acquire_read(lock_path),
+        acquire_read(lock_path),
+        timeout_write(lock_path))
+
+
+def test_write_lock_timeout_with_multiple_readers_3_2(lock_path):
+    multiproc_test(
+        acquire_read(lock_path),
+        acquire_read(lock_path),
+        acquire_read(lock_path),
+        timeout_write(lock_path),
+        timeout_write(lock_path))
+
+
+def test_write_lock_timeout_with_multiple_readers_2_1_ranges(lock_path):
+    multiproc_test(
+        acquire_read(lock_path, 0, 10),
+        acquire_read(lock_path, 0.5, 10),
+        timeout_write(lock_path, 5, 5))
+
+
+def test_write_lock_timeout_with_multiple_readers_2_3_ranges(lock_path):
+    multiproc_test(
+        acquire_read(lock_path, 0, 10),
+        acquire_read(lock_path, 5, 15),
+        timeout_write(lock_path, 0, 1),
+        timeout_write(lock_path, 11, 3),
+        timeout_write(lock_path, 7, 1))
+
+
+def test_write_lock_timeout_with_multiple_readers_3_1_ranges(lock_path):
+    multiproc_test(
+        acquire_read(lock_path, 0, 5),
+        acquire_read(lock_path, 5, 5),
+        acquire_read(lock_path, 10, 5),
+        timeout_write(lock_path, 0, 15))
+
+
+def test_write_lock_timeout_with_multiple_readers_3_2_ranges(lock_path):
+    multiproc_test(
+        acquire_read(lock_path, 0, 5),
+        acquire_read(lock_path, 5, 5),
+        acquire_read(lock_path, 10, 5),
+        timeout_write(lock_path, 3, 10),
+        timeout_write(lock_path, 5, 1))
+
+
+#
+# Test that read can be upgraded to write.
+#
+def test_upgrade_read_to_write(lock_path):
     # ensure lock file exists the first time, so we open it read-only
     # to begin wtih.
-        touch(self.lock_path)
+    touch(lock_path)
 
-        lock = Lock(self.lock_path)
+    lock = Lock(lock_path)
-        self.assertTrue(lock._reads == 0)
+    assert lock._reads == 0
-        self.assertTrue(lock._writes == 0)
+    assert lock._writes == 0
 
     lock.acquire_read()
-        self.assertTrue(lock._reads == 1)
+    assert lock._reads == 1
-        self.assertTrue(lock._writes == 0)
+    assert lock._writes == 0
-        self.assertTrue(lock._file.mode == 'r+')
+    assert lock._file.mode == 'r+'
 
     lock.acquire_write()
-        self.assertTrue(lock._reads == 1)
+    assert lock._reads == 1
-        self.assertTrue(lock._writes == 1)
+    assert lock._writes == 1
-        self.assertTrue(lock._file.mode == 'r+')
+    assert lock._file.mode == 'r+'
 
     lock.release_write()
-        self.assertTrue(lock._reads == 1)
+    assert lock._reads == 1
-        self.assertTrue(lock._writes == 0)
+    assert lock._writes == 0
-        self.assertTrue(lock._file.mode == 'r+')
+    assert lock._file.mode == 'r+'
 
     lock.release_read()
-        self.assertTrue(lock._reads == 0)
+    assert lock._reads == 0
-        self.assertTrue(lock._writes == 0)
+    assert lock._writes == 0
-        self.assertTrue(lock._file is None)
+    assert lock._file is None
 
-    #
+#
-    # Test that read-only file can be read-locked but not write-locked.
+# Test that read-only file can be read-locked but not write-locked.
-    #
+#
-    def test_upgrade_read_to_write_fails_with_readonly_file(self):
+def test_upgrade_read_to_write_fails_with_readonly_file(lock_path):
     # ensure lock file exists the first time, so we open it read-only
     # to begin wtih.
-        touch(self.lock_path)
+    touch(lock_path)
-        os.chmod(self.lock_path, 0o444)
+    os.chmod(lock_path, 0o444)
 
-        lock = Lock(self.lock_path)
+    lock = Lock(lock_path)
-        self.assertTrue(lock._reads == 0)
+    assert lock._reads == 0
-        self.assertTrue(lock._writes == 0)
+    assert lock._writes == 0
 
     lock.acquire_read()
-        self.assertTrue(lock._reads == 1)
+    assert lock._reads == 1
-        self.assertTrue(lock._writes == 0)
+    assert lock._writes == 0
-        self.assertTrue(lock._file.mode == 'r')
+    assert lock._file.mode == 'r'
 
-        self.assertRaises(LockError, lock.acquire_write)
+    with pytest.raises(LockError):
+        lock.acquire_write()
 
-    #
+#
-    # Longer test case that ensures locks are reusable. Ordering is
+# Longer test case that ensures locks are reusable. Ordering is
-    # enforced by barriers throughout -- steps are shown with numbers.
+# enforced by barriers throughout -- steps are shown with numbers.
-    #
+#
-    def test_complex_acquire_and_release_chain(self):
+def test_complex_acquire_and_release_chain(lock_path):
     def p1(barrier):
-            lock = Lock(self.lock_path)
+        lock = Lock(lock_path)
 
         lock.acquire_write()
         barrier.wait()  # ---------------------------------------- 1
@@ -310,7 +403,8 @@ def p1(barrier):
         barrier.wait()  # ---------------------------------------- 2
         lock.release_write()   # release and others acquire read
         barrier.wait()  # ---------------------------------------- 3
-            self.assertRaises(LockError, lock.acquire_write, 0.1)
+        with pytest.raises(LockError):
+            lock.acquire_write(0.1)
         lock.acquire_read()
         barrier.wait()  # ---------------------------------------- 4
         lock.release_read()
@@ -318,8 +412,10 @@ def p1(barrier):
 
         # p2 upgrades read to write
         barrier.wait()  # ---------------------------------------- 6
-            self.assertRaises(LockError, lock.acquire_write, 0.1)
+        with pytest.raises(LockError):
-            self.assertRaises(LockError, lock.acquire_read, 0.1)
+            lock.acquire_write(0.1)
+        with pytest.raises(LockError):
+            lock.acquire_read(0.1)
         barrier.wait()  # ---------------------------------------- 7
         # p2 releases write and read
         barrier.wait()  # ---------------------------------------- 8
@@ -328,8 +424,10 @@ def p1(barrier):
         barrier.wait()  # ---------------------------------------- 9
         # p3 upgrades read to write
         barrier.wait()  # ---------------------------------------- 10
-            self.assertRaises(LockError, lock.acquire_write, 0.1)
+        with pytest.raises(LockError):
-            self.assertRaises(LockError, lock.acquire_read, 0.1)
+            lock.acquire_write(0.1)
+        with pytest.raises(LockError):
+            lock.acquire_read(0.1)
         barrier.wait()  # ---------------------------------------- 11
         # p3 releases locks
         barrier.wait()  # ---------------------------------------- 12
@@ -338,12 +436,14 @@ def p1(barrier):
         lock.release_read()
 
     def p2(barrier):
-            lock = Lock(self.lock_path)
+        lock = Lock(lock_path)
 
         # p1 acquires write
         barrier.wait()  # ---------------------------------------- 1
-            self.assertRaises(LockError, lock.acquire_write, 0.1)
+        with pytest.raises(LockError):
-            self.assertRaises(LockError, lock.acquire_read, 0.1)
+            lock.acquire_write(0.1)
+        with pytest.raises(LockError):
+            lock.acquire_read(0.1)
         barrier.wait()  # ---------------------------------------- 2
         lock.acquire_read()
         barrier.wait()  # ---------------------------------------- 3
@@ -364,8 +464,10 @@ def p2(barrier):
         barrier.wait()  # ---------------------------------------- 9
         # p3 upgrades read to write
         barrier.wait()  # ---------------------------------------- 10
-            self.assertRaises(LockError, lock.acquire_write, 0.1)
+        with pytest.raises(LockError):
-            self.assertRaises(LockError, lock.acquire_read, 0.1)
+            lock.acquire_write(0.1)
+        with pytest.raises(LockError):
+            lock.acquire_read(0.1)
         barrier.wait()  # ---------------------------------------- 11
         # p3 releases locks
         barrier.wait()  # ---------------------------------------- 12
@@ -374,12 +476,14 @@ def p2(barrier):
         lock.release_read()
 
     def p3(barrier):
-            lock = Lock(self.lock_path)
+        lock = Lock(lock_path)
 
         # p1 acquires write
         barrier.wait()  # ---------------------------------------- 1
-            self.assertRaises(LockError, lock.acquire_write, 0.1)
+        with pytest.raises(LockError):
-            self.assertRaises(LockError, lock.acquire_read, 0.1)
+            lock.acquire_write(0.1)
+        with pytest.raises(LockError):
+            lock.acquire_read(0.1)
         barrier.wait()  # ---------------------------------------- 2
         lock.acquire_read()
         barrier.wait()  # ---------------------------------------- 3
@@ -390,8 +494,10 @@ def p3(barrier):
 
         # p2 upgrades read to write
         barrier.wait()  # ---------------------------------------- 6
-            self.assertRaises(LockError, lock.acquire_write, 0.1)
+        with pytest.raises(LockError):
-            self.assertRaises(LockError, lock.acquire_read, 0.1)
+            lock.acquire_write(0.1)
+        with pytest.raises(LockError):
+            lock.acquire_read(0.1)
         barrier.wait()  # ---------------------------------------- 7
         # p2 releases write & read
         barrier.wait()  # ---------------------------------------- 8
@@ -409,9 +515,9 @@ def p3(barrier):
         barrier.wait()  # ---------------------------------------- 13
         lock.release_read()
 
-        self.multiproc_test(p1, p2, p3)
+    multiproc_test(p1, p2, p3)
 
-    def test_transaction(self):
+def test_transaction(lock_path):
     def enter_fn():
         vals['entered'] = True
 
@@ -419,24 +525,24 @@ def exit_fn(t, v, tb):
         vals['exited'] = True
         vals['exception'] = (t or v or tb)
 
-        lock = Lock(self.lock_path)
+    lock = Lock(lock_path)
     vals = {'entered': False, 'exited': False, 'exception': False}
     with ReadTransaction(lock, enter_fn, exit_fn):
         pass
 
-        self.assertTrue(vals['entered'])
+    assert vals['entered']
-        self.assertTrue(vals['exited'])
+    assert vals['exited']
-        self.assertFalse(vals['exception'])
+    assert not vals['exception']
 
     vals = {'entered': False, 'exited': False, 'exception': False}
     with WriteTransaction(lock, enter_fn, exit_fn):
         pass
 
-        self.assertTrue(vals['entered'])
+    assert vals['entered']
-        self.assertTrue(vals['exited'])
+    assert vals['exited']
-        self.assertFalse(vals['exception'])
+    assert not vals['exception']
 
-    def test_transaction_with_exception(self):
+def test_transaction_with_exception(lock_path):
     def enter_fn():
         vals['entered'] = True
 
@@ -444,7 +550,7 @@ def exit_fn(t, v, tb):
         vals['exited'] = True
         vals['exception'] = (t or v or tb)
 
-        lock = Lock(self.lock_path)
+    lock = Lock(lock_path)
 
     def do_read_with_exception():
         with ReadTransaction(lock, enter_fn, exit_fn):
@@ -455,18 +561,20 @@ def do_write_with_exception():
             raise Exception()
 
     vals = {'entered': False, 'exited': False, 'exception': False}
-        self.assertRaises(Exception, do_read_with_exception)
+    with pytest.raises(Exception):
-        self.assertTrue(vals['entered'])
+        do_read_with_exception()
-        self.assertTrue(vals['exited'])
+    assert vals['entered']
-        self.assertTrue(vals['exception'])
+    assert vals['exited']
+    assert vals['exception']
 
     vals = {'entered': False, 'exited': False, 'exception': False}
-        self.assertRaises(Exception, do_write_with_exception)
+    with pytest.raises(Exception):
-        self.assertTrue(vals['entered'])
+        do_write_with_exception()
-        self.assertTrue(vals['exited'])
+    assert vals['entered']
-        self.assertTrue(vals['exception'])
+    assert vals['exited']
+    assert vals['exception']
 
-    def test_transaction_with_context_manager(self):
+def test_transaction_with_context_manager(lock_path):
     class TestContextManager(object):
 
         def __enter__(self):
@@ -480,55 +588,54 @@ def exit_fn(t, v, tb):
         vals['exited_fn'] = True
         vals['exception_fn'] = (t or v or tb)
 
-        lock = Lock(self.lock_path)
+    lock = Lock(lock_path)
 
     vals = {'entered': False, 'exited': False, 'exited_fn': False,
             'exception': False, 'exception_fn': False}
     with ReadTransaction(lock, TestContextManager, exit_fn):
         pass
 
-        self.assertTrue(vals['entered'])
+    assert vals['entered']
-        self.assertTrue(vals['exited'])
+    assert vals['exited']
-        self.assertFalse(vals['exception'])
+    assert not vals['exception']
-        self.assertTrue(vals['exited_fn'])
+    assert vals['exited_fn']
-        self.assertFalse(vals['exception_fn'])
+    assert not vals['exception_fn']
 
     vals = {'entered': False, 'exited': False, 'exited_fn': False,
             'exception': False, 'exception_fn': False}
     with ReadTransaction(lock, TestContextManager):
         pass
 
-        self.assertTrue(vals['entered'])
+    assert vals['entered']
-        self.assertTrue(vals['exited'])
+    assert vals['exited']
-        self.assertFalse(vals['exception'])
+    assert not vals['exception']
-        self.assertFalse(vals['exited_fn'])
+    assert not vals['exited_fn']
-        self.assertFalse(vals['exception_fn'])
+    assert not vals['exception_fn']
 
     vals = {'entered': False, 'exited': False, 'exited_fn': False,
             'exception': False, 'exception_fn': False}
     with WriteTransaction(lock, TestContextManager, exit_fn):
         pass
 
-        self.assertTrue(vals['entered'])
+    assert vals['entered']
-        self.assertTrue(vals['exited'])
+    assert vals['exited']
-        self.assertFalse(vals['exception'])
+    assert not vals['exception']
-        self.assertTrue(vals['exited_fn'])
+    assert vals['exited_fn']
-        self.assertFalse(vals['exception_fn'])
+    assert not vals['exception_fn']
 
     vals = {'entered': False, 'exited': False, 'exited_fn': False,
             'exception': False, 'exception_fn': False}
     with WriteTransaction(lock, TestContextManager):
         pass
 
-        self.assertTrue(vals['entered'])
+    assert vals['entered']
-        self.assertTrue(vals['exited'])
+    assert vals['exited']
-        self.assertFalse(vals['exception'])
+    assert not vals['exception']
-        self.assertFalse(vals['exited_fn'])
+    assert not vals['exited_fn']
-        self.assertFalse(vals['exception_fn'])
+    assert not vals['exception_fn']
 
-    def test_transaction_with_context_manager_and_exception(self):
+def test_transaction_with_context_manager_and_exception(lock_path):
     class TestContextManager(object):
-
         def __enter__(self):
             vals['entered'] = True
 
@@ -540,7 +647,7 @@ def exit_fn(t, v, tb):
         vals['exited_fn'] = True
         vals['exception_fn'] = (t or v or tb)
 
-        lock = Lock(self.lock_path)
+    lock = Lock(lock_path)
 
     def do_read_with_exception(exit_fn):
         with ReadTransaction(lock, TestContextManager, exit_fn):
@@ -552,36 +659,40 @@ def do_write_with_exception(exit_fn):
 
     vals = {'entered': False, 'exited': False, 'exited_fn': False,
             'exception': False, 'exception_fn': False}
-        self.assertRaises(Exception, do_read_with_exception, exit_fn)
+    with pytest.raises(Exception):
-        self.assertTrue(vals['entered'])
+        do_read_with_exception(exit_fn)
-        self.assertTrue(vals['exited'])
+    assert vals['entered']
-        self.assertTrue(vals['exception'])
+    assert vals['exited']
-        self.assertTrue(vals['exited_fn'])
+    assert vals['exception']
-        self.assertTrue(vals['exception_fn'])
+    assert vals['exited_fn']
+    assert vals['exception_fn']
 
     vals = {'entered': False, 'exited': False, 'exited_fn': False,
             'exception': False, 'exception_fn': False}
-        self.assertRaises(Exception, do_read_with_exception, None)
+    with pytest.raises(Exception):
-        self.assertTrue(vals['entered'])
+        do_read_with_exception(None)
-        self.assertTrue(vals['exited'])
+    assert vals['entered']
-        self.assertTrue(vals['exception'])
+    assert vals['exited']
-        self.assertFalse(vals['exited_fn'])
+    assert vals['exception']
-        self.assertFalse(vals['exception_fn'])
+    assert not vals['exited_fn']
+    assert not vals['exception_fn']
 
     vals = {'entered': False, 'exited': False, 'exited_fn': False,
             'exception': False, 'exception_fn': False}
-        self.assertRaises(Exception, do_write_with_exception, exit_fn)
+    with pytest.raises(Exception):
-        self.assertTrue(vals['entered'])
+        do_write_with_exception(exit_fn)
-        self.assertTrue(vals['exited'])
+    assert vals['entered']
-        self.assertTrue(vals['exception'])
+    assert vals['exited']
-        self.assertTrue(vals['exited_fn'])
+    assert vals['exception']
-        self.assertTrue(vals['exception_fn'])
+    assert vals['exited_fn']
+    assert vals['exception_fn']
 
     vals = {'entered': False, 'exited': False, 'exited_fn': False,
             'exception': False, 'exception_fn': False}
-        self.assertRaises(Exception, do_write_with_exception, None)
+    with pytest.raises(Exception):
-        self.assertTrue(vals['entered'])
+        do_write_with_exception(None)
-        self.assertTrue(vals['exited'])
+    assert vals['entered']
-        self.assertTrue(vals['exception'])
+    assert vals['exited']
-        self.assertFalse(vals['exited_fn'])
+    assert vals['exception']
-        self.assertFalse(vals['exception_fn'])
+    assert not vals['exited_fn']
+    assert not vals['exception_fn']