feat(test): Move to pytest

1 files changed, 363 insertions, 295 deletions

diff --git a/kazoo/tests/test_client.py b/kazoo/tests/test_client.py
index 32cc0d1..1800c57 100644
--- a/kazoo/tests/test_client.py
+++ b/kazoo/tests/test_client.py
@@ -7,9 +7,7 @@ import unittest
 
 import mock
 from mock import patch
-from nose import SkipTest
-from nose.tools import eq_, ok_, assert_not_equal
-from nose.tools import raises
+import pytest
 
 from kazoo.testing import KazooTestCase
 from kazoo.exceptions import (
@@ -55,77 +53,82 @@ class TestClientTransitions(KazooTestCase):
                 rc.set()
 
         self.client.stop()
-        eq_(states, [KazooState.LOST])
+        assert states == [KazooState.LOST]
         states.pop()
 
         self.client.start()
         rc.wait(2)
-        eq_(states, [KazooState.CONNECTED])
+        assert states == [KazooState.CONNECTED]
         rc.clear()
         states.pop()
         self.expire_session(self.make_event)
         rc.wait(2)
 
         req_states = [KazooState.LOST, KazooState.CONNECTED]
-        eq_(states, req_states)
+        assert states == req_states
 
 
 class TestClientConstructor(unittest.TestCase):
-
     def _makeOne(self, *args, **kw):
         from kazoo.client import KazooClient
+
         return KazooClient(*args, **kw)
 
     def test_invalid_handler(self):
         from kazoo.handlers.threading import SequentialThreadingHandler
-        self.assertRaises(
-            ConfigurationError,
-            self._makeOne, handler=SequentialThreadingHandler)
+
+        with pytest.raises(ConfigurationError):
+            self._makeOne(handler=SequentialThreadingHandler)
 
     def test_chroot(self):
-        self.assertEqual(self._makeOne(hosts='127.0.0.1:2181/').chroot, '')
-        self.assertEqual(self._makeOne(hosts='127.0.0.1:2181/a').chroot, '/a')
-        self.assertEqual(self._makeOne(hosts='127.0.0.1/a').chroot, '/a')
-        self.assertEqual(self._makeOne(hosts='127.0.0.1/a/b').chroot, '/a/b')
-        self.assertEqual(self._makeOne(
-            hosts='127.0.0.1:2181,127.0.0.1:2182/a/b').chroot, '/a/b')
+        assert self._makeOne(hosts='127.0.0.1:2181/').chroot == ''
+        assert self._makeOne(hosts='127.0.0.1:2181/a').chroot == '/a'
+        assert self._makeOne(hosts='127.0.0.1/a').chroot == '/a'
+        assert self._makeOne(hosts='127.0.0.1/a/b').chroot == '/a/b'
+        assert (
+            self._makeOne(hosts='127.0.0.1:2181,127.0.0.1:2182/a/b').chroot
+            == '/a/b'
+        )
 
     def test_connection_timeout(self):
         from kazoo.handlers.threading import KazooTimeoutError
+
         client = self._makeOne(hosts='127.0.0.1:9')
-        self.assertTrue(client.handler.timeout_exception is KazooTimeoutError)
-        self.assertRaises(KazooTimeoutError, client.start, 0.1)
+        assert client.handler.timeout_exception is KazooTimeoutError
+
+        with pytest.raises(KazooTimeoutError):
+            client.start(0.1)
 
     def test_ordered_host_selection(self):
         client = self._makeOne(hosts='127.0.0.1:9,127.0.0.2:9/a',
                                randomize_hosts=False)
         hosts = [h for h in client.hosts]
-        eq_(hosts, [('127.0.0.1', 9), ('127.0.0.2', 9)])
+        assert hosts == [('127.0.0.1', 9), ('127.0.0.2', 9)]
 
     def test_invalid_hostname(self):
         client = self._makeOne(hosts='nosuchhost/a')
         timeout = client.handler.timeout_exception
-        self.assertRaises(timeout, client.start, 0.1)
+        with pytest.raises(timeout):
+            client.start(0.1)
 
     def test_another_invalid_hostname(self):
-        self.assertRaises(
-            ValueError,
-            self._makeOne, hosts='/nosuchhost/a')
+        with pytest.raises(ValueError):
+            self._makeOne(hosts='/nosuchhost/a')
 
     def test_retry_options_dict(self):
         from kazoo.retry import KazooRetry
         client = self._makeOne(command_retry=dict(max_tries=99),
                                connection_retry=dict(delay=99))
-        self.assertTrue(type(client._conn_retry) is KazooRetry)
-        self.assertTrue(type(client._retry) is KazooRetry)
-        eq_(client._retry.max_tries, 99)
-        eq_(client._conn_retry.delay, 99)
+        assert type(client._conn_retry) is KazooRetry
+        assert type(client._retry) is KazooRetry
+        assert client._retry.max_tries == 99
+        assert client._conn_retry.delay == 99
 
 
 class TestAuthentication(KazooTestCase):
-
     def _makeAuth(self, *args, **kwargs):
         from kazoo.security import make_digest_acl
+
         return make_digest_acl(*args, **kwargs)
 
     def test_auth(self):
@@ -146,14 +149,18 @@ class TestAuthentication(KazooTestCase):
             client.ensure_path("/1/2/3")
 
             eve = self._get_client()
+
             eve.start()
 
-            self.assertRaises(NoAuthError, eve.get, "/1/2")
+            with pytest.raises(NoAuthError):
+                eve.get("/1/2")
 
             # try again with the wrong auth token
             eve.add_auth("digest", "badbad:bad")
 
-            self.assertRaises(NoAuthError, eve.get, "/1/2")
+            with pytest.raises(NoAuthError):
+                eve.get("/1/2")
+
         finally:
             # Ensure we remove the ACL protected nodes
             client.delete("/1", recursive=True)
@@ -173,7 +180,10 @@ class TestAuthentication(KazooTestCase):
             client.create('/1', acl=(acl,))
             # give ZK a chance to copy data to other node
             time.sleep(0.1)
-            self.assertRaises(NoAuthError, self.client.get, "/1")
+
+            with pytest.raises(NoAuthError):
+                self.client.get("/1")
+
         finally:
             client.delete('/1')
             client.stop()
@@ -197,12 +207,15 @@ class TestAuthentication(KazooTestCase):
             eve = self._get_client()
             eve.start()
 
-            self.assertRaises(NoAuthError, eve.get, "/1/2")
+            with pytest.raises(NoAuthError):
+                eve.get("/1/2")
 
             # try again with the wrong auth token
             eve.add_auth("digest", "badbad:bad")
 
-            self.assertRaises(NoAuthError, eve.get, "/1/2")
+            with pytest.raises(NoAuthError):
+                eve.get("/1/2")
+
         finally:
             # Ensure we remove the ACL protected nodes
             client.delete("/1", recursive=True)
@@ -212,10 +225,12 @@ class TestAuthentication(KazooTestCase):
     def test_invalid_auth(self):
         client = self._get_client()
         client.start()
-        self.assertRaises(TypeError, client.add_auth,
-                          'digest', ('user', 'pass'))
-        self.assertRaises(TypeError, client.add_auth,
-                          None, ('user', 'pass'))
+
+        with pytest.raises(TypeError):
+            client.add_auth('digest', ('user', 'pass'))
+
+        with pytest.raises(TypeError):
+            client.add_auth(None, ('user', 'pass'))
 
     def test_async_auth(self):
         client = self._get_client()
@@ -224,7 +239,7 @@ class TestAuthentication(KazooTestCase):
         password = uuid.uuid4().hex
         digest_auth = "%s:%s" % (username, password)
         result = client.add_auth_async("digest", digest_auth)
-        self.assertTrue(result.get())
+        assert result.get() is True
 
     def test_async_auth_failure(self):
         client = self._get_client()
@@ -233,8 +248,8 @@ class TestAuthentication(KazooTestCase):
         password = uuid.uuid4().hex
         digest_auth = "%s:%s" % (username, password)
 
-        self.assertRaises(AuthFailedError, client.add_auth,
-                          "unknown-scheme", digest_auth)
+        with pytest.raises(AuthFailedError):
+            client.add_auth("unknown-scheme", digest_auth)
 
     def test_add_auth_on_reconnect(self):
         client = self._get_client()
@@ -243,7 +258,7 @@ class TestAuthentication(KazooTestCase):
         client._connection._socket.shutdown(socket.SHUT_RDWR)
         while not client.connected:
             time.sleep(0.1)
-        self.assertTrue(("digest", "jsmith:jsmith") in client.auth_data)
+        assert ("digest", "jsmith:jsmith") in client.auth_data
 
 
 class TestConnection(KazooTestCase):
@@ -300,6 +315,7 @@ class TestConnection(KazooTestCase):
 
     def test_state_listener(self):
         from kazoo.protocol.states import KazooState
+
         states = []
         condition = self.make_condition()
 
@@ -309,7 +325,7 @@ class TestConnection(KazooTestCase):
                 condition.notify_all()
 
         self.client.stop()
-        eq_(self.client.state, KazooState.LOST)
+        assert self.client.state == KazooState.LOST
         self.client.add_listener(listener)
         self.client.start(5)
 
@@ -317,15 +333,17 @@ class TestConnection(KazooTestCase):
             if not states:
                 condition.wait(5)
 
-        eq_(len(states), 1)
-        eq_(states[0], KazooState.CONNECTED)
+        assert len(states) == 1
+        assert states[0] == KazooState.CONNECTED
 
     def test_invalid_listener(self):
-        self.assertRaises(ConfigurationError, self.client.add_listener, 15)
+        with pytest.raises(ConfigurationError):
+            self.client.add_listener(15)
 
     def test_listener_only_called_on_real_state_change(self):
         from kazoo.protocol.states import KazooState
-        self.assertTrue(self.client.state, KazooState.CONNECTED)
+
+        assert self.client.state == KazooState.CONNECTED
         called = [False]
         condition = self.make_event()
 
@@ -336,14 +354,16 @@ class TestConnection(KazooTestCase):
         self.client.add_listener(listener)
         self.client._make_state_change(KazooState.CONNECTED)
         condition.wait(3)
-        self.assertFalse(called[0])
+        assert called[0] is False
 
     def test_no_connection(self):
         client = self.client
         client.stop()
-        self.assertFalse(client.connected)
-        self.assertTrue(client.client_id is None)
-        self.assertRaises(ConnectionClosedError, client.exists, '/')
+        assert client.connected is False
+        assert client.client_id is None
+
+        with pytest.raises(ConnectionClosedError):
+            client.exists('/')
 
     def test_close_connecting_connection(self):
         client = self.client
@@ -367,24 +387,24 @@ class TestConnection(KazooTestCase):
         # ...and then wait until the connection is lost
         ev.wait(5)
 
-        self.assertRaises(ConnectionClosedError,
-                          self.client.create, '/foobar')
+        with pytest.raises(ConnectionClosedError):
+            self.client.create('/foobar')
 
     def test_double_start(self):
-        self.assertTrue(self.client.connected)
+        assert self.client.connected is True
         self.client.start()
-        self.assertTrue(self.client.connected)
+        assert self.client.connected is True
 
     def test_double_stop(self):
         self.client.stop()
-        self.assertFalse(self.client.connected)
+        assert self.client.connected is False
         self.client.stop()
-        self.assertFalse(self.client.connected)
+        assert self.client.connected is False
 
     def test_restart(self):
-        self.assertTrue(self.client.connected)
+        assert self.client.connected is True
         self.client.restart()
-        self.assertTrue(self.client.connected)
+        assert self.client.connected is True
 
     def test_closed(self):
         client = self.client
@@ -394,20 +414,24 @@ class TestConnection(KazooTestCase):
 
         # close the connection to free the socket
         client.close()
-        eq_(client._connection._write_sock, None)
+        assert client._connection._write_sock is None
 
         # sneak in and patch client to simulate race between a thread
         # calling stop(); close() and one running a command
         oldstate = client._state
         client._state = KeeperState.CONNECTED
         client._connection._write_sock = write_sock
+
         try:
             # simulate call made after write socket is closed
-            self.assertRaises(ConnectionClosedError, client.exists, '/')
+            with pytest.raises(ConnectionClosedError):
+                client.exists('/')
 
             # simulate call made after write socket is set to None
             client._connection._write_sock = None
-            self.assertRaises(ConnectionClosedError, client.exists, '/')
+
+            with pytest.raises(ConnectionClosedError):
+                client.exists('/')
 
         finally:
             # reset for teardown
@@ -433,10 +457,12 @@ class TestConnection(KazooTestCase):
 class TestClient(KazooTestCase):
     def _makeOne(self, *args):
         from kazoo.handlers.threading import SequentialThreadingHandler
+
         return SequentialThreadingHandler(*args)
 
     def _getKazooState(self):
         from kazoo.protocol.states import KazooState
+
         return KazooState
 
     def test_server_version_retries_fail(self):
@@ -449,9 +475,8 @@ class TestClient(KazooTestCase):
         ]
         client.command = mock.MagicMock()
         client.command.side_effect = side_effects
