remove nose from test_attrs

Author: alimanfoo

zarr/tests/test_attrs.py

@@ -4,7 +4,7 @@
 import unittest
 
 
-from nose.tools import eq_ as eq, assert_raises
+import pytest
 
 
 from zarr.attrs import Attributes
@@ -24,14 +24,14 @@ def test_storage(self):
         a = Attributes(store=store, key='attrs')
         assert 'foo' not in a
         assert 'bar' not in a
-        eq(dict(), a.asdict())
+        assert dict() == a.asdict()
 
         a['foo'] = 'bar'
         a['baz'] = 42
         assert 'attrs' in store
         assert isinstance(store['attrs'], binary_type)
         d = json.loads(text_type(store['attrs'], 'ascii'))
-        eq(dict(foo='bar', baz=42), d)
+        assert dict(foo='bar', baz=42) == d
 
     def test_get_set_del_contains(self):
 
@@ -41,11 +41,11 @@ def test_get_set_del_contains(self):
         a['baz'] = 42
         assert 'foo' in a
         assert 'baz' in a
-        eq('bar', a['foo'])
-        eq(42, a['baz'])
+        assert 'bar' == a['foo']
+        assert 42 == a['baz']
         del a['foo']
         assert 'foo' not in a
-        with assert_raises(KeyError):
+        with pytest.raises(KeyError):
             # noinspection PyStatementEffect
             a['foo']
 
@@ -57,44 +57,44 @@ def test_update_put(self):
         assert 'baz' not in a
 
         a.update(foo='spam', bar=42, baz=4.2)
-        eq(a['foo'], 'spam')
-        eq(a['bar'], 42)
-        eq(a['baz'], 4.2)
+        assert a['foo'] == 'spam'
+        assert a['bar'] == 42
+        assert a['baz'] == 4.2
 
         a.put(dict(foo='eggs', bar=84))
-        eq(a['foo'], 'eggs')
-        eq(a['bar'], 84)
+        assert a['foo'] == 'eggs'
+        assert a['bar'] == 84
         assert 'baz' not in a
 
     def test_iterators(self):
 
         a = self.init_attributes(dict())
-        eq(0, len(a))
-        eq(set(), set(a))
-        eq(set(), set(a.keys()))
-        eq(set(), set(a.values()))
-        eq(set(), set(a.items()))
+        assert 0 == len(a)
+        assert set() == set(a)
+        assert set() == set(a.keys())
+        assert set() == set(a.values())
+        assert set() == set(a.items())
 
         a['foo'] = 'bar'
         a['baz'] = 42
 
-        eq(2, len(a))
-        eq({'foo', 'baz'}, set(a))
-        eq({'foo', 'baz'}, set(a.keys()))
-        eq({'bar', 42}, set(a.values()))
-        eq({('foo', 'bar'), ('baz', 42)}, set(a.items()))
+        assert 2 == len(a)
+        assert {'foo', 'baz'} == set(a)
+        assert {'foo', 'baz'} == set(a.keys())
+        assert {'bar', 42} == set(a.values())
+        assert {('foo', 'bar'), ('baz', 42)} == set(a.items())
 
     def test_read_only(self):
         store = dict()
         a = self.init_attributes(store, read_only=True)
         store['attrs'] = json.dumps(dict(foo='bar', baz=42)).encode('ascii')
-        eq(a['foo'], 'bar')
-        eq(a['baz'], 42)
-        with assert_raises(PermissionError):
+        assert a['foo'] == 'bar'
+        assert a['baz'] == 42
+        with pytest.raises(PermissionError):
             a['foo'] = 'quux'
-        with assert_raises(PermissionError):
+        with pytest.raises(PermissionError):
             del a['foo']
-        with assert_raises(PermissionError):
+        with pytest.raises(PermissionError):
             a.update(foo='quux')
 
     def test_key_completions(self):
@@ -118,108 +118,108 @@ def test_caching_on(self):
 
         # setup store
         store = CountingDict()
