Rudimentary column object tests

Author: honno

README.md

@@ -16,7 +16,7 @@ it's a **work in progress**.
 
 * **Signatures** ([`test_signatures.py`](./tests/test_signatures.py)): Assert methods have the correct signatures.
 
-* **Basic functionality** ([`test_dataframe_object.py`](./tests/test_dataframe_object.py)): Smoke methods can take valid input, and assert they return valid output (where appropiate).
+* **Basic functionality** (e.g. [`test_dataframe_object.py`](./tests/test_dataframe_object.py)): Smoke methods can take valid input, and assert they return valid output (where appropiate).
 
 ### What the heck is `LibraryInfo`?
 

tests/conftest.py

@@ -62,3 +62,5 @@ def pytest_collection_modifyitems(config, items):
         for item in items:
             if any(id_ in item.nodeid for id_ in ci_failing_ids):
                 item.add_marker(pytest.mark.xfail())
+            elif "test_column_object" in item.nodeid:
+                item.add_marker(pytest.mark.skip("TODO"))

tests/strategies.py

@@ -15,14 +15,14 @@ class NominalDtype(Enum):
     DATETIME64NS = "datetime64[ns]"
     CATEGORY = "category"
     # Numerics
-    UINT8 = "uint8"
-    UINT16 = "uint16"
-    UINT32 = "uint32"
-    UINT64 = "uint64"
     INT8 = "int8"
     INT16 = "int16"
     INT32 = "int32"
     INT64 = "int64"
+    UINT8 = "uint8"
+    UINT16 = "uint16"
+    UINT32 = "uint32"
+    UINT64 = "uint64"
     FLOAT32 = "float32"
     FLOAT64 = "float64"
 
@@ -56,12 +56,12 @@ def __iter__(self):
     def __len__(self):
         return len(self._name_to_column)
 
-    def num_rows(self) -> int:
-        return self._nrows
-
     def num_columns(self) -> int:
         return self._ncols
 
+    def num_rows(self) -> int:
+        return self._nrows
+
     def __repr__(self) -> str:
         col_reprs = []
         for name, col in self.items():

tests/test_column_object.py