-        self.assertRaises(KazooException,
-                          client.server_version,
-                          retries=len(side_effects) - 1)
+        with pytest.raises(KazooException):
+            client.server_version(retries=len(side_effects) - 1)
 
     def test_server_version_retries_eventually_ok(self):
         client = self.client
@@ -461,106 +486,120 @@ class TestClient(KazooTestCase):
             side_effects.append(actual_version[0:i])
         client.command = mock.MagicMock()
         client.command.side_effect = side_effects
-        self.assertEqual((1, 2),
-                         client.server_version(retries=len(side_effects) - 1))
+        assert client.server_version(retries=len(side_effects) - 1) == (1, 2)
 
     def test_client_id(self):
         client_id = self.client.client_id
-        self.assertEqual(type(client_id), tuple)
+        assert type(client_id) is tuple
         # make sure password is of correct length
-        self.assertEqual(len(client_id[1]), 16)
+        assert len(client_id[1]) == 16
 
     def test_connected(self):
         client = self.client
-        self.assertTrue(client.connected)
+        assert client.connected
 
     def test_create(self):
         client = self.client
         path = client.create("/1")
-        eq_(path, "/1")
-        self.assertTrue(client.exists("/1"))
+        assert path == "/1"
+        assert client.exists("/1")
 
     def test_create_on_broken_connection(self):
         client = self.client
         client.start()
 
         client._state = KeeperState.EXPIRED_SESSION
