Move to use pytest instead of nose

7 files changed, 142 insertions, 109 deletions

diff --git a/.gitignore b/.gitignore
index 8b80b10..f3abb7a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,3 +33,4 @@ pip-log.txt
 *.swp
 
 .pypirc
+coverage.xml
diff --git a/pymemcache/test/test_client.py b/pymemcache/test/test_client.py
index 689d9e1..1cfbc0f 100644
--- a/pymemcache/test/test_client.py
+++ b/pymemcache/test/test_client.py
@@ -17,8 +17,8 @@ import errno
 import json
 import socket
 import unittest
+import pytest
 
-from nose import tools
 from pymemcache.client import PooledClient
 from pymemcache.client import Client, MemcacheUnknownCommandError
 from pymemcache.client import MemcacheClientError, MemcacheServerError
@@ -75,7 +75,7 @@ class ClientTestMixin(object):
     def test_set_success(self):
         client = self.make_client([b'STORED\r\n'])
         result = client.set(b'key', b'value', noreply=False)
-        tools.assert_equal(result, True)
+        assert result is True
 
     def test_set_unicode_key(self):
         client = self.make_client([b''])
@@ -83,7 +83,8 @@ class ClientTestMixin(object):
         def _set():
             client.set(u'\u0FFF', b'value', noreply=False)
 
-        tools.assert_raises(MemcacheIllegalInputError, _set)
+        with pytest.raises(MemcacheIllegalInputError):
+            _set()
 
     def test_set_unicode_value(self):
         client = self.make_client([b''])
@@ -91,34 +92,35 @@ class ClientTestMixin(object):
         def _set():
             client.set(b'key', u'\u0FFF', noreply=False)
 
-        tools.assert_raises(MemcacheIllegalInputError, _set)
+        with pytest.raises(MemcacheIllegalInputError):
+            _set()
 
     def test_set_noreply(self):
         client = self.make_client([])
         result = client.set(b'key', b'value', noreply=True)
-        tools.assert_equal(result, True)
+        assert result is True
 
     def test_set_many_success(self):
         client = self.make_client([b'STORED\r\n'])
         result = client.set_many({b'key' : b'value'}, noreply=False)
-        tools.assert_equal(result, True)
+        assert result is True
 
     def test_add_stored(self):
         client = self.make_client([b'STORED\r', b'\n'])
         result = client.add(b'key', b'value', noreply=False)
-        tools.assert_equal(result, True)
+        assert result is True
 
     def test_add_not_stored(self):
         client = self.make_client([b'STORED\r', b'\n',
                                    b'NOT_', b'STOR', b'ED', b'\r\n'])
         result = client.add(b'key', b'value', noreply=False)
         result = client.add(b'key', b'value', noreply=False)
-        tools.assert_equal(result, False)
+        assert result is False
 
     def test_get_not_found(self):
         client = self.make_client([b'END\r\n'])
         result = client.get(b'key')
-        tools.assert_equal(result, None)
+        assert result is None
 
     def test_get_found(self):
         client = self.make_client([
@@ -127,12 +129,12 @@ class ClientTestMixin(object):
         ])
         result = client.set(b'key', b'value', noreply=False)
         result = client.get(b'key')
-        tools.assert_equal(result, b'value')
+        assert result == b'value'
 
     def test_get_many_none_found(self):
         client = self.make_client([b'END\r\n'])
         result = client.get_many([b'key1', b'key2'])
-        tools.assert_equal(result, {})
+        assert result == {}
 
     def test_get_many_some_found(self):
         client = self.make_client([
@@ -141,7 +143,7 @@ class ClientTestMixin(object):
         ])
         result = client.set(b'key1', b'value1', noreply=False)
         result = client.get_many([b'key1', b'key2'])