-        eq(0, store.counter['__getitem__', 'attrs'])
-        eq(0, store.counter['__setitem__', 'attrs'])
+        assert 0 == store.counter['__getitem__', 'attrs']
+        assert 0 == store.counter['__setitem__', 'attrs']
         store['attrs'] = json.dumps(dict(foo='xxx', bar=42)).encode('ascii')
-        eq(0, store.counter['__getitem__', 'attrs'])
-        eq(1, store.counter['__setitem__', 'attrs'])
+        assert 0 == store.counter['__getitem__', 'attrs']
+        assert 1 == store.counter['__setitem__', 'attrs']
 
         # setup attributes
         a = self.init_attributes(store)
 
         # test __getitem__ causes all attributes to be cached
-        eq(a['foo'], 'xxx')
-        eq(1, store.counter['__getitem__', 'attrs'])
-        eq(a['bar'], 42)
-        eq(1, store.counter['__getitem__', 'attrs'])
-        eq(a['foo'], 'xxx')
-        eq(1, store.counter['__getitem__', 'attrs'])
+        assert a['foo'] == 'xxx'
+        assert 1 == store.counter['__getitem__', 'attrs']
+        assert a['bar'] == 42
+        assert 1 == store.counter['__getitem__', 'attrs']
+        assert a['foo'] == 'xxx'
+        assert 1 == store.counter['__getitem__', 'attrs']
 
         # test __setitem__ updates the cache
         a['foo'] = 'yyy'
-        eq(2, store.counter['__getitem__', 'attrs'])
-        eq(2, store.counter['__setitem__', 'attrs'])
-        eq(a['foo'], 'yyy')
-        eq(2, store.counter['__getitem__', 'attrs'])
-        eq(2, store.counter['__setitem__', 'attrs'])
+        assert 2 == store.counter['__getitem__', 'attrs']
+        assert 2 == store.counter['__setitem__', 'attrs']
+        assert a['foo'] == 'yyy'
+        assert 2 == store.counter['__getitem__', 'attrs']
+        assert 2 == store.counter['__setitem__', 'attrs']
 
         # test update() updates the cache
         a.update(foo='zzz', bar=84)
-        eq(3, store.counter['__getitem__', 'attrs'])
-        eq(3, store.counter['__setitem__', 'attrs'])
-        eq(a['foo'], 'zzz')
-        eq(a['bar'], 84)
-        eq(3, store.counter['__getitem__', 'attrs'])
-        eq(3, store.counter['__setitem__', 'attrs'])
+        assert 3 == store.counter['__getitem__', 'attrs']
+        assert 3 == store.counter['__setitem__', 'attrs']
+        assert a['foo'] == 'zzz'
+        assert a['bar'] == 84
+        assert 3 == store.counter['__getitem__', 'attrs']
+        assert 3 == store.counter['__setitem__', 'attrs']
 
         # test __contains__ uses the cache
         assert 'foo' in a
-        eq(3, store.counter['__getitem__', 'attrs'])
-        eq(3, store.counter['__setitem__', 'attrs'])
+        assert 3 == store.counter['__getitem__', 'attrs']
+        assert 3 == store.counter['__setitem__', 'attrs']
         assert 'spam' not in a
-        eq(3, store.counter['__getitem__', 'attrs'])
-        eq(3, store.counter['__setitem__', 'attrs'])
+        assert 3 == store.counter['__getitem__', 'attrs']
+        assert 3 == store.counter['__setitem__', 'attrs']
 
         # test __delitem__ updates the cache
         del a['bar']
-        eq(4, store.counter['__getitem__', 'attrs'])
-        eq(4, store.counter['__setitem__', 'attrs'])
+        assert 4 == store.counter['__getitem__', 'attrs']
+        assert 4 == store.counter['__setitem__', 'attrs']
         assert 'bar' not in a
-        eq(4, store.counter['__getitem__', 'attrs'])
-        eq(4, store.counter['__setitem__', 'attrs'])
+        assert 4 == store.counter['__getitem__', 'attrs']
+        assert 4 == store.counter['__setitem__', 'attrs']
 
         # test refresh()
         store['attrs'] = json.dumps(dict(foo='xxx', bar=42)).encode('ascii')