-        self.assertRaises(SessionExpiredError, client.create,
-                          '/closedpath', b'bar')
+        with pytest.raises(SessionExpiredError):
+            client.create('/closedpath', b'bar')
 
         client._state = KeeperState.AUTH_FAILED
-        self.assertRaises(AuthFailedError, client.create,
-                          '/closedpath', b'bar')
+        with pytest.raises(AuthFailedError):
+            client.create('/closedpath', b'bar')
 
         client.stop()
         client.close()
 
-        self.assertRaises(ConnectionClosedError, client.create,
-                          '/closedpath', b'bar')
+        with pytest.raises(ConnectionClosedError):
+            client.create('/closedpath', b'bar')
 
     def test_create_null_data(self):
         client = self.client
         client.create("/nulldata", None)
         value, _ = client.get("/nulldata")
-        self.assertEqual(value, None)
+        assert value is None
 
     def test_create_empty_string(self):
         client = self.client
         client.create("/empty", b"")
         value, _ = client.get("/empty")
-        eq_(value, b"")
+        assert value == b""
 
     def test_create_unicode_path(self):
         client = self.client
         path = client.create(u("/ascii"))
-        eq_(path, u("/ascii"))
+        assert path == u("/ascii")
         path = client.create(u("/\xe4hm"))
-        eq_(path, u("/\xe4hm"))
+        assert path == u("/\xe4hm")
 
     def test_create_async_returns_unchrooted_path(self):
         client = self.client
         path = client.create_async('/1').get()
-        eq_(path, "/1")
+        assert path == "/1"
 
     def test_create_invalid_path(self):
         client = self.client
-        self.assertRaises(TypeError, client.create, ('a', ))
-        self.assertRaises(ValueError, client.create, ".")
-        self.assertRaises(ValueError, client.create, "/a/../b")
-        self.assertRaises(BadArgumentsError, client.create, "/b\x00")
-        self.assertRaises(BadArgumentsError, client.create, "/b\x1e")
+        with pytest.raises(TypeError):
+            client.create(('a',))
+        with pytest.raises(ValueError):
+            client.create(".")
+        with pytest.raises(ValueError):
+            client.create("/a/../b")
+        with pytest.raises(BadArgumentsError):
+            client.create("/b\x00")
+        with pytest.raises(BadArgumentsError):
+            client.create("/b\x1e")
 
     def test_create_invalid_arguments(self):
         from kazoo.security import OPEN_ACL_UNSAFE
+
         single_acl = OPEN_ACL_UNSAFE[0]
         client = self.client
-        self.assertRaises(TypeError, client.create, 'a', acl='all')
-        self.assertRaises(TypeError, client.create, 'a', acl=single_acl)
-        self.assertRaises(TypeError, client.create, 'a', value=['a'])
-        self.assertRaises(TypeError, client.create, 'a', ephemeral='yes')
-        self.assertRaises(TypeError, client.create, 'a', sequence='yes')
-        self.assertRaises(TypeError, client.create, 'a', makepath='yes')
+        with pytest.raises(TypeError):
+            client.create('a', acl='all')
+        with pytest.raises(TypeError):
+            client.create('a', acl=single_acl)
+        with pytest.raises(TypeError):
+            client.create('a', value=['a'])
+        with pytest.raises(TypeError):
+            client.create('a', ephemeral='yes')
+        with pytest.raises(TypeError):
+            client.create('a', sequence='yes')
+        with pytest.raises(TypeError):
+            client.create('a', makepath='yes')
 
     def test_create_value(self):
         client = self.client
         client.create("/1", b"bytes")
         data, stat = client.get("/1")
-        eq_(data, b"bytes")
+        assert data == b"bytes"
 
     def test_create_unicode_value(self):
         client = self.client
-        self.assertRaises(TypeError, client.create, "/1", u("\xe4hm"))
+        with pytest.raises(TypeError):
+            client.create("/1", u("\xe4hm"))
 
     def test_create_large_value(self):
         client = self.client
         kb_512 = b"a" * (512 * 1024)
         client.create("/1", kb_512)
-        self.assertTrue(client.exists("/1"))
+        assert client.exists("/1")
         mb_2 = b"a" * (2 * 1024 * 1024)
-        self.assertRaises(ConnectionLoss, client.create, "/2", mb_2)
+        with pytest.raises(ConnectionLoss):
+            client.create("/2", mb_2)
 
     def test_create_acl_duplicate(self):
         from kazoo.security import OPEN_ACL_UNSAFE
+
         single_acl = OPEN_ACL_UNSAFE[0]
         client = self.client
         client.create("/1", acl=[single_acl, single_acl])
@@ -570,107 +609,113 @@ class TestClient(KazooTestCase):
             version = TRAVIS_ZK_VERSION
         else:
             version = client.server_version()
-        self.assertEqual(len(acls), 1 if version > (3, 4) else 2)
+        assert len(acls) == 1 if version > (3, 4) else 2
 
     def test_create_acl_empty_list(self):
         from kazoo.security import OPEN_ACL_UNSAFE
+
         client = self.client
         client.create("/1", acl=[])
         acls, stat = client.get_acls("/1")
-        self.assertEqual(acls, OPEN_ACL_UNSAFE)
+        assert acls == OPEN_ACL_UNSAFE
 
     def test_version_no_connection(self):
