1 files changed, 22 insertions, 13 deletions

diff --git a/kazoo/tests/test_retry.py b/kazoo/tests/test_retry.py
index 3ce4a41..7a30667 100644
--- a/kazoo/tests/test_retry.py
+++ b/kazoo/tests/test_retry.py
@@ -1,15 +1,14 @@
 import unittest
 
-from nose.tools import eq_
-
+import pytest
 
 class TestRetrySleeper(unittest.TestCase):
-
     def _pass(self):
         pass
 
     def _fail(self, times=1):
         from kazoo.retry import ForceRetryError
+
         scope = dict(times=0)
 
         def inner():
@@ -18,24 +17,28 @@ class TestRetrySleeper(unittest.TestCase):
             else:
                 scope['times'] += 1
                 raise ForceRetryError('Failed!')
+
         return inner
 
     def _makeOne(self, *args, **kwargs):
         from kazoo.retry import KazooRetry
+
         return KazooRetry(*args, **kwargs)
 
     def test_reset(self):
         retry = self._makeOne(delay=0, max_tries=2)
         retry(self._fail())
-        eq_(retry._attempts, 1)
+        assert retry._attempts == 1
         retry.reset()
-        eq_(retry._attempts, 0)
+        assert retry._attempts == 0
 
     def test_too_many_tries(self):
         from kazoo.retry import RetryFailedError
+
         retry = self._makeOne(delay=0)
-        self.assertRaises(RetryFailedError, retry, self._fail(times=999))
-        eq_(retry._attempts, 1)
+        with pytest.raises(RetryFailedError):
+            retry(self._fail(times=999))
+        assert retry._attempts == 1
 
     def test_maximum_delay(self):
         def sleep_func(_time):
@@ -43,9 +46,9 @@ class TestRetrySleeper(unittest.TestCase):
 
         retry = self._makeOne(delay=10, max_tries=100, sleep_func=sleep_func)
         retry(self._fail(times=10))
-        self.assertTrue(retry._cur_delay < 4000, retry._cur_delay)
+        assert retry._cur_delay < 4000
         # gevent's sleep function is picky about the type
-        eq_(type(retry._cur_delay), float)
+        assert type(retry._cur_delay) == float
 
     def test_copy(self):
         def _sleep(t):
@@ -53,27 +56,33 @@ class TestRetrySleeper(unittest.TestCase):
 
         retry = self._makeOne(sleep_func=_sleep)
         rcopy = retry.copy()
-        self.assertTrue(rcopy.sleep_func is _sleep)
+        assert rcopy.sleep_func is _sleep
 
 
 class TestKazooRetry(unittest.TestCase):
-
     def _makeOne(self, **kw):
         from kazoo.retry import KazooRetry
+
         return KazooRetry(**kw)
 
     def test_connection_closed(self):
         from kazoo.exceptions import ConnectionClosedError
+
         retry = self._makeOne()
 
         def testit():
             raise ConnectionClosedError()
-        self.assertRaises(ConnectionClosedError, retry, testit)
+
+        with pytest.raises(ConnectionClosedError):
+            retry(testit)
 
     def test_session_expired(self):
         from kazoo.exceptions import SessionExpiredError
+
         retry = self._makeOne(max_tries=1)
 
         def testit():
             raise SessionExpiredError()
-        self.assertRaises(Exception, retry, testit)
+
+        with pytest.raises(Exception):
+            retry(testit)