diff --git a/docs/tutorial.rst b/docs/tutorial.rst
index 68673f1295..18c232ae40 100644
--- a/docs/tutorial.rst
+++ b/docs/tutorial.rst
@@ -176,7 +176,7 @@ print some diagnostics, e.g.::
     Read-only          : False
     Compressor         : Blosc(cname='zstd', clevel=3, shuffle=BITSHUFFLE,
                        : blocksize=0)
-    Store type         : builtins.dict
+    Store type         : zarr.storage.KVStore
     No. bytes          : 400000000 (381.5M)
     No. bytes stored   : 3379344 (3.2M)
     Storage ratio      : 118.4
@@ -268,7 +268,7 @@ Here is an example using a delta filter with the Blosc compressor::
     Read-only          : False
     Filter [0]         : Delta(dtype='<i4')
     Compressor         : Blosc(cname='zstd', clevel=1, shuffle=SHUFFLE, blocksize=0)
-    Store type         : builtins.dict
+    Store type         : zarr.storage.KVStore
     No. bytes          : 400000000 (381.5M)
     No. bytes stored   : 1290562 (1.2M)
     Storage ratio      : 309.9
@@ -805,8 +805,10 @@ Here is an example using S3Map to read an array created previously::
     Order              : C
     Read-only          : False
     Compressor         : Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
-    Store type         : fsspec.mapping.FSMap
+    Store type         : zarr.storage.KVStore
     No. bytes          : 21