-        @raises(ConnectionLoss)
-        def testit():
-            self.client.server_version()
         self.client.stop()
-        testit()
+        with pytest.raises(ConnectionLoss):
+            self.client.server_version()
 
     def test_create_ephemeral(self):
         client = self.client
         client.create("/1", b"ephemeral", ephemeral=True)
         data, stat = client.get("/1")
-        eq_(data, b"ephemeral")
-        eq_(stat.ephemeralOwner, client.client_id[0])
+        assert data == b"ephemeral"
+        assert stat.ephemeralOwner == client.client_id[0]
 
     def test_create_no_ephemeral(self):
         client = self.client
         client.create("/1", b"val1")
         data, stat = client.get("/1")
-        self.assertFalse(stat.ephemeralOwner)
+        assert not stat.ephemeralOwner
 
     def test_create_ephemeral_no_children(self):
         from kazoo.exceptions import NoChildrenForEphemeralsError
+
         client = self.client
         client.create("/1", b"ephemeral", ephemeral=True)
-        self.assertRaises(NoChildrenForEphemeralsError,
-                          client.create, "/1/2", b"val1")
-        self.assertRaises(NoChildrenForEphemeralsError,
-                          client.create, "/1/2", b"val1", ephemeral=True)
+        with pytest.raises(NoChildrenForEphemeralsError):
+            client.create("/1/2", b"val1")
+        with pytest.raises(NoChildrenForEphemeralsError):
+            client.create("/1/2", b"val1", ephemeral=True)
 
     def test_create_sequence(self):
         client = self.client
         client.create("/folder")
         path = client.create("/folder/a", b"sequence", sequence=True)
-        eq_(path, "/folder/a0000000000")
+        assert path == "/folder/a0000000000"
         path2 = client.create("/folder/a", b"sequence", sequence=True)
-        eq_(path2, "/folder/a0000000001")
+        assert path2 == "/folder/a0000000001"
         path3 = client.create("/folder/", b"sequence", sequence=True)
-        eq_(path3, "/folder/0000000002")
+        assert path3 == "/folder/0000000002"
 
     def test_create_ephemeral_sequence(self):
         basepath = "/" + uuid.uuid4().hex
         realpath = self.client.create(basepath, b"sandwich",
                                       sequence=True, ephemeral=True)
-        self.assertTrue(basepath != realpath and realpath.startswith(basepath))
+        assert basepath != realpath and realpath.startswith(basepath)
         data, stat = self.client.get(realpath)
-        eq_(data, b"sandwich")
+        assert data == b"sandwich"
 
     def test_create_makepath(self):
         self.client.create("/1/2", b"val1", makepath=True)
         data, stat = self.client.get("/1/2")
-        eq_(data, b"val1")
+        assert data == b"val1"
 
         self.client.create("/1/2/3/4/5", b"val2", makepath=True)
         data, stat = self.client.get("/1/2/3/4/5")
-        eq_(data, b"val2")
+        assert data == b"val2"
 
-        self.assertRaises(NodeExistsError, self.client.create,
-                          "/1/2/3/4/5", b"val2", makepath=True)
+        with pytest.raises(NodeExistsError):
+            self.client.create("/1/2/3/4/5", b"val2", makepath=True)
 
     def test_create_makepath_incompatible_acls(self):
         from kazoo.client import KazooClient
         from kazoo.security import make_digest_acl_credential, CREATOR_ALL_ACL
+
         credential = make_digest_acl_credential("username", "password")
         alt_client = KazooClient(
             self.cluster[0].address + self.client.chroot,
-            max_retries=5, auth_data=[("digest", credential)],
-            handler=self._makeOne())
+            max_retries=5,
+            auth_data=[("digest", credential)],
+            handler=self._makeOne(),
+        )
         alt_client.start()
         alt_client.create("/1/2", b"val2", makepath=True, acl=CREATOR_ALL_ACL)
 
         try:
-            self.assertRaises(NoAuthError, self.client.create,
-                              "/1/2/3/4/5", b"val2", makepath=True)
+            with pytest.raises(NoAuthError):
+                self.client.create("/1/2/3/4/5", b"val2", makepath=True)
+
         finally:
             alt_client.delete('/', recursive=True)
             alt_client.stop()
 
     def test_create_no_makepath(self):
-        self.assertRaises(NoNodeError, self.client.create,
-                          "/1/2", b"val1")
-        self.assertRaises(NoNodeError, self.client.create,
-                          "/1/2", b"val1", makepath=False)
+        with pytest.raises(NoNodeError):
+            self.client.create("/1/2", b"val1")
+        with pytest.raises(NoNodeError):
+            self.client.create("/1/2", b"val1", makepath=False)
 
         self.client.create("/1/2", b"val1", makepath=True)
-        self.assertRaises(NoNodeError, self.client.create,
-                          "/1/2/3/4", b"val1", makepath=False)
+        with pytest.raises(NoNodeError):
+            self.client.create("/1/2/3/4", b"val1", makepath=False)
 
     def test_create_exists(self):
         from kazoo.exceptions import NodeExistsError
+
         client = self.client
         path = client.create("/1")
-        self.assertRaises(NodeExistsError, client.create, path)
+        with pytest.raises(NodeExistsError):
+            client.create(path)
 
     def test_create_stat(self):
         if TRAVIS_ZK_VERSION:
@@ -678,12 +723,12 @@ class TestClient(KazooTestCase):
         else:
             version = self.client.server_version()
         if not version or version < (3, 5):
-            raise SkipTest("Must use Zookeeper 3.5 or above")
+            pytest.skip("Must use Zookeeper 3.5 or above")
         client = self.client
         path, stat1 = client.create("/1", b"bytes", include_data=True)
         data, stat2 = client.get("/1")
-        eq_(data, b"bytes")
-        eq_(stat1, stat2)
+        assert data == b"bytes"
+        assert stat1 == stat2
 
     def test_create_get_set(self):
         nodepath = "/" + uuid.uuid4().hex
@@ -691,80 +736,86 @@ class TestClient(KazooTestCase):
         self.client.create(nodepath, b"sandwich", ephemeral=True)
 
         data, stat = self.client.get(nodepath)
-        eq_(data, b"sandwich")
+        assert data == b"sandwich"
 
         newstat = self.client.set(nodepath, b"hats", stat.version)
-        self.assertTrue(newstat)
+        assert newstat
         assert newstat.version > stat.version
 
         # Some other checks of the ZnodeStat object we got