-        tools.assert_equal(result, {b'key1': b'value1'})
+        assert result == {b'key1': b'value1'}
 
     def test_get_many_all_found(self):
         client = self.make_client([
@@ -153,7 +155,7 @@ class ClientTestMixin(object):
         result = client.set(b'key1', b'value1', noreply=False)
         result = client.set(b'key2', b'value2', noreply=False)
         result = client.get_many([b'key1', b'key2'])
-        tools.assert_equal(result, {b'key1': b'value1', b'key2': b'value2'})
+        assert result == {b'key1': b'value1', b'key2': b'value2'}
 
     def test_get_unicode_key(self):
         client = self.make_client([b''])
@@ -161,34 +163,35 @@ class ClientTestMixin(object):
         def _get():
             client.get(u'\u0FFF')
 
-        tools.assert_raises(MemcacheIllegalInputError, _get)
+        with pytest.raises(MemcacheIllegalInputError):
+            _get()
 
     def test_delete_not_found(self):
         client = self.make_client([b'NOT_FOUND\r\n'])
         result = client.delete(b'key', noreply=False)
-        tools.assert_equal(result, False)
+        assert result is False
 
     def test_delete_found(self):
         client = self.make_client([b'STORED\r', b'\n', b'DELETED\r\n'])
         result = client.add(b'key', b'value', noreply=False)
         result = client.delete(b'key', noreply=False)
-        tools.assert_equal(result, True)
+        assert result is True
 
     def test_delete_noreply(self):
         client = self.make_client([])
         result = client.delete(b'key', noreply=True)
-        tools.assert_equal(result, True)
+        assert result is True
 
     def test_incr_not_found(self):
         client = self.make_client([b'NOT_FOUND\r\n'])
         result = client.incr(b'key', 1, noreply=False)
-        tools.assert_equal(result, None)
+        assert result is None
 
     def test_incr_found(self):
         client = self.make_client([b'STORED\r\n', b'1\r\n'])
         client.set(b'key', 0, noreply=False)
         result = client.incr(b'key', 1, noreply=False)
-        tools.assert_equal(result, 1)
+        assert result == 1
 
     def test_incr_noreply(self):
         client = self.make_client([b'STORED\r\n'])
@@ -196,18 +199,18 @@ class ClientTestMixin(object):
 
         client = self.make_client([])
         result = client.incr(b'key', 1, noreply=True)
-        tools.assert_equal(result, None)
+        assert result is None
 
     def test_decr_not_found(self):
         client = self.make_client([b'NOT_FOUND\r\n'])
         result = client.decr(b'key', 1, noreply=False)
-        tools.assert_equal(result, None)
+        assert result is None
 
     def test_decr_found(self):
         client = self.make_client([b'STORED\r\n', b'1\r\n'])
         client.set(b'key', 2, noreply=False)
         result = client.decr(b'key', 1, noreply=False)
-        tools.assert_equal(result, 1)
+        assert result == 1
 
 
 class TestClient(ClientTestMixin, unittest.TestCase):
@@ -217,27 +220,27 @@ class TestClient(ClientTestMixin, unittest.TestCase):
     def test_append_stored(self):
         client = self.make_client([b'STORED\r\n'])
         result = client.append(b'key', b'value', noreply=False)
-        tools.assert_equal(result, True)
+        assert result is True
 
     def test_prepend_stored(self):
         client = self.make_client([b'STORED\r\n'])
         result = client.prepend(b'key', b'value', noreply=False)
-        tools.assert_equal(result, True)
+        assert result is True
 
     def test_cas_stored(self):
         client = self.make_client([b'STORED\r\n'])
         result = client.cas(b'key', b'value', b'cas', noreply=False)
-        tools.assert_equal(result, True)
+        assert result is True
 
     def test_cas_exists(self):
         client = self.make_client([b'EXISTS\r\n'])
         result = client.cas(b'key', b'value', b'cas', noreply=False)
-        tools.assert_equal(result, False)
+        assert result is False
 
     def test_cas_not_found(self):
         client = self.make_client([b'NOT_FOUND\r\n'])
         result = client.cas(b'key', b'value', b'cas', noreply=False)
-        tools.assert_equal(result, None)
+        assert result is None
 
     def test_cr_nl_boundaries(self):
         client = self.make_client([b'VALUE key1 0 6\r',
@@ -246,7 +249,7 @@ class TestClient(ClientTestMixin, unittest.TestCase):
                                    b'value2\r\n'
                                    b'END\r\n'])
         result = client.get_many([b'key1', b'key2'])
-        tools.assert_equals(result, {b'key1': b'value1', b'key2': b'value2'})
+        assert result == {b'key1': b'value1', b'key2': b'value2'}
 
         client = self.make_client([b'VALUE key1 0 6\r\n',
                                    b'value1\r',
@@ -254,7 +257,7 @@ class TestClient(ClientTestMixin, unittest.TestCase):
                                    b'value2\r\n',
                                    b'END\r\n'])
         result = client.get_many([b'key1', b'key2'])
-        tools.assert_equals(result, {b'key1': b'value1', b'key2': b'value2'})
+        assert result == {b'key1': b'value1', b'key2': b'value2'}
 
         client = self.make_client([b'VALUE key1 0 6\r\n',
                                    b'value1\r\n',
@@ -262,7 +265,7 @@ class TestClient(ClientTestMixin, unittest.TestCase):
                                    b'\nvalue2\r\n',
                                    b'END\r\n'])
         result = client.get_many([b'key1', b'key2'])
-        tools.assert_equals(result, {b'key1': b'value1', b'key2': b'value2'})
+        assert result == {b'key1': b'value1', b'key2': b'value2'}
 
 
         client = self.make_client([b'VALUE key1 0 6\r\n',
@@ -271,7 +274,7 @@ class TestClient(ClientTestMixin, unittest.TestCase):
                                    b'value2\r',
                                    b'\nEND\r\n'])
         result = client.get_many([b'key1', b'key2'])
-        tools.assert_equals(result, {b'key1': b'value1', b'key2': b'value2'})
+        assert result == {b'key1': b'value1', b'key2': b'value2'}
 
         client = self.make_client([b'VALUE key1 0 6\r\n',
                                    b'value1\r\n',
@@ -280,7 +283,7 @@ class TestClient(ClientTestMixin, unittest.TestCase):
                                    b'END\r',
                                    b'\n'])
         result = client.get_many([b'key1', b'key2'])
-        tools.assert_equals(result, {b'key1': b'value1', b'key2': b'value2'})
+        assert result == {b'key1': b'value1', b'key2': b'value2'}
 
         client = self.make_client([b'VALUE key1 0 6\r',
                                    b'\nvalue1\r',
@@ -289,7 +292,7 @@ class TestClient(ClientTestMixin, unittest.TestCase):
                                    b'\nEND\r',
                                    b'\n'])
         result = client.get_many([b'key1', b'key2'])
-        tools.assert_equals(result, {b'key1': b'value1', b'key2': b'value2'})
+        assert result == {b'key1': b'value1', b'key2': b'value2'}
 
     def test_delete_exception(self):
         client = self.make_client([Exception('fail')])
@@ -297,13 +300,15 @@ class TestClient(ClientTestMixin, unittest.TestCase):
         def _delete():
             client.delete(b'key', noreply=False)
 
-        tools.assert_raises(Exception, _delete)
-        tools.assert_equal(client.sock, None)
+        with pytest.raises(Exception):
+            _delete()
+
+        assert client.sock is None
 
     def test_flush_all(self):
         client = self.make_client([b'OK\r\n'])
         result = client.flush_all(noreply=False)
-        tools.assert_equal(result, True)
+        assert result is True
 
     def test_incr_exception(self):
         client = self.make_client([Exception('fail')])
@@ -311,8 +316,10 @@ class TestClient(ClientTestMixin, unittest.TestCase):
         def _incr():
             client.incr(b'key', 1)
 
-        tools.assert_raises(Exception, _incr)
-        tools.assert_equal(client.sock, None)
+        with pytest.raises(Exception):
+            _incr()
+
+        assert client.sock is None
 
     def test_get_error(self):
         client = self.make_client([b'ERROR\r\n'])
@@ -320,13 +327,14 @@ class TestClient(ClientTestMixin, unittest.TestCase):
         def _get():
             client.get(b'key')
 
-        tools.assert_raises(MemcacheUnknownCommandError, _get)
+        with pytest.raises(MemcacheUnknownCommandError):
+            _get()
 
     def test_get_recv_chunks(self):
         client = self.make_client([b'VALUE key', b' 0 5\r', b'\nvalue',
                                    b'\r\n', b'END', b'\r', b'\n'])
         result = client.get(b'key')
-        tools.assert_equal(result, b'value')
+        assert result == b'value'
 
     def test_get_unknown_error(self):
         client = self.make_client([b'foobarbaz\r\n'])
@@ -334,53 +342,54 @@ class TestClient(ClientTestMixin, unittest.TestCase):
         def _get():
             client.get(b'key')
 
-        tools.assert_raises(MemcacheUnknownError, _get)
+        with pytest.raises(MemcacheUnknownError):
+            _get()
 
     def test_gets_not_found(self):
         client = self.make_client([b'END\r\n'])
         result = client.gets(b'key')
-        tools.assert_equal(result, (None, None))
+        assert result == (None, None)
 
     def test_gets_found(self):
         client = self.make_client([b'VALUE key 0 5 10\r\nvalue\r\nEND\r\n'])
         result = client.gets(b'key')
-        tools.assert_equal(result, (b'value', b'10'))
+        assert result == (b'value', b'10')
 
     def test_gets_many_none_found(self):
         client = self.make_client([b'END\r\n'])
         result = client.gets_many([b'key1', b'key2'])
-        tools.assert_equal(result, {})
+        assert result == {}
 
     def test_gets_many_some_found(self):
         client = self.make_client([b'VALUE key1 0 6 11\r\nvalue1\r\nEND\r\n'])
         result = client.gets_many([b'key1', b'key2'])
-        tools.assert_equal(result, {b'key1': (b'value1', b'11')})
+        assert result == {b'key1': (b'value1', b'11')}
 
     def test_touch_not_found(self):
         client = self.make_client([b'NOT_FOUND\r\n'])
         result = client.touch(b'key', noreply=False)
-        tools.assert_equal(result, False)
+        assert result is False
 
     def test_touch_found(self):
         client = self.make_client([b'TOUCHED\r\n'])
         result = client.touch(b'key', noreply=False)
-        tools.assert_equal(result, True)
+        assert result is True
 
     def test_quit(self):
         client = self.make_client([])
         result = client.quit()
-        tools.assert_equal(result, None)
-        tools.assert_equal(client.sock, None)
+        assert result is None
+        assert client.sock is None
 
     def test_replace_stored(self):
         client = self.make_client([b'STORED\r\n'])
         result = client.replace(b'key', b'value', noreply=False)
-        tools.assert_equal(result, True)
+        assert result is True
 
     def test_replace_not_stored(self):
         client = self.make_client([b'NOT_STORED\r\n'])
         result = client.replace(b'key', b'value', noreply=False)
-        tools.assert_equal(result, False)
+        assert result is False
 
     def test_serialization(self):
         def _ser(key, value):
@@ -388,16 +397,16 @@ class TestClient(ClientTestMixin, unittest.TestCase):
 
         client = self.make_client([b'STORED\r\n'], serializer=_ser)
         client.set('key', {'c': 'd'})
-        tools.assert_equal(client.sock.send_bufs, [
+        assert client.sock.send_bufs == [
             b'set key 0 0 10 noreply\r\n{"c": "d"}\r\n'
-        ])
+        ]
 
     def test_set_socket_handling(self):
         client = self.make_client([b'STORED\r\n'])
         result = client.set(b'key', b'value', noreply=False)
-        tools.assert_equal(result, True)
-        tools.assert_equal(client.sock.closed, False)
-        tools.assert_equal(len(client.sock.send_bufs), 1)
+        assert result is True
+        assert client.sock.closed is False
+        assert len(client.sock.send_bufs) == 1
 
     def test_set_error(self):
         client = self.make_client([b'ERROR\r\n'])
@@ -405,16 +414,18 @@ class TestClient(ClientTestMixin, unittest.TestCase):
         def _set():
             client.set(b'key', b'value', noreply=False)
 
-        tools.assert_raises(MemcacheUnknownCommandError, _set)
+        with pytest.raises(MemcacheUnknownCommandError):
+            _set()
 
     def test_set_exception(self):
         client = self.make_client([Exception('fail')])
 
         def _set():
             client.set(b'key', b'value', noreply=False)
+        with pytest.raises(Exception):
+            _set()
 
-        tools.assert_raises(Exception, _set)
-        tools.assert_equal(client.sock, None)
+        assert client.sock == None
 
     def test_set_client_error(self):
         client = self.make_client([b'CLIENT_ERROR some message\r\n'])
@@ -422,7 +433,8 @@ class TestClient(ClientTestMixin, unittest.TestCase):
         def _set():
             client.set('key', 'value', noreply=False)
 
-        tools.assert_raises(MemcacheClientError, _set)
+        with pytest.raises(MemcacheClientError):
+            _set()
 
     def test_set_server_error(self):
         client = self.make_client([b'SERVER_ERROR some message\r\n'])
@@ -430,7 +442,8 @@ class TestClient(ClientTestMixin, unittest.TestCase):
         def _set():
             client.set(b'key', b'value', noreply=False)
 
-        tools.assert_raises(MemcacheServerError, _set)
+        with pytest.raises(MemcacheServerError):
+            _set()
 
     def test_set_unknown_error(self):
         client = self.make_client([b'foobarbaz\r\n'])
@@ -438,14 +451,15 @@ class TestClient(ClientTestMixin, unittest.TestCase):
         def _set():
             client.set(b'key', b'value', noreply=False)
 
-        tools.assert_raises(MemcacheUnknownError, _set)
+        with pytest.raises(MemcacheUnknownError):
+            _set()
 
     def test_set_many_socket_handling(self):
         client = self.make_client([b'STORED\r\n'])
         result = client.set_many({b'key': b'value'}, noreply=False)
-        tools.assert_equal(result, True)
-        tools.assert_equal(client.sock.closed, False)
-        tools.assert_equal(len(client.sock.send_bufs), 1)
+        assert result is True
+        assert client.sock.closed is False
+        assert len(client.sock.send_bufs) == 1
 
     def test_set_many_exception(self):
         client = self.make_client([b'STORED\r\n', Exception('fail')])
@@ -454,24 +468,26 @@ class TestClient(ClientTestMixin, unittest.TestCase):
             client.set_many({b'key': b'value', b'other': b'value'},
                             noreply=False)
 
-        tools.assert_raises(Exception, _set)
-        tools.assert_equal(client.sock, None)
+        with pytest.raises(Exception):
+            _set()
+
+        assert client.sock is None
 
     def test_stats(self):
         client = self.make_client([b'STAT fake_stats 1\r\n', b'END\r\n'])
         result = client.stats()
-        tools.assert_equal(client.sock.send_bufs, [
+        assert client.sock.send_bufs == [
             b'stats \r\n'
-        ])
-        tools.assert_equal(result, {b'fake_stats': 1})
+        ]
+        assert result == {b'fake_stats': 1}
 
     def test_stats_with_args(self):
         client = self.make_client([b'STAT fake_stats 1\r\n', b'END\r\n'])
         result = client.stats('some_arg')
-        tools.assert_equal(client.sock.send_bufs, [
+        assert client.sock.send_bufs == [
             b'stats some_arg\r\n'
-        ])
-        tools.assert_equal(result, {b'fake_stats': 1})
+        ]
+        assert result == {b'fake_stats': 1}
 
     def test_stats_conversions(self):
         client = self.make_client([
@@ -491,9 +507,9 @@ class TestClient(ClientTestMixin, unittest.TestCase):
             b'END\r\n',
         ])
         result = client.stats()
-        tools.assert_equal(client.sock.send_bufs, [
+        assert client.sock.send_bufs == [
             b'stats \r\n'
-        ])
+        ]
         expected = {
             b'cmd_get': 2519,
             b'cmd_set': 3099,
@@ -504,7 +520,7 @@ class TestClient(ClientTestMixin, unittest.TestCase):
             b'slab_reassign_running': True,
             b'version': b'1.4.14',
         }
-        tools.assert_equal(result, expected)
+        assert result == expected
 
     def test_python_dict_set_is_supported(self):
         client = self.make_client([b'STORED\r\n'])
@@ -512,7 +528,7 @@ class TestClient(ClientTestMixin, unittest.TestCase):
 
     def test_python_dict_get_is_supported(self):
         client = self.make_client([b'VALUE key 0 5\r\nvalue\r\nEND\r\n'])
-        tools.assert_equal(client[b'key'], b'value')
+        assert client[b'key'] == b'value'
 
     def test_python_dict_get_not_found_is_supported(self):
         client = self.make_client([b'END\r\n'])
@@ -520,7 +536,8 @@ class TestClient(ClientTestMixin, unittest.TestCase):
         def _get():
             _ = client[b'key']
 
-        tools.assert_raises(KeyError, _get)
+        with pytest.raises(KeyError):
+            _get()
 
     def test_python_dict_del_is_supported(self):
         client = self.make_client([b'DELETED\r\n'])
@@ -528,15 +545,20 @@ class TestClient(ClientTestMixin, unittest.TestCase):
 
     def test_too_long_key(self):
         client = self.make_client([b'END\r\n'])
-        tools.assert_raises(MemcacheClientError, client.get, b'x' * 251)
+
+        with pytest.raises(MemcacheClientError):
+            client.get(b'x' * 251)
 
     def test_key_contains_spae(self):
         client = self.make_client([b'END\r\n'])
-        tools.assert_raises(MemcacheClientError, client.get, b'abc xyz')
+        with pytest.raises(MemcacheClientError):
+            client.get(b'abc xyz')
 
     def test_key_contains_nonascii(self):
         client = self.make_client([b'END\r\n'])
-        tools.assert_raises(MemcacheClientError, client.get, u'\u3053\u3093\u306b\u3061\u306f')
+
+        with pytest.raises(MemcacheClientError):
+            client.get(u'\u3053\u3093\u306b\u3061\u306f')
 
 
 class TestClientSocketConnect(unittest.TestCase):
@@ -545,23 +567,23 @@ class TestClientSocketConnect(unittest.TestCase):
 
         client = Client(server, socket_module=MockSocketModule())
         client._connect()
-        tools.assert_equal(client.sock.connections, [server])
+        assert client.sock.connections == [server]
 
         timeout = 2
         connect_timeout = 3
         client = Client(server, connect_timeout=connect_timeout, timeout=timeout,
                         socket_module=MockSocketModule())
         client._connect()
-        tools.assert_equal(client.sock.timeouts, [connect_timeout, timeout])
+        assert client.sock.timeouts == [connect_timeout, timeout]
 
         client = Client(server, socket_module=MockSocketModule())
         client._connect()
-        tools.assert_equal(client.sock.socket_options, [])
+        assert client.sock.socket_options == []
 
         client = Client(server, socket_module=MockSocketModule(), no_delay=True)
         client._connect()
-        tools.assert_equal(client.sock.socket_options, [(socket.IPPROTO_TCP,
-                                                        socket.TCP_NODELAY, 1)])
+        assert client.sock.socket_options == [(socket.IPPROTO_TCP,
+                                               socket.TCP_NODELAY, 1)]
 
 
 class TestPooledClient(ClientTestMixin, unittest.TestCase):
@@ -593,7 +615,7 @@ class TestPrefixedClient(ClientTestMixin, unittest.TestCase):
         ])
         result = client.set(b'key', b'value', noreply=False)
         result = client.get(b'key')
