behave-tables 0.1.0__tar.gz

behave_tables-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+    tags: ["v*"]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[dev,pydantic]"
+      - run: ruff check .
+      - run: pytest tests/ -v --cov --cov-report=xml
+      - uses: codecov/codecov-action@v4
+        if: matrix.python-version == '3.12'
+        with:
+          file: ./coverage.xml
+

behave_tables-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,38 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          attestations: true

behave_tables-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.pytest_cache/
+.coverage
+htmlcov/
+coverage.xml
+.tox/
+.mypy_cache/
+.ruff_cache/

behave_tables-0.1.0/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.0] - 2026-07-13
+
+### Added
+
+- `TableWrapper` class wrapping `behave.model.Table`
+- `wrap()` convenience function
+- `as_dicts()` — rows as list of dicts
+- `as_models(model)` — rows as Pydantic or dataclass instances
+- `column(name)` — extract single column values
+- `find_row(**filters)` — find first matching row
+- `validate_columns(*expected)` — column validation
+- `transpose()` — swap rows and columns
+- `to_csv()` — CSV export
+- `to_json()` — JSON export
+- `headers` property
+- `__iter__`, `__getitem__`, `__len__` for dict-like iteration
+- `ColumnMismatchError` exception
+- Zero required dependencies (pydantic optional)

behave_tables-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mathias Paulenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

behave_tables-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: behave-tables
+Version: 0.1.0
+Summary: Polished API for Behave Data Tables — as_dicts, as_models, transpose, to_csv, to_json
+Project-URL: Homepage, https://github.com/MathiasPaulenko/behave-tables
+Project-URL: Repository, https://github.com/MathiasPaulenko/behave-tables
+Project-URL: Issues, https://github.com/MathiasPaulenko/behave-tables/issues
+Project-URL: Changelog, https://github.com/MathiasPaulenko/behave-tables/blob/main/CHANGELOG.md
+Author: Mathias Paulenko
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bdd,behave,cucumber,data-tables,gherkin,tables,testing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: behave>=1.2.6; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Provides-Extra: pydantic
+Requires-Dist: pydantic>=2.0; extra == 'pydantic'
+Description-Content-Type: text/markdown
+
+# behave-tables
+
+Polished API for Behave Data Tables.
+
+## Why?
+
+Behave's `Table` requires manual iteration: `for row in table.rows: name = row["name"]`. No conversion to dicts, models, CSV, or JSON. Every project reimplements helpers.
+
+## Install
+
+```bash
+pip install behave-tables
+# Optional: pydantic for as_models() with validation
+pip install behave-tables[pydantic]
+```
+
+## Quick start
+
+```python
+from behave_tables import wrap
+
+# In a step definition
+@then("the users should be")
+def step_impl(context):
+    table = wrap(context.table)
+
+    # As dicts
+    users = table.as_dicts()
+    # [{"name": "Alice", "age": "30"}, {"name": "Bob", "age": "25"}]
+
+    # As models (Pydantic or dataclass)
+    users = table.as_models(User)
+
+    # Column extraction
+    names = table.column("name")  # ["Alice", "Bob"]
+
+    # Find first matching row
+    alice = table.find_row(name="Alice")  # {"name": "Alice", "age": "30"}
+
+    # Export
+    csv_str = table.to_csv()
+    json_str = table.to_json()
+
+    # Transpose
+    transposed = table.transpose()
+
+    # Iterate as dicts
+    for row in table:
+        print(row["name"])
+
+    # Index
+    table[0]  # {"name": "Alice", "age": "30"}
+    len(table)  # 2
+```
+
+## API
+
+| Method | Returns | Description |
+|---|---|---|
+| `as_dicts()` | `list[dict[str, str]]` | All rows as dicts |
+| `as_models(model)` | `list[Model]` | Rows as Pydantic or dataclass instances |
+| `column(name)` | `list[str]` | Values for a single column |
+| `find_row(**filters)` | `dict[str, str] \| None` | First row matching all filters |
+| `validate_columns(*expected)` | `None` | Raise `ColumnMismatchError` if columns missing |
+| `transpose()` | `TableWrapper` | New wrapper with rows and columns swapped |
+| `to_csv()` | `str` | CSV string |
+| `to_json()` | `str` | JSON string |
+| `headers` | `list[str]` | Column names |
+| `__iter__` | `Iterator[dict]` | Iterate rows as dicts |
+| `__getitem__(i)` | `dict[str, str]` | Row at index as dict |
+| `__len__` | `int` | Number of rows |
+
+## Zero dependencies
+
+`behave-tables` has no required dependencies. `as_models()` works with stdlib `dataclasses` out of the box. Install `pydantic` optionally for validation.
+
+## License
+
+MIT

