openstack/deb-python-pymemcache
Code Issues Proposed changes

Move to use pytest instead of nose

Browse Source
This commit is contained in:
John Anderson
2015-06-19 20:26:04 -07:00
parent 67c4a2f698
commit a7c1972dad
7 changed files with 142 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -33,3 +33,4 @@ pip-log.txt
*.swp
.pypirc
coverage.xml

204
pymemcache/test/test_client.py
View File

@@ -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'

25
pymemcache/test/test_utils.py
View File

@@ -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

11
setup.cfg
View File

@@ -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

3
setup.py
View File

@@ -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',
],
)

2
test-requirements.txt Normal file
View File

@@ -0,0 +1,2 @@
pytest
pytest-cov

5
tox.ini
View File

@@ -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