-        eq(4, store.counter['__getitem__', 'attrs'])
+        assert 4 == store.counter['__getitem__', 'attrs']
         a.refresh()
-        eq(5, store.counter['__getitem__', 'attrs'])
-        eq(a['foo'], 'xxx')
-        eq(5, store.counter['__getitem__', 'attrs'])
-        eq(a['bar'], 42)
-        eq(5, store.counter['__getitem__', 'attrs'])
+        assert 5 == store.counter['__getitem__', 'attrs']
+        assert a['foo'] == 'xxx'
+        assert 5 == store.counter['__getitem__', 'attrs']
+        assert a['bar'] == 42
+        assert 5 == store.counter['__getitem__', 'attrs']
 
     def test_caching_off(self):
 
         # setup store
         store = CountingDict()
-        eq(0, store.counter['__getitem__', 'attrs'])
-        eq(0, store.counter['__setitem__', 'attrs'])
+        assert 0 == store.counter['__getitem__', 'attrs']
+        assert 0 == store.counter['__setitem__', 'attrs']
         store['attrs'] = json.dumps(dict(foo='xxx', bar=42)).encode('ascii')
-        eq(0, store.counter['__getitem__', 'attrs'])
-        eq(1, store.counter['__setitem__', 'attrs'])
+        assert 0 == store.counter['__getitem__', 'attrs']
+        assert 1 == store.counter['__setitem__', 'attrs']
 
         # setup attributes
         a = self.init_attributes(store, cache=False)
 
         # test __getitem__
-        eq(a['foo'], 'xxx')
-        eq(1, store.counter['__getitem__', 'attrs'])
-        eq(a['bar'], 42)
-        eq(2, store.counter['__getitem__', 'attrs'])
-        eq(a['foo'], 'xxx')
-        eq(3, store.counter['__getitem__', 'attrs'])
+        assert a['foo'] == 'xxx'
+        assert 1 == store.counter['__getitem__', 'attrs']
+        assert a['bar'] == 42
+        assert 2 == store.counter['__getitem__', 'attrs']
+        assert a['foo'] == 'xxx'
+        assert 3 == store.counter['__getitem__', 'attrs']
 
         # test __setitem__
         a['foo'] = 'yyy'
-        eq(4, store.counter['__getitem__', 'attrs'])
-        eq(2, store.counter['__setitem__', 'attrs'])
-        eq(a['foo'], 'yyy')
-        eq(5, store.counter['__getitem__', 'attrs'])
-        eq(2, store.counter['__setitem__', 'attrs'])
+        assert 4 == store.counter['__getitem__', 'attrs']
+        assert 2 == store.counter['__setitem__', 'attrs']
+        assert a['foo'] == 'yyy'
+        assert 5 == store.counter['__getitem__', 'attrs']
+        assert 2 == store.counter['__setitem__', 'attrs']
 
         # test update()
         a.update(foo='zzz', bar=84)
-        eq(6, store.counter['__getitem__', 'attrs'])
-        eq(3, store.counter['__setitem__', 'attrs'])
-        eq(a['foo'], 'zzz')
-        eq(a['bar'], 84)
-        eq(8, store.counter['__getitem__', 'attrs'])
-        eq(3, store.counter['__setitem__', 'attrs'])
+        assert 6 == store.counter['__getitem__', 'attrs']
+        assert 3 == store.counter['__setitem__', 'attrs']
+        assert a['foo'] == 'zzz'
+        assert a['bar'] == 84
+        assert 8 == store.counter['__getitem__', 'attrs']
+        assert 3 == store.counter['__setitem__', 'attrs']
 
         # test __contains__
         assert 'foo' in a
-        eq(9, store.counter['__getitem__', 'attrs'])
-        eq(3, store.counter['__setitem__', 'attrs'])
+        assert 9 == store.counter['__getitem__', 'attrs']
+        assert 3 == store.counter['__setitem__', 'attrs']
         assert 'spam' not in a
-        eq(10, store.counter['__getitem__', 'attrs'])
-        eq(3, store.counter['__setitem__', 'attrs'])
+        assert 10 == store.counter['__getitem__', 'attrs']
+        assert 3 == store.counter['__setitem__', 'attrs']