behave_tables-0.1.0/README.md

@@ -0,0 +1,79 @@
+# behave-tables
+
+Polished API for Behave Data Tables.
+
+## Why?
+
+Behave's `Table` requires manual iteration: `for row in table.rows: name = row["name"]`. No conversion to dicts, models, CSV, or JSON. Every project reimplements helpers.
+
+## Install
+
+```bash
+pip install behave-tables
+# Optional: pydantic for as_models() with validation
+pip install behave-tables[pydantic]
+```
+
+## Quick start
+
+```python
+from behave_tables import wrap
+
+# In a step definition
+@then("the users should be")
+def step_impl(context):
+    table = wrap(context.table)
+
+    # As dicts
+    users = table.as_dicts()
+    # [{"name": "Alice", "age": "30"}, {"name": "Bob", "age": "25"}]
+
+    # As models (Pydantic or dataclass)
+    users = table.as_models(User)
+
+    # Column extraction
+    names = table.column("name")  # ["Alice", "Bob"]
+
+    # Find first matching row
+    alice = table.find_row(name="Alice")  # {"name": "Alice", "age": "30"}
+
+    # Export
+    csv_str = table.to_csv()
+    json_str = table.to_json()
+
+    # Transpose
+    transposed = table.transpose()
+
+    # Iterate as dicts
+    for row in table:
+        print(row["name"])
+
+    # Index
+    table[0]  # {"name": "Alice", "age": "30"}
+    len(table)  # 2
+```
+
+## API
+
+| Method | Returns | Description |
+|---|---|---|
+| `as_dicts()` | `list[dict[str, str]]` | All rows as dicts |
+| `as_models(model)` | `list[Model]` | Rows as Pydantic or dataclass instances |
+| `column(name)` | `list[str]` | Values for a single column |
+| `find_row(**filters)` | `dict[str, str] \| None` | First row matching all filters |
+| `validate_columns(*expected)` | `None` | Raise `ColumnMismatchError` if columns missing |
+| `transpose()` | `TableWrapper` | New wrapper with rows and columns swapped |
+| `to_csv()` | `str` | CSV string |
+| `to_json()` | `str` | JSON string |
+| `headers` | `list[str]` | Column names |
+| `__iter__` | `Iterator[dict]` | Iterate rows as dicts |
+| `__getitem__(i)` | `dict[str, str]` | Row at index as dict |
+| `__len__` | `int` | Number of rows |
+
+## Zero dependencies
+
+`behave-tables` has no required dependencies. `as_models()` works with stdlib `dataclasses` out of the box. Install `pydantic` optionally for validation.
+
+## License
+
+MIT

behave_tables-0.1.0/behave_tables/__init__.py

@@ -0,0 +1,19 @@
+"""behave-tables — Polished API for Behave Data Tables."""
+
+from __future__ import annotations
+
+from .exceptions import ColumnMismatchError
+from .wrapper import TableWrapper
+
+__version__ = "0.1.0"
+
+__all__ = ["TableWrapper", "wrap", "ColumnMismatchError", "__version__"]
+
+
+def wrap(table: object) -> TableWrapper:
+    """Wrap a behave.model.Table with TableWrapper.
+
+    Convenience function: ``wrap(context.table)`` instead of
+    ``TableWrapper(context.table)``.
+    """
+    return TableWrapper(table)

behave_tables-0.1.0/behave_tables/_mock.py