@@ -0,0 +1,171 @@
+from enum import IntEnum
+from typing import Dict, Iterator, Tuple
+
+import numpy as np
+import pytest
+from hypothesis import given
+from hypothesis import strategies as st
+
+from tests.api import Column
+
+from .strategies import MockColumn, NominalDtype, mock_dataframes
+from .wrappers import LibraryInfo
+
+# TODO: helpful assertion messages
+# TODO: better column generation
+
+
+def columns_and_mock_columns(
+    libinfo: LibraryInfo, data: st.DataObject
+) -> Iterator[Tuple[Column, MockColumn]]:
+    mock_df = data.draw(
+        mock_dataframes(**{**libinfo.mock_dataframes_kwargs, "allow_zero_cols": False}),
+        label="mock_df",
+    )
+    df = libinfo.mock_to_interchange(mock_df)
+    for name in mock_df.keys():
+        yield df.get_column_by_name(name), mock_df[name]
+
+
+@given(data=st.data())
+def test_size(libinfo: LibraryInfo, data: st.DataObject):
+    for col, mock_col in columns_and_mock_columns(libinfo, data):
+        size = col.size
+        if size is not None:
+            assert isinstance(size, int)
+            assert size == mock_col.array.size
+
+
+@given(data=st.data())
+def test_offset(libinfo: LibraryInfo, data: st.DataObject):
+    for col, _ in columns_and_mock_columns(libinfo, data):
+        offset = col.offset
+        assert isinstance(offset, int)
+
+
+INT_DTYPES = tuple(e for e in NominalDtype if e.value.startswith("int"))
+UINT_DTYPES = tuple(e for e in NominalDtype if e.value.startswith("uint"))
+FLOAT_DTYPES = tuple(e for e in NominalDtype if e.value.startswith("float"))
+
+
+class DtypeKind(IntEnum):
+    INT = 0
+    UINT = 1
+    FLOAT = 2
+    BOOL = 20
+    STRING = 21
+    DATETIME = 22
+    CATEGORICAL = 23
+
+
+NOMINAL_TO_KIND: Dict[NominalDtype, DtypeKind] = {
+    **{nd: DtypeKind.INT for nd in INT_DTYPES},
+    **{nd: DtypeKind.UINT for nd in UINT_DTYPES},
+    **{nd: DtypeKind.FLOAT for nd in FLOAT_DTYPES},
+    NominalDtype.BOOL: DtypeKind.BOOL,
+    NominalDtype.UTF8: DtypeKind.STRING,
+    NominalDtype.DATETIME64NS: DtypeKind.DATETIME,
+    NominalDtype.CATEGORY: DtypeKind.CATEGORICAL,
+}
+
+
+@given(data=st.data())
+def test_dtype(libinfo: LibraryInfo, data: st.DataObject):
+    for col, mock_col in columns_and_mock_columns(libinfo, data):
+        dtype = col.dtype
+        assert isinstance(dtype, tuple)
+        assert len(dtype) == 4
+        kind, bitwidth, fstring, endianness = col.dtype
+        assert isinstance(kind, IntEnum)
+        assert kind.value == NOMINAL_TO_KIND[mock_col.nominal_dtype].value
+        assert isinstance(bitwidth, int)
+        # TODO: Test fstring and endianness have valid values
+        assert isinstance(fstring, str)
+        assert isinstance(endianness, str)
+
+
+@given(data=st.data())
+def test_describe_categorical(libinfo: LibraryInfo, data: st.DataObject):
+    # TODO: ensure generation for categorical columns
+    for col, mock_col in columns_and_mock_columns(libinfo, data):
+        if mock_col.nominal_dtype == NominalDtype.CATEGORY:
+            catinfo = col.describe_categorical
+            assert isinstance(catinfo, dict)
+            for key in ["is_ordered", "is_dictionary", "mapping"]:
+                assert key in catinfo.keys()
+            assert isinstance(catinfo["is_ordered"], bool)
+            assert isinstance(catinfo["is_dictionary"], bool)
+            mapping = catinfo["mapping"]
+            if mapping is not None:
+                assert isinstance(mapping, dict)
+        else:
+            with pytest.raises(RuntimeError):
+                col.describe_categorical
+
+
+@given(data=st.data())
+def test_describe_null(libinfo: LibraryInfo, data: st.DataObject):
+    for col, _ in columns_and_mock_columns(libinfo, data):
+        nullinfo = col.describe_null
+        assert isinstance(nullinfo, tuple)
+        assert len(nullinfo) == 2
+        kind, value = nullinfo
+        assert isinstance(kind, int)
+        assert kind in [0, 1, 2, 3, 4]
+        if kind in [0, 1]:  # noll-nullable or NaN/NaT
+            assert value is None
+        elif kind in [3, 4]:  # bit or byte mask
+            assert isinstance(value, int)
+            assert value in [0, 1]
+
+
+@given(data=st.data())
+def test_null_count(libinfo: LibraryInfo, data: st.DataObject):
+    for col, mock_col in columns_and_mock_columns(libinfo, data):
+        null_count = col.null_count
+        if null_count is not None:
+            assert isinstance(null_count, int)
+            assert null_count == sum(np.isnan(mock_col.array))
+
+
+@given(data=st.data())
+def test_num_chunks(libinfo: LibraryInfo, data: st.DataObject):
+    for col, _ in columns_and_mock_columns(libinfo, data):
+        num_chunks = col.num_chunks()
+        assert isinstance(num_chunks, int)
+
+
+@given(data=st.data())
+def test_get_chunks(libinfo: LibraryInfo, data: st.DataObject):
+    for col, _ in columns_and_mock_columns(libinfo, data):
+        num_chunks = col.num_chunks()
+        n_chunks = data.draw(
+            st.none() | st.integers(1, 2).map(lambda n: n * num_chunks),
+            label="n_chunks",
+        )
+        if n_chunks is None and not data.draw(st.booleans(), label="pass n_chunks"):
+            args = []
+        else:
+            args = [n_chunks]
+        col.get_chunks(*args)
+
+
+@given(data=st.data())
+def test_get_buffers(libinfo: LibraryInfo, data: st.DataObject):
+    for col, _ in columns_and_mock_columns(libinfo, data):
+        bufinfo = col.get_buffers()
+        assert isinstance(bufinfo, dict)
+        for key in ["data", "validity", "offsets"]:
+            assert key in bufinfo.keys()
+        # TODO: test returned dtypes (probably generalise it)
+        data = bufinfo["data"]
+        assert isinstance(data, tuple)
+        assert len(data) == 2
+        validity = bufinfo["validity"]
+        if validity is not None:
+            assert isinstance(validity, tuple)
+            assert len(validity) == 2
+        offsets = bufinfo["offsets"]
+        if offsets is not None:
+            assert isinstance(offsets, tuple)
+            assert len(offsets) == 2

tests/test_meta.py

@@ -6,13 +6,13 @@
 from hypothesis import given
 from hypothesis import strategies as st
 
-from .strategies import mock_dataframes
+from .strategies import MockDataFrame, mock_dataframes
 from .wrappers import LibraryInfo
 
 
 @given(mock_dataframes())
-def test_mock_dataframes(_):
-    pass
+def test_mock_dataframes(mock_df):
+    assert isinstance(mock_df, MockDataFrame)
 
 
 @pytest.mark.parametrize(