increase test coverage

Author: alimanfoo

zarr/compat.py

@@ -9,19 +9,13 @@
 
 if PY2:  # pragma: no cover
 
-    def itervalues(d, **kw):
-        return d.itervalues(**kw)
-
     text_type = unicode
     binary_type = str
     integer_types = (int, long)
     reduce = reduce
 
 else:
 
-    def itervalues(d, **kw):
-        return iter(d.values(**kw))
-
     text_type = str
     binary_type = bytes
     integer_types = int,

zarr/core.py

@@ -82,10 +82,6 @@ def __init__(self, store, path=None, readonly=False):
             self._key_prefix = ''
         self._readonly = readonly
 
-        # guard conditions
-        if contains_group(store, path=self._path):
-            raise ValueError('store contains a group')
-
         # initialise metadata
         try:
             mkey = self._key_prefix + array_meta_key

zarr/creation.py

@@ -320,33 +320,42 @@ def open_array(path, mode='a', shape=None, chunks=None, dtype=None,
     # w- or x : create, fail if exists
     # a : read/write if exists, create otherwise (default)
 
-    # ensure directory exists
-    # TODO is this needed any more? DirectoryStore creates directory on demand
-    if not os.path.exists(path):
-        if mode in ['w', 'w-', 'x', 'a']:
-            os.makedirs(path)
-        elif mode in ['r', 'r+']:
-            raise ValueError('path does not exist: %r' % path)
-
     # setup store
     store = DirectoryStore(path)
 
-    # store can either hold array or group, not both
-    if contains_group(store):
-        raise ValueError('path contains group')
+    # ensure store is initialized
 
-    exists = contains_array(store)
+    if mode in ['r', 'r+']:
+        if contains_group(store):
+            raise ValueError('store contains group')
+        elif not contains_array(store):
+            raise ValueError('array does not exist')
 
-    # ensure store is initialized
-    if mode in ['r', 'r+'] and not exists:
-        raise ValueError('array does not exist')
-    elif mode in ['w-', 'x'] and exists:
-        raise ValueError('array exists')
-    elif mode == 'w' or (mode in ['a', 'w-', 'x'] and not exists):
+    elif mode == 'w':
         init_array(store, shape=shape, chunks=chunks, dtype=dtype,
                    compression=compression, compression_opts=compression_opts,
                    fill_value=fill_value, order=order, overwrite=True)
 
+    elif mode == 'a':
+        if contains_group(store):
+            raise ValueError('store contains group')
+        elif not contains_array(store):
+            init_array(store, shape=shape, chunks=chunks, dtype=dtype,
+                       compression=compression,
+                       compression_opts=compression_opts,
+                       fill_value=fill_value, order=order)
+
+    elif mode in ['w-', 'x']:
+        if contains_group(store):
+            raise ValueError('store contains group')
+        elif contains_array(store):
+            raise ValueError('store contains array')
+        else:
+            init_array(store, shape=shape, chunks=chunks, dtype=dtype,
+                       compression=compression,
+                       compression_opts=compression_opts,
+                       fill_value=fill_value, order=order)
+
     # determine readonly status
     readonly = mode == 'r'
 

zarr/tests/test_core.py

@@ -6,13 +6,14 @@
 import shutil
 import pickle
 import os
+from collections import OrderedDict
 
 
 import numpy as np
 from numpy.testing import assert_array_equal
 from nose.tools import eq_ as eq, assert_is_instance, \
-    assert_raises, assert_true, assert_false
-from zarr.storage import DirectoryStore, ZipStore, init_array
+    assert_raises, assert_true, assert_false, assert_is, assert_is_none
+from zarr.storage import DirectoryStore, ZipStore, init_array, init_group
 
 
 from zarr.core import Array
@@ -22,44 +23,99 @@
 class TestArray(unittest.TestCase):
 
     def test_array_init(self):
-        store = dict()  # store not initialised
+
+        # normal initialization
+        store = dict()
+        init_array(store, shape=100, chunks=10)
+        a = Array(store)
+        assert_is_instance(a, Array)
+        eq((100,), a.shape)
+        eq((10,), a.chunks)
+        eq('', a.path)
+        assert_is_none(a.name)
+        assert_is(store, a.store)
+
+        # initialize at path
+        store = dict()
+        init_array(store, shape=100, chunks=10, path='foo/bar')
+        a = Array(store, path='foo/bar')
+        assert_is_instance(a, Array)
+        eq((100,), a.shape)
+        eq((10,), a.chunks)
+        eq('foo/bar', a.path)
+        eq('/foo/bar', a.name)
+        assert_is(store, a.store)
+
+        # store not initialized
+        store = dict()
         with assert_raises(ValueError):
             Array(store)
 
+        # group is in the way
+        store = dict()
+        init_group(store, path='baz')
+        with assert_raises(ValueError):
+            Array(store, path='baz')
+
     @staticmethod
-    def create_array(store=None, readonly=False, **kwargs):
+    def create_array(store=None, path=None, readonly=False, **kwargs):
         if store is None:
             store = dict()
-        init_array(store, **kwargs)
-        return Array(store, readonly=readonly)
+        init_array(store, path=path, **kwargs)
+        return Array(store, path=path, readonly=readonly)
 
     def test_nbytes_stored(self):
 
+        # custom store, does not implement getsize()
+        class CustomMapping(object):
+            def __init__(self):
+                self.inner = dict()
+
+            def __getitem__(self, item):
+                return self.inner[item]
+
+            def __setitem__(self, item, value):
+                self.inner[item] = value
+
+            def __contains__(self, item):
+                return item in self.inner
+
+        store = CustomMapping()
+        z = self.create_array(store=store, shape=1000, chunks=100)
+        eq(-1, z.nbytes_stored)
+        z[:] = 42
+        eq(-1, z.nbytes_stored)
+
+        # dict as store
         store = dict()
         z = self.create_array(store=store, shape=1000, chunks=100)
         eq(sum(len(v) for v in store.values()), z.nbytes_stored)
         z[:] = 42
         eq(sum(len(v) for v in store.values()), z.nbytes_stored)
+        # mess with store
+        store['foo'] = list(range(10))
+        eq(-1, z.nbytes_stored)
+
+        # for comparison
+        z = self.create_array(store=dict(), shape=1000, chunks=100,
+                              compression='zlib', compression_opts=1)
+        z[:] = 42
 
         # DirectoryStore
         path = mkdtemp()
         atexit.register(shutil.rmtree, path)
         store = DirectoryStore(path)
-        z = self.create_array(store=store, shape=1000, chunks=100,
-                              compression='zlib', compression_opts=1,
-                              fill_value=0)
-        eq(sum(len(v) for v in store.values()), z.nbytes_stored)
-        z[:] = 42
-        eq(sum(len(v) for v in store.values()), z.nbytes_stored)
+        zz = self.create_array(store=store, shape=1000, chunks=100,
+                               compression='zlib', compression_opts=1)
+        zz[:] = 42
+        eq(z.nbytes_stored, zz.nbytes_stored)
 
         # ZipStore
         if os.path.exists('test.zip'):
             os.remove('test.zip')
         store = ZipStore('test.zip')
-        z = self.create_array(store=store, shape=1000, chunks=100,
-                              compression='zlib', compression_opts=1,
-                              fill_value=0)
-        zz = Array(store)
+        zz = self.create_array(store=store, shape=1000, chunks=100,
+                               compression='zlib', compression_opts=1)
         zz[:] = 42
         eq(z.nbytes_stored, zz.nbytes_stored)
 
@@ -454,3 +510,30 @@ def test_pickle(self):
             eq(z.compression_opts, z2.compression_opts)
             eq(z.fill_value, z2.fill_value)
             assert_array_equal(z[:], z2[:])
+
+    def test_repr(self):
+
+        # no path
+        z = self.create_array(shape=100, chunks=10, dtype='f4',
+                              compression='zlib', compression_opts=1)
+        expect = """zarr.core.Array((100,), float32, chunks=(10,), order=C)
+  compression: zlib; compression_opts: 1
+  nbytes: 400; nbytes_stored: 210; ratio: 1.9; initialized: 0/10
+  store: builtins.dict
+"""
+        actual = repr(z)
+        for l1, l2 in zip(expect.split('\n'), actual.split('\n')):
+            eq(l1, l2)
+
+        # with path
+        z = self.create_array(path='foo/bar', shape=100, chunks=10, dtype='f4',
+                              compression='zlib', compression_opts=1)
+        # flake8: noqa
+        expect = """zarr.core.Array(/foo/bar, (100,), float32, chunks=(10,), order=C)
+  compression: zlib; compression_opts: 1
+  nbytes: 400; nbytes_stored: 210; ratio: 1.9; initialized: 0/10
+  store: builtins.dict
+"""
+        actual = repr(z)
+        for l1, l2 in zip(expect.split('\n'), actual.split('\n')):
+            eq(l1, l2)

zarr/tests/test_creation.py

@@ -12,11 +12,13 @@
 from numpy.testing import assert_array_equal
 
 
-from zarr.creation import array, empty, zeros, ones, full, open, empty_like, \
-    zeros_like, ones_like, full_like, open_like, create
+from zarr.creation import array, empty, zeros, ones, full, open_array, \
+    empty_like, zeros_like, ones_like, full_like, open_like, create
 from zarr.sync import ThreadSynchronizer, SynchronizedArray
 from zarr.core import Array
 from zarr.storage import DirectoryStore, init_array
+from zarr.hierarchy import open_group
+from zarr.errors import ReadOnlyError
 
 
 def test_array():
@@ -93,45 +95,72 @@ def test_full():
     assert_array_equal(np.full(100, fill_value=42, dtype='i4'), z[:])
 
 
-def test_open():
+def test_open_array():
 
-    path = tempfile.mktemp()
-    atexit.register(
-        lambda: shutil.rmtree(path) if os.path.exists(path) else None
-    )
-    z = open(path, mode='w', shape=100, chunks=10, dtype='i4')
+    path = 'example'
+
+    # mode == 'w'
+    z = open_array(path, mode='w', shape=100, chunks=10)
     z[:] = 42
+    assert_is_instance(z, Array)
+    assert_is_instance(z.store, DirectoryStore)
     eq((100,), z.shape)
     eq((10,), z.chunks)
-    assert_array_equal(np.full(100, fill_value=42, dtype='i4'), z[:])
-    z2 = open(path, mode='r')
-    eq((100,), z2.shape)
-    eq((10,), z2.chunks)
-    assert_array_equal(z[:], z2[:])
-
-    # path does not exist
-    path = 'doesnotexist'
-    with assert_raises(ValueError):
-        open(path, mode='r')
-
-    # path exists but store not initialised
-    path = tempfile.mkdtemp()
-    atexit.register(shutil.rmtree, path)
-    with assert_raises(ValueError):
-        open(path, mode='r')
-    with assert_raises(ValueError):
-        open(path, mode='r+')
+    assert_array_equal(np.full(100, fill_value=42), z[:])
+
+    # mode in 'r', 'r+'
+    open_group('example_group', mode='w')
+    for mode in 'r', 'r+':
+        with assert_raises(ValueError):
+            open_array('doesnotexist', mode=mode)
+        with assert_raises(ValueError):
+            open_array('example_group', mode=mode)
+    z = open_array(path, mode='r')
+    assert_is_instance(z, Array)
+    assert_is_instance(z.store, DirectoryStore)
+    eq((100,), z.shape)
+    eq((10,), z.chunks)
+    assert_array_equal(np.full(100, fill_value=42), z[:])
+    with assert_raises(ReadOnlyError):
+        z[:] = 43
+    z = open_array(path, mode='r+')
+    assert_is_instance(z, Array)
+    assert_is_instance(z.store, DirectoryStore)
+    eq((100,), z.shape)
+    eq((10,), z.chunks)
+    assert_array_equal(np.full(100, fill_value=42), z[:])
+    z[:] = 43
+    assert_array_equal(np.full(100, fill_value=43), z[:])
 
-    # store initialised, mode w-
-    store = DirectoryStore(path)
-    init_array(store, shape=100, chunks=10)
-    with assert_raises(ValueError):
-        open(path, mode='w-')
+    # mode == 'a'
+    shutil.rmtree(path)
+    z = open_array(path, mode='a', shape=100, chunks=10)
+    z[:] = 42
+    assert_is_instance(z, Array)
+    assert_is_instance(z.store, DirectoryStore)
+    eq((100,), z.shape)
+    eq((10,), z.chunks)
+    assert_array_equal(np.full(100, fill_value=42), z[:])
     with assert_raises(ValueError):
-        open(path, mode='x')
+        open_array('example_group', mode='a')
+
+    # mode in 'w-', 'x'
+    for mode in 'w-', 'x':
+        shutil.rmtree(path)
+        z = open_array(path, mode=mode, shape=100, chunks=10)
+        z[:] = 42
+        assert_is_instance(z, Array)
+        assert_is_instance(z.store, DirectoryStore)
+        eq((100,), z.shape)
+        eq((10,), z.chunks)
+        assert_array_equal(np.full(100, fill_value=42), z[:])
+        with assert_raises(ValueError):
+            open_array(path, mode=mode)
+        with assert_raises(ValueError):
+            open_array('example_group', mode=mode)
 
     # with synchronizer
-    z = open(path, synchronizer=ThreadSynchronizer())
+    z = open_array(path, synchronizer=ThreadSynchronizer())
     assert_is_instance(z, SynchronizedArray)