Duckarray tests for constructors and properties

xarray/tests/conftest.py

@@ -12,6 +12,48 @@ def backend(request):
     return request.param
 
 
+def pytest_configure(config):
+    config.addinivalue_line(
+        "markers",
+        "apply_marks(marks): function to attach marks to tests and test variants",
+    )
+
+
+def always_sequence(obj):
+    if not isinstance(obj, (list, tuple)):
+        obj = [obj]
+
+    return obj
+
+
+def pytest_collection_modifyitems(session, config, items):
+    for item in items:
+        mark = item.get_closest_marker("apply_marks")
+        if mark is None:
+            continue
+
+        marks = mark.args[0]
+        if not isinstance(marks, dict):
+            continue
+
+        possible_marks = marks.get(item.originalname)
+        if possible_marks is None:
+            continue
+
+        if not isinstance(possible_marks, dict):
+            for mark in always_sequence(possible_marks):
+                item.add_marker(mark)
+            continue
+
+        variant = item.name[len(item.originalname) :]
+        to_attach = possible_marks.get(variant)
+        if to_attach is None:
+            continue
+
+        for mark in always_sequence(to_attach):
+            item.add_marker(mark)
+
+
 @pytest.fixture(params=[1])
 def ds(request, backend):
     if request.param == 1:

xarray/tests/duckarrays/base/__init__.py

@@ -0,0 +1,15 @@
+from .constructors import (
+    DataArrayConstructorTests,
+    DatasetConstructorTests,
+    VariableConstructorTests,
+)
+from .reduce import DataArrayReduceTests, DatasetReduceTests, VariableReduceTests
+
+__all__ = [
+    "VariableConstructorTests",
+    "DataArrayConstructorTests",
+    "DatasetConstructorTests",
+    "VariableReduceTests",
+    "DataArrayReduceTests",
+    "DatasetReduceTests",
+]

xarray/tests/duckarrays/base/constructors.py

@@ -0,0 +1,59 @@
+import hypothesis.strategies as st
+import numpy as np
+import numpy.testing as npt
+from hypothesis import given, note, settings
+
+import xarray as xr
+
+from . import strategies
+
+
+class VariableConstructorTests:
+    def check(self, var, arr):
+        self.check_types(var, arr)
+        self.check_values(var, arr)
+        self.check_attributes(var, arr)
+
+    def check_types(self, var, arr):
+        # test type of wrapped array
+        assert isinstance(
+            var.data, type(arr)
+        ), f"found {type(var.data)}, expected {type(arr)}"
+
+    def check_attributes(self, var, arr):
+        # test ndarry attributes are exposed correctly
+        assert var.ndim == arr.ndim
+        assert var.shape == arr.shape
+        assert var.dtype == arr.dtype
+        assert var.size == arr.size
+        assert var.nbytes == arr.nbytes
+
+    def check_values(self, var, arr):
+        # test coersion to numpy
+        npt.assert_equal(var.to_numpy(), np.asarray(arr))
+
+    @staticmethod
+    def create(shape, dtypes):
+        return strategies.numpy_array(shape, dtypes)
+
+    @given(st.data())
+    @settings(deadline=None)
+    def test_construct(self, data):
+        arr = data.draw(
+            strategies.duckarray(lambda shape, dtypes: self.create(shape, dtypes))
+        )
+
+        # TODO generalize to N dimensions
+        dims = ["dim_0", "dim_1", "dim_2"]
+
+        var = xr.Variable(dims=dims[0 : arr.ndim], data=arr)
+
+        self.check(var, arr)
+
+
+class DataArrayConstructorTests:
+    ...
+
+
+class DatasetConstructorTests:
+    ...

xarray/tests/duckarrays/base/reduce.py

@@ -0,0 +1,144 @@
+import hypothesis.strategies as st
+import numpy as np
+import pytest
+from hypothesis import given, note, settings
+
+from ... import assert_identical
+from . import strategies
+
+
+class VariableReduceTests:
+    def check_reduce(self, obj, op, *args, **kwargs):
+        actual = getattr(obj, op)(*args, **kwargs)
+
+        data = np.asarray(obj.data)
+        expected = getattr(obj.copy(data=data), op)(*args, **kwargs)
+
+        note(f"actual:\n{actual}")
+        note(f"expected:\n{expected}")
+
+        assert_identical(actual, expected)
+
+    @staticmethod
+    def create(shape, dtypes):
+        return strategies.numpy_array(shape)
+
+    @pytest.mark.parametrize(
+        "method",
+        (
+            "all",
+            "any",
+            "cumprod",
+            "cumsum",
+            "max",
+            "mean",
+            "median",
+            "min",
+            "prod",
+            "std",
+            "sum",
+            "var",
+        ),
+    )
+    @given(st.data())
+    @settings(deadline=None)
+    def test_reduce(self, method, data):
+        var = data.draw(
+            strategies.variable(lambda shape, dtypes: self.create(shape, dtypes))
+        )
+
+        reduce_dims = data.draw(strategies.valid_dims(var.dims))
+
+        self.check_reduce(var, method, dim=reduce_dims)
+
+
+class DataArrayReduceTests:
+    def check_reduce(self, obj, op, *args, **kwargs):
+        actual = getattr(obj, op)(*args, **kwargs)
+
+        data = np.asarray(obj.data)
+        expected = getattr(obj.copy(data=data), op)(*args, **kwargs)
+
+        note(f"actual:\n{actual}")
+        note(f"expected:\n{expected}")
+
+        assert_identical(actual, expected)
+
+    @staticmethod
+    def create(shape, dtypes, op):
+        return strategies.numpy_array(shape, dtypes)
+
+    @pytest.mark.parametrize(
+        "method",
+        (
+            "all",
+            "any",
+            "cumprod",
+            "cumsum",
+            "max",
+            "mean",
+            "median",
+            "min",
+            "prod",
+            "std",
+            "sum",
+            "var",
+        ),
+    )
+    @given(st.data())
+    @settings(deadline=None)
+    def test_reduce(self, method, data):
+        arr = data.draw(
+            strategies.data_array(lambda shape, dtypes: self.create(shape, dtypes))
+        )
+
+        reduce_dims = data.draw(strategies.valid_dims(arr.dims))
+
+        self.check_reduce(arr, method, dim=reduce_dims)
+
+
+class DatasetReduceTests:
+    def check_reduce(self, obj, op, *args, **kwargs):
+        actual = getattr(obj, op)(*args, **kwargs)
+
+        data = {name: np.asarray(obj.data) for name, obj in obj.variables.items()}
+        expected = getattr(obj.copy(data=data), op)(*args, **kwargs)
+
+        note(f"actual:\n{actual}")
+        note(f"expected:\n{expected}")
+
+        assert_identical(actual, expected)
+
+    @staticmethod
+    def create(shape, dtypes):
+        return strategies.numpy_array(shape, dtypes)
+
+    @pytest.mark.parametrize(
+        "method",
+        (
+            "all",
+            "any",
+            "cumprod",
+            "cumsum",
+            "max",
+            "mean",
+            "median",
+            "min",
+            "prod",
+            "std",
+            "sum",
+            "var",
+        ),
+    )
+    @given(st.data())
+    @settings(deadline=None)
+    def test_reduce(self, method, data):
+        ds = data.draw(
+            strategies.dataset(
+                lambda shape, dtypes: self.create(shape, dtypes), max_size=5
+            )
+        )
+
+        reduce_dims = data.draw(strategies.valid_dims(ds.dims))
+
+        self.check_reduce(ds, method, dim=reduce_dims)