-        eq_(newstat.acl_version, stat.acl_version)
-        eq_(newstat.created, stat.ctime / 1000.0)
-        eq_(newstat.last_modified, newstat.mtime / 1000.0)
-        eq_(newstat.owner_session_id, stat.ephemeralOwner)
-        eq_(newstat.creation_transaction_id, stat.czxid)
-        eq_(newstat.last_modified_transaction_id, newstat.mzxid)
-        eq_(newstat.data_length, newstat.dataLength)
-        eq_(newstat.children_count, stat.numChildren)
-        eq_(newstat.children_version, stat.cversion)
+        assert newstat.acl_version == stat.acl_version
+        assert newstat.created == stat.ctime / 1000.0
+        assert newstat.last_modified == newstat.mtime / 1000.0
+        assert newstat.owner_session_id == stat.ephemeralOwner
+        assert newstat.creation_transaction_id == stat.czxid
+        assert newstat.last_modified_transaction_id == newstat.mzxid
+        assert newstat.data_length == newstat.dataLength
+        assert newstat.children_count == stat.numChildren
+        assert newstat.children_version == stat.cversion
 
     def test_get_invalid_arguments(self):
         client = self.client
-        self.assertRaises(TypeError, client.get, ('a', 'b'))
-        self.assertRaises(TypeError, client.get, 'a', watch=True)
+        with pytest.raises(TypeError):
+            client.get(('a', 'b'))
+        with pytest.raises(TypeError):
+            client.get('a', watch=True)
 
     def test_bad_argument(self):
         client = self.client
         client.ensure_path("/1")
-        self.assertRaises(TypeError, self.client.set, "/1", 1)
+        with pytest.raises(TypeError):
+            self.client.set("/1", 1)
 
     def test_ensure_path(self):
         client = self.client
         client.ensure_path("/1/2")
-        self.assertTrue(client.exists("/1/2"))
+        assert client.exists("/1/2")
 
         client.ensure_path("/1/2/3/4")
-        self.assertTrue(client.exists("/1/2/3/4"))
+        assert client.exists("/1/2/3/4")
 
+    @pytest.mark.skip("BUG: sync() call is not chroot'd")
     def test_sync(self):
         client = self.client
-        self.assertTrue(client.sync('/'), '/')
+        assert client.sync('/') == '/'
 
     def test_exists(self):
         nodepath = "/" + uuid.uuid4().hex
 
         exists = self.client.exists(nodepath)
-        eq_(exists, None)
+        assert exists is None
 
         self.client.create(nodepath, b"sandwich", ephemeral=True)
         exists = self.client.exists(nodepath)
-        self.assertTrue(exists)
+        assert exists
         assert isinstance(exists.version, int)
 
         multi_node_nonexistent = "/" + uuid.uuid4().hex + "/hats"
         exists = self.client.exists(multi_node_nonexistent)
-        eq_(exists, None)
+        assert exists is None
 
     def test_exists_invalid_arguments(self):
         client = self.client
-        self.assertRaises(TypeError, client.exists, ('a', 'b'))
-        self.assertRaises(TypeError, client.exists, 'a', watch=True)
+        with pytest.raises(TypeError):
+            client.exists(('a', 'b'))
+        with pytest.raises(TypeError):
+            client.exists('a', watch=True)
 
     def test_exists_watch(self):
         nodepath = "/" + uuid.uuid4().hex
         event = self.client.handler.event_object()
 
         def w(watch_event):
-            eq_(watch_event.path, nodepath)
+            assert watch_event.path == nodepath
             event.set()
 
         exists = self.client.exists(nodepath, watch=w)
-        eq_(exists, None)
+        assert exists is None
 
         self.client.create(nodepath, ephemeral=True)
 
         event.wait(1)
-        self.assertTrue(event.is_set())
+        assert event.is_set() is True
 
     def test_exists_watcher_exception(self):
         nodepath = "/" + uuid.uuid4().hex
@@ -772,18 +823,18 @@ class TestClient(KazooTestCase):
 
         # if the watcher throws an exception, all we can really do is log it
         def w(watch_event):
-            eq_(watch_event.path, nodepath)
+            assert watch_event.path == nodepath
             event.set()
 
             raise Exception("test exception in callback")
 
         exists = self.client.exists(nodepath, watch=w)
-        eq_(exists, None)
+        assert exists is None
 
         self.client.create(nodepath, ephemeral=True)
 
         event.wait(1)
-        self.assertTrue(event.is_set())
+        assert event.is_set() is True
 
     def test_create_delete(self):
         nodepath = "/" + uuid.uuid4().hex
@@ -793,10 +844,11 @@ class TestClient(KazooTestCase):
         self.client.delete(nodepath)
 
         exists = self.client.exists(nodepath)
-        eq_(exists, None)
+        assert exists is None
 
     def test_get_acls(self):
         from kazoo.security import make_digest_acl
+
         user = 'user'
         passw = 'pass'
         acl = make_digest_acl(user, passw, all=True)
@@ -804,16 +856,18 @@ class TestClient(KazooTestCase):
         try:
             client.create('/a', acl=[acl])
             client.add_auth('digest', '{}:{}'.format(user, passw))
-            self.assertTrue(acl in client.get_acls('/a')[0])
+            assert acl in client.get_acls('/a')[0]
         finally:
             client.delete('/a')
 
     def test_get_acls_invalid_arguments(self):
         client = self.client
-        self.assertRaises(TypeError, client.get_acls, ('a', 'b'))
+        with pytest.raises(TypeError):
+            client.get_acls(('a', 'b'))
 
     def test_set_acls(self):
         from kazoo.security import make_digest_acl
+
         user = 'user'
         passw = 'pass'
         acl = make_digest_acl(user, passw, all=True)
@@ -822,64 +876,75 @@ class TestClient(KazooTestCase):
         try:
             client.set_acls('/a', [acl])
             client.add_auth('digest', '{}:{}'.format(user, passw))
-            self.assertTrue(acl in client.get_acls('/a')[0])
+            assert acl in client.get_acls('/a')[0]
         finally:
             client.delete('/a')
 
     def test_set_acls_empty(self):
         client = self.client
         client.create('/a')
-        self.assertRaises(InvalidACLError, client.set_acls, '/a', [])
+        with pytest.raises(InvalidACLError):
+            client.set_acls('/a', [])
 
     def test_set_acls_no_node(self):
         from kazoo.security import OPEN_ACL_UNSAFE
+
         client = self.client
-        self.assertRaises(NoNodeError, client.set_acls, '/a', OPEN_ACL_UNSAFE)
+        with pytest.raises(NoNodeError):
+            client.set_acls('/a', OPEN_ACL_UNSAFE)
 
     def test_set_acls_invalid_arguments(self):
         from kazoo.security import OPEN_ACL_UNSAFE
