db-test-helpers-sqlite 0.1.0__tar.gz

db_test_helpers_sqlite-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.env.test

db_test_helpers_sqlite-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: db-test-helpers-sqlite
+Version: 0.1.0
+Summary: SQLite adapter for db-test-helpers
+Project-URL: Homepage, https://github.com/takaaa220/db-test-helpers
+Project-URL: Repository, https://github.com/takaaa220/db-test-helpers
+Project-URL: Issues, https://github.com/takaaa220/db-test-helpers/issues
+Author: takaaa220
+License-Expression: MIT
+Keywords: database,sqlite,test-helpers,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.12
+Requires-Dist: db-test-helpers<0.2.0,>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# db-test-helpers-sqlite
+
+SQLite adapter for [db-test-helpers](https://github.com/takaaa220/db-test-helpers).
+
+## Installation
+
+```bash
+pip install db-test-helpers-sqlite
+```
+
+## Documentation
+
+See the [main repository](https://github.com/takaaa220/db-test-helpers) for usage and documentation.

db_test_helpers_sqlite-0.1.0/README.md

@@ -0,0 +1,13 @@
+# db-test-helpers-sqlite
+
+SQLite adapter for [db-test-helpers](https://github.com/takaaa220/db-test-helpers).
+
+## Installation
+
+```bash
+pip install db-test-helpers-sqlite
+```
+
+## Documentation
+
+See the [main repository](https://github.com/takaaa220/db-test-helpers) for usage and documentation.

db_test_helpers_sqlite-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "db-test-helpers-sqlite"
+version = "0.1.0"
+description = "SQLite adapter for db-test-helpers"
+license = "MIT"
+readme = "README.md"
+authors = [{ name = "takaaa220" }]
+keywords = ["testing", "database", "sqlite", "test-helpers"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Testing",
+]
+requires-python = ">=3.12"
+dependencies = [
+    "db-test-helpers>=0.1.0,<0.2.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/takaaa220/db-test-helpers"
+Repository = "https://github.com/takaaa220/db-test-helpers"
+Issues = "https://github.com/takaaa220/db-test-helpers/issues"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.8",
+]
+
+[tool.uv.sources]
+db-test-helpers = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+only-include = ["src/db_test_helpers/sqlite"]
+sources = ["src"]

db_test_helpers_sqlite-0.1.0/src/db_test_helpers/sqlite/__init__.py

@@ -0,0 +1,3 @@
+from db_test_helpers.sqlite._adapter import SqliteAdapter
+
+__all__ = ["SqliteAdapter"]

db_test_helpers_sqlite-0.1.0/src/db_test_helpers/sqlite/_adapter.py

@@ -0,0 +1,56 @@
+"""SQLite adapter for db-test-helpers."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from typing import Any
+
+from db_test_helpers.core._errors import UnsupportedError
+
+
+def _quote_identifier(name: str) -> str:
+    if not name:
+        raise ValueError("identifier must not be empty")
+    return '"' + name.replace('"', '""') + '"'
+
+
+def _check_parent_path(parent_path: str) -> None:
+    if parent_path:
+        raise UnsupportedError("SqliteAdapter does not support parent_path")
+
+
+class SqliteAdapter:
+    """DatabaseAdapter for SQLite via the standard library sqlite3 module.
+
+    Args:
+        conn: An open ``sqlite3.Connection``.
+    """
+
+    def __init__(self, conn: sqlite3.Connection) -> None:
+        self._conn = conn
+
+    def clear_group(self, group: str, parent_path: str) -> None:
+        _check_parent_path(parent_path)
+        self._conn.execute(f"DROP TABLE IF EXISTS {_quote_identifier(group)}")
+        self._conn.commit()
+
+    def write_record(self, group: str, parent_path: str, data: dict[str, Any]) -> dict[str, Any]:
+        _check_parent_path(parent_path)
+        if "__document_id__" in data:
+            raise UnsupportedError("SqliteAdapter does not support __document_id__")
+        table = _quote_identifier(group)
+        self._conn.execute(f"CREATE TABLE IF NOT EXISTS {table} (_data TEXT NOT NULL)")
+        self._conn.execute(f"INSERT INTO {table} (_data) VALUES (?)", (json.dumps(data),))
+        self._conn.commit()
+        return dict(data)
+
+    def read_records(self, group: str, parent_path: str) -> list[dict[str, Any]]:
+        _check_parent_path(parent_path)
+        try:
+            cursor = self._conn.execute(f"SELECT _data FROM {_quote_identifier(group)}")
+        except sqlite3.OperationalError as e:
+            if "no such table" in str(e):
+                return []
+            raise
+        return [json.loads(row[0]) for row in cursor.fetchall()]

db_test_helpers_sqlite-0.1.0/src/db_test_helpers/sqlite/_adapter_test.py

@@ -0,0 +1,161 @@
+import sqlite3
+
+import pytest
+
+from db_test_helpers.core._errors import UnsupportedError
+from db_test_helpers.sqlite import SqliteAdapter
+from db_test_helpers.sqlite._adapter import _quote_identifier
+
+
+class TestQuoteIdentifier:
+    def test_normal_identifier(self):
+        assert _quote_identifier("users") == '"users"'
+
+    def test_identifier_with_double_quote(self):
+        assert _quote_identifier('my"table') == '"my""table"'
+
+    def test_empty_string_raises(self):
+        with pytest.raises(ValueError):
+            _quote_identifier("")
+
+
+class TestDocumentIdGuard:
+    def test_rejects_document_id(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        with pytest.raises(UnsupportedError, match="SqliteAdapter does not support __document_id__"):
+            adapter.write_record("t", "", {"__document_id__": "abc", "name": "Alice"})
+
+
+class TestParentPathGuard:
+    def test_clear_group_rejects_non_empty_parent_path(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        with pytest.raises(UnsupportedError):
+            adapter.clear_group("t", "some/path")
+
+    def test_write_record_rejects_non_empty_parent_path(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        with pytest.raises(UnsupportedError):
+            adapter.write_record("t", "some/path", {"x": 1})
+
+    def test_read_records_rejects_non_empty_parent_path(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        with pytest.raises(UnsupportedError):
+            adapter.read_records("t", "some/path")
+
+
+class TestWriteRecord:
+    def test_basic(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        result = adapter.write_record("users", "", {"name": "Alice", "age": 30})
+        assert result == {"name": "Alice", "age": 30}
+
+    def test_multiple_fields(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        data = {"a": 1, "b": "two", "c": 3.0, "d": True, "e": None}
+        result = adapter.write_record("t", "", data)
+        assert result == {"a": 1, "b": "two", "c": 3.0, "d": True, "e": None}
+
+    def test_none_value(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        result = adapter.write_record("t", "", {"x": None})
+        assert result == {"x": None}
+
+    def test_nested_dict_and_list(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        data = {"nested": {"a": 1}, "items": [1, "two", True]}
+        result = adapter.write_record("t", "", data)
+        assert result == {"nested": {"a": 1}, "items": [1, "two", True]}
+
+    def test_bool_preserved(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        adapter.write_record("t", "", {"flag": True, "other": False})
+        records = adapter.read_records("t", "")
+        assert records[0]["flag"] is True
+        assert records[0]["other"] is False
+
+    def test_table_name_with_double_quote(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        adapter.write_record('my"table', "", {"x": 1})
+        records = adapter.read_records('my"table', "")
+        assert records == [{"x": 1}]
+
+    def test_table_name_with_sql_keyword(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        adapter.write_record("select", "", {"x": 1})
+        records = adapter.read_records("select", "")
+        assert records == [{"x": 1}]
+
+    def test_does_not_mutate_input(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        data = {"name": "Alice"}
+        adapter.write_record("t", "", data)
+        assert data == {"name": "Alice"}
+
+
+class TestReadRecords:
+    def test_empty_table(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        conn.execute('CREATE TABLE "t" (_data TEXT NOT NULL)')
+        assert adapter.read_records("t", "") == []
+
+    def test_multiple_records(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        adapter.write_record("t", "", {"x": 1})
+        adapter.write_record("t", "", {"x": 2})
+        records = adapter.read_records("t", "")
+        assert len(records) == 2
+        assert {"x": 1} in records
+        assert {"x": 2} in records
+
+    def test_table_not_exists_returns_empty(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        assert adapter.read_records("nonexistent", "") == []
+
+    def test_type_roundtrip(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        data = {
+            "int_val": 42,
+            "float_val": 3.14,
+            "bool_val": True,
+            "none_val": None,
+            "dict_val": {"nested": "yes"},
+            "list_val": [1, 2, 3],
+        }
+        adapter.write_record("t", "", data)
+        records = adapter.read_records("t", "")
+        assert len(records) == 1
+        record = records[0]
+        assert record["int_val"] == 42
+        assert isinstance(record["int_val"], int)
+        assert record["float_val"] == 3.14
+        assert isinstance(record["float_val"], float)
+        assert record["bool_val"] is True
+        assert record["none_val"] is None
+        assert record["dict_val"] == {"nested": "yes"}
+        assert record["list_val"] == [1, 2, 3]
+
+
+class TestClearGroup:
+    def test_drops_table(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        adapter.write_record("t", "", {"x": 1})
+        adapter.clear_group("t", "")
+        assert adapter.read_records("t", "") == []
+
+    def test_nonexistent_table_no_error(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        adapter.clear_group("nonexistent", "")
+
+    def test_clear_does_not_affect_other_tables(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        adapter.write_record("a", "", {"x": 1})
+        adapter.write_record("b", "", {"x": 2})
+        adapter.clear_group("a", "")
+        assert adapter.read_records("a", "") == []
+        assert adapter.read_records("b", "") == [{"x": 2}]
+
+    def test_table_name_with_double_quote(self, conn: sqlite3.Connection):
+        adapter = SqliteAdapter(conn)
+        adapter.write_record('my"table', "", {"x": 1})
+        adapter.clear_group('my"table', "")
+        assert adapter.read_records('my"table', "") == []

db_test_helpers_sqlite-0.1.0/src/db_test_helpers/sqlite/_e2e_test.py

@@ -0,0 +1,142 @@
+"""E2E tests: set_db_data + verify_db_data with SQLite."""
+
+from __future__ import annotations
+
+import sqlite3
+
+import pytest
+
+from db_test_helpers.core import Config, UnsupportedError, set_db_data, verify_db_data
+from db_test_helpers.sqlite import SqliteAdapter
+
+
+class TestE2eBasic:
+    def test_set_and_verify(self, conn: sqlite3.Connection, tmp_path):
+        seed = tmp_path / "seed.yaml"
+        seed.write_text(
+            """\
+users:
+  - name: "Alice"
+    age: 30
+  - name: "Bob"
+    age: 25
+"""
+        )
+        expected = tmp_path / "expected.yaml"
+        expected.write_text(
+            """\
+users:
+  - name: "Bob"
+    age: 25
+  - name: "Alice"
+    age: 30
+"""
+        )
+        adapter = SqliteAdapter(conn)
+        set_db_data(adapter, str(seed))
+        verify_db_data(adapter, str(expected))
+
+    def test_set_replaces_existing(self, conn: sqlite3.Connection, tmp_path):
+        adapter = SqliteAdapter(conn)
+
+        adapter.write_record("users", "", {"name": "OldUser"})
+
+        seed = tmp_path / "seed.yaml"
+        seed.write_text(
+            """\
+users:
+  - name: "Alice"
+"""
+        )
+        set_db_data(adapter, str(seed))
+
+        records = adapter.read_records("users", "")
+        assert len(records) == 1
+        assert records[0]["name"] == "Alice"
+
+
+class TestE2eDsl:
+    def test_var_and_any(self, conn: sqlite3.Connection, tmp_path):
+        seed = tmp_path / "seed.yaml"
+        seed.write_text(
+            """\
+users:
+  - name: "$var(user_name)"
+    role: "admin"
+  - name: "Bob"
+    role: "member"
+"""
+        )
+        expected = tmp_path / "expected.yaml"
+        expected.write_text(
+            """\
+users:
+  - name: "$var(user_name)"
+    role: "admin"
+  - name: "$any()"
+    role: "member"
+"""
+        )
+        adapter = SqliteAdapter(conn)
+        config = Config(variables={"user_name": "Alice"})
+
+        set_db_data(adapter, str(seed), config)
+        verify_db_data(adapter, str(expected), config)
+
+    def test_matchers_in_verify(self, conn: sqlite3.Connection, tmp_path):
+        seed = tmp_path / "seed.yaml"
+        seed.write_text(
+            """\
+users:
+  - name: "Alice"
+    age: 30
+"""
+        )
+        expected = tmp_path / "expected.yaml"
+        expected.write_text(
+            """\
+users:
+  - name: "$eq(Alice)"
+    age: "$and($gt(0),$lt(100))"
+"""
+        )
+        adapter = SqliteAdapter(conn)
+        set_db_data(adapter, str(seed))
+        verify_db_data(adapter, str(expected))
+
+    def test_verify_failure(self, conn: sqlite3.Connection, tmp_path):
+        seed = tmp_path / "seed.yaml"
+        seed.write_text(
+            """\
+users:
+  - name: "Alice"
+"""
+        )
+        expected = tmp_path / "expected.yaml"
+        expected.write_text(
+            """\
+users:
+  - name: "Bob"
+"""
+        )
+        adapter = SqliteAdapter(conn)
+        set_db_data(adapter, str(seed))
+        with pytest.raises(AssertionError):
+            verify_db_data(adapter, str(expected))
+
+
+class TestE2eChildren:
+    def test_children_raises_not_implemented(self, conn: sqlite3.Connection, tmp_path):
+        seed = tmp_path / "seed.yaml"
+        seed.write_text(
+            """\
+users:
+  - name: "Alice"
+    __children__:
+      posts:
+        - title: "Hello"
+"""
+        )
+        adapter = SqliteAdapter(conn)
+        with pytest.raises(UnsupportedError):
+            set_db_data(adapter, str(seed))

db_test_helpers_sqlite-0.1.0/src/db_test_helpers/sqlite/conftest.py

@@ -0,0 +1,10 @@
+import sqlite3
+
+import pytest
+
+
+@pytest.fixture
+def conn():
+    conn = sqlite3.connect(":memory:")
+    yield conn
+    conn.close()