crashbytes-testkit 1.0.0__tar.gz

crashbytes_testkit-1.0.0/.github/CODEOWNERS

@@ -0,0 +1 @@
+* @CrashBytes

crashbytes_testkit-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "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]"
+      - run: ruff check src/ tests/
+      - run: mypy --strict src/
+      - run: pytest --cov=crashbytes_testkit --cov-branch --cov-fail-under=90

crashbytes_testkit-1.0.0/.github/workflows/publish.yml

@@ -0,0 +1,19 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

crashbytes_testkit-1.0.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+*.pyo
+dist/
+build/
+*.egg-info/
+.coverage
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+

crashbytes_testkit-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CrashBytes
+
+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.

crashbytes_testkit-1.0.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: crashbytes-testkit
+Version: 1.0.0
+Summary: Test data builders for Python — auto-generate dataclass instances from type hints.
+Project-URL: Homepage, https://github.com/CrashBytes/crashbytes-testkit
+Project-URL: Repository, https://github.com/CrashBytes/crashbytes-testkit
+Project-URL: Issues, https://github.com/CrashBytes/crashbytes-testkit/issues
+Author-email: CrashBytes <crashbytes@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: builder,dataclass,fixture,test-data,testing
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# crashbytes-testkit
+
+Test data builders for Python — auto-generate dataclass instances from type hints.
+
+## Install
+
+```bash
+pip install crashbytes-testkit
+```
+
+## Usage
+
+```python
+from dataclasses import dataclass
+from crashbytes_testkit import Fixture, Builder
+
+@dataclass
+class User:
+    name: str
+    age: int
+    email: str
+
+# Auto-generate from type hints
+user = Fixture.create(User)
+users = Fixture.create_many(User, 5)
+
+# Override specific fields
+admin = Fixture.create(User, name="Admin", age=30)
+
+# Fluent builder
+user = (
+    Builder(User)
+    .with_field("name", "Alice")
+    .with_field("age", 25)
+    .build()
+)
+```
+
+Supports: `str`, `int`, `float`, `bool`, `bytes`, `datetime`, `date`, `UUID`, `list[T]`, `dict[K,V]`, `set[T]`, `tuple`, `Optional[T]`, nested dataclasses.
+
+## License
+
+MIT

crashbytes_testkit-1.0.0/README.md

@@ -0,0 +1,43 @@
+# crashbytes-testkit
+
+Test data builders for Python — auto-generate dataclass instances from type hints.
+
+## Install
+
+```bash
+pip install crashbytes-testkit
+```
+
+## Usage
+
+```python
+from dataclasses import dataclass
+from crashbytes_testkit import Fixture, Builder
+
+@dataclass
+class User:
+    name: str
+    age: int
+    email: str
+
+# Auto-generate from type hints
+user = Fixture.create(User)
+users = Fixture.create_many(User, 5)
+
+# Override specific fields
+admin = Fixture.create(User, name="Admin", age=30)
+
+# Fluent builder
+user = (
+    Builder(User)
+    .with_field("name", "Alice")
+    .with_field("age", 25)
+    .build()
+)
+```
+
+Supports: `str`, `int`, `float`, `bool`, `bytes`, `datetime`, `date`, `UUID`, `list[T]`, `dict[K,V]`, `set[T]`, `tuple`, `Optional[T]`, nested dataclasses.
+
+## License
+
+MIT

crashbytes_testkit-1.0.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "crashbytes-testkit"
+version = "1.0.0"
+description = "Test data builders for Python — auto-generate dataclass instances from type hints."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "CrashBytes", email = "crashbytes@users.noreply.github.com" }]
+keywords = ["testing", "fixture", "builder", "dataclass", "test-data"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-cov", "mypy", "ruff"]
+
+[project.urls]
+Homepage = "https://github.com/CrashBytes/crashbytes-testkit"
+Repository = "https://github.com/CrashBytes/crashbytes-testkit"
+Issues = "https://github.com/CrashBytes/crashbytes-testkit/issues"
+
+[tool.ruff]
+target-version = "py310"
+line-length = 99
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "UP", "B", "SIM", "TCH"]
+
+[tool.mypy]
+strict = true
+python_version = "3.10"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.coverage.run]
+branch = true
+source = ["crashbytes_testkit"]
+
+[tool.coverage.report]
+fail_under = 90

crashbytes_testkit-1.0.0/src/crashbytes_testkit/__init__.py

@@ -0,0 +1,5 @@
+"""crashbytes-testkit — Test data builders for Python."""
+
+from crashbytes_testkit._core import Builder, Fixture
+
+__all__ = ["Builder", "Fixture"]