@@ -0,0 +1,31 @@
+"""Internal mock table for transpose() and testing."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class MockRow:
+    """A minimal row implementation compatible with TableWrapper."""
+
+    _data: dict[str, str]
+
+    def as_dict(self) -> dict[str, str]:
+        return dict(self._data)
+
+    def __getitem__(self, key: str) -> str:
+        return self._data[key]
+
+
+@dataclass
+class MockTable:
+    """A minimal table implementation compatible with TableWrapper."""
+
+    headings: list[str]
+    rows_data: list[dict[str, str]] = field(default_factory=list)
+
+    @property
+    def rows(self) -> list[MockRow]:
+        return [MockRow(d) for d in self.rows_data]

behave_tables-0.1.0/behave_tables/converters.py

@@ -0,0 +1,35 @@
+"""Type conversion logic for as_models()."""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any
+
+
+def is_pydantic_model(model: type) -> bool:
+    """Check if a class is a Pydantic v2 BaseModel subclass."""
+    try:
+        from pydantic import BaseModel
+
+        return isinstance(model, type) and issubclass(model, BaseModel)
+    except ImportError:
+        return False
+
+
+def is_dataclass_type(model: type) -> bool:
+    """Check if a class is a dataclass."""
+    return isinstance(model, type) and dataclasses.is_dataclass(model)
+
+
+def convert_row_to_model(row: dict[str, str], model: type) -> Any:
+    """Convert a dict row to a model instance.
+
+    Detects Pydantic v2 BaseModel or stdlib dataclass automatically.
+    """
+    if is_pydantic_model(model):
+        return model(**row)
+    if is_dataclass_type(model):
+        return model(**row)
+    raise TypeError(
+        f"model must be a Pydantic BaseModel or dataclass, got {model!r}"
+    )

behave_tables-0.1.0/behave_tables/exceptions.py

@@ -0,0 +1,15 @@
+"""Custom exceptions for behave-tables."""
+
+from __future__ import annotations
+
+
+class ColumnMismatchError(ValueError):
+    """Raised when expected columns are not found in the table."""
+
+    def __init__(self, missing: list[str], extra: list[str] | None = None) -> None:
+        parts = [f"missing columns: {missing}"] if missing else []
+        if extra:
+            parts.append(f"unexpected columns: {extra}")
+        super().__init__("; ".join(parts))
+        self.missing = missing
+        self.extra = extra or []

behave_tables-0.1.0/behave_tables/wrapper.py

@@ -0,0 +1,144 @@
+"""TableWrapper — polished API for Behave Data Tables."""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+from typing import Any, Iterator, Protocol
+
+from .converters import convert_row_to_model
+from .exceptions import ColumnMismatchError
+
+
+class TableLike(Protocol):
+    """Protocol for behave.model.Table or any table-like object."""
+
+    headings: list[str]
+
+    @property
+    def rows(self) -> list[Any]: ...
+
+
+class RowLike(Protocol):
+    """Protocol for behave.model.Row or any row-like object."""
+
+    def as_dict(self) -> dict[str, str]: ...
+
+    def __getitem__(self, key: str) -> str: ...
+
+
+class TableWrapper:
+    """Wraps a behave.model.Table with an ergonomic API.
+
+    Zero dependencies. Works with any table-like object that has
+    ``headings`` (list[str]) and ``rows`` (list of objects with
+    ``as_dict()`` or ``__getitem__``).
+    """
+
+    def __init__(self, table: TableLike) -> None:
+        self._table = table
+        self._rows: list[dict[str, str]] = self._extract_rows(table)
+
+    @staticmethod
+    def _extract_rows(table: TableLike) -> list[dict[str, str]]:
+        """Extract rows as list of dicts from any table-like object."""
+        rows: list[dict[str, str]] = []
+        for row in table.rows:
+            if hasattr(row, "as_dict"):
+                rows.append(dict(row.as_dict()))
+            elif hasattr(row, "__getitem__"):
+                rows.append({h: row[h] for h in table.headings})
+            else:
+                raise TypeError(f"Unsupported row type: {type(row)!r}")
+        return rows
+
+    @property
+    def headers(self) -> list[str]:
+        """Return column headers."""
+        return list(self._table.headings)
+
+    def as_dicts(self) -> list[dict[str, str]]:
+        """Return all rows as a list of dicts (copies)."""
+        return [dict(row) for row in self._rows]
+
+    def as_models(self, model: type) -> list[Any]:
+        """Convert all rows to model instances.
+
+        Supports Pydantic v2 BaseModel and stdlib dataclasses.
+        """
+        return [convert_row_to_model(row, model) for row in self._rows]
+
+    def column(self, name: str) -> list[str]:
+        """Return all values for a single column.
+
+        Raises KeyError if the column does not exist.
+        """
+        if name not in self.headers:
+            raise KeyError(
+                f"Column {name!r} not found. Available: {self.headers}"
+            )
+        return [row[name] for row in self._rows]
+
+    def find_row(self, **filters: str) -> dict[str, str] | None:
+        """Return the first row matching all filters, or None."""
+        if not filters:
+            return self._rows[0] if self._rows else None
+        for row in self._rows:
+            if all(row.get(k) == v for k, v in filters.items()):
+                return row
+        return None
+
+    def validate_columns(self, *expected: str) -> None:
+        """Raise ColumnMismatchError if expected columns are missing."""
+        headers = set(self.headers)
+        missing = [col for col in expected if col not in headers]
+        if missing:
+            raise ColumnMismatchError(missing=missing)
+
+    def transpose(self) -> TableWrapper:
+        """Return a new TableWrapper with rows and columns swapped.
+
+        Original headers become the first column.
+        Original row indices become the new headers.
+        """
+        from behave_tables._mock import MockTable
+
+        new_headers = [str(i) for i in range(len(self._rows))]
+        new_rows: list[dict[str, str]] = []
+
+        for col_idx, header in enumerate(self.headers):
+            row_dict: dict[str, str] = {"_column": header}
+            for row_idx, row in enumerate(self._rows):
+                row_dict[str(row_idx)] = row[header]
+            new_rows.append(row_dict)
+
+        mock = MockTable(
+            headings=["_column"] + new_headers,
+            rows_data=new_rows,
+        )
+        return TableWrapper(mock)
+
+    def to_csv(self) -> str:
+        """Return table as a CSV string."""
+        output = io.StringIO()
+        writer = csv.DictWriter(output, fieldnames=self.headers)
+        writer.writeheader()
+        writer.writerows(self._rows)
+        return output.getvalue().replace("\r\n", "\n").rstrip("\n")
+
+    def to_json(self, indent: int = 2) -> str:
+        """Return table as a JSON string (list of objects)."""
+        return json.dumps(self._rows, indent=indent, ensure_ascii=False)
+
+    def __iter__(self) -> Iterator[dict[str, str]]:
+        return iter(self._rows)
+
+    def __getitem__(self, index: int) -> dict[str, str]:
+        return self._rows[index]
+
+    def __len__(self) -> int:
+        return len(self._rows)
+
+    def __repr__(self) -> str:
+        return f"TableWrapper(headers={self.headers!r}, rows={len(self)})"

behave_tables-0.1.0/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "behave-tables"
+version = "0.1.0"
+description = "Polished API for Behave Data Tables — as_dicts, as_models, transpose, to_csv, to_json"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+authors = [
+    { name = "Mathias Paulenko" },
+]
+keywords = ["behave", "bdd", "cucumber", "gherkin", "tables", "data-tables", "testing"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Testing",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = []
+
+[project.optional-dependencies]
+pydantic = ["pydantic>=2.0"]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+    "ruff>=0.5",
+    "behave>=1.2.6",
+]
+
+[project.urls]
+Homepage = "https://github.com/MathiasPaulenko/behave-tables"
+Repository = "https://github.com/MathiasPaulenko/behave-tables"
+Issues = "https://github.com/MathiasPaulenko/behave-tables/issues"
+Changelog = "https://github.com/MathiasPaulenko/behave-tables/blob/main/CHANGELOG.md"
+
+[tool.hatch.build.targets.wheel]
+packages = ["behave_tables"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "N", "UP", "B", "SIM"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["behave_tables"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra --strict-markers"
+pythonpath = ["."]
+
+[tool.coverage.run]
+source = ["behave_tables"]
+omit = ["*/tests/*"]
+
+[tool.coverage.report]
+show_missing = true
+fail_under = 90

behave_tables-0.1.0/tests/conftest.py

@@ -0,0 +1,41 @@
+"""Test fixtures — mock behave Table and Row objects."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class FakeRow:
+    """Mimics behave.model.Row."""
+
+    cells: list[str]
+    headings: list[str]
+
+    def as_dict(self) -> dict[str, str]:
+        return dict(zip(self.headings, self.cells))
+
+    def __getitem__(self, key: str) -> str:
+        idx = self.headings.index(key)
+        return self.cells[idx]
+
+
+@dataclass
+class FakeTable:
+    """Mimics behave.model.Table."""
+
+    headings: list[str]
+    rows_cells: list[list[str]] = field(default_factory=list)
+
+    @property
+    def rows(self) -> list[FakeRow]:
+        return [FakeRow(cells=c, headings=self.headings) for c in self.rows_cells]
+
+
+def make_table(
+    headings: list[str],
+    rows: list[list[str]],
+) -> FakeTable:
+    """Build a FakeTable for testing."""
+    return FakeTable(headings=headings, rows_cells=rows)