+
         single_acl = OPEN_ACL_UNSAFE[0]
         client = self.client
-        self.assertRaises(TypeError, client.set_acls, ('a', 'b'), ())
-        self.assertRaises(TypeError, client.set_acls, 'a', single_acl)
-        self.assertRaises(TypeError, client.set_acls, 'a', 'all')
-        self.assertRaises(TypeError, client.set_acls, 'a', [single_acl], 'V1')
+        with pytest.raises(TypeError):
+            client.set_acls(('a', 'b'), ())
+        with pytest.raises(TypeError):
+            client.set_acls('a', single_acl)
+        with pytest.raises(TypeError):
+            client.set_acls('a', 'all')
+        with pytest.raises(TypeError):
+            client.set_acls('a', [single_acl], 'V1')
 
     def test_set(self):
         client = self.client
         client.create('a', b'first')
         stat = client.set('a', b'second')
         data, stat2 = client.get('a')
-        self.assertEqual(data, b'second')
-        self.assertEqual(stat, stat2)
+        assert data == b'second'
+        assert stat == stat2
 
     def test_set_null_data(self):
         client = self.client
         client.create("/nulldata", b"not none")
         client.set("/nulldata", None)
         value, _ = client.get("/nulldata")
-        self.assertEqual(value, None)
+        assert value is None
 
     def test_set_empty_string(self):
         client = self.client
         client.create("/empty", b"not empty")
         client.set("/empty", b"")
         value, _ = client.get("/empty")
-        eq_(value, b"")
+        assert value == b""
 
     def test_set_invalid_arguments(self):
         client = self.client
         client.create('a', b'first')
-        self.assertRaises(TypeError, client.set, ('a', 'b'), b'value')
-        self.assertRaises(TypeError, client.set, 'a', ['v', 'w'])
-        self.assertRaises(TypeError, client.set, 'a', b'value', 'V1')
+        with pytest.raises(TypeError):
+            client.set(('a', 'b'), b'value')
+        with pytest.raises(TypeError):
+            client.set('a', ['v', 'w'])
+        with pytest.raises(TypeError):
+            client.set('a', b'value', 'V1')
 
     def test_delete(self):
         client = self.client
         client.ensure_path('/a/b')
-        self.assertTrue('b' in client.get_children('a'))
+        assert 'b' in client.get_children('a')
         client.delete('/a/b')
-        self.assertFalse('b' in client.get_children('a'))
+        assert 'b' not in client.get_children('a')
 
     def test_delete_recursive(self):
         client = self.client
@@ -887,30 +952,33 @@ class TestClient(KazooTestCase):
         client.ensure_path('/a/b/d')
         client.delete('/a/b', recursive=True)
         client.delete('/a/b/c', recursive=True)
-        self.assertFalse('b' in client.get_children('a'))
+        assert 'b' not in client.get_children('a')
 
     def test_delete_invalid_arguments(self):
         client = self.client
         client.ensure_path('/a/b')
-        self.assertRaises(TypeError, client.delete, '/a/b', recursive='all')
-        self.assertRaises(TypeError, client.delete, ('a', 'b'))
-        self.assertRaises(TypeError, client.delete, '/a/b', version='V1')
+        with pytest.raises(TypeError):
+            client.delete('/a/b', recursive='all')
+        with pytest.raises(TypeError):
+            client.delete(('a', 'b'))
+        with pytest.raises(TypeError):
+            client.delete('/a/b', version='V1')
 
     def test_get_children(self):
         client = self.client
         client.ensure_path('/a/b/c')
         client.ensure_path('/a/b/d')
-        self.assertEqual(client.get_children('/a'), ['b'])
-        self.assertEqual(set(client.get_children('/a/b')), set(['c', 'd']))
-        self.assertEqual(client.get_children('/a/b/c'), [])
+        assert client.get_children('/a') == ['b']
+        assert set(client.get_children('/a/b')) == set(['c', 'd'])
+        assert client.get_children('/a/b/c') == []
 
     def test_get_children2(self):
         client = self.client
         client.ensure_path('/a/b')
         children, stat = client.get_children('/a', include_data=True)
         value, stat2 = client.get('/a')
-        self.assertEqual(children, ['b'])
-        self.assertEqual(stat2.version, stat.version)
+        assert children == ['b']
+        assert stat2.version == stat.version
 
     def test_get_children2_many_nodes(self):
         client = self.client
@@ -919,25 +987,29 @@ class TestClient(KazooTestCase):
         client.ensure_path('/a/d')
         children, stat = client.get_children('/a', include_data=True)
         value, stat2 = client.get('/a')
-        self.assertEqual(set(children), set(['b', 'c', 'd']))
-        self.assertEqual(stat2.version, stat.version)
+        assert set(children) == set(['b', 'c', 'd'])
+        assert stat2.version == stat.version
 
     def test_get_children_no_node(self):
         client = self.client
-        self.assertRaises(NoNodeError, client.get_children, '/none')
-        self.assertRaises(NoNodeError, client.get_children,
-                          '/none', include_data=True)
+        with pytest.raises(NoNodeError):
+            client.get_children('/none')
+        with pytest.raises(NoNodeError):
+            client.get_children('/none', include_data=True)
 
     def test_get_children_invalid_path(self):
         client = self.client
-        self.assertRaises(ValueError, client.get_children, '../a')
+        with pytest.raises(ValueError):
+            client.get_children('../a')
 
     def test_get_children_invalid_arguments(self):
         client = self.client
-        self.assertRaises(TypeError, client.get_children, ('a', 'b'))
-        self.assertRaises(TypeError, client.get_children, 'a', watch=True)
-        self.assertRaises(TypeError, client.get_children,
-                          'a', include_data='yes')
+        with pytest.raises(TypeError):
+            client.get_children(('a', 'b'))
+        with pytest.raises(TypeError):
+            client.get_children('a', watch=True)
+        with pytest.raises(TypeError):
+            client.get_children('a', include_data='yes')
 
     def test_invalid_auth(self):
         from kazoo.exceptions import AuthFailedError
@@ -947,26 +1019,26 @@ class TestClient(KazooTestCase):
         client.stop()
         client._state = KeeperState.AUTH_FAILED
 
-        @raises(AuthFailedError)
-        def testit():
+        with pytest.raises(AuthFailedError):
             client.get('/')
-        testit()
 
     def test_client_state(self):
         from kazoo.protocol.states import KeeperState
-        eq_(self.client.client_state, KeeperState.CONNECTED)
+
+        assert self.client.client_state == KeeperState.CONNECTED
 
     def test_update_host_list(self):
         from kazoo.client import KazooClient
         from kazoo.protocol.states import KeeperState