+    No. bytes stored   : 382
+    Storage ratio      : 0.1
     Chunks initialized : 3/3
     >>> z[:]
     array([b'H', b'e', b'l', b'l', b'o', b' ', b'f', b'r', b'o', b'm', b' ',
@@ -1274,7 +1276,7 @@ ratios, depending on the correlation structure within the data. E.g.::
     Order              : C
     Read-only          : False
     Compressor         : Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
-    Store type         : builtins.dict
+    Store type         : zarr.storage.KVStore
     No. bytes          : 400000000 (381.5M)
     No. bytes stored   : 6696010 (6.4M)
     Storage ratio      : 59.7
@@ -1288,7 +1290,7 @@ ratios, depending on the correlation structure within the data. E.g.::
     Order              : F
     Read-only          : False
     Compressor         : Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
-    Store type         : builtins.dict
+    Store type         : zarr.storage.KVStore
     No. bytes          : 400000000 (381.5M)
     No. bytes stored   : 4684636 (4.5M)
     Storage ratio      : 85.4
diff --git a/mypy.ini b/mypy.ini
index cb3c188f47..7c1be49cd6 100644
--- a/mypy.ini
+++ b/mypy.ini
@@ -1,4 +1,4 @@
 [mypy]
-python_version = 3.7
+python_version = 3.8
 ignore_missing_imports = True
 follow_imports = silent
diff --git a/pytest.ini b/pytest.ini
index 61a0a99ab5..8e3c0adb22 100644
--- a/pytest.ini
+++ b/pytest.ini
@@ -3,4 +3,6 @@ doctest_optionflags = NORMALIZE_WHITESPACE ELLIPSIS IGNORE_EXCEPTION_DETAIL
 addopts = --durations=10
 filterwarnings =
     error::DeprecationWarning:zarr.*
+    error::UserWarning:zarr.*
     ignore:PY_SSIZE_T_CLEAN will be required.*:DeprecationWarning
+    ignore:The loop argument is deprecated since Python 3.8.*:DeprecationWarning
diff --git a/zarr/_storage/absstore.py b/zarr/_storage/absstore.py
index 0dc5bf1892..01bfbd5039 100644
--- a/zarr/_storage/absstore.py
+++ b/zarr/_storage/absstore.py
@@ -1,16 +1,16 @@
 """This module contains storage classes related to Azure Blob Storage (ABS)"""
 
 import warnings
-from collections.abc import MutableMapping
 from numcodecs.compat import ensure_bytes
 from zarr.util import normalize_storage_path
+from zarr._storage.store import Store
 
 __doctest_requires__ = {
     ('ABSStore', 'ABSStore.*'): ['azure.storage.blob'],
 }
 
 
-class ABSStore(MutableMapping):
+class ABSStore(Store):
     """Storage class using Azure Blob Storage (ABS).
 
     Parameters
diff --git a/zarr/_storage/store.py b/zarr/_storage/store.py
new file mode 100644
index 0000000000..a779a4e26a
--- /dev/null
+++ b/zarr/_storage/store.py
@@ -0,0 +1,166 @@
+from collections.abc import MutableMapping
+from typing import Any, List, Optional, Union
+
+from zarr.util import normalize_storage_path
+
+# v2 store keys
+array_meta_key = '.zarray'
+group_meta_key = '.zgroup'
+attrs_key = '.zattrs'
+
+
+class BaseStore(MutableMapping):
+    """Abstract base class for store implementations.
+
+    This is a thin wrapper over MutableMapping that provides methods to check
+    whether a store is readable, writeable, eraseable and or listable.
+
+    Stores cannot be mutable mapping as they do have a couple of other
+    requirements that would break Liskov substitution principle (stores only
+    allow strings as keys, mutable mapping are more generic).
+
+    Having no-op base method also helps simplifying store usage and do not need
+    to check the presence of attributes and methods, like `close()`.
+
+    Stores can be used as context manager to make sure they close on exit.
+
+    .. added: 2.11.0
+
+    """
+
+    _readable = True
+    _writeable = True
+    _erasable = True
+    _listable = True
+
+    def is_readable(self):
+        return self._readable
+
+    def is_writeable(self):
+        return self._writeable
+
+    def is_listable(self):
+        return self._listable
+
+    def is_erasable(self):
+        return self._erasable
+
+    def __enter__(self):
+        if not hasattr(self, "_open_count"):
+            self._open_count = 0
+        self._open_count += 1
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._open_count -= 1
+        if self._open_count == 0:
+            self.close()
+
+    def close(self) -> None:
+        """Do nothing by default"""
+        pass
+
+    def rename(self, src_path: str, dst_path: str) -> None:
+        if not self.is_erasable():
+            raise NotImplementedError(
+                f'{type(self)} is not erasable, cannot call "rename"'
+            )  # pragma: no cover
+        _rename_from_keys(self, src_path, dst_path)
+
+    @staticmethod
+    def _ensure_store(store: Any):
+        """
+        We want to make sure internally that zarr stores are always a class
+        with a specific interface derived from ``BaseStore``, which is slightly
+        different than ``MutableMapping``.
+
+        We'll do this conversion in a few places automatically
+        """
+        from zarr.storage import KVStore  # avoid circular import
+
+        if store is None:
+            return None
+        elif isinstance(store, BaseStore):
+            return store
+        elif isinstance(store, MutableMapping):
+            return KVStore(store)
+        else:
+            for attr in [
+                "keys",
+                "values",
+                "get",
+                "__setitem__",
+                "__getitem__",
+                "__delitem__",
+                "__contains__",
+            ]:
+                if not hasattr(store, attr):
+                    break
+            else:
+                return KVStore(store)
+
+        raise ValueError(
+            "Starting with Zarr 2.11.0, stores must be subclasses of "
+            "BaseStore, if your store exposes the MutableMapping interface "
+            f"wrap it in Zarr.storage.KVStore. Got {store}"
+        )
+
+
+class Store(BaseStore):
+    """Abstract store class used by implementations following the Zarr v2 spec.
+
+    Adds public `listdir`, `rename`, and `rmdir` methods on top of BaseStore.
+
+    .. added: 2.11.0
+
+    """
+    def listdir(self, path: str = "") -> List[str]:
+        path = normalize_storage_path(path)
+        return _listdir_from_keys(self, path)
+
+    def rmdir(self, path: str = "") -> None:
+        if not self.is_erasable():
+            raise NotImplementedError(
+                f'{type(self)} is not erasable, cannot call "rmdir"'
+            )  # pragma: no cover
+        path = normalize_storage_path(path)
+        _rmdir_from_keys(self, path)
+
+
+def _path_to_prefix(path: Optional[str]) -> str:
+    # assume path already normalized
+    if path:
+        prefix = path + '/'
+    else:
+        prefix = ''
+    return prefix
+
+
+def _rename_from_keys(store: BaseStore, src_path: str, dst_path: str) -> None:
+    # assume path already normalized
+    src_prefix = _path_to_prefix(src_path)
+    dst_prefix = _path_to_prefix(dst_path)
+    for key in list(store.keys()):
+        if key.startswith(src_prefix):
+            new_key = dst_prefix + key.lstrip(src_prefix)
+            store[new_key] = store.pop(key)
+
+
+def _rmdir_from_keys(store: Union[BaseStore, MutableMapping], path: Optional[str] = None) -> None:
+    # assume path already normalized
+    prefix = _path_to_prefix(path)
+    for key in list(store.keys()):
+        if key.startswith(prefix):
+            del store[key]
+
+
+def _listdir_from_keys(store: BaseStore, path: Optional[str] = None) -> List[str]:
+    # assume path already normalized
+    prefix = _path_to_prefix(path)
+    children = set()
+    for key in list(store.keys()):
+        if key.startswith(prefix) and len(key) > len(prefix):
+            suffix = key[len(prefix):]
+            child = suffix.split('/')[0]
+            children.add(child)
+    return sorted(children)
diff --git a/zarr/attrs.py b/zarr/attrs.py
index ea6b831608..ec01dbe04f 100644
--- a/zarr/attrs.py
+++ b/zarr/attrs.py
@@ -1,6 +1,7 @@
 from collections.abc import MutableMapping
 
 from zarr.meta import parse_metadata
+from zarr._storage.store import Store
 from zarr.util import json_dumps
 
 
@@ -26,7 +27,7 @@ class Attributes(MutableMapping):
 
     def __init__(self, store, key='.zattrs', read_only=False, cache=True,
                  synchronizer=None):
-        self.store = store
+        self.store = Store._ensure_store(store)
         self.key = key
         self.read_only = read_only
         self.cache = cache
diff --git a/zarr/convenience.py b/zarr/convenience.py
index 80cf7fffd4..18b59a77b2 100644
--- a/zarr/convenience.py
+++ b/zarr/convenience.py
@@ -3,7 +3,7 @@
 import itertools
 import os
 import re
-from collections.abc import Mapping
+from collections.abc import Mapping, MutableMapping
 
 from zarr.core import Array
 from zarr.creation import array as _create_array
@@ -13,17 +13,21 @@
 from zarr.hierarchy import group as _create_group
 from zarr.hierarchy import open_group
 from zarr.meta import json_dumps, json_loads
-from zarr.storage import contains_array, contains_group
+from zarr.storage import contains_array, contains_group, BaseStore
 from zarr.util import TreeViewer, buffer_size, normalize_storage_path
 
+from typing import Union
+
+StoreLike = Union[BaseStore, MutableMapping, str, None]
+
 
 # noinspection PyShadowingBuiltins
-def open(store=None, mode='a', **kwargs):
+def open(store: StoreLike = None, mode: str = "a", **kwargs):
     """Convenience function to open a group or array using file-mode-like semantics.
 
     Parameters
     ----------
-    store : MutableMapping or string, optional
+    store : Store or string, optional
         Store or path to directory in file system or name of zip file.
     mode : {'r', 'r+', 'a', 'w', 'w-'}, optional
         Persistence mode: 'r' means read only (must exist); 'r+' means
@@ -76,27 +80,28 @@ def open(store=None, mode='a', **kwargs):
     clobber = mode == 'w'
     # we pass storage options explicitly, since normalize_store_arg might construct
     # a store if the input is a fsspec-compatible URL
-    store = normalize_store_arg(store, clobber=clobber,
-                                storage_options=kwargs.pop("storage_options", {}))
+    _store: BaseStore = normalize_store_arg(
+        store, clobber=clobber, storage_options=kwargs.pop("storage_options", {})
+    )
     path = normalize_storage_path(path)
 
     if mode in {'w', 'w-', 'x'}:
         if 'shape' in kwargs:
-            return open_array(store, mode=mode, **kwargs)
+            return open_array(_store, mode=mode, **kwargs)
         else:
-            return open_group(store, mode=mode, **kwargs)
+            return open_group(_store, mode=mode, **kwargs)
 
     elif mode == "a":
-        if "shape" in kwargs or contains_array(store, path):
-            return open_array(store, mode=mode, **kwargs)
+        if "shape" in kwargs or contains_array(_store, path):
+            return open_array(_store, mode=mode, **kwargs)
         else:
-            return open_group(store, mode=mode, **kwargs)
+            return open_group(_store, mode=mode, **kwargs)
 
     else:
-        if contains_array(store, path):
-            return open_array(store, mode=mode, **kwargs)
-        elif contains_group(store, path):
-            return open_group(store, mode=mode, **kwargs)
+        if contains_array(_store, path):
+            return open_array(_store, mode=mode, **kwargs)
+        elif contains_group(_store, path):
+            return open_group(_store, mode=mode, **kwargs)
         else:
             raise PathNotFoundError(path)
 
@@ -105,7 +110,7 @@ def _might_close(path):
     return isinstance(path, (str, os.PathLike))
 
 
-def save_array(store, arr, **kwargs):
+def save_array(store: StoreLike, arr, **kwargs):
     """Convenience function to save a NumPy array to the local file system, following a
     similar API to the NumPy save() function.
 
@@ -137,16 +142,16 @@ def save_array(store, arr, **kwargs):
 
     """
     may_need_closing = _might_close(store)
-    store = normalize_store_arg(store, clobber=True)
+    _store: BaseStore = normalize_store_arg(store, clobber=True)
     try:
-        _create_array(arr, store=store, overwrite=True, **kwargs)
+        _create_array(arr, store=_store, overwrite=True, **kwargs)
     finally:
-        if may_need_closing and hasattr(store, 'close'):
+        if may_need_closing:
             # needed to ensure zip file records are written
-            store.close()
+            _store.close()
 
 
-def save_group(store, *args, **kwargs):
+def save_group(store: StoreLike, *args, **kwargs):
     """Convenience function to save several NumPy arrays to the local file system, following a
     similar API to the NumPy savez()/savez_compressed() functions.
 
@@ -208,21 +213,21 @@ def save_group(store, *args, **kwargs):
         raise ValueError('at least one array must be provided')
     # handle polymorphic store arg
     may_need_closing = _might_close(store)
-    store = normalize_store_arg(store, clobber=True)
+    _store: BaseStore = normalize_store_arg(store, clobber=True)
     try:
-        grp = _create_group(store, overwrite=True)
+        grp = _create_group(_store, overwrite=True)
         for i, arr in enumerate(args):
             k = 'arr_{}'.format(i)
             grp.create_dataset(k, data=arr, overwrite=True)
         for k, arr in kwargs.items():
             grp.create_dataset(k, data=arr, overwrite=True)
     finally:
-        if may_need_closing and hasattr(store, 'close'):
+        if may_need_closing:
             # needed to ensure zip file records are written
-            store.close()
+            _store.close()
 
 
-def save(store, *args, **kwargs):
+def save(store: StoreLike, *args, **kwargs):
     """Convenience function to save an array or group of arrays to the local file system.
 
     Parameters
@@ -332,7 +337,7 @@ def __repr__(self):
         return r
 
 
-def load(store):
+def load(store: StoreLike):
     """Load data from an array or group into memory.
 
     Parameters
@@ -358,11 +363,11 @@ def load(store):
 
     """
     # handle polymorphic store arg
-    store = normalize_store_arg(store)
-    if contains_array(store, path=None):
-        return Array(store=store, path=None)[...]
-    elif contains_group(store, path=None):
-        grp = Group(store=store, path=None)
+    _store = normalize_store_arg(store)
+    if contains_array(_store, path=None):
+        return Array(store=_store, path=None)[...]
+    elif contains_group(_store, path=None):
+        grp = Group(store=_store, path=None)
         return LazyLoader(grp)
 
 
@@ -1078,7 +1083,7 @@ def copy_all(source, dest, shallow=False, without_attrs=False, log=None,
     return n_copied, n_skipped, n_bytes_copied
 
 
-def consolidate_metadata(store, metadata_key='.zmetadata'):
+def consolidate_metadata(store: StoreLike, metadata_key=".zmetadata"):
     """
     Consolidate all metadata for groups and arrays within the given store
     into a single resource and put it under the given key.
@@ -1129,7 +1134,7 @@ def is_zarr_key(key):
     return open_consolidated(store, metadata_key=metadata_key)
 
 
-def open_consolidated(store, metadata_key='.zmetadata', mode='r+', **kwargs):
+def open_consolidated(store: StoreLike, metadata_key=".zmetadata", mode="r+", **kwargs):
     """Open group using metadata previously consolidated into a single key.
 
     This is an optimised method for opening a Zarr group, where instead of
diff --git a/zarr/core.py b/zarr/core.py
index 6865a0694c..56b22ead8d 100644
--- a/zarr/core.py
+++ b/zarr/core.py
@@ -9,6 +9,8 @@
 import numpy as np
 from numcodecs.compat import ensure_bytes, ensure_ndarray
 
+from collections.abc import MutableMapping
+
 from zarr.attrs import Attributes
 from zarr.codecs import AsType, get_codec
 from zarr.errors import ArrayNotFoundError, ReadOnlyError, ArrayIndexError
@@ -30,7 +32,7 @@
     pop_fields,
 )
 from zarr.meta import decode_array_metadata, encode_array_metadata
-from zarr.storage import array_meta_key, attrs_key, getsize, listdir
+from zarr.storage import array_meta_key, attrs_key, getsize, listdir, BaseStore
 from zarr.util import (
     all_equal,
     InfoReporter,
@@ -145,7 +147,7 @@ class Array:
 
     def __init__(
         self,
-        store,
+        store: BaseStore,
         path=None,
         read_only=False,
         chunk_store=None,
@@ -158,6 +160,9 @@ def __init__(
         # N.B., expect at this point store is fully initialized with all
         # configuration metadata fully specified and normalized
 
+        store = BaseStore._ensure_store(store)
+        chunk_store = BaseStore._ensure_store(chunk_store)
+
         self._store = store
         self._chunk_store = chunk_store
         self._path = normalize_storage_path(path)
@@ -2113,7 +2118,7 @@ def _encode_chunk(self, chunk):
             cdata = chunk
 
         # ensure in-memory data is immutable and easy to compare
-        if isinstance(self.chunk_store, dict):
+        if isinstance(self.chunk_store, MutableMapping):
             cdata = ensure_bytes(cdata)
 
         return cdata
@@ -2146,10 +2151,10 @@ def info(self):
         Order              : C
         Read-only          : False
         Compressor         : Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
-        Store type         : builtins.dict
+        Store type         : zarr.storage.KVStore
         No. bytes          : 4000000 (3.8M)
-        No. bytes stored   : ...
-        Storage ratio      : ...
+        No. bytes stored   : 320
+        Storage ratio      : 12500.0
         Chunks initialized : 0/10
 
         """
diff --git a/zarr/creation.py b/zarr/creation.py
index 75ff1d0212..244a9b080c 100644
--- a/zarr/creation.py
+++ b/zarr/creation.py
@@ -1,4 +1,3 @@
-import os
 from warnings import warn
 
 import numpy as np
@@ -10,10 +9,9 @@
     ContainsArrayError,
     ContainsGroupError,
 )
-from zarr.n5 import N5Store
-from zarr.storage import (DirectoryStore, ZipStore, contains_array,
-                          contains_group, default_compressor, init_array,
-                          normalize_storage_path, FSStore)
+from zarr.storage import (contains_array, contains_group, default_compressor,
+                          init_array, normalize_storage_path,
+                          normalize_store_arg)
 from zarr.util import normalize_dimension_separator
 
 
@@ -157,27 +155,6 @@ def create(shape, chunks=True, dtype=None, compressor='default',
     return z
 
 
-def normalize_store_arg(store, clobber=False, storage_options=None, mode='w'):
-    if store is None:
-        return dict()
-    if isinstance(store, os.PathLike):
-        store = os.fspath(store)
-    if isinstance(store, str):
-        mode = mode if clobber else "r"
-        if "://" in store or "::" in store:
-            return FSStore(store, mode=mode, **(storage_options or {}))
-        elif storage_options:
-            raise ValueError("storage_options passed with non-fsspec path")
-        if store.endswith('.zip'):
-            return ZipStore(store, mode=mode)
-        elif store.endswith('.n5'):
-            return N5Store(store)
-        else:
-            return DirectoryStore(store)
-    else:
-        return store
-
-
 def _kwargs_compat(compressor, fill_value, kwargs):
 
     # to be compatible with h5py, as well as backwards-compatible with Zarr
diff --git a/zarr/hierarchy.py b/zarr/hierarchy.py
index 87c2178e61..402b8dd976 100644
--- a/zarr/hierarchy.py
+++ b/zarr/hierarchy.py
@@ -15,11 +15,26 @@
     ReadOnlyError,
 )
 from zarr.meta import decode_group_metadata
-from zarr.storage import (MemoryStore, attrs_key, contains_array,
-                          contains_group, group_meta_key, init_group, listdir,
-                          rename, rmdir)
-from zarr.util import (InfoReporter, TreeViewer, is_valid_python_name, nolock,
-                       normalize_shape, normalize_storage_path)
+from zarr.storage import (
+    BaseStore,
+    MemoryStore,
+    attrs_key,
+    contains_array,
+    contains_group,
+    group_meta_key,
+    init_group,
+    listdir,
+    rename,
+    rmdir,
+)
+from zarr.util import (
+    InfoReporter,
+    TreeViewer,
+    is_valid_python_name,
+    nolock,
+    normalize_shape,
+    normalize_storage_path,
+)
 
 
 class Group(MutableMapping):
@@ -96,6 +111,8 @@ class Group(MutableMapping):
 
     def __init__(self, store, path=None, read_only=False, chunk_store=None,
                  cache_attrs=True, synchronizer=None):
+        store: BaseStore = BaseStore._ensure_store(store)
+        chunk_store: BaseStore = BaseStore._ensure_store(chunk_store)
         self._store = store
         self._chunk_store = chunk_store
         self._path = normalize_storage_path(path)
@@ -237,11 +254,8 @@ def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        """If the underlying Store has a ``close`` method, call it."""
-        try:
-            self.store.close()
-        except AttributeError:
-            pass
+        """Call the close method of the underlying Store."""
+        self.store.close()
 
     def info_items(self):
 
@@ -804,11 +818,13 @@ def create_dataset(self, name, **kwargs):
         <zarr.core.Array '/bar/baz/qux' (100, 100, 100) float64>
 
         """
+        assert "mode" not in kwargs
 
         return self._write_op(self._create_dataset_nosync, name, **kwargs)
 
     def _create_dataset_nosync(self, name, data=None, **kwargs):
 
+        assert "mode" not in kwargs
         path = self._item_path(name)
 
         # determine synchronizer
diff --git a/zarr/storage.py b/zarr/storage.py
index 92be9df0aa..901011c9d2 100644
--- a/zarr/storage.py
+++ b/zarr/storage.py
@@ -31,7 +31,7 @@
 from os import scandir
 from pickle import PicklingError
 from threading import Lock, RLock
-from typing import Optional, Union, List, Tuple, Dict
+from typing import Optional, Union, List, Tuple, Dict, Any
 import uuid
 import time
 
@@ -57,6 +57,15 @@
                        normalize_shape, normalize_storage_path, retry_call)
 
 from zarr._storage.absstore import ABSStore  # noqa: F401
+from zarr._storage.store import (_listdir_from_keys,
+                                 _path_to_prefix,
+                                 _rename_from_keys,
+                                 _rmdir_from_keys,
+                                 array_meta_key,
+                                 group_meta_key,
+                                 attrs_key,
+                                 BaseStore,
+                                 Store)
 
 __doctest_requires__ = {
     ('RedisStore', 'RedisStore.*'): ['redis'],
@@ -65,9 +74,6 @@
 }
 
 
-array_meta_key = '.zarray'
-group_meta_key = '.zgroup'
-attrs_key = '.zattrs'
 try:
     # noinspection PyUnresolvedReferences
     from zarr.codecs import Blosc
@@ -78,18 +84,11 @@
 
 
 Path = Union[str, bytes, None]
+# allow MutableMapping for backwards compatibility
+StoreLike = Union[BaseStore, MutableMapping]
 
 
-def _path_to_prefix(path: Optional[str]) -> str:
-    # assume path already normalized
-    if path:
-        prefix = path + '/'
-    else:
-        prefix = ''
-    return prefix
-
-
-def contains_array(store: MutableMapping, path: Path = None) -> bool:
+def contains_array(store: StoreLike, path: Path = None) -> bool:
     """Return True if the store contains an array at the given logical path."""
     path = normalize_storage_path(path)
     prefix = _path_to_prefix(path)
@@ -97,7 +96,7 @@ def contains_array(store: MutableMapping, path: Path = None) -> bool:
     return key in store
 
 
-def contains_group(store: MutableMapping, path: Path = None) -> bool:
+def contains_group(store: StoreLike, path: Path = None) -> bool:
     """Return True if the store contains a group at the given logical path."""
     path = normalize_storage_path(path)
     prefix = _path_to_prefix(path)
@@ -105,41 +104,47 @@ def contains_group(store: MutableMapping, path: Path = None) -> bool:
     return key in store
 
 
-def _rmdir_from_keys(store: MutableMapping, path: Optional[str] = None) -> None:
-    # assume path already normalized
-    prefix = _path_to_prefix(path)
-    for key in list(store.keys()):
-        if key.startswith(prefix):
-            del store[key]
+def normalize_store_arg(store: Any, clobber=False, storage_options=None, mode="w") -> BaseStore:
+    if store is None:
+        return BaseStore._ensure_store(dict())
+    elif isinstance(store, os.PathLike):
+        store = os.fspath(store)
+    if isinstance(store, str):
+        mode = mode if clobber else "r"
+        if "://" in store or "::" in store:
+            return FSStore(store, mode=mode, **(storage_options or {}))
+        elif storage_options:
+            raise ValueError("storage_options passed with non-fsspec path")
+        if store.endswith('.zip'):
+            return ZipStore(store, mode=mode)
+        elif store.endswith('.n5'):
+            from zarr.n5 import N5Store
+            return N5Store(store)
+        else:
+            return DirectoryStore(store)
+    else:
+        if not isinstance(store, BaseStore) and isinstance(store, MutableMapping):
+            store = BaseStore._ensure_store(store)
+        return store
 
 
-def rmdir(store, path: Path = None):
+def rmdir(store: StoreLike, path: Path = None):
     """Remove all items under the given path. If `store` provides a `rmdir` method,
     this will be called, otherwise will fall back to implementation via the
-    `MutableMapping` interface."""
+    `Store` interface."""
     path = normalize_storage_path(path)
-    if hasattr(store, 'rmdir'):
+    if hasattr(store, "rmdir") and store.is_erasable():  # type: ignore
         # pass through
-        store.rmdir(path)
+        store.rmdir(path)  # type: ignore
     else:
         # slow version, delete one key at a time
         _rmdir_from_keys(store, path)
 
 
-def _rename_from_keys(store: MutableMapping, src_path: str, dst_path: str) -> None:
-    # assume path already normalized
-    src_prefix = _path_to_prefix(src_path)
-    dst_prefix = _path_to_prefix(dst_path)
-    for key in list(store.keys()):
-        if key.startswith(src_prefix):
-            new_key = dst_prefix + key.lstrip(src_prefix)
-            store[new_key] = store.pop(key)
-
-
-def rename(store, src_path: Path, dst_path: Path):
+def rename(store: BaseStore, src_path: Path, dst_path: Path):
     """Rename all items under the given path. If `store` provides a `rename` method,
     this will be called, otherwise will fall back to implementation via the
-    `MutableMapping` interface."""
+    `Store` interface."""
     src_path = normalize_storage_path(src_path)
     dst_path = normalize_storage_path(dst_path)
     if hasattr(store, 'rename'):
@@ -150,39 +155,32 @@ def rename(store, src_path: Path, dst_path: Path):
         _rename_from_keys(store, src_path, dst_path)
 
 
-def _listdir_from_keys(store: MutableMapping, path: Optional[str] = None) -> List[str]:
-    # assume path already normalized
-    prefix = _path_to_prefix(path)
-    children = set()
-    for key in list(store.keys()):
-        if key.startswith(prefix) and len(key) > len(prefix):
-            suffix = key[len(prefix):]
-            child = suffix.split('/')[0]
-            children.add(child)
-    return sorted(children)
-
-
-def listdir(store, path: Path = None):
+def listdir(store: BaseStore, path: Path = None):
     """Obtain a directory listing for the given path. If `store` provides a `listdir`
     method, this will be called, otherwise will fall back to implementation via the
     `MutableMapping` interface."""
     path = normalize_storage_path(path)
     if hasattr(store, 'listdir'):
         # pass through
-        return store.listdir(path)
+        return store.listdir(path)  # type: ignore
     else:
         # slow version, iterate through all keys
+        warnings.warn(
+            f"Store {store} has no `listdir` method. From zarr 2.9 onwards "
+            "may want to inherit from `Store`.",
+            stacklevel=2,
+        )
         return _listdir_from_keys(store, path)
 
 
-def getsize(store, path: Path = None) -> int:
+def getsize(store: BaseStore, path: Path = None) -> int:
     """Compute size of stored items for a given path. If `store` provides a `getsize`
     method, this will be called, otherwise will return -1."""
     path = normalize_storage_path(path)
     if hasattr(store, 'getsize'):
         # pass through
-        return store.getsize(path)
-    elif isinstance(store, dict):
+        return store.getsize(path)  # type: ignore
+    elif isinstance(store, MutableMapping):
         # compute from size of values
         if path in store:
             v = store[path]
@@ -208,8 +206,8 @@ def getsize(store, path: Path = None) -> int:
 
 def _require_parent_group(
     path: Optional[str],
-    store: MutableMapping,
-    chunk_store: Optional[MutableMapping],
+    store: StoreLike,
+    chunk_store: Optional[StoreLike],
     overwrite: bool,
 ):
     # assume path is normalized
@@ -225,7 +223,7 @@ def _require_parent_group(
 
 
 def init_array(
-    store: MutableMapping,
+    store: StoreLike,
     shape: Tuple[int, ...],
     chunks: Union[bool, int, Tuple[int, ...]] = True,
     dtype=None,
@@ -234,7 +232,7 @@ def init_array(
     order: str = "C",
     overwrite: bool = False,
     path: Path = None,
-    chunk_store: MutableMapping = None,
+    chunk_store: StoreLike = None,
     filters=None,
     object_codec=None,
     dimension_separator=None,
@@ -244,7 +242,7 @@ def init_array(
 
     Parameters
     ----------
-    store : MutableMapping
+    store : Store
         A mapping that supports string keys and bytes-like values.
     shape : int or tuple of ints
         Array shape.
@@ -263,7 +261,7 @@ def init_array(
         If True, erase all data in `store` prior to initialisation.
     path : string, bytes, optional
         Path under which array is stored.
-    chunk_store : MutableMapping, optional
+    chunk_store : Store, optional
         Separate storage for chunks. If not provided, `store` will be used
         for storage of both chunks and metadata.
     filters : sequence, optional
@@ -277,8 +275,8 @@ def init_array(
     --------
     Initialize an array store::
 
-        >>> from zarr.storage import init_array
-        >>> store = dict()
+        >>> from zarr.storage import init_array, KVStore
+        >>> store = KVStore(dict())
         >>> init_array(store, shape=(10000, 10000), chunks=(1000, 1000))
         >>> sorted(store.keys())
         ['.zarray']
@@ -311,7 +309,7 @@ def init_array(
 
     Initialize an array using a storage path::
 
-        >>> store = dict()
+        >>> store = KVStore(dict())
         >>> init_array(store, shape=100000000, chunks=1000000, dtype='i1', path='foo')
         >>> sorted(store.keys())
         ['.zgroup', 'foo/.zarray']
@@ -456,23 +454,23 @@ def _init_array_metadata(
 
 
 def init_group(
-    store: MutableMapping,
+    store: StoreLike,
     overwrite: bool = False,
     path: Path = None,
-    chunk_store: MutableMapping = None,
+    chunk_store: StoreLike = None,
 ):
     """Initialize a group store. Note that this is a low-level function and there should be no
     need to call this directly from user code.
 
     Parameters
     ----------
-    store : MutableMapping
+    store : Store
         A mapping that supports string keys and byte sequence values.
     overwrite : bool, optional
         If True, erase all data in `store` prior to initialisation.
     path : string, optional
         Path under which array is stored.
-    chunk_store : MutableMapping, optional
+    chunk_store : Store, optional
         Separate storage for chunks. If not provided, `store` will be used
         for storage of both chunks and metadata.
 
@@ -491,10 +489,10 @@ def init_group(
 
 
 def _init_group_metadata(
-    store: MutableMapping,
+    store: StoreLike,
     overwrite: Optional[bool] = False,
     path: Optional[str] = None,
-    chunk_store: MutableMapping = None,
+    chunk_store: StoreLike = None,
 ):
 
     # guard conditions
@@ -526,7 +524,50 @@ def _dict_store_keys(d: Dict, prefix="", cls=dict):
             yield prefix + k
 
 
-class MemoryStore(MutableMapping):
+class KVStore(Store):
+    """
+    This provides a default implementation of a store interface around
+    a mutable mapping, to avoid having to test stores for presence of methods.
+
+    This, for most methods should just be a pass-through to the underlying KV
+    store which is likely to expose a MuttableMapping interface,
+    """
+
+    def __init__(self, mutablemapping):
+        self._mutable_mapping = mutablemapping
+
+    def __getitem__(self, key):
+        return self._mutable_mapping[key]
+
+    def __setitem__(self, key, value):
+        self._mutable_mapping[key] = value
+
+    def __delitem__(self, key):
+        del self._mutable_mapping[key]
+
+    def get(self, key, default=None):
+        return self._mutable_mapping.get(key, default)
+
+    def values(self):
+        return self._mutable_mapping.values()
+
+    def __iter__(self):
+        return iter(self._mutable_mapping)
+
+    def __len__(self):
+        return len(self._mutable_mapping)
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}: \n{repr(self._mutable_mapping)}\n at {hex(id(self))}>"
+
+    def __eq__(self, other):
+        if isinstance(other, KVStore):
+            return self._mutable_mapping == other._mutable_mapping
+        else:
+            return NotImplemented
+
+
+class MemoryStore(Store):
     """Store class that uses a hierarchy of :class:`dict` objects, thus all data
     will be held in main memory.
 
@@ -544,7 +585,7 @@ class MemoryStore(MutableMapping):
 
         >>> z = zarr.zeros(100)
         >>> type(z.store)
-        <class 'dict'>
+        <class 'zarr.storage.KVStore'>
 
     Notes
     -----
@@ -730,7 +771,7 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
 
-class DirectoryStore(MutableMapping):
+class DirectoryStore(Store):
     """Storage class using directories and files on a standard file system.
 
     Parameters
@@ -1041,7 +1082,7 @@ def atexit_rmglob(path,
             rmtree(p)
 
 
-class FSStore(MutableMapping):
+class FSStore(Store):
     """Wraps an fsspec.FSMap to give access to arbitrary filesystems
 
     Requires that ``fsspec`` is installed, as well as any additional
@@ -1352,7 +1393,7 @@ def __eq__(self, other):
 
 
 # noinspection PyPep8Naming
-class ZipStore(MutableMapping):
+class ZipStore(Store):
     """Storage class using a Zip file.
 
     Parameters
@@ -1444,6 +1485,8 @@ class also supports the context manager protocol, which ensures the ``close()``
 
     """
 
+    _erasable = False
+
     def __init__(self, path, compression=zipfile.ZIP_STORED, allowZip64=True, mode='a',
                  dimension_separator=None):
 
@@ -1606,7 +1649,7 @@ def migrate_1to2(store):
 
     Parameters
     ----------
-    store : MutableMapping
+    store : Store
         Store to be migrated.
 
     Notes
@@ -1650,7 +1693,7 @@ def migrate_1to2(store):
 
 
 # noinspection PyShadowingBuiltins
-class DBMStore(MutableMapping):
+class DBMStore(Store):
     """Storage class using a DBM-style database.
 
     Parameters
@@ -1842,7 +1885,7 @@ def __contains__(self, key):
         return key in self.db
 
 
-class LMDBStore(MutableMapping):
+class LMDBStore(Store):
     """Storage class using LMDB. Requires the `lmdb <http://lmdb.readthedocs.io/>`_
     package to be installed.
 
@@ -2019,7 +2062,7 @@ def __len__(self):
         return self.db.stat()['entries']
 
 
-class LRUStoreCache(MutableMapping):
+class LRUStoreCache(Store):
     """Storage class that implements a least-recently-used (LRU) cache layer over
     some other store. Intended primarily for use with stores that can be slow to
     access, e.g., remote stores that require network communication to store and
@@ -2027,7 +2070,7 @@ class LRUStoreCache(MutableMapping):
 
     Parameters
     ----------
-    store : MutableMapping
+    store : Store
         The store containing the actual data to be cached.
     max_size : int
         The maximum size that the cache may grow to, in number of bytes. Provide `None`
@@ -2056,14 +2099,14 @@ class LRUStoreCache(MutableMapping):
 
     """
 
-    def __init__(self, store, max_size):
-        self._store = store
+    def __init__(self, store: Store, max_size: int):
+        self._store = Store._ensure_store(store)
         self._max_size = max_size
         self._current_size = 0
         self._keys_cache = None
         self._contains_cache = None
-        self._listdir_cache = dict()
-        self._values_cache = OrderedDict()
+        self._listdir_cache: Dict[Path, Any] = dict()
+        self._values_cache: Dict[Path, Any] = OrderedDict()
         self._mutex = Lock()
         self.hits = self.misses = 0
 
@@ -2103,7 +2146,7 @@ def _keys(self):
             self._keys_cache = list(self._store.keys())
         return self._keys_cache
 
-    def listdir(self, path=None):
+    def listdir(self, path: Path = None):
         with self._mutex:
             try:
                 return self._listdir_cache[path]
@@ -2112,7 +2155,7 @@ def listdir(self, path=None):
                 self._listdir_cache[path] = listing
                 return listing
 
-    def getsize(self, path=None):
+    def getsize(self, path=None) -> int:
         return getsize(self._store, path=path)
 
     def _pop_value(self):
@@ -2129,7 +2172,7 @@ def _accommodate_value(self, value_size):
             v = self._pop_value()
             self._current_size -= buffer_size(v)
 
-    def _cache_value(self, key, value):
+    def _cache_value(self, key: Path, value):
         # cache a value
         value_size = buffer_size(value)
         # check size of the value against max size, as if the value itself exceeds max
@@ -2201,7 +2244,7 @@ def __delitem__(self, key):
             self._invalidate_value(key)
 
 
-class SQLiteStore(MutableMapping):
+class SQLiteStore(Store):
     """Storage class using SQLite.
 
     Parameters
@@ -2404,7 +2447,7 @@ def clear(self):
             )
 
 
-class MongoDBStore(MutableMapping):
+class MongoDBStore(Store):
     """Storage class using MongoDB.
 
     .. note:: This is an experimental feature.
@@ -2487,7 +2530,7 @@ def clear(self):
         self.collection.delete_many({})
 
 
-class RedisStore(MutableMapping):
+class RedisStore(Store):
     """Storage class using Redis.
 
     .. note:: This is an experimental feature.
@@ -2556,7 +2599,7 @@ def clear(self):
             del self[key]
 
 
-class ConsolidatedMetadataStore(MutableMapping):
+class ConsolidatedMetadataStore(Store):
     """A layer over other storage, where the metadata has been consolidated into
     a single key.
 
@@ -2580,7 +2623,7 @@ class ConsolidatedMetadataStore(MutableMapping):
 
     Parameters
     ----------
-    store: MutableMapping
+    store: Store
         Containing the zarr array.
     metadata_key: str
         The target in the store where all of the metadata are stored. We
@@ -2592,8 +2635,8 @@ class ConsolidatedMetadataStore(MutableMapping):
 
     """
 
-    def __init__(self, store, metadata_key='.zmetadata'):
-        self.store = store
+    def __init__(self, store: StoreLike, metadata_key=".zmetadata"):
+        self.store = Store._ensure_store(store)
 
         # retrieve consolidated metadata
         meta = json_loads(store[metadata_key])
@@ -2605,7 +2648,7 @@ def __init__(self, store, metadata_key='.zmetadata'):
                                 consolidated_format)
 
         # decode metadata
-        self.meta_store = meta['metadata']
+        self.meta_store: Store = KVStore(meta["metadata"])
 
     def __getitem__(self, key):
         return self.meta_store[key]
diff --git a/zarr/tests/test_attrs.py b/zarr/tests/test_attrs.py
index 2aced3abaa..b2de736d4a 100644
--- a/zarr/tests/test_attrs.py
+++ b/zarr/tests/test_attrs.py
@@ -1,21 +1,26 @@
 import json
-import unittest
 
 import pytest
 
 from zarr.attrs import Attributes
 from zarr.tests.util import CountingDict
+from zarr.storage import KVStore
 
 
-class TestAttributes(unittest.TestCase):
+class TestAttributes():
 
     def init_attributes(self, store, read_only=False, cache=True):
         return Attributes(store, key='attrs', read_only=read_only, cache=cache)
 
-    def test_storage(self):
+    @pytest.mark.parametrize('store_from_dict', [False, True])
+    def test_storage(self, store_from_dict):
 
-        store = dict()
+        if store_from_dict:
+            store = dict()
+        else:
+            store = KVStore(dict())
         a = Attributes(store=store, key='attrs')
+        assert isinstance(a.store, KVStore)
         assert 'foo' not in a
         assert 'bar' not in a
         assert dict() == a.asdict()
diff --git a/zarr/tests/test_convenience.py b/zarr/tests/test_convenience.py
index d2bd91038b..e5ccbd494d 100644
--- a/zarr/tests/test_convenience.py
+++ b/zarr/tests/test_convenience.py
@@ -24,8 +24,12 @@
 from zarr.core import Array
 from zarr.errors import CopyError
 from zarr.hierarchy import Group, group
-from zarr.storage import (ConsolidatedMetadataStore, MemoryStore,
-                          atexit_rmtree, getsize)
+from zarr.storage import (
+    ConsolidatedMetadataStore,
+    MemoryStore,
+    atexit_rmtree,
+    getsize,
+)
 
 
 def test_open_array(path_type):
diff --git a/zarr/tests/test_core.py b/zarr/tests/test_core.py
index 4544a6cae9..2b44ac0574 100644
--- a/zarr/tests/test_core.py
+++ b/zarr/tests/test_core.py
@@ -24,11 +24,12 @@
     ABSStore,
     DBMStore,
     DirectoryStore,
+    FSStore,
+    KVStore,
     LMDBStore,
     LRUStoreCache,
     NestedDirectoryStore,
     SQLiteStore,
-    FSStore,
     atexit_rmglob,
     atexit_rmtree,
     init_array,
@@ -45,8 +46,8 @@ class TestArray(unittest.TestCase):
     def test_array_init(self):
 
         # normal initialization
-        store = dict()
-        init_array(store, shape=100, chunks=10, dtype='<f8')
+        store = KVStore(dict())
+        init_array(store, shape=100, chunks=10, dtype="<f8")
         a = Array(store)
         assert isinstance(a, Array)
         assert (100,) == a.shape
@@ -56,9 +57,10 @@ def test_array_init(self):
         assert a.basename is None
         assert store is a.store
         assert "8fecb7a17ea1493d9c1430d04437b4f5b0b34985" == a.hexdigest()
+        store.close()
 
         # initialize at path
-        store = dict()
+        store = KVStore(dict())
         init_array(store, shape=100, chunks=10, path='foo/bar', dtype='<f8')
         a = Array(store, path='foo/bar')
         assert isinstance(a, Array)
@@ -71,18 +73,18 @@ def test_array_init(self):
         assert "8fecb7a17ea1493d9c1430d04437b4f5b0b34985" == a.hexdigest()
 
         # store not initialized
-        store = dict()
+        store = KVStore(dict())
         with pytest.raises(ValueError):
             Array(store)
 
         # group is in the way
-        store = dict()
+        store = KVStore(dict())
         init_group(store, path='baz')
         with pytest.raises(ValueError):
             Array(store, path='baz')
 
     def create_array(self, read_only=False, **kwargs):
-        store = dict()
+        store = KVStore(dict())
         kwargs.setdefault('compressor', Zlib(level=1))
         cache_metadata = kwargs.pop('cache_metadata', True)
         cache_attrs = kwargs.pop('cache_attrs', True)
@@ -103,8 +105,7 @@ def test_store_has_text_keys(self):
             if not isinstance(k, expected_type):  # pragma: no cover
                 pytest.fail("Non-text key: %s" % repr(k))
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_store_has_binary_values(self):
         # Initialize array
@@ -118,8 +119,7 @@ def test_store_has_binary_values(self):
             except TypeError:  # pragma: no cover
                 pytest.fail("Non-bytes-like value: %s" % repr(v))
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_store_has_bytes_values(self):
         # Test that many stores do hold bytes values.
@@ -134,8 +134,7 @@ def test_store_has_bytes_values(self):
         # Check in-memory array only contains `bytes`
         assert all([isinstance(v, bytes) for v in z.chunk_store.values()])
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_nbytes_stored(self):
 
@@ -154,6 +153,8 @@ def test_nbytes_stored(self):
         except TypeError:
             pass
 
+        z.store.close()
+
     # noinspection PyStatementEffect
     def test_array_1d(self):
         a = np.arange(1050)
@@ -235,8 +236,7 @@ def test_array_1d(self):
         assert_array_equal(b[190:310], z[190:310])
         assert_array_equal(a[310:], z[310:])
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_array_1d_fill_value(self):
         for fill_value in -1, 0, 1, 10:
@@ -252,8 +252,7 @@ def test_array_1d_fill_value(self):
             assert_array_equal(a[190:310], z[190:310])
             assert_array_equal(f[310:], z[310:])
 
-            if hasattr(z.store, 'close'):
-                z.store.close()
+            z.store.close()
 
     def test_array_1d_set_scalar(self):
         # test setting the contents of an array with a scalar value
@@ -272,8 +271,7 @@ def test_array_1d_set_scalar(self):
             z[:] = value
             assert_array_equal(a, z[:])
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_array_1d_selections(self):
         # light test here, full tests in test_indexing
@@ -317,8 +315,7 @@ def test_array_1d_selections(self):
         z.oindex[bix] = 9
         assert_array_equal(9, z.oindex[bix])
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     # noinspection PyStatementEffect
     def test_array_2d(self):
@@ -428,8 +425,7 @@ def test_array_2d(self):
         assert_array_equal(a[310:], z[310:])
         assert_array_equal(a[:, 7:], z[:, 7:])
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_array_2d_edge_case(self):
         # this fails with filters - chunks extend beyond edge of array, messes with delta
@@ -443,8 +439,7 @@ def test_array_2d_edge_case(self):
         actual = z[:]
         assert_array_equal(expect, actual)
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_array_2d_partial(self):
         z = self.create_array(shape=(1000, 10), chunks=(100, 2), dtype='i4',
@@ -486,8 +481,7 @@ def test_array_2d_partial(self):
         assert -1 == z[2, 2]
         assert -1 == z[-1, -1]
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_array_order(self):
 
@@ -504,8 +498,7 @@ def test_array_order(self):
             z[:] = a
             assert_array_equal(a, z[:])
 
-            if hasattr(z.store, 'close'):
-                z.store.close()
+            z.store.close()
 
         # 2D
         a = np.arange(10000).reshape((100, 100))
@@ -521,8 +514,7 @@ def test_array_order(self):
             actual = z[:]
             assert_array_equal(a, actual)
 
-            if hasattr(z.store, 'close'):
-                z.store.close()
+            z.store.close()
 
     def test_setitem_data_not_shared(self):
         # check that data don't end up being shared with another array
@@ -533,8 +525,7 @@ def test_setitem_data_not_shared(self):
         assert_array_equal(z[:], np.arange(20, dtype='i4'))
         a[:] = 0
         assert_array_equal(z[:], np.arange(20, dtype='i4'))
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def expected(self):
         return [
@@ -551,34 +542,29 @@ def test_hexdigest(self):
         # Check basic 1-D array
         z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         found.append(z.hexdigest())
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         # Check basic 1-D array with different type
         z = self.create_array(shape=(1050,), chunks=100, dtype='<f4')
         found.append(z.hexdigest())
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         # Check basic 2-D array
         z = self.create_array(shape=(20, 35,), chunks=10, dtype='<i4')
         found.append(z.hexdigest())
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         # Check basic 1-D array with some data
         z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z[200:400] = np.arange(200, 400, dtype='i4')
         found.append(z.hexdigest())
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         # Check basic 1-D array with attributes
         z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z.attrs['foo'] = 'bar'
         found.append(z.hexdigest())
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         assert self.expected() == found
 
@@ -617,8 +603,7 @@ def test_resize_1d(self):
         assert (105,) == z.shape
         assert (105,) == z[:].shape
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_resize_2d(self):
 
@@ -664,8 +649,7 @@ def test_resize_2d(self):
         assert (105, 105) == z.shape
         assert (105, 105) == z[:].shape
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_append_1d(self):
 
@@ -694,8 +678,7 @@ def test_append_1d(self):
         assert (10,) == z.chunks
         assert_array_equal(f, z[:])
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_append_2d(self):
 
@@ -717,8 +700,7 @@ def test_append_2d(self):
         actual = z[:]
         assert_array_equal(e, actual)
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_append_2d_axis(self):
 
@@ -738,8 +720,7 @@ def test_append_2d_axis(self):
         assert (10, 10) == z.chunks
         assert_array_equal(e, z[:])
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_append_bad_shape(self):
         a = np.arange(100)
@@ -748,15 +729,13 @@ def test_append_bad_shape(self):
         b = a.reshape(10, 10)
         with pytest.raises(ValueError):
             z.append(b)
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_read_only(self):
 
         z = self.create_array(shape=1000, chunks=100)
         assert not z.read_only
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         z = self.create_array(shape=1000, chunks=100, read_only=True)
         assert z.read_only
@@ -779,8 +758,7 @@ def test_read_only(self):
         with pytest.raises(PermissionError):
             z.set_mask_selection(np.ones(z.shape, dtype=bool), 42)
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_pickle(self):
 
@@ -803,8 +781,7 @@ def test_pickle(self):
         dump = pickle.dumps(z)
         # some stores cannot be opened twice at the same time, need to close
         # store before can round-trip through pickle
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
         z2 = pickle.loads(dump)
 
         # verify
@@ -818,8 +795,7 @@ def test_pickle(self):
         assert attrs_cache == z2.attrs.cache
         assert_array_equal(a, z2[:])
 
-        if hasattr(z2.store, 'close'):
-            z2.store.close()
+        z2.store.close()
 
     def test_np_ufuncs(self):
         z = self.create_array(shape=(100, 100), chunks=(10, 10))
@@ -837,8 +813,7 @@ def test_np_ufuncs(self):
         assert_array_equal(np.take(a, indices, axis=1),
                            np.take(z, indices, axis=1))
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         # use zarr array as indices or condition
         zc = self.create_array(shape=condition.shape, dtype=condition.dtype,
@@ -846,8 +821,7 @@ def test_np_ufuncs(self):
         zc[:] = condition
         assert_array_equal(np.compress(condition, a, axis=0),
                            np.compress(zc, a, axis=0))
-        if hasattr(zc.store, 'close'):
-            zc.store.close()
+        zc.store.close()
 
         zi = self.create_array(shape=indices.shape, dtype=indices.dtype,
                                chunks=10, filters=None)
@@ -855,8 +829,7 @@ def test_np_ufuncs(self):
         # this triggers __array__() call with dtype argument
         assert_array_equal(np.take(a, indices, axis=1),
                            np.take(a, zi, axis=1))
-        if hasattr(zi.store, 'close'):
-            zi.store.close()
+        zi.store.close()
 
     # noinspection PyStatementEffect
     def test_0len_dim_1d(self):
@@ -891,8 +864,7 @@ def test_0len_dim_1d(self):
         with pytest.raises(IndexError):
             z[0] = 42
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     # noinspection PyStatementEffect
     def test_0len_dim_2d(self):
@@ -931,8 +903,7 @@ def test_0len_dim_2d(self):
         with pytest.raises(IndexError):
             z[:, 0] = 42
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     # noinspection PyStatementEffect
     def test_array_0d(self):
@@ -983,8 +954,7 @@ def test_array_0d(self):
         with pytest.raises(ValueError):
             z[...] = np.array([1, 2, 3])
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_nchunks_initialized(self):
         for fill_value in (0, 1.0, np.nan):
@@ -1008,26 +978,7 @@ def test_nchunks_initialized(self):
             del z.chunk_store[z._chunk_key((0,))]
             assert 9 == z.nchunks_initialized
 
-            if hasattr(z.store, 'close'):
-                z.store.close()
-
-            # second round of similar tests with write_empty_chunks set to
-            # False
-            z = self.create_array(shape=100,
-                                  chunks=10,
-                                  fill_value=fill_value,
-                                  dtype=dtype,
-                                  write_empty_chunks=False)
-            z[:] = 42
-            assert 10 == z.nchunks_initialized
-            # manually remove a chunk from the store
-            del z.chunk_store[z._chunk_key((0,))]
-            assert 9 == z.nchunks_initialized
-            z[:] = z.fill_value
-            assert 0 == z.nchunks_initialized
-
-            if hasattr(z.store, 'close'):
-                z.store.close()
+            z.store.close()
 
     def test_array_dtype_shape(self):
 
@@ -1049,8 +1000,7 @@ def test_array_dtype_shape(self):
                     assert fill_value == z.fill_value
                 z[...] = a
                 assert_array_equal(a, z[...])
-                if hasattr(z.store, 'close'):
-                    z.store.close()
+                z.store.close()
 
     def check_structured_array(self, d, fill_values):
         for a in (d, d[:0]):
@@ -1091,8 +1041,7 @@ def check_structured_array(self, d, fill_values):
                     for f in a.dtype.names:
                         assert_array_equal(a[f], z[f])
 
-                if hasattr(z.store, 'close'):
-                    z.store.close()
+                z.store.close()
 
     def test_structured_array(self):
         d = np.array([(b'aaa', 1, 4.2),
@@ -1128,8 +1077,7 @@ def test_dtypes(self):
             a = np.arange(z.shape[0], dtype=dtype)
             z[:] = a
             assert_array_equal(a, z[:])
-            if hasattr(z.store, 'close'):
-                z.store.close()
+            z.store.close()
 
         # floats
         for dtype in 'f2', 'f4', 'f8':
@@ -1138,8 +1086,7 @@ def test_dtypes(self):
             a = np.linspace(0, 1, z.shape[0], dtype=dtype)
             z[:] = a
             assert_array_almost_equal(a, z[:])
-            if hasattr(z.store, 'close'):
-                z.store.close()
+            z.store.close()
 
         # complex
         for dtype in 'c8', 'c16':
@@ -1149,8 +1096,7 @@ def test_dtypes(self):
             a -= 1j * a
             z[:] = a
             assert_array_almost_equal(a, z[:])
-            if hasattr(z.store, 'close'):
-                z.store.close()
+            z.store.close()
 
         # datetime, timedelta
         for base_type in 'Mm':
@@ -1163,8 +1109,7 @@ def test_dtypes(self):
                                       dtype='i8').view(dtype)
                 z[:] = a
                 assert_array_equal(a, z[:])
-                if hasattr(z.store, 'close'):
-                    z.store.close()
+                z.store.close()
 
         # check that datetime generic units are not allowed
         with pytest.raises(ValueError):
@@ -1182,8 +1127,7 @@ def test_object_arrays(self):
         # filters to maintain API backwards compatibility
         with pytest.warns(FutureWarning):
             z = self.create_array(shape=10, chunks=3, dtype=object, filters=[MsgPack()])
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         # create an object array using msgpack
         z = self.create_array(shape=10, chunks=3, dtype=object, object_codec=MsgPack())
@@ -1199,8 +1143,7 @@ def test_object_arrays(self):
         assert z[4] == {'a': 'b', 'c': 'd'}
         a = z[:]
         assert a.dtype == object
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         # create an object array using pickle
         z = self.create_array(shape=10, chunks=3, dtype=object, object_codec=Pickle())
@@ -1216,8 +1159,7 @@ def test_object_arrays(self):
         assert z[4] == {'a': 'b', 'c': 'd'}
         a = z[:]
         assert a.dtype == object
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         # create an object array using JSON
         z = self.create_array(shape=10, chunks=3, dtype=object, object_codec=JSON())
@@ -1233,8 +1175,7 @@ def test_object_arrays(self):
         assert z[4] == {'a': 'b', 'c': 'd'}
         a = z[:]
         assert a.dtype == object
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_object_arrays_vlen_text(self):
 
@@ -1251,8 +1192,7 @@ def test_object_arrays_vlen_text(self):
         a = z[:]
         assert a.dtype == object
         assert_array_equal(data, a)
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         # convenience API
         z = self.create_array(shape=data.shape, dtype=str)
@@ -1260,33 +1200,28 @@ def test_object_arrays_vlen_text(self):
         assert isinstance(z.filters[0], VLenUTF8)
         z[:] = data
         assert_array_equal(data, z[:])
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         z = self.create_array(shape=data.shape, dtype=object, object_codec=MsgPack())
         z[:] = data
         assert_array_equal(data, z[:])
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         z = self.create_array(shape=data.shape, dtype=object, object_codec=JSON())
         z[:] = data
         assert_array_equal(data, z[:])
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         z = self.create_array(shape=data.shape, dtype=object, object_codec=Pickle())
         z[:] = data
         assert_array_equal(data, z[:])
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         z = self.create_array(shape=data.shape, dtype=object,
                               object_codec=Categorize(greetings, dtype=object))
         z[:] = data
         assert_array_equal(data, z[:])
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_object_arrays_vlen_bytes(self):
 
@@ -1304,8 +1239,7 @@ def test_object_arrays_vlen_bytes(self):
         a = z[:]
         assert a.dtype == object
         assert_array_equal(data, a)
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         # convenience API
         z = self.create_array(shape=data.shape, dtype=bytes)
@@ -1313,14 +1247,12 @@ def test_object_arrays_vlen_bytes(self):
         assert isinstance(z.filters[0], VLenBytes)
         z[:] = data
         assert_array_equal(data, z[:])
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         z = self.create_array(shape=data.shape, dtype=object, object_codec=Pickle())
         z[:] = data
         assert_array_equal(data, z[:])
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_object_arrays_vlen_array(self):
 
@@ -1346,8 +1278,7 @@ def compare_arrays(expected, actual, item_dtype):
             a = z[:]
             assert a.dtype == object
             compare_arrays(data, a, codec.dtype)
-            if hasattr(z.store, 'close'):
-                z.store.close()
+            z.store.close()
 
         # convenience API
         for item_type in 'int', '<u4':
@@ -1357,8 +1288,7 @@ def compare_arrays(expected, actual, item_dtype):
             assert z.filters[0].dtype == np.dtype(item_type)
             z[:] = data
             compare_arrays(data, z[:], np.dtype(item_type))
-            if hasattr(z.store, 'close'):
-                z.store.close()
+            z.store.close()
 
     def test_object_arrays_danger(self):
 
@@ -1370,8 +1300,7 @@ def test_object_arrays_danger(self):
             z[0] = 'foo'
         with pytest.raises(RuntimeError):
             z[:] = 42
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
         # do something else dangerous
         data = greetings * 10
@@ -1385,16 +1314,14 @@ def test_object_arrays_danger(self):
             with pytest.raises(RuntimeError):
                 # noinspection PyStatementEffect
                 v[:]
-            if hasattr(z.store, 'close'):
-                z.store.close()
+            z.store.close()
 
     def test_object_codec_warnings(self):
 
         with pytest.warns(UserWarning):
             # provide object_codec, but not object dtype
-            z = self.create_array(shape=10, chunks=5, dtype='i4', object_codec=JSON())
-        if hasattr(z.store, 'close'):
-            z.store.close()
+            z = self.create_array(shape=10, chunks=5, dtype="i4", object_codec=JSON())
+        z.store.close()
 
     @unittest.skipIf(parse_version(np.__version__) < parse_version('1.14.0'),
                      "unsupported numpy version")
@@ -1466,8 +1393,7 @@ def test_iteration_exceptions(self):
         # check behavior for start > end
         assert [] == list(z.islice(6, 5))
 
-        if hasattr(z.store, 'close'):
-            z.store.close()
+        z.store.close()
 
     def test_iter(self):
         params = (
@@ -1491,8 +1417,7 @@ def test_iter(self):
             z[:] = a
             for expect, actual in zip_longest(a, z):
                 assert_array_equal(expect, actual)
-            if hasattr(z.store, 'close'):
-                z.store.close()
+            z.store.close()
 
     def test_islice(self):
         params = (
@@ -1530,8 +1455,7 @@ def test_compressors(self):
             assert np.all(a[0:100] == 1)
             a[:] = 1
             assert np.all(a[:] == 1)
-            if hasattr(a.store, 'close'):
-                a.store.close()
+            a.store.close()
 
     def test_endian(self):
         dtype = np.dtype('float32')
@@ -1542,10 +1466,8 @@ def test_endian(self):
         a2[:] = 1
         x2 = a2[:]
         assert_array_equal(x1, x2)
-        if hasattr(a1.store, 'close'):
-            a1.store.close()
-        if hasattr(a2.store, 'close'):
-            a2.store.close()
+        a1.store.close()
+        a2.store.close()
 
     def test_attributes(self):
         a = self.create_array(shape=10, chunks=10, dtype='i8')
@@ -1559,8 +1481,7 @@ def test_attributes(self):
         attrs = json_loads(a.store[a.attrs.key])
         assert 'foo' in attrs and attrs['foo'] == 'bar'
         assert 'bar' in attrs and attrs['bar'] == 'foo'
-        if hasattr(a.store, 'close'):
-            a.store.close()
+        a.store.close()
 
     def test_structured_with_object(self):
         a = self.create_array(fill_value=(0.0, None),
@@ -1575,7 +1496,7 @@ class TestArrayWithPath(TestArray):
 
     @staticmethod
     def create_array(read_only=False, **kwargs):
-        store = dict()
+        store = KVStore(dict())
         cache_metadata = kwargs.pop('cache_metadata', True)
         cache_attrs = kwargs.pop('cache_attrs', True)
         write_empty_chunks = kwargs.pop('write_empty_chunks', True)
@@ -1584,6 +1505,9 @@ def create_array(read_only=False, **kwargs):
                      cache_metadata=cache_metadata, cache_attrs=cache_attrs,
                      write_empty_chunks=write_empty_chunks)
 
+    def test_nchunks_initialized(self):
+        pass
+
     def test_hexdigest(self):
         # Check basic 1-D array
         z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
@@ -1609,7 +1533,7 @@ def test_hexdigest(self):
 
     def test_nbytes_stored(self):
 
-        # dict as store
+        # MemoryStore as store
         z = self.create_array(shape=1000, chunks=100)
         expect_nbytes_stored = sum(buffer_size(v)
                                    for k, v in z.store.items()
@@ -1630,9 +1554,9 @@ class TestArrayWithChunkStore(TestArray):
 
     @staticmethod
     def create_array(read_only=False, **kwargs):
-        store = dict()
+        store = KVStore(dict())
         # separate chunk store
-        chunk_store = dict()
+        chunk_store = KVStore(dict())
         cache_metadata = kwargs.pop('cache_metadata', True)
         cache_attrs = kwargs.pop('cache_attrs', True)
         write_empty_chunks = kwargs.pop('write_empty_chunks', True)
@@ -1708,6 +1632,16 @@ def test_nbytes_stored(self):
         assert expect_nbytes_stored == z.nbytes_stored
 
 
+def test_array_init_from_dict():
+    # initialization via non-Store MutableMapping
+    store = dict()
+    init_array(store, shape=100, chunks=10, dtype="<f8")
+    a = Array(store)
+    assert isinstance(a, Array)
+    assert a.store is not store
+    assert isinstance(a.store, KVStore)
+
+
 @skip_test_env_var("ZARR_TEST_ABS")
 class TestArrayWithABSStore(TestArray):
 
@@ -2215,7 +2149,7 @@ def test_nbytes_stored(self):
 class TestArrayWithNoCompressor(TestArray):
 
     def create_array(self, read_only=False, **kwargs):
-        store = dict()
+        store = KVStore(dict())
         kwargs.setdefault('compressor', None)
         cache_metadata = kwargs.pop('cache_metadata', True)
         cache_attrs = kwargs.pop('cache_attrs', True)
@@ -2251,7 +2185,7 @@ def test_hexdigest(self):
 class TestArrayWithBZ2Compressor(TestArray):
 
     def create_array(self, read_only=False, **kwargs):
-        store = dict()
+        store = KVStore(dict())
         compressor = BZ2(level=1)
         kwargs.setdefault('compressor', compressor)
         cache_metadata = kwargs.pop('cache_metadata', True)
@@ -2288,7 +2222,7 @@ def test_hexdigest(self):
 class TestArrayWithBloscCompressor(TestArray):
 
     def create_array(self, read_only=False, **kwargs):
-        store = dict()
+        store = KVStore(dict())
         compressor = Blosc(cname='zstd', clevel=1, shuffle=1)
         kwargs.setdefault('compressor', compressor)
         cache_metadata = kwargs.pop('cache_metadata', True)
@@ -2332,7 +2266,7 @@ def test_hexdigest(self):
 class TestArrayWithLZMACompressor(TestArray):
 
     def create_array(self, read_only=False, **kwargs):
-        store = dict()
+        store = KVStore(dict())
         compressor = LZMA(preset=1)
         kwargs.setdefault('compressor', compressor)
         cache_metadata = kwargs.pop('cache_metadata', True)
@@ -2370,7 +2304,7 @@ class TestArrayWithFilters(TestArray):
 
     @staticmethod
     def create_array(read_only=False, **kwargs):
-        store = dict()
+        store = KVStore(dict())
         dtype = kwargs.get('dtype', None)
         filters = [
             Delta(dtype=dtype),
@@ -2414,7 +2348,7 @@ def test_astype_no_filters(self):
         dtype = np.dtype(np.int8)
         astype = np.dtype(np.float32)
 
-        store = dict()
+        store = KVStore(dict())
         init_array(store, shape=shape, chunks=10, dtype=dtype)
 
         data = np.arange(np.prod(shape), dtype=dtype).reshape(shape)
@@ -2492,7 +2426,10 @@ def test_structured_array_contain_object(self):
 class CustomMapping(object):
 
     def __init__(self):
-        self.inner = dict()
+        self.inner = KVStore(dict())
+
+    def __iter__(self):
+        return iter(self.keys())
 
     def keys(self):
         return self.inner.keys()
@@ -2534,16 +2471,16 @@ def create_array(read_only=False, **kwargs):
 
     def test_nbytes_stored(self):
         z = self.create_array(shape=1000, chunks=100)
-        assert -1 == z.nbytes_stored
+        assert 245 == z.nbytes_stored
         z[:] = 42
-        assert -1 == z.nbytes_stored
+        assert 515 == z.nbytes_stored
 
 
 class TestArrayNoCache(TestArray):
 
     @staticmethod
     def create_array(read_only=False, **kwargs):
-        store = dict()
+        store = KVStore(dict())
         kwargs.setdefault('compressor', Zlib(level=1))
         cache_metadata = kwargs.pop('cache_metadata', True)
         cache_attrs = kwargs.pop('cache_attrs', True)
diff --git a/zarr/tests/test_creation.py b/zarr/tests/test_creation.py
index d92d5aa73d..117bc338b6 100644
--- a/zarr/tests/test_creation.py
+++ b/zarr/tests/test_creation.py
@@ -2,6 +2,7 @@
 import os.path
 import shutil
 import tempfile
+import warnings
 
 import numpy as np
 import pytest
@@ -14,7 +15,7 @@
                            zeros_like)
 from zarr.hierarchy import open_group
 from zarr.n5 import N5Store
-from zarr.storage import DirectoryStore
+from zarr.storage import DirectoryStore, KVStore
 from zarr.sync import ThreadSynchronizer
 
 
@@ -271,6 +272,30 @@ def test_open_array():
     assert_array_equal(np.full(100, fill_value=42), a[:])
 
 
+def test_open_array_dict_store():
+
+    # dict will become a KVStore
+    store = dict()
+
+    # mode == 'w'
+    z = open_array(store, mode='w', shape=100, chunks=10)
+    z[:] = 42
+    assert isinstance(z, Array)
+    assert isinstance(z.store, KVStore)
+    assert (100,) == z.shape
+    assert (10,) == z.chunks
+    assert_array_equal(np.full(100, fill_value=42), z[:])
+
+
+def test_create_in_dict():
+    for func in [empty, zeros, ones]:
+        a = func(100, store=dict())
+        assert isinstance(a.store, KVStore)
+
+    a = full(100, 5, store=dict())
+    assert isinstance(a.store, KVStore)
+
+
 def test_empty_like():
 
     # zarr array
@@ -463,29 +488,33 @@ def test_create():
 
 def test_compression_args():
 
-    z = create(100, compression='zlib', compression_opts=9)
-    assert isinstance(z, Array)
-    assert 'zlib' == z.compressor.codec_id
-    assert 9 == z.compressor.level
-
-    # 'compressor' overrides 'compression'
-    z = create(100, compressor=Zlib(9), compression='bz2', compression_opts=1)
-    assert isinstance(z, Array)
-    assert 'zlib' == z.compressor.codec_id
-    assert 9 == z.compressor.level
-
-    # 'compressor' ignores 'compression_opts'
-    z = create(100, compressor=Zlib(9), compression_opts=1)
-    assert isinstance(z, Array)
-    assert 'zlib' == z.compressor.codec_id
-    assert 9 == z.compressor.level
+    with warnings.catch_warnings():
+        warnings.simplefilter("default")
+        z = create(100, compression="zlib", compression_opts=9)
+        assert isinstance(z, Array)
+        assert "zlib" == z.compressor.codec_id
+        assert 9 == z.compressor.level
 
-    with pytest.warns(UserWarning):
         # 'compressor' overrides 'compression'
-        create(100, compressor=Zlib(9), compression='bz2', compression_opts=1)
-    with pytest.warns(UserWarning):
+        with pytest.warns(UserWarning):
+            z = create(100, compressor=Zlib(9), compression="bz2", compression_opts=1)
+        assert isinstance(z, Array)
+        assert "zlib" == z.compressor.codec_id
+        assert 9 == z.compressor.level
+
         # 'compressor' ignores 'compression_opts'
-        create(100, compressor=Zlib(9), compression_opts=1)
+        with pytest.warns(UserWarning):
+            z = create(100, compressor=Zlib(9), compression_opts=1)
+        assert isinstance(z, Array)
+        assert "zlib" == z.compressor.codec_id
+        assert 9 == z.compressor.level
+
+        with pytest.warns(UserWarning):
+            # 'compressor' overrides 'compression'
+            create(100, compressor=Zlib(9), compression="bz2", compression_opts=1)
+        with pytest.warns(UserWarning):
+            # 'compressor' ignores 'compression_opts'
+            create(100, compressor=Zlib(9), compression_opts=1)
 
 
 def test_create_read_only():
diff --git a/zarr/tests/test_hierarchy.py b/zarr/tests/test_hierarchy.py
index 4cb9ac9f43..1b4f96a73f 100644
--- a/zarr/tests/test_hierarchy.py
+++ b/zarr/tests/test_hierarchy.py
@@ -22,7 +22,7 @@
 from zarr.core import Array
 from zarr.creation import open_array
 from zarr.hierarchy import Group, group, open_group
-from zarr.storage import (ABSStore, DBMStore, DirectoryStore, FSStore,
+from zarr.storage import (ABSStore, DBMStore, KVStore, DirectoryStore, FSStore,
                           LMDBStore, LRUStoreCache, MemoryStore,
                           NestedDirectoryStore, SQLiteStore, ZipStore,
                           array_meta_key, atexit_rmglob, atexit_rmtree,
@@ -37,7 +37,7 @@ class TestGroup(unittest.TestCase):
     @staticmethod
     def create_store():
         # can be overridden in sub-classes
-        return dict(), None
+        return KVStore(dict()), None
 
     def create_group(self, store=None, path=None, read_only=False,
                      chunk_store=None, synchronizer=None):
@@ -67,8 +67,7 @@ def test_group_init_1(self):
         assert isinstance(g.info, InfoReporter)
         assert isinstance(repr(g.info), str)
         assert isinstance(g.info._repr_html_(), str)
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_group_init_2(self):
         store, chunk_store = self.create_store()
@@ -80,16 +79,14 @@ def test_group_init_2(self):
         assert '/foo/bar' == g.name
         assert 'bar' == g.basename
         assert isinstance(g.attrs, Attributes)
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_group_init_errors_1(self):
         store, chunk_store = self.create_store()
         # group metadata not initialized
         with pytest.raises(ValueError):
             Group(store, chunk_store=chunk_store)
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_group_init_errors_2(self):
         store, chunk_store = self.create_store()
@@ -97,8 +94,7 @@ def test_group_init_errors_2(self):
         # array blocks group
         with pytest.raises(ValueError):
             Group(store, chunk_store=chunk_store)
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_create_group(self):
         g1 = self.create_group()
@@ -169,8 +165,7 @@ def __str__(self):
         assert isinstance(g7, Group)
         assert g7.path == 'z'
 
-        if hasattr(g1.store, 'close'):
-            g1.store.close()
+        g1.store.close()
 
     def test_require_group(self):
         g1 = self.create_group()
@@ -213,8 +208,7 @@ def test_require_group(self):
         assert isinstance(g7, Group)
         assert g7.path == 'z'
 
-        if hasattr(g1.store, 'close'):
-            g1.store.close()
+        g1.store.close()
 
     def test_create_dataset(self):
         g = self.create_group()
@@ -290,8 +284,7 @@ def test_create_dataset(self):
         assert d.compressor.codec_id == 'zlib'
         assert 1 == d.compressor.level
 
-        if hasattr(g.store, 'close'):
-            g.store.close()
+        g.store.close()
 
     def test_require_dataset(self):
         g = self.create_group()
@@ -337,8 +330,7 @@ def test_require_dataset(self):
             g.require_dataset('foo', shape=1000, chunks=100, dtype='i2',
                               exact=True)
 
-        if hasattr(g.store, 'close'):
-            g.store.close()
+        g.store.close()
 
     def test_create_errors(self):
         g = self.create_group()
@@ -393,8 +385,7 @@ def test_create_errors(self):
         with pytest.raises(PermissionError):
             g.require_dataset('zzz', shape=100, chunks=10)
 
-        if hasattr(g.store, 'close'):
-            g.store.close()
+        g.store.close()
 
     def test_create_overwrite(self):
         try:
@@ -420,8 +411,7 @@ def test_create_overwrite(self):
                 assert (400,) == d.shape
                 assert isinstance(g['foo'], Group)
 
-                if hasattr(g.store, 'close'):
-                    g.store.close()
+                g.store.close()
         except NotImplementedError:
             pass
 
@@ -649,8 +639,7 @@ def visitor1(val, *args):
         assert g1.visitvalues(visitor1) is True
         assert g1.visititems(visitor1) is True
 
-        if hasattr(g1.store, 'close'):
-            g1.store.close()
+        g1.store.close()
 
     def test_empty_getitem_contains_iterators(self):
         # setup
@@ -662,8 +651,7 @@ def test_empty_getitem_contains_iterators(self):
         assert 0 == len(g)
         assert 'foo' not in g
 
-        if hasattr(g.store, 'close'):
-            g.store.close()
+        g.store.close()
 
     def test_iterators_recurse(self):
         # setup
@@ -689,8 +677,7 @@ def test_iterators_recurse(self):
         assert 'zab' == arrays_recurse[0][0]
         assert g1['foo']['bar']['zab'] == arrays_recurse[0][1]
 
-        if hasattr(g1.store, 'close'):
-            g1.store.close()
+        g1.store.close()
 
     def test_getattr(self):
         # setup
@@ -704,8 +691,7 @@ def test_getattr(self):
         # test that hasattr returns False instead of an exception (issue #88)
         assert not hasattr(g1, 'unexistingattribute')
 
-        if hasattr(g1.store, 'close'):
-            g1.store.close()
+        g1.store.close()
 
     def test_setitem(self):
         g = self.create_group()
@@ -722,8 +708,7 @@ def test_setitem(self):
             assert 42 == g['foo'][()]
         except NotImplementedError:
             pass
-        if hasattr(g.store, 'close'):
-            g.store.close()
+        g.store.close()
 
     def test_delitem(self):
         g = self.create_group()
@@ -742,8 +727,7 @@ def test_delitem(self):
             assert 'foo' in g
             assert 'bar' not in g
             assert 'bar/baz' not in g
-        if hasattr(g.store, 'close'):
-            g.store.close()
+        g.store.close()
 
     def test_move(self):
         g = self.create_group()
@@ -754,45 +738,41 @@ def test_move(self):
         data = np.arange(100)
         g['foo'] = data
 
-        try:
-            g.move('foo', 'bar')
-            assert 'foo' not in g
-            assert 'bar' in g
-            assert_array_equal(data, g['bar'])
+        g.move("foo", "bar")
+        assert "foo" not in g
+        assert "bar" in g
+        assert_array_equal(data, g["bar"])
+
+        g.move("bar", "foo/bar")
+        assert "bar" not in g
+        assert "foo" in g
+        assert "foo/bar" in g
+        assert isinstance(g["foo"], Group)
+        assert_array_equal(data, g["foo/bar"])
+
+        g.move("foo", "foo2")
+        assert "foo" not in g
+        assert "foo/bar" not in g
+        assert "foo2" in g
+        assert "foo2/bar" in g
+        assert isinstance(g["foo2"], Group)
+        assert_array_equal(data, g["foo2/bar"])
+
+        g2 = g["foo2"]
+        g2.move("bar", "/bar")
+        assert "foo2" in g
+        assert "foo2/bar" not in g
+        assert "bar" in g
+        assert isinstance(g["foo2"], Group)
+        assert_array_equal(data, g["bar"])
 
-            g.move('bar', 'foo/bar')
-            assert 'bar' not in g
-            assert 'foo' in g
-            assert 'foo/bar' in g
-            assert isinstance(g['foo'], Group)
-            assert_array_equal(data, g['foo/bar'])
-
-            g.move('foo', 'foo2')
-            assert 'foo' not in g
-            assert 'foo/bar' not in g
-            assert 'foo2' in g
-            assert 'foo2/bar' in g
-            assert isinstance(g['foo2'], Group)
-            assert_array_equal(data, g['foo2/bar'])
-
-            g2 = g['foo2']
-            g2.move('bar', '/bar')
-            assert 'foo2' in g
-            assert 'foo2/bar' not in g
-            assert 'bar' in g
-            assert isinstance(g['foo2'], Group)
-            assert_array_equal(data, g['bar'])
-
-            with pytest.raises(ValueError):
-                g2.move('bar', 'bar2')
-
-            with pytest.raises(ValueError):
-                g.move('bar', 'boo')
-        except NotImplementedError:
-            pass
+        with pytest.raises(ValueError):
+            g2.move("bar", "bar2")
 
-        if hasattr(g.store, 'close'):
-            g.store.close()
+        with pytest.raises(ValueError):
+            g.move("bar", "boo")
+
+        g.store.close()
 
     def test_array_creation(self):
         grp = self.create_group()
@@ -829,8 +809,7 @@ def test_array_creation(self):
         assert isinstance(j, Array)
         assert_array_equal(np.arange(100), j[:])
 
-        if hasattr(grp.store, 'close'):
-            grp.store.close()
+        grp.store.close()
 
         grp = self.create_group(read_only=True)
         with pytest.raises(PermissionError):
@@ -856,8 +835,7 @@ def test_array_creation(self):
         with pytest.raises(PermissionError):
             grp.full_like('aa', a)
 
-        if hasattr(grp.store, 'close'):
-            grp.store.close()
+        grp.store.close()
 
     def test_paths(self):
         g1 = self.create_group()
@@ -890,8 +868,7 @@ def test_paths(self):
         with pytest.raises(ValueError):
             g1['foo/../bar']
 
-        if hasattr(g1.store, 'close'):
-            g1.store.close()
+        g1.store.close()
 
     def test_pickle(self):
 
@@ -908,8 +885,7 @@ def test_pickle(self):
         dump = pickle.dumps(g)
         # some stores cannot be opened twice at the same time, need to close
         # store before can round-trip through pickle
-        if hasattr(g.store, 'close'):
-            g.store.close()
+        g.store.close()
         g2 = pickle.loads(dump)
 
         # verify
@@ -920,8 +896,7 @@ def test_pickle(self):
         assert isinstance(g2['foo'], Group)
         assert isinstance(g2['foo/bar'], Array)
 
-        if hasattr(g2.store, 'close'):
-            g2.store.close()
+        g2.store.close()
 
     def test_context_manager(self):
 
@@ -930,6 +905,22 @@ def test_context_manager(self):
             d[:] = np.arange(100)
 
 
+@pytest.mark.parametrize('chunk_dict', [False, True])
+def test_group_init_from_dict(chunk_dict):
+    if chunk_dict:
+        store, chunk_store = dict(), dict()
+    else:
+        store, chunk_store = dict(), None
+    init_group(store, path=None, chunk_store=chunk_store)
+    g = Group(store, path=None, read_only=False, chunk_store=chunk_store)
+    assert store is not g.store
+    assert isinstance(g.store, KVStore)
+    if chunk_store is None:
+        assert g.store is g.chunk_store
+    else:
+        assert chunk_store is not g.chunk_store
+
+
 class TestGroupWithMemoryStore(TestGroup):
 
     @staticmethod
@@ -1039,6 +1030,11 @@ def test_context_manager(self):
         with pytest.raises(ValueError):
             store.zf.extractall()
 
+    def test_move(self):
+        # zip store is not erasable (can so far only append to a zip
+        # so we can't test for move.
+        pass
+
 
 class TestGroupWithDBMStore(TestGroup):
 
@@ -1086,7 +1082,7 @@ class TestGroupWithChunkStore(TestGroup):
 
     @staticmethod
     def create_store():
-        return dict(), dict()
+        return KVStore(dict()), KVStore(dict())
 
     def test_chunk_store(self):
         # setup
@@ -1131,13 +1127,13 @@ def test_group():
     assert '/' == g.name
 
     # usage with custom store
-    store = dict()
+    store = KVStore(dict())
     g = group(store=store)
     assert isinstance(g, Group)
     assert store is g.store
 
     # overwrite behaviour
-    store = dict()
+    store = KVStore(dict())
     init_array(store, shape=100, chunks=10)
     with pytest.raises(ValueError):
         group(store)
diff --git a/zarr/tests/test_storage.py b/zarr/tests/test_storage.py
index 51bc9bf782..889fa80043 100644
--- a/zarr/tests/test_storage.py
+++ b/zarr/tests/test_storage.py
@@ -25,13 +25,14 @@
                        encode_group_metadata)
 from zarr.n5 import N5Store, N5FSStore
 from zarr.storage import (ABSStore, ConsolidatedMetadataStore, DBMStore,
-                          DictStore, DirectoryStore, LMDBStore, LRUStoreCache,
-                          MemoryStore, MongoDBStore, NestedDirectoryStore,
-                          RedisStore, SQLiteStore, TempStore, ZipStore,
+                          DictStore, DirectoryStore, KVStore, LMDBStore,
+                          LRUStoreCache, MemoryStore, MongoDBStore,
+                          NestedDirectoryStore, RedisStore, SQLiteStore,
+                          Store, TempStore, ZipStore,
                           array_meta_key, atexit_rmglob, atexit_rmtree,
                           attrs_key, default_compressor, getsize,
                           group_meta_key, init_array, init_group, migrate_1to2)
-from zarr.storage import FSStore
+from zarr.storage import FSStore, rename, listdir
 from zarr.tests.util import CountingDict, have_fsspec, skip_test_env_var, abs_container
 
 
@@ -54,6 +55,46 @@ def skip_if_nested_chunks(**kwargs):
         pytest.skip("nested chunks are unsupported")
 
 
+def test_kvstore_repr():
+    repr(KVStore(dict()))
+
+
+def test_invalid_store():
+    class InvalidStore:
+        pass
+
+    with pytest.raises(ValueError):
+        Store._ensure_store(InvalidStore())
+
+
+def test_capabilities():
+    s = KVStore(dict())
+    assert s.is_readable()
+    assert s.is_listable()
+    assert s.is_erasable()
+    assert s.is_writeable()
+
+
+def test_getsize_non_implemented():
+    assert getsize(object()) == -1
+
+
+def test_kvstore_eq():
+    assert KVStore(dict()) != dict()
+
+
+def test_coverage_rename():
+    store = dict()
+    store['a'] = 1
+    rename(store, 'a', 'b')
+
+
+def test_deprecated_listdir_nosotre():
+    store = dict()
+    with pytest.warns(UserWarning, match="has no `listdir`"):
+        listdir(store)
+
+
 class StoreTests(object):
     """Abstract store tests."""
 
@@ -61,6 +102,10 @@ def create_store(self, **kwargs):  # pragma: no cover
         # implement in sub-class
         raise NotImplementedError
 
+    def test_context_manager(self):
+        with self.create_store():
+            pass
+
     def test_get_set_del_contains(self):
         store = self.create_store()
 
@@ -87,8 +132,7 @@ def test_get_set_del_contains(self):
                 # noinspection PyStatementEffect
                 del store['foo']
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_set_invalid_content(self):
         store = self.create_store()
@@ -96,8 +140,7 @@ def test_set_invalid_content(self):
         with pytest.raises(TypeError):
             store['baz'] = list(range(5))
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_clear(self):
         store = self.create_store()
@@ -109,8 +152,7 @@ def test_clear(self):
         assert 'foo' not in store
         assert 'baz' not in store
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_pop(self):
         store = self.create_store()
@@ -132,8 +174,7 @@ def test_pop(self):
         v = store.pop('xxx', None)
         assert v is None
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_popitem(self):
         store = self.create_store()
@@ -145,8 +186,7 @@ def test_popitem(self):
         with pytest.raises(KeyError):
             store.popitem()
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_writeable_values(self):
         store = self.create_store()
@@ -157,8 +197,7 @@ def test_writeable_values(self):
         store['foo3'] = array.array('B', b'bar')
         store['foo4'] = np.frombuffer(b'bar', dtype='u1')
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_update(self):
         store = self.create_store()
@@ -168,8 +207,7 @@ def test_update(self):
         assert b'bar' == ensure_bytes(store['foo'])
         assert b'quux' == ensure_bytes(store['baz'])
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_iterators(self):
         store = self.create_store()
@@ -195,8 +233,7 @@ def test_iterators(self):
         assert ({('a', b'aaa'), ('b', b'bbb'), ('c/d', b'ddd'), ('c/e/f', b'fff')} ==
                 set(map(lambda kv: (kv[0], ensure_bytes(kv[1])), store.items())))
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_pickle(self):
 
@@ -211,10 +248,9 @@ def test_pickle(self):
         dump = pickle.dumps(store)
         # some stores cannot be opened twice at the same time, need to close
         # store before can round-trip through pickle
-        if hasattr(store, 'close'):
-            store.close()
-            # check can still pickle after close
-            assert dump == pickle.dumps(store)
+        store.close()
+        # check can still pickle after close
+        assert dump == pickle.dumps(store)
         store2 = pickle.loads(dump)
 
         # verify
@@ -223,8 +259,7 @@ def test_pickle(self):
         assert b'bar' == ensure_bytes(store2['foo'])
         assert b'quux' == ensure_bytes(store2['baz'])
 
-        if hasattr(store2, 'close'):
-            store2.close()
+        store2.close()
 
     def test_getsize(self):
         store = self.create_store()
@@ -246,8 +281,7 @@ def test_getsize(self):
             assert 15 == getsize(store)
             assert 5 == getsize(store, 'spong')
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     # noinspection PyStatementEffect
     def test_hierarchy(self):
@@ -312,59 +346,58 @@ def test_hierarchy(self):
             assert [] == store.listdir('c/e/f')
 
         # test rename (optional)
-        if hasattr(store, 'rename'):
-            store.rename('c/e', 'c/e2')
-            assert 'c/d' in store
-            assert 'c/e' not in store
-            assert 'c/e/f' not in store
-            assert 'c/e/g' not in store
-            assert 'c/e2' not in store
-            assert 'c/e2/f' in store
-            assert 'c/e2/g' in store
-            store.rename('c/e2', 'c/e')
-            assert 'c/d' in store
-            assert 'c/e2' not in store
-            assert 'c/e2/f' not in store
-            assert 'c/e2/g' not in store
-            assert 'c/e' not in store
-            assert 'c/e/f' in store
-            assert 'c/e/g' in store
-            store.rename('c', 'c1/c2/c3')
-            assert 'a' in store
-            assert 'c' not in store
-            assert 'c/d' not in store
-            assert 'c/e' not in store
-            assert 'c/e/f' not in store
-            assert 'c/e/g' not in store
-            assert 'c1' not in store
-            assert 'c1/c2' not in store
-            assert 'c1/c2/c3' not in store
-            assert 'c1/c2/c3/d' in store
-            assert 'c1/c2/c3/e' not in store
-            assert 'c1/c2/c3/e/f' in store
-            assert 'c1/c2/c3/e/g' in store
-            store.rename('c1/c2/c3', 'c')
-            assert 'c' not in store
-            assert 'c/d' in store
-            assert 'c/e' not in store
-            assert 'c/e/f' in store
-            assert 'c/e/g' in store
-            assert 'c1' not in store
-            assert 'c1/c2' not in store
-            assert 'c1/c2/c3' not in store
-            assert 'c1/c2/c3/d' not in store
-            assert 'c1/c2/c3/e' not in store
-            assert 'c1/c2/c3/e/f' not in store
-            assert 'c1/c2/c3/e/g' not in store
-
-        # test rmdir (optional)
-        if hasattr(store, 'rmdir'):
-            store.rmdir('c/e')
-            assert 'c/d' in store
-            assert 'c/e/f' not in store
-            assert 'c/e/g' not in store
-            store.rmdir('c')
-            assert 'c/d' not in store
+        if store.is_erasable():
+            store.rename("c/e", "c/e2")
+            assert "c/d" in store
+            assert "c/e" not in store
+            assert "c/e/f" not in store
+            assert "c/e/g" not in store
+            assert "c/e2" not in store
+            assert "c/e2/f" in store
+            assert "c/e2/g" in store
+            store.rename("c/e2", "c/e")
+            assert "c/d" in store
+            assert "c/e2" not in store
+            assert "c/e2/f" not in store
+            assert "c/e2/g" not in store
+            assert "c/e" not in store
+            assert "c/e/f" in store
+            assert "c/e/g" in store
+            store.rename("c", "c1/c2/c3")
+            assert "a" in store
+            assert "c" not in store
+            assert "c/d" not in store
+            assert "c/e" not in store
+            assert "c/e/f" not in store
+            assert "c/e/g" not in store
+            assert "c1" not in store
+            assert "c1/c2" not in store
+            assert "c1/c2/c3" not in store
+            assert "c1/c2/c3/d" in store
+            assert "c1/c2/c3/e" not in store
+            assert "c1/c2/c3/e/f" in store
+            assert "c1/c2/c3/e/g" in store
+            store.rename("c1/c2/c3", "c")
+            assert "c" not in store
+            assert "c/d" in store
+            assert "c/e" not in store
+            assert "c/e/f" in store
+            assert "c/e/g" in store
+            assert "c1" not in store
+            assert "c1/c2" not in store
+            assert "c1/c2/c3" not in store
+            assert "c1/c2/c3/d" not in store
+            assert "c1/c2/c3/e" not in store
+            assert "c1/c2/c3/e/f" not in store
+            assert "c1/c2/c3/e/g" not in store
+
+            # test rmdir (optional)
+            store.rmdir("c/e")
+            assert "c/d" in store
+            assert "c/e/f" not in store
+            assert "c/e/g" not in store
+            store.rmdir("c")
+            assert "c/d" not in store
             store.rmdir()
             assert 'a' not in store
             assert 'b' not in store
@@ -383,8 +416,7 @@ def test_hierarchy(self):
             assert 'c/d' in store
             assert 'c/e/f' in store
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_init_array(self, dimension_separator_fixture):
 
@@ -405,8 +437,7 @@ def test_init_array(self, dimension_separator_fixture):
         # Missing MUST be assumed to be "."
         assert meta.get('dimension_separator', ".") is want_dim_sep
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_init_array_overwrite(self):
         self._test_init_array_overwrite('F')
@@ -457,8 +488,7 @@ def _test_init_array_overwrite(self, order):
             assert (100,) == meta['chunks']
             assert np.dtype('i4') == meta['dtype']
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_init_array_path(self):
         path = 'foo/bar'
@@ -476,8 +506,7 @@ def test_init_array_path(self):
         assert default_compressor.get_config() == meta['compressor']
         assert meta['fill_value'] is None
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def _test_init_array_overwrite_path(self, order):
         # setup
@@ -514,8 +543,7 @@ def _test_init_array_overwrite_path(self, order):
             assert (100,) == meta['chunks']
             assert np.dtype('i4') == meta['dtype']
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_init_array_overwrite_group(self):
         # setup
@@ -542,8 +570,7 @@ def test_init_array_overwrite_group(self):
             assert (100,) == meta['chunks']
             assert np.dtype('i4') == meta['dtype']
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def _test_init_array_overwrite_chunk_store(self, order):
         # setup
@@ -581,10 +608,8 @@ def _test_init_array_overwrite_chunk_store(self, order):
             assert '0' not in chunk_store
             assert '1' not in chunk_store
 
-        if hasattr(store, 'close'):
-            store.close()
-        if hasattr(chunk_store, 'close'):
-            chunk_store.close()
+        store.close()
+        chunk_store.close()
 
     def test_init_array_compat(self):
         store = self.create_store()
@@ -592,8 +617,7 @@ def test_init_array_compat(self):
         meta = decode_array_metadata(store[array_meta_key])
         assert meta['compressor'] is None
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def test_init_group(self):
         store = self.create_store()
@@ -604,8 +628,7 @@ def test_init_group(self):
         meta = decode_group_metadata(store[group_meta_key])
         assert ZARR_FORMAT == meta['zarr_format']
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def _test_init_group_overwrite(self, order):
         # setup
@@ -639,8 +662,7 @@ def _test_init_group_overwrite(self, order):
         with pytest.raises(ValueError):
             init_group(store)
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def _test_init_group_overwrite_path(self, order):
         # setup
@@ -674,8 +696,7 @@ def _test_init_group_overwrite_path(self, order):
             meta = decode_group_metadata(store[path + '/' + group_meta_key])
             assert ZARR_FORMAT == meta['zarr_format']
 
-        if hasattr(store, 'close'):
-            store.close()
+        store.close()
 
     def _test_init_group_overwrite_chunk_store(self, order):
         # setup
@@ -714,17 +735,15 @@ def _test_init_group_overwrite_chunk_store(self, order):
         with pytest.raises(ValueError):
             init_group(store)
 
-        if hasattr(store, 'close'):
-            store.close()
-        if hasattr(chunk_store, 'close'):
-            chunk_store.close()
+        store.close()
+        chunk_store.close()
 
 
 class TestMappingStore(StoreTests):
 
     def create_store(self, **kwargs):
         skip_if_nested_chunks(**kwargs)
-        return dict()
+        return KVStore(dict())
 
     def test_set_invalid_content(self):
         # Generic mappings support non-buffer types
@@ -1090,11 +1109,13 @@ def test_s3_complex(self):
 
         with pytest.raises(PermissionError):
             # even though overwrite=True, store is read-only, so fails
-            g2.create_dataset("data", shape=(8, 8, 8), mode='w',
-                              fill_value=-1, chunks=(1, 1, 1), overwrite=True)
+            g2.create_dataset(
+                "data", shape=(8, 8, 8), fill_value=-1, chunks=(1, 1, 1), overwrite=True
+            )
 
-        a = g.create_dataset("data", shape=(8, 8, 8), mode='w',
-                             fill_value=-1, chunks=(1, 1, 1), overwrite=True)
+        a = g.create_dataset(
+            "data", shape=(8, 8, 8), fill_value=-1, chunks=(1, 1, 1), overwrite=True
+        )
         assert (a[:] == -np.ones((8, 8, 8))).all()
 
 
@@ -1896,14 +1917,14 @@ def test_cache_keys(self):
 
 
 def test_getsize():
-    store = dict()
+    store = KVStore(dict())
     store['foo'] = b'aaa'
     store['bar'] = b'bbbb'
     store['baz/quux'] = b'ccccc'
     assert 7 == getsize(store)
     assert 5 == getsize(store, 'baz')
 
-    store = dict()
+    store = KVStore(dict())
     store['boo'] = None
     assert -1 == getsize(store)
 
@@ -1915,7 +1936,7 @@ def test_migrate_1to2():
     # concerned about migrating a single array at the root of the store
 
     # setup
-    store = dict()
+    store = KVStore(dict())
     meta = dict(
         shape=(100,),
         chunks=(10,),
@@ -1953,7 +1974,7 @@ def test_migrate_1to2():
     assert meta_migrated['compressor'] == Zlib(1).get_config()
 
     # check dict compression_opts
-    store = dict()
+    store = KVStore(dict())
     meta['compression'] = 'blosc'
     meta['compression_opts'] = dict(cname='lz4', clevel=5, shuffle=1)
     meta_json = meta_v1.encode_metadata(meta)
@@ -1967,7 +1988,7 @@ def test_migrate_1to2():
             Blosc(cname='lz4', clevel=5, shuffle=1).get_config())
 
     # check 'none' compression is migrated to None (null in JSON)
-    store = dict()
+    store = KVStore(dict())
     meta['compression'] = 'none'
     meta_json = meta_v1.encode_metadata(meta)
     store['meta'] = meta_json
diff --git a/zarr/tests/test_sync.py b/zarr/tests/test_sync.py
index 274ce166be..700c23eb45 100644
--- a/zarr/tests/test_sync.py
+++ b/zarr/tests/test_sync.py
@@ -12,7 +12,8 @@
 from zarr.attrs import Attributes
 from zarr.core import Array
 from zarr.hierarchy import Group
-from zarr.storage import DirectoryStore, atexit_rmtree, init_array, init_group
+from zarr.storage import (DirectoryStore, KVStore, atexit_rmtree, init_array,
+                          init_group)
 from zarr.sync import ProcessSynchronizer, ThreadSynchronizer
 from zarr.tests.test_attrs import TestAttributes
 from zarr.tests.test_core import TestArray
@@ -96,7 +97,7 @@ def test_parallel_append(self):
 class TestArrayWithThreadSynchronizer(TestArray, MixinArraySyncTests):
 
     def create_array(self, read_only=False, **kwargs):
-        store = dict()
+        store = KVStore(dict())
         cache_metadata = kwargs.pop('cache_metadata', True)
         cache_attrs = kwargs.pop('cache_attrs', True)
         write_empty_chunks = kwargs.pop('write_empty_chunks', True)
diff --git a/zarr/tests/util.py b/zarr/tests/util.py
index 1de014589b..e0f11d72ad 100644
--- a/zarr/tests/util.py
+++ b/zarr/tests/util.py
@@ -1,11 +1,12 @@
 import collections
-from collections.abc import MutableMapping
 import os
 
+from zarr.storage import Store
+
 import pytest
 
 
-class CountingDict(MutableMapping):
+class CountingDict(Store):
 
     def __init__(self):
         self.wrapped = dict()