behave_tables-0.1.0/tests/helpers.py

@@ -0,0 +1,40 @@
+"""Test helpers — mock behave Table and Row objects."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class FakeRow:
+    """Mimics behave.model.Row."""
+
+    cells: list[str]
+    headings: list[str]
+
+    def as_dict(self) -> dict[str, str]:
+        return dict(zip(self.headings, self.cells))
+
+    def __getitem__(self, key: str) -> str:
+        idx = self.headings.index(key)
+        return self.cells[idx]
+
+
+@dataclass
+class FakeTable:
+    """Mimics behave.model.Table."""
+
+    headings: list[str]
+    rows_cells: list[list[str]] = field(default_factory=list)
+
+    @property
+    def rows(self) -> list[FakeRow]:
+        return [FakeRow(cells=c, headings=self.headings) for c in self.rows_cells]
+
+
+def make_table(
+    headings: list[str],
+    rows: list[list[str]],
+) -> FakeTable:
+    """Build a FakeTable for testing."""
+    return FakeTable(headings=headings, rows_cells=rows)

behave_tables-0.1.0/tests/test_exceptions.py

@@ -0,0 +1,26 @@
+"""Tests for exceptions."""
+
+from __future__ import annotations
+
+import pytest
+
+from behave_tables import ColumnMismatchError
+
+
+class TestColumnMismatchError:
+    def test_missing_only(self):
+        err = ColumnMismatchError(missing=["email", "phone"])
+        assert "email" in str(err)
+        assert "phone" in str(err)
+        assert err.missing == ["email", "phone"]
+        assert err.extra == []
+
+    def test_missing_and_extra(self):
+        err = ColumnMismatchError(missing=["email"], extra=["id"])
+        assert "missing" in str(err)
+        assert "unexpected" in str(err)
+        assert err.extra == ["id"]
+
+    def test_is_value_error(self):
+        err = ColumnMismatchError(missing=["x"])
+        assert isinstance(err, ValueError)

behave_tables-0.1.0/tests/test_models.py

@@ -0,0 +1,68 @@
+"""Tests for as_models() with dataclasses and Pydantic."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pytest
+
+from behave_tables import wrap
+from helpers import make_table
+
+
+@dataclass
+class UserDC:
+    name: str
+    age: int
+
+
+class TestAsModelsDataclass:
+    def test_basic(self):
+        table = make_table(["name", "age"], [["Alice", "30"], ["Bob", "25"]])
+        wt = wrap(table)
+        users = wt.as_models(UserDC)
+        assert len(users) == 2
+        assert users[0].name == "Alice"
+        assert users[1].name == "Bob"
+
+    def test_empty_table(self):
+        table = make_table(["name", "age"], [])
+        wt = wrap(table)
+        assert wt.as_models(UserDC) == []
+
+    def test_type_error_on_non_model(self):
+        table = make_table(["name"], [["Alice"]])
+        wt = wrap(table)
+        with pytest.raises(TypeError, match="Pydantic BaseModel or dataclass"):
+            wt.as_models(dict)
+
+
+class TestAsModelsPydantic:
+    def test_basic(self):
+        pydantic = pytest.importorskip("pydantic")
+        from pydantic import BaseModel
+
+        class UserPyd(BaseModel):
+            name: str
+            age: int
+
+        table = make_table(["name", "age"], [["Alice", "30"], ["Bob", "25"]])
+        wt = wrap(table)
+        users = wt.as_models(UserPyd)
+        assert len(users) == 2
+        assert users[0].name == "Alice"
+        assert users[0].age == 30
+        assert isinstance(users[0], BaseModel)
+
+    def test_pydantic_validation_error(self):
+        pytest.importorskip("pydantic")
+        from pydantic import BaseModel, ValidationError
+
+        class StrictUser(BaseModel):
+            name: str
+            age: int
+
+        table = make_table(["name", "age"], [["Alice", "not_a_number"]])
+        wt = wrap(table)
+        with pytest.raises(ValidationError):
+            wt.as_models(StrictUser)