+
         hosts = self.cluster[0].address
         # create a client with only one server in its list
         client = KazooClient(hosts=hosts)
         client.start()
 
         # try to change the chroot, not currently allowed
-        self.assertRaises(ConfigurationError,
-                          client.set_hosts, hosts + '/new_chroot')
+        with pytest.raises(ConfigurationError):
+            client.set_hosts(hosts + '/new_chroot')
 
         # grow the cluster to 3
         client.set_hosts(self.servers)
@@ -975,13 +1047,14 @@ class TestClient(KazooTestCase):
         try:
             self.cluster[0].stop()
             time.sleep(5)
-            eq_(client.client_state, KeeperState.CONNECTED)
+            assert client.client_state == KeeperState.CONNECTED
         finally:
             self.cluster[0].run()
 
     # utility for test_request_queuing*
     def _make_request_queuing_client(self):
         from kazoo.client import KazooClient
+
         server = self.cluster[0]
         handler = self._makeOne()
         # create a client with only one server in its list, and
@@ -994,8 +1067,8 @@ class TestClient(KazooTestCase):
                 delay=0.1,
                 backoff=1,
                 max_jitter=0.0,
-                sleep_func=handler.sleep_func
-            )
+                sleep_func=handler.sleep_func,
+            ),
         )
 
         return client, server
@@ -1010,6 +1083,7 @@ class TestClient(KazooTestCase):
                 ev_suspended.set()
             elif state == KazooState.CONNECTED:
                 ev_connected.set()
+
         client.add_listener(listener)
 
         # wait for the client to connect
@@ -1020,14 +1094,14 @@ class TestClient(KazooTestCase):
             server.stop()
 
             ev_suspended.wait(5)
-            ok_(ev_suspended.is_set())
+            assert ev_suspended.is_set()
             ev_connected.clear()
 
             # submit a request, expecting it to be queued
             result = client.create_async(path)
-            assert_not_equal(len(client._queue), 0)
-            eq_(result.ready(), False)
-            eq_(client.state, KazooState.SUSPENDED)
+            assert len(client._queue) != 0
+            assert result.ready() is False
+            assert client.state == KazooState.SUSPENDED
 
             # optionally cause a SessionExpiredError to occur by
             # mangling the first byte of the session password.
@@ -1042,7 +1116,7 @@ class TestClient(KazooTestCase):
         # wait for the client to reconnect (either with a recovered
         # session, or with a new one if expire_session was set)
         ev_connected.wait(5)
-        ok_(ev_connected.is_set())
+        assert ev_connected.is_set()
 
         return result
 
@@ -1058,8 +1132,8 @@ class TestClient(KazooTestCase):
                 expire_session=False
             )
 
-            eq_(result.get(), path)
-            assert_not_equal(client.exists(path), None)
+            assert result.get() == path
+            assert client.exists(path) is not None
         finally:
             client.stop()
 
@@ -1075,21 +1149,29 @@ class TestClient(KazooTestCase):
                 expire_session=True
             )
 
-            eq_(len(client._queue), 0)
-            self.assertRaises(SessionExpiredError, result.get)
+            assert len(client._queue) == 0
+            with pytest.raises(SessionExpiredError):
+                result.get()
         finally:
             client.stop()
 
 
 dummy_dict = {
-    'aversion': 1, 'ctime': 0, 'cversion': 1,
-    'czxid': 110, 'dataLength': 1, 'ephemeralOwner': 'ben',
-    'mtime': 1, 'mzxid': 1, 'numChildren': 0, 'pzxid': 1, 'version': 1
+    'aversion': 1,
+    'ctime': 0,
+    'cversion': 1,
+    'czxid': 110,
+    'dataLength': 1,
+    'ephemeralOwner': 'ben',
+    'mtime': 1,
+    'mzxid': 1,
+    'numChildren': 0,
+    'pzxid': 1,
+    'version': 1,
 }
 
 
 class TestClientTransactions(KazooTestCase):
-
     def setUp(self):
         KazooTestCase.setUp(self)
         skip = False
@@ -1102,7 +1184,7 @@ class TestClientTransactions(KazooTestCase):
             if ver[1] < 4:
                 skip = True
         if skip:
-            raise SkipTest("Must use Zookeeper 3.4 or above")
+            pytest.skip("Must use Zookeeper 3.4 or above")
 
     def test_basic_create(self):
         t = self.client.transaction()
@@ -1110,25 +1192,23 @@ class TestClientTransactions(KazooTestCase):
         t.create('/fred', ephemeral=True)
         t.create('/smith', sequence=True)
         results = t.commit()
-        eq_(len(results), 3)
-        eq_(results[0], '/freddy')
-        self.assertTrue(results[2].startswith('/smith0'))
+        assert len(results) == 3
+        assert results[0] == '/freddy'
+        assert results[2].startswith('/smith0') is True
 
     def test_bad_creates(self):
         args_list = [(True,), ('/smith', 0), ('/smith', b'', 'bleh'),
                      ('/smith', b'', None, 'fred'),
                      ('/smith', b'', None, True, 'fred')]
 
-        @raises(TypeError)
-        def testit(args):
-            t = self.client.transaction()
-            t.create(*args)
-
         for args in args_list:
-            testit(args)
+            with pytest.raises(TypeError):
+                t = self.client.transaction()
+                t.create(*args)
 
     def test_default_acl(self):
         from kazoo.security import make_digest_acl
+
         username = uuid.uuid4().hex
         password = uuid.uuid4().hex
 
@@ -1141,25 +1221,22 @@ class TestClientTransactions(KazooTestCase):
         t = self.client.transaction()
         t.create('/freddy')
         results = t.commit()
-        eq_(results[0], '/freddy')
+        assert results[0] == '/freddy'
 
     def test_basic_delete(self):
         self.client.create('/fred')
         t = self.client.transaction()
         t.delete('/fred')
         results = t.commit()
-        eq_(results[0], True)
+        assert results[0] is True
 
     def test_bad_deletes(self):
         args_list = [(True,), ('/smith', 'woops'), ]
 
-        @raises(TypeError)
-        def testit(args):
-            t = self.client.transaction()
-            t.delete(*args)
-
         for args in args_list:
-            testit(args)
+            with pytest.raises(TypeError):
+                t = self.client.transaction()
+                t.delete(*args)
 
     def test_set(self):
         self.client.create('/fred', b'01')
@@ -1167,18 +1244,15 @@ class TestClientTransactions(KazooTestCase):
         t.set_data('/fred', b'oops')
         t.commit()
         res = self.client.get('/fred')
-        eq_(res[0], b'oops')
+        assert res[0] == b'oops'
 
     def test_bad_sets(self):
         args_list = [(42, 52), ('/smith', False), ('/smith', b'', 'oops')]
 