crashbytes_testkit-1.0.0/src/crashbytes_testkit/_core.py

@@ -0,0 +1,146 @@
+"""Test data builders — auto-generate dataclass instances from type hints."""
+
+from __future__ import annotations
+
+import dataclasses
+import random
+import string
+import uuid
+from datetime import date, datetime
+from typing import Any, TypeVar, get_type_hints
+
+T = TypeVar("T")
+
+_counter = 0
+
+
+def _next_id() -> int:
+    global _counter  # noqa: PLW0603
+    _counter += 1
+    return _counter
+
+
+def _random_string(length: int = 8) -> str:
+    return "".join(random.choices(string.ascii_lowercase, k=length))
+
+
+def _generate_value(type_hint: Any, field_name: str = "") -> Any:
+    """Generate a plausible value for a given type hint."""
+    origin = getattr(type_hint, "__origin__", None)
+    args = getattr(type_hint, "__args__", ())
+
+    # Handle Union types (Optional[X], X | Y, etc.)
+    import types
+    import typing
+    if origin is typing.Union or isinstance(type_hint, types.UnionType):
+        type_args = args if args else getattr(type_hint, "__args__", ())
+        non_none = [a for a in type_args if a is not type(None)]
+        if non_none:
+            return _generate_value(non_none[0], field_name)
+        return None
+
+    if type_hint is str:
+        return f"{field_name}_{_random_string()}" if field_name else _random_string()
+    if type_hint is int:
+        return _next_id()
+    if type_hint is float:
+        return round(random.uniform(0.0, 100.0), 2)
+    if type_hint is bool:
+        return random.choice([True, False])
+    if type_hint is bytes:
+        return _random_string().encode()
+    if type_hint is datetime:
+        return datetime(2024, 1, 1, 12, 0, 0)
+    if type_hint is date:
+        return date(2024, 1, 1)
+
+    # list[X]
+    if origin is list:
+        inner = args[0] if args else str
+        return [_generate_value(inner, field_name) for _ in range(2)]
+
+    # dict[K, V]
+    if origin is dict:
+        k_type = args[0] if args else str
+        v_type = args[1] if len(args) > 1 else str  # type: ignore[misc]
+        return {_generate_value(k_type): _generate_value(v_type) for _ in range(2)}
+
+    # set[X]
+    if origin is set:
+        inner = args[0] if args else str
+        return {_generate_value(inner, field_name) for _ in range(2)}
+
+    # tuple[X, ...]
+    if origin is tuple:
+        if args:
+            return tuple(_generate_value(a, field_name) for a in args if a is not Ellipsis)
+        return ()
+
+    # UUID
+    if type_hint is uuid.UUID:
+        return uuid.uuid4()
+
+    # Nested dataclass
+    if dataclasses.is_dataclass(type_hint) and isinstance(type_hint, type):
+        return _create_instance(type_hint)
+
+    # Fallback
+    return None
+
+
+def _create_instance(cls: type[T], overrides: dict[str, Any] | None = None) -> T:
+    """Create an instance of *cls* with auto-generated values."""
+    hints = get_type_hints(cls)
+    kwargs: dict[str, Any] = {}
+
+    for field in dataclasses.fields(cls):  # type: ignore[arg-type]
+        if overrides and field.name in overrides:
+            kwargs[field.name] = overrides[field.name]
+        elif field.default is not dataclasses.MISSING:
+            kwargs[field.name] = field.default
+        elif field.default_factory is not dataclasses.MISSING:
+            kwargs[field.name] = field.default_factory()
+        else:
+            type_hint = hints.get(field.name, str)
+            kwargs[field.name] = _generate_value(type_hint, field.name)
+
+    return cls(**kwargs)
+
+
+class Fixture:
+    """Auto-generate test data from dataclass type hints."""
+
+    @staticmethod
+    def create(cls: type[T], **overrides: Any) -> T:
+        """Create a single instance of *cls*."""
+        if not dataclasses.is_dataclass(cls):
+            raise TypeError(f"{cls.__name__} is not a dataclass")
+        return _create_instance(cls, overrides or None)
+
+    @staticmethod
+    def create_many(cls: type[T], count: int = 3, **overrides: Any) -> list[T]:
+        """Create *count* instances of *cls*."""
+        return [Fixture.create(cls, **overrides) for _ in range(count)]
+
+
+class Builder:
+    """Fluent builder for constructing test data."""
+
+    def __init__(self, cls: type[Any]) -> None:
+        if not dataclasses.is_dataclass(cls):
+            raise TypeError(f"{cls.__name__} is not a dataclass")
+        self._cls = cls
+        self._overrides: dict[str, Any] = {}
+
+    def with_field(self, name: str, value: Any) -> Builder:
+        """Set a specific field value."""
+        self._overrides[name] = value
+        return self
+
+    def build(self) -> Any:
+        """Build the instance."""
+        return _create_instance(self._cls, self._overrides)
+
+    def build_many(self, count: int = 3) -> list[Any]:
+        """Build *count* instances."""
+        return [self.build() for _ in range(count)]