behave_tables-0.1.0/tests/test_wrapper.py

@@ -0,0 +1,214 @@
+"""Tests for TableWrapper core methods."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from behave_tables import TableWrapper, wrap, ColumnMismatchError
+from helpers import make_table
+
+
+class TestAsDicts:
+    def test_basic(self):
+        table = make_table(["name", "age"], [["Alice", "30"], ["Bob", "25"]])
+        wt = wrap(table)
+        assert wt.as_dicts() == [
+            {"name": "Alice", "age": "30"},
+            {"name": "Bob", "age": "25"},
+        ]
+
+    def test_empty_table(self):
+        table = make_table(["name", "age"], [])
+        wt = wrap(table)
+        assert wt.as_dicts() == []
+
+    def test_single_row(self):
+        table = make_table(["x"], [["1"]])
+        wt = wrap(table)
+        assert wt.as_dicts() == [{"x": "1"}]
+
+    def test_single_column(self):
+        table = make_table(["only"], [["a"], ["b"], ["c"]])
+        wt = wrap(table)
+        assert wt.as_dicts() == [{"only": "a"}, {"only": "b"}, {"only": "c"}]
+
+    def test_returns_copy(self):
+        table = make_table(["name"], [["Alice"]])
+        wt = wrap(table)
+        dicts = wt.as_dicts()
+        dicts[0]["name"] = "modified"
+        assert wt.as_dicts()[0]["name"] == "Alice"
+
+
+class TestColumn:
+    def test_basic(self):
+        table = make_table(["name", "age"], [["Alice", "30"], ["Bob", "25"]])
+        wt = wrap(table)
+        assert wt.column("name") == ["Alice", "Bob"]
+        assert wt.column("age") == ["30", "25"]
+
+    def test_missing_column(self):
+        table = make_table(["name"], [["Alice"]])
+        wt = wrap(table)
+        with pytest.raises(KeyError, match="not found"):
+            wt.column("email")
+
+    def test_empty_table(self):
+        table = make_table(["name"], [])
+        wt = wrap(table)
+        assert wt.column("name") == []
+
+
+class TestFindRow:
+    def test_single_filter(self):
+        table = make_table(["name", "age"], [["Alice", "30"], ["Bob", "25"]])
+        wt = wrap(table)
+        assert wt.find_row(name="Alice") == {"name": "Alice", "age": "30"}
+
+    def test_multiple_filters(self):
+        table = make_table(["name", "age"], [["Alice", "30"], ["Bob", "25"]])
+        wt = wrap(table)
+        assert wt.find_row(name="Alice", age="30") == {"name": "Alice", "age": "30"}
+
+    def test_no_match(self):
+        table = make_table(["name", "age"], [["Alice", "30"]])
+        wt = wrap(table)
+        assert wt.find_row(name="Charlie") is None
+
+    def test_no_filters_returns_first(self):
+        table = make_table(["name"], [["Alice"], ["Bob"]])
+        wt = wrap(table)
+        assert wt.find_row() == {"name": "Alice"}
+
+    def test_no_filters_empty_table(self):
+        table = make_table(["name"], [])
+        wt = wrap(table)
+        assert wt.find_row() is None
+
+
+class TestValidateColumns:
+    def test_all_present(self):
+        table = make_table(["name", "age", "email"], [])
+        wt = wrap(table)
+        wt.validate_columns("name", "age")
+
+    def test_missing(self):
+        table = make_table(["name"], [])
+        wt = wrap(table)
+        with pytest.raises(ColumnMismatchError, match="missing columns"):
+            wt.validate_columns("name", "email", "phone")
+
+    def test_empty_expected(self):
+        table = make_table(["name"], [])
+        wt = wrap(table)
+        wt.validate_columns()
+
+
+class TestTranspose:
+    def test_basic(self):
+        table = make_table(["name", "age"], [["Alice", "30"], ["Bob", "25"]])
+        wt = wrap(table)
+        transposed = wt.transpose()
+        assert transposed.headers == ["_column", "0", "1"]
+        dicts = transposed.as_dicts()
+        assert dicts[0] == {"_column": "name", "0": "Alice", "1": "Bob"}
+        assert dicts[1] == {"_column": "age", "0": "30", "1": "25"}
+
+    def test_original_unchanged(self):
+        table = make_table(["name", "age"], [["Alice", "30"]])
+        wt = wrap(table)
+        transposed = wt.transpose()
+        assert wt.as_dicts() == [{"name": "Alice", "age": "30"}]
+        assert transposed.headers != wt.headers
+
+    def test_empty_table(self):
+        table = make_table(["name", "age"], [])
+        wt = wrap(table)
+        transposed = wt.transpose()
+        assert len(transposed) == 2
+        assert transposed.headers == ["_column"]
+
+
+class TestToCsv:
+    def test_basic(self):
+        table = make_table(["name", "age"], [["Alice", "30"], ["Bob", "25"]])
+        wt = wrap(table)
+        csv_str = wt.to_csv()
+        lines = csv_str.split("\n")
+        assert lines[0] == "name,age"
+        assert lines[1] == "Alice,30"
+        assert lines[2] == "Bob,25"
+
+    def test_empty_table(self):
+        table = make_table(["name", "age"], [])
+        wt = wrap(table)
+        csv_str = wt.to_csv()
+        assert csv_str == "name,age"
+
+
+class TestToJson:
+    def test_basic(self):
+        table = make_table(["name", "age"], [["Alice", "30"], ["Bob", "25"]])
+        wt = wrap(table)
+        json_str = wt.to_json()
+        parsed = json.loads(json_str)
+        assert parsed == [
+            {"name": "Alice", "age": "30"},
+            {"name": "Bob", "age": "25"},
+        ]
+
+    def test_empty_table(self):
+        table = make_table(["name"], [])
+        wt = wrap(table)
+        json_str = wt.to_json()
+        assert json.loads(json_str) == []
+
+
+class TestIteration:
+    def test_iter(self):
+        table = make_table(["name"], [["Alice"], ["Bob"]])
+        wt = wrap(table)
+        rows = [r for r in wt]
+        assert rows == [{"name": "Alice"}, {"name": "Bob"}]
+
+    def test_getitem(self):
+        table = make_table(["name", "age"], [["Alice", "30"], ["Bob", "25"]])
+        wt = wrap(table)
+        assert wt[0] == {"name": "Alice", "age": "30"}
+        assert wt[1] == {"name": "Bob", "age": "25"}
+
+    def test_len(self):
+        table = make_table(["name"], [["Alice"], ["Bob"], ["Charlie"]])
+        wt = wrap(table)
+        assert len(wt) == 3
+
+    def test_len_empty(self):
+        table = make_table(["name"], [])
+        wt = wrap(table)
+        assert len(wt) == 0
+
+
+class TestHeaders:
+    def test_basic(self):
+        table = make_table(["name", "age", "email"], [])
+        wt = wrap(table)
+        assert wt.headers == ["name", "age", "email"]
+
+    def test_returns_copy(self):
+        table = make_table(["name"], [])
+        wt = wrap(table)
+        headers = wt.headers
+        headers.append("extra")
+        assert wt.headers == ["name"]
+
+
+class TestRepr:
+    def test_repr(self):
+        table = make_table(["name", "age"], [["Alice", "30"], ["Bob", "25"]])
+        wt = wrap(table)
+        r = repr(wt)
+        assert "TableWrapper" in r
+        assert "name" in r
+        assert "rows=2" in r