-        @raises(TypeError)
-        def testit(args):
-            t = self.client.transaction()
-            t.set_data(*args)
-
         for args in args_list:
-            testit(args)
+            with pytest.raises(TypeError):
+                t = self.client.transaction()
+                t.set_data(*args)
 
     def test_check(self):
         self.client.create('/fred')
@@ -1187,50 +1261,43 @@ class TestClientTransactions(KazooTestCase):
         t.check('/fred', version)
         t.create('/blah')
         results = t.commit()
-        eq_(results[0], True)
-        eq_(results[1], '/blah')
+        assert results[0] is True
+        assert results[1] == '/blah'
 
     def test_bad_checks(self):
         args_list = [(42, 52), ('/smith', 'oops')]
 
-        @raises(TypeError)
-        def testit(args):
-            t = self.client.transaction()
-            t.check(*args)
-
         for args in args_list:
-            testit(args)
+            with pytest.raises(TypeError):
+                t = self.client.transaction()
+                t.check(*args)
 
     def test_bad_transaction(self):
         from kazoo.exceptions import RolledBackError, NoNodeError
+
         t = self.client.transaction()
         t.create('/fred')
         t.delete('/smith')
         results = t.commit()
-        eq_(results[0].__class__, RolledBackError)
-        eq_(results[1].__class__, NoNodeError)
+        assert results[0].__class__ == RolledBackError
+        assert results[1].__class__ == NoNodeError
 
     def test_bad_commit(self):
         t = self.client.transaction()
+        t.committed = True
 
-        @raises(ValueError)
-        def testit():
+        with pytest.raises(ValueError):
             t.commit()
 
-        t.committed = True
-        testit()
-
     def test_bad_context(self):
-        @raises(TypeError)
-        def testit():
+        with pytest.raises(TypeError):
             with self.client.transaction() as t:
                 t.check(4232)
-        testit()
 
     def test_context(self):
         with self.client.transaction() as t:
             t.create('/smith', b'32')
-        eq_(self.client.get('/smith')[0], b'32')
+        assert self.client.get('/smith')[0] == b'32'
 
 
 class TestSessionCallbacks(unittest.TestCase):
@@ -1243,25 +1310,25 @@ class TestSessionCallbacks(unittest.TestCase):
         client._live.set()
 
         result = client._session_callback(KeeperState.CONNECTED)
-        eq_(result, None)
+        assert result is None
 
         # Now with stopped
         client._stopped.set()
         result = client._session_callback(KeeperState.CONNECTED)
-        eq_(result, None)
+        assert result is None
 
         # Test several state transitions
         client._stopped.clear()
         client.start_async = lambda: True
         client._session_callback(KeeperState.CONNECTED)
-        eq_(client.state, KazooState.CONNECTED)
+        assert client.state == KazooState.CONNECTED
 
         client._session_callback(KeeperState.AUTH_FAILED)
-        eq_(client.state, KazooState.LOST)
+        assert client.state == KazooState.LOST
 
         client._handle = 1
         client._session_callback(-250)
-        eq_(client.state, KazooState.SUSPENDED)
+        assert client.state == KazooState.SUSPENDED
 
 
 class TestCallbacks(KazooTestCase):
@@ -1280,17 +1347,17 @@ class TestCallbacks(KazooTestCase):
         # this should be on another thread,
         # simultaneously with the stop procedure
         async_result.set_exception(
-            Exception("Anything that throws an exception"))
+            Exception("Anything that throws an exception")
+        )
 
         # with the fix the callback should be called
-        self.assertGreater(callback_mock.call_count, 0)
+        assert callback_mock.call_count > 0
 
 
 class TestNonChrootClient(KazooTestCase):
-
     def test_create(self):
         client = self._get_nonchroot_client()
-        self.assertEqual(client.chroot, '')
+        assert client.chroot == ''
         client.start()
         node = uuid.uuid4().hex
         path = client.create(node, ephemeral=True)
@@ -1300,8 +1367,8 @@ class TestNonChrootClient(KazooTestCase):
     def test_unchroot(self):
         client = self._get_nonchroot_client()
         client.chroot = '/a'
-        self.assertEquals(client.unchroot('/a/b'), '/b')
-        self.assertEquals(client.unchroot('/b/c'), '/b/c')
+        assert client.unchroot('/a/b') == '/b'
+        assert client.unchroot('/b/c') == '/b/c'
 
 
 class TestReconfig(KazooTestCase):
@@ -1313,14 +1380,15 @@ class TestReconfig(KazooTestCase):
         else:
             version = self.client.server_version()
         if not version or version < (3, 5):
-            raise SkipTest("Must use Zookeeper 3.5 or above")
+            pytest.skip("Must use Zookeeper 3.5 or above")
 
     def test_no_super_auth(self):
-        self.assertRaises(NoAuthError,
-                          self.client.reconfig,
-                          joining='server.999=0.0.0.0:1234:2345:observer;3456',
-                          leaving=None,
-                          new_members=None)
+        with pytest.raises(NoAuthError):
+            self.client.reconfig(
+                joining='server.999=0.0.0.0:1234:2345:observer;3456',
+                leaving=None,
+                new_members=None,
+            )
 
     def test_add_remove_observer(self):
         def free_sock_port():
@@ -1347,25 +1415,25 @@ class TestReconfig(KazooTestCase):
         data, _ = client.reconfig(joining=joining,
                                   leaving=None,
                                   new_members=None)
-        self.assertIn(joining.encode('utf8'), data)
+        assert joining.encode('utf8') in data
 
         data, _ = client.reconfig(joining=None,
                                   leaving='100',
                                   new_members=None)
-        self.assertNotIn(joining.encode('utf8'), data)
+        assert joining.encode('utf8') not in data
 
         # try to add it again, but a config number in the future
         curver = int(data.decode().split('\n')[-1].split('=')[1], base=16)
-        self.assertRaises(BadVersionError,
-                          self.client.reconfig,
-                          joining=joining,
-                          leaving=None,
-                          new_members=None,
-                          from_config=curver + 1)
+        with pytest.raises(BadVersionError):
+            self.client.reconfig(
+                joining=joining,
+                leaving=None,
+                new_members=None,
+                from_config=curver + 1,
+            )
 
     def test_bad_input(self):
-        self.assertRaises(BadArgumentsError,
-                          self.client.reconfig,
-                          joining='some thing',
-                          leaving=None,
-                          new_members=None)
+        with pytest.raises(BadArgumentsError):
+            self.client.reconfig(
+                joining='some thing', leaving=None, new_members=None
+            )