-        tools.assert_equal(result, b'value')
+        assert result == b'value'
 
     def test_get_many_some_found(self):
         client = self.make_client([
@@ -602,7 +624,7 @@ class TestPrefixedClient(ClientTestMixin, unittest.TestCase):
         ])
         result = client.set(b'key1', b'value1', noreply=False)
         result = client.get_many([b'key1', b'key2'])
-        tools.assert_equal(result, {b'key1': b'value1'})
+        assert result == {b'key1': b'value1'}
 
     def test_get_many_all_found(self):
         client = self.make_client([
@@ -614,11 +636,11 @@ class TestPrefixedClient(ClientTestMixin, unittest.TestCase):
         result = client.set(b'key1', b'value1', noreply=False)
         result = client.set(b'key2', b'value2', noreply=False)
         result = client.get_many([b'key1', b'key2'])
-        tools.assert_equal(result, {b'key1': b'value1', b'key2': b'value2'})
+        assert result == {b'key1': b'value1', b'key2': b'value2'}
 
     def test_python_dict_get_is_supported(self):
         client = self.make_client([b'VALUE xyz:key 0 5\r\nvalue\r\nEND\r\n'])
-        tools.assert_equal(client[b'key'], b'value')
+        assert client[b'key'] == b'value'
 
 
 class TestPrefixedPooledClient(TestPrefixedClient):
@@ -644,4 +666,4 @@ class TestRetryOnEINTR(unittest.TestCase):
             socket.error(errno.EINTR, "Interrupted system call"),
             b'ue1\r\nEND\r\n',
             ])
