coverage to 100%

Author: alimanfoo

zarr/storage.py

@@ -539,7 +539,7 @@ def __setitem__(self, key, value):
         if not os.path.exists(dir_path):
             try:
                 os.makedirs(dir_path)
-            except NotADirectoryError:
+            except Exception:
                 raise KeyError(key)
 
         # write to temporary file

zarr/tests/test_core.py

@@ -6,7 +6,6 @@
 import shutil
 import pickle
 import os
-from collections import OrderedDict
 
 
 import numpy as np
@@ -18,6 +17,7 @@
 
 from zarr.core import Array
 from zarr.errors import ReadOnlyError
+from zarr.compat import PY2
 
 
 class TestArray(unittest.TestCase):
@@ -512,28 +512,29 @@ def test_pickle(self):
             assert_array_equal(z[:], z2[:])
 
     def test_repr(self):
+        if not PY2:
 
-        # 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)
+            # 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)
+            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)
+            actual = repr(z)
+            for l1, l2 in zip(expect.split('\n'), actual.split('\n')):
+                eq(l1, l2)

zarr/tests/test_hierarchy.py

@@ -509,6 +509,35 @@ def test_array_creation(self):
         with assert_raises(ReadOnlyError):
             grp.full_like('aa', a)
 
+    def test_paths(self):
+        store = self.create_store()
+        init_group(store)
+        g1 = Group(store=store)
+        g2 = g1.create_group('foo/bar')
+
+        eq(g1, g1['/'])
+        eq(g1, g1['//'])
+        eq(g1, g1['///'])
+        eq(g1, g2['/'])
+        eq(g1, g2['//'])
+        eq(g1, g2['///'])
+        eq(g2, g1['foo/bar'])
+        eq(g2, g1['/foo/bar'])
+        eq(g2, g1['foo/bar/'])
+        eq(g2, g1['//foo/bar'])
+        eq(g2, g1['//foo//bar//'])
+        eq(g2, g1['///foo///bar///'])
+        eq(g2, g2['/foo/bar'])
+
+        with assert_raises(ValueError):
+            g1['']
+            g1['.']
+            g1['..']
+            g1['foo/.']
+            g1['foo/..']
+            g1['foo/./bar']
+            g1['foo/../bar']
+
 
 class TestGroupDictStore(TestGroup):
 

zarr/util.py

@@ -196,17 +196,12 @@ def normalize_storage_path(path):
         path = path.replace('\\', '/')
 
         # ensure no leading slash
-        while path[0] == '/':
+        while len(path) > 0 and path[0] == '/':
             path = path[1:]
-            if not path:
-                break
 
         # ensure no trailing slash
-        if path:
-            while path[-1] == '/':
-                path = path[:-1]
-                if not path:
-                    break
+        while len(path) > 0 and path[-1] == '/':
+            path = path[:-1]
 
         # collapse any repeated slashes
         previous_char = None