Convert session dict tests to py.test style

Makefile

@@ -1,23 +1,17 @@
 # Some simple testing tasks (sorry, UNIX only).
 
-FLAGS=
-
-
 flake:
 	flake8 aiohttp_session tests 
 
 
 test: flake
-	nosetests -s $(FLAGS) ./tests/
+	py.test ./tests/
 
 vtest: flake develop
-	nosetests -s -v $(FLAGS) ./tests/
+	py.test ./tests/
 
 cov cover coverage: flake
-	@coverage erase
-	@coverage run -m nose -s $(FLAGS) tests
-	@coverage report
-	@coverage html
+	py.test --cov aiohttp_session --cov-report-type html ./tests/
 	@echo "open file://`pwd`/coverage/index.html"
 
 clean:

requirements-dev.txt

@@ -1,5 +1,4 @@
 flake8
-nose
 coverage
 sphinx
 alabaster>=0.6.2
@@ -8,3 +7,5 @@ pep257
 aioredis
 cryptography
 pynacl
+pytest-aiohttp
+pytest-cov

tests/test_session_dict.py

@@ -1,146 +1,146 @@
-import unittest
 import time
 
 from aiohttp_session import Session
 
 
-class SessionTests(unittest.TestCase):
-
-    def test_create(self):
-        s = Session('test_identity', data=None, new=True)
-        self.assertEqual(s, {})
-        self.assertTrue(s.new)
-        self.assertEqual('test_identity', s.identity)
-        self.assertFalse(s._changed)
-        self.assertIsNotNone(s.created)
-
-    def test_create2(self):
-        s = Session('test_identity', data={'session': {'some': 'data'}},
-                    new=False)
-        self.assertEqual(s, {'some': 'data'})
-        self.assertFalse(s.new)
-        self.assertEqual('test_identity', s.identity)
-        self.assertFalse(s._changed)
-        self.assertIsNotNone(s.created)
-
-    def test_create3(self):
-        s = Session(identity=1, data=None, new=True)
-        self.assertEqual(s, {})
-        self.assertTrue(s.new)
-        self.assertEqual(s.identity, 1)
-        self.assertFalse(s._changed)
-        self.assertIsNotNone(s.created)
-
-    def test__repr__(self):
-        s = Session('test_identity', data=None, new=True)
-        self.assertEqual(
-            str(s),
-            '<Session [new:True, changed:False, created:{0}] {{}}>'.format(
-                s.created))
-        s['foo'] = 'bar'
-        self.assertEqual(
-            str(s),
-            "<Session [new:True, changed:True, created:{0}]"
-            " {{'foo': 'bar'}}>".format(s.created))
-
-    def test__repr__2(self):
-        created = int(time.time()) - 1000
-        session_data = {
-            'session': {
-                'key': 123
-            },
-            'created': created
-        }
-        s = Session('test_identity', data=session_data, new=False)
-        self.assertEqual(
-            str(s),
-            "<Session [new:False, changed:False, created:{0}]"
-            " {{'key': 123}}>".format(created))
-        s.invalidate()
-        self.assertEqual(
-            str(s),
-            "<Session [new:False, changed:True, created:{0}] {{}}>".format(
-                created))
-
-    def test_invalidate(self):
-        s = Session('test_identity', data={'session': {'foo': 'bar'}},
-                    new=False)
-        self.assertEqual(s, {'foo': 'bar'})
-        self.assertFalse(s._changed)
-
-        s.invalidate()
-        self.assertEqual(s, {})
-        self.assertTrue(s._changed)
-        self.assertIsNotNone(s.created)
-
-    def test_invalidate2(self):
-        s = Session('test_identity', data={'session': {'foo': 'bar'}},
-                    new=False)
-        self.assertEqual(s, {'foo': 'bar'})
-        self.assertFalse(s._changed)
-
-        s.invalidate()
-        self.assertEqual(s, {})
-        self.assertTrue(s._changed)
-        self.assertIsNotNone(s.created)
-
-    def test_operations(self):
-        s = Session('test_identity', data=None, new=False)
-        self.assertEqual(s, {})
-        self.assertEqual(len(s), 0)
-        self.assertEqual(list(s), [])
-        self.assertNotIn('foo', s)
-        self.assertNotIn('key', s)
-
-        s = Session('test_identity', data={'session': {'foo': 'bar'}},
-                    new=False)
-        self.assertEqual(len(s), 1)
-        self.assertEqual(s, {'foo': 'bar'})
-        self.assertEqual(list(s), ['foo'])
-        self.assertIn('foo', s)
-        self.assertNotIn('key', s)
-
-        s['key'] = 'value'
-        self.assertEqual(len(s), 2)
-        self.assertEqual(s, {'foo': 'bar', 'key': 'value'})
-        self.assertEqual(sorted(s), ['foo', 'key'])
-        self.assertIn('foo', s)
-        self.assertIn('key', s)
-
-        del s['key']
-        self.assertEqual(len(s), 1)
-        self.assertEqual(s, {'foo': 'bar'})
-        self.assertEqual(list(s), ['foo'])
-        self.assertIn('foo', s)
-        self.assertNotIn('key', s)
-
-        s.pop('foo')
-        self.assertEqual(len(s), 0)
-        self.assertEqual(s, {})
-        self.assertEqual(list(s), [])
-        self.assertNotIn('foo', s)
-        self.assertNotIn('key', s)
-
-    def test_change(self):
-        created = int(time.time())
-        s = Session('test_identity', new=False, data={
-            'session': {
-                'a': {'key': 'value'}
-            },
-            'created': created
-        })
-        self.assertFalse(s._changed)
-
-        s['a']['key2'] = 'val2'
-        self.assertFalse(s._changed)
-        self.assertEqual({'a': {'key': 'value',
-                                'key2': 'val2'}},
-                         s)
-        self.assertEqual(s.created, created)
-
-        s.changed()
-        self.assertTrue(s._changed)
-        self.assertEqual({'a': {'key': 'value',
-                                'key2': 'val2'}},
-                         s)
-        self.assertEqual(s.created, created)
+def test_create():
+    s = Session('test_identity', data=None, new=True)
+    assert s == {}
+    assert s.new
+    assert 'test_identity' == s.identity
+    assert not s._changed
+    assert s.created is not None
+
+
+def test_create2():
+    s = Session('test_identity', data={'session': {'some': 'data'}},
+                new=False)
+    assert s == {'some': 'data'}
+    assert not s.new
+    assert 'test_identity' == s.identity
+    assert not s._changed
+    assert s.created is not None
+
+
+def test_create3():
+    s = Session(identity=1, data=None, new=True)
+    assert s == {}
+    assert s.new
+    assert s.identity == 1
+    assert not s._changed
+    assert s.created is not None
+
+
+def test__repr__():
+    s = Session('test_identity', data=None, new=True)
+    assert str(s) == \
+        '<Session [new:True, changed:False, created:{0}] {{}}>'.format(
+            s.created)
+    s['foo'] = 'bar'
+    assert str(s) == \
+        "<Session [new:True, changed:True, created:{0}]" \
+        " {{'foo': 'bar'}}>".format(s.created)
+
+
+def test__repr__2():
+    created = int(time.time()) - 1000
+    session_data = {
+        'session': {
+            'key': 123
+        },
+        'created': created
+    }
+    s = Session('test_identity', data=session_data, new=False)
+    assert str(s) == \
+        "<Session [new:False, changed:False, created:{0}]" \
+        " {{'key': 123}}>".format(created)
+    s.invalidate()
+    assert str(s) == \
+        "<Session [new:False, changed:True, created:{0}] {{}}>".format(
+            created)
+
+
+def test_invalidate():
+    s = Session('test_identity', data={'session': {'foo': 'bar'}},
+                new=False)
+    assert s == {'foo': 'bar'}
+    assert not s._changed
+
+    s.invalidate()
+    assert s == {}
+    assert s._changed
+    assert s.created is not None
+
+
+def test_invalidate2():
+    s = Session('test_identity', data={'session': {'foo': 'bar'}},
+                new=False)
+    assert s == {'foo': 'bar'}
+    assert not s._changed
+
+    s.invalidate()
+    assert s == {}
+    assert s._changed
+    assert s.created is not None
+
+
+def test_operations():
+    s = Session('test_identity', data=None, new=False)
+    assert s == {}
+    assert len(s) == 0
+    assert list(s) == []
+    assert 'foo' not in s
+    assert 'key' not in s
+
+    s = Session('test_identity', data={'session': {'foo': 'bar'}},
+                new=False)
+    assert len(s) == 1
+    assert s == {'foo': 'bar'}
+    assert list(s) == ['foo']
+    assert 'foo' in s
+    assert 'key' not in s
+
+    s['key'] = 'value'
+    assert len(s) == 2
+    assert s == {'foo': 'bar', 'key': 'value'}
+    assert sorted(s) == ['foo', 'key']
+    assert 'foo' in s
+    assert 'key' in s
+
+    del s['key']
+    assert len(s) == 1
+    assert s == {'foo': 'bar'}
+    assert list(s) == ['foo']
+    assert 'foo' in s
+    assert 'key' not in s
+
+    s.pop('foo')
+    assert len(s) == 0
+    assert s == {}
+    assert list(s) == []
+    assert 'foo' not in s
+    assert 'key' not in s
+
+
+def test_change():
+    created = int(time.time())
+    s = Session('test_identity', new=False, data={
+        'session': {
+            'a': {'key': 'value'}
+        },
+        'created': created
+    })
+    assert not s._changed
+
+    s['a']['key2'] = 'val2'
+    assert not s._changed
+    assert {'a': {'key': 'value',
+                  'key2': 'val2'}} == s
+
+    assert s.created == created
+
+    s.changed()
+    assert s._changed
+    assert {'a': {'key': 'value',
+                  'key2': 'val2'}} == s
+    assert s.created == created