-        tools.assert_equal(client[b'key1'], b'value1')
+        assert client[b'key1'] == b'value1'
diff --git a/pymemcache/test/test_utils.py b/pymemcache/test/test_utils.py
index 40bafec..d283aeb 100644
--- a/pymemcache/test/test_utils.py
+++ b/pymemcache/test/test_utils.py
@@ -1,50 +1,49 @@
-from nose import tools
 import six
+import pytest
 
 from pymemcache.test.utils import MockMemcacheClient
 
 
 def test_get_set():
     client = MockMemcacheClient()
-    tools.assert_equal(client.get(b"hello"), None)
+    assert client.get(b"hello") is None
 
     client.set(b"hello", 12)
-    tools.assert_equal(client.get(b"hello"), 12)
+    assert client.get(b"hello") == 12
 
 
 def test_get_many_set_many():
     client = MockMemcacheClient()
     client.set(b"h", 1)
 
-    tools.assert_equal(client.get_many([b"h", b"e", b"l", b"o"]),
-                       {b"h": 1})
+    result = client.get_many([b"h", b"e", b"l", b"o"])
+    assert result == {b"h": 1}
 
     # Convert keys into bytes
     d = dict((k.encode('ascii'), v)
              for k, v in six.iteritems(dict(h=1, e=2, l=3)))
     client.set_many(d)