crashbytes_testkit-1.0.0/tests/test_testkit.py

@@ -0,0 +1,289 @@
+"""Tests for crashbytes-testkit."""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from datetime import date, datetime
+
+import pytest
+
+from crashbytes_testkit import Builder, Fixture
+
+
+@dataclass
+class SimpleUser:
+    name: str
+    age: int
+    active: bool
+
+
+@dataclass
+class Address:
+    street: str
+    city: str
+    zip_code: str
+
+
+@dataclass
+class UserWithAddress:
+    name: str
+    address: Address
+
+
+@dataclass
+class UserWithDefaults:
+    name: str
+    role: str = "user"
+    tags: list[str] = field(default_factory=list)
+
+
+@dataclass
+class UserWithOptional:
+    name: str
+    nickname: str | None = None
+
+
+@dataclass
+class UserWithCollections:
+    name: str
+    scores: list[int] = field(default_factory=list)
+    metadata: dict[str, str] = field(default_factory=dict)
+    unique_ids: set[int] = field(default_factory=set)
+
+
+@dataclass
+class UserWithTypes:
+    id: uuid.UUID
+    created_at: datetime
+    birth_date: date
+    score: float
+    data: bytes
+
+
+@dataclass
+class UserWithTuple:
+    name: str
+    coords: tuple[float, float] = (0.0, 0.0)
+
+
+class TestFixtureCreate:
+    def test_creates_instance(self) -> None:
+        user = Fixture.create(SimpleUser)
+        assert isinstance(user, SimpleUser)
+        assert isinstance(user.name, str)
+        assert isinstance(user.age, int)
+        assert isinstance(user.active, bool)
+
+    def test_overrides(self) -> None:
+        user = Fixture.create(SimpleUser, name="John", age=30)
+        assert user.name == "John"
+        assert user.age == 30
+
+    def test_with_defaults(self) -> None:
+        user = Fixture.create(UserWithDefaults)
+        assert user.role == "user"
+        assert user.tags == []
+
+    def test_with_optional(self) -> None:
+        user = Fixture.create(UserWithOptional)
+        assert isinstance(user.name, str)
+        # nickname should be generated as a string (non-None branch)
+        assert user.nickname is None or isinstance(user.nickname, str)
+
+    def test_nested_dataclass(self) -> None:
+        user = Fixture.create(UserWithAddress)
+        assert isinstance(user.address, Address)
+        assert isinstance(user.address.street, str)
+
+    def test_with_types(self) -> None:
+        user = Fixture.create(UserWithTypes)
+        assert isinstance(user.id, uuid.UUID)
+        assert isinstance(user.created_at, datetime)
+        assert isinstance(user.birth_date, date)
+        assert isinstance(user.score, float)
+        assert isinstance(user.data, bytes)
+
+    def test_raises_for_non_dataclass(self) -> None:
+        with pytest.raises(TypeError, match="not a dataclass"):
+            Fixture.create(dict)  # type: ignore[arg-type]
+
+
+class TestFixtureCreateMany:
+    def test_creates_multiple(self) -> None:
+        users = Fixture.create_many(SimpleUser, 5)
+        assert len(users) == 5
+        assert all(isinstance(u, SimpleUser) for u in users)
+
+    def test_default_count(self) -> None:
+        users = Fixture.create_many(SimpleUser)
+        assert len(users) == 3
+
+    def test_with_overrides(self) -> None:
+        users = Fixture.create_many(SimpleUser, 3, active=True)
+        assert all(u.active is True for u in users)
+
+
+class TestBuilder:
+    def test_basic_build(self) -> None:
+        user = Builder(SimpleUser).build()
+        assert isinstance(user, SimpleUser)
+
+    def test_with_field(self) -> None:
+        user = Builder(SimpleUser).with_field("name", "Alice").with_field("age", 25).build()
+        assert user.name == "Alice"
+        assert user.age == 25
+
+    def test_build_many(self) -> None:
+        users = Builder(SimpleUser).with_field("active", True).build_many(4)
+        assert len(users) == 4
+        assert all(u.active is True for u in users)
+
+    def test_fluent_chaining(self) -> None:
+        builder = Builder(SimpleUser)
+        result = builder.with_field("name", "Bob")
+        assert result is builder  # Returns self
+
+    def test_raises_for_non_dataclass(self) -> None:
+        with pytest.raises(TypeError, match="not a dataclass"):
+            Builder(list)  # type: ignore[arg-type]
+
+
+class TestCollections:
+    def test_list_generation(self) -> None:
+        user = Fixture.create(UserWithCollections)
+        # Default factory will be used
+        assert isinstance(user.scores, list)
+        assert isinstance(user.metadata, dict)
+
+    def test_tuple_with_default(self) -> None:
+        user = Fixture.create(UserWithTuple)
+        assert user.coords == (0.0, 0.0)
+
+
+# Additional types for coverage
+
+
+@dataclass
+class WithList:
+    items: list[str]
+
+
+@dataclass
+class WithDict:
+    data: dict[str, int]
+
+
+@dataclass
+class WithSet:
+    ids: set[int]
+
+
+@dataclass
+class WithTuple:
+    pair: tuple[int, str]
+
+
+@dataclass
+class WithBareList:
+    items: list[str]
+
+
+@dataclass
+class WithOptionalStr:
+    name: str
+    bio: str | None = None
+
+
+class TestGenerateValuePaths:
+    def test_list_type(self) -> None:
+        obj = Fixture.create(WithList)
+        assert isinstance(obj.items, list)
+        assert len(obj.items) == 2
+        assert all(isinstance(i, str) for i in obj.items)
+
+    def test_dict_type(self) -> None:
+        obj = Fixture.create(WithDict)
+        assert isinstance(obj.data, dict)
+        assert len(obj.data) == 2
+
+    def test_set_type(self) -> None:
+        obj = Fixture.create(WithSet)
+        assert isinstance(obj.ids, set)
+        assert all(isinstance(i, int) for i in obj.ids)
+
+    def test_tuple_type(self) -> None:
+        obj = Fixture.create(WithTuple)
+        assert isinstance(obj.pair, tuple)
+        assert isinstance(obj.pair[0], int)
+        assert isinstance(obj.pair[1], str)
+
+    def test_optional_generates_value(self) -> None:
+        # Test the Union/Optional branch
+        obj = Fixture.create(WithOptionalStr)
+        assert isinstance(obj.name, str)
+
+    def test_bytes_type(self) -> None:
+        obj = Fixture.create(UserWithTypes)
+        assert isinstance(obj.data, bytes)
+
+    def test_float_type(self) -> None:
+        obj = Fixture.create(UserWithTypes)
+        assert isinstance(obj.score, float)
+        assert 0.0 <= obj.score <= 100.0
+
+    def test_uuid_type(self) -> None:
+        obj = Fixture.create(UserWithTypes)
+        assert isinstance(obj.id, uuid.UUID)
+
+    def test_datetime_type(self) -> None:
+        obj = Fixture.create(UserWithTypes)
+        assert isinstance(obj.created_at, datetime)
+
+    def test_date_type(self) -> None:
+        obj = Fixture.create(UserWithTypes)
+        assert isinstance(obj.birth_date, date)
+
+    def test_nested_dataclass(self) -> None:
+        obj = Fixture.create(UserWithAddress)
+        assert isinstance(obj.address, Address)
+        assert isinstance(obj.address.city, str)
+
+    def test_field_name_in_string(self) -> None:
+        user = Fixture.create(SimpleUser)
+        assert "name" in user.name
+
+    def test_create_many_unique(self) -> None:
+        users = Fixture.create_many(SimpleUser, 5)
+        names = [u.name for u in users]
+        assert len(set(names)) == 5  # All unique
+
+
+@dataclass
+class WithBareTuple:
+    data: tuple[()]
+
+
+@dataclass
+class WithUnknownType:
+    value: object
+
+
+@dataclass
+class WithOptionalTyping:
+    name: str | None
+
+
+class TestEdgeCases:
+    def test_empty_tuple(self) -> None:
+        obj = Fixture.create(WithBareTuple)
+        assert isinstance(obj.data, tuple)
+
+    def test_unknown_type_returns_none(self) -> None:
+        obj = Fixture.create(WithUnknownType)
+        assert obj.value is None
+
+    def test_union_type_syntax(self) -> None:
+        obj = Fixture.create(WithOptionalTyping)
+        # Should generate a string (non-None branch of str | None)
+        assert obj.name is None or isinstance(obj.name, str)