-    tools.assert_equal(client.get_many([b"h", b"e", b"l", b"o"]),
-                       d)
+    assert client.get_many([b"h", b"e", b"l", b"o"]) == d
 
 
 def test_add():
     client = MockMemcacheClient()
 
     client.add(b"k", 2)
-    tools.assert_equal(client.get(b"k"), 2)
+    assert client.get(b"k") == 2
 
     client.add(b"k", 25)
-    tools.assert_equal(client.get(b"k"), 2)
+    assert client.get(b"k") == 2
 
 
 def test_delete():
     client = MockMemcacheClient()
 
     client.add(b"k", 2)
-    tools.assert_equal(client.get(b"k"), 2)
+    assert client.get(b"k") == 2
 
     client.delete(b"k")
-    tools.assert_equal(client.get(b"k"), None)
+    assert client.get(b"k") is None
 
 
 def test_incr_decr():
@@ -53,7 +52,7 @@ def test_incr_decr():
     client.add(b"k", 2)
 
     client.incr(b"k", 4)
-    tools.assert_equal(client.get(b"k"), 6)
+    assert client.get(b"k") == 6
 
     client.decr(b"k", 2)
-    tools.assert_equal(client.get(b"k"), 4)
+    assert client.get(b"k") == 4
diff --git a/setup.cfg b/setup.cfg
index f15c017..59da379 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,2 +1,13 @@
 [wheel]
 universal = true
+
+[pytest]
+norecursedirs = build docs/_build *.egg .tox *.venv
+addopts =
+    --verbose
+    --tb=short
+    --capture=no
+    # show extra test summary info as specified by chars (f)ailed, (E)error,
+    # (s)skipped, (x)failed, (X)passed.
+    -rfEsxX
+    --cov=pymemcache --cov-report=xml --cov-report=term-missing
diff --git a/setup.py b/setup.py
index 7180e63..d6c0846 100644
--- a/setup.py
+++ b/setup.py
@@ -10,8 +10,6 @@ setup(
     author = 'Charles Gordon',
     author_email = 'charles@pinterest.com',
     packages = find_packages(),
-    tests_require = ['nose>=1.0'],
-    test_suite = 'nose.collector',
     install_requires = ['six'],
     description = 'A comprehensive, fast, pure Python memcached client',
     long_description = open('README.md').read(),
@@ -26,4 +24,3 @@ setup(
         'Topic :: Database',
     ],
 )
-
diff --git a/test-requirements.txt b/test-requirements.txt
new file mode 100644
index 0000000..9955dec
--- /dev/null
+++ b/test-requirements.txt
@@ -0,0 +1,2 @@
+pytest
+pytest-cov
diff --git a/tox.ini b/tox.ini
index 727d0e3..1cd4506 100644
--- a/tox.ini
+++ b/tox.ini
@@ -2,6 +2,7 @@
 envlist = py26, py27, pypy, py33, py34
 
 [testenv]
-deps = nose
 commands =
-    python setup.py nosetests
+    pip install -r test-requirements.txt
+    pip install -e .
+    py.test