db-test-helpers-postgres 0.1.0__tar.gz

db_test_helpers_postgres-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_postgres-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: db-test-helpers-postgres
+Version: 0.1.0
+Summary: PostgreSQL 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,postgresql,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
+Requires-Dist: psycopg[binary]>=3.1
+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-postgres
+
+PostgreSQL adapter for [db-test-helpers](https://github.com/takaaa220/db-test-helpers).
+
+## Installation
+
+```bash
+pip install db-test-helpers-postgres
+```
+
+## Documentation
+
+See the [main repository](https://github.com/takaaa220/db-test-helpers) for usage and documentation.

db_test_helpers_postgres-0.1.0/README.md

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

db_test_helpers_postgres-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "db-test-helpers-postgres"
+version = "0.1.0"
+description = "PostgreSQL adapter for db-test-helpers"
+license = "MIT"
+readme = "README.md"
+authors = [{ name = "takaaa220" }]
+keywords = ["testing", "database", "postgresql", "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",
+    "psycopg[binary]>=3.1",
+]
+
+[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/postgres"]
+sources = ["src"]

db_test_helpers_postgres-0.1.0/src/db_test_helpers/postgres/__init__.py

@@ -0,0 +1,5 @@
+"""db-test-helpers-postgres: PostgreSQL adapter for db-test-helpers."""
+
+from db_test_helpers.postgres._adapter import PostgresAdapter
+
+__all__ = ["PostgresAdapter"]

db_test_helpers_postgres-0.1.0/src/db_test_helpers/postgres/_adapter.py

@@ -0,0 +1,57 @@
+"""PostgreSQL adapter for db-test-helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import psycopg
+from psycopg import sql
+from psycopg.rows import dict_row
+
+from db_test_helpers.core._errors import UnsupportedError
+
+
+def _check_parent_path(parent_path: str) -> None:
+    if parent_path:
+        raise UnsupportedError("PostgresAdapter does not support parent_path")
+
+
+class PostgresAdapter:
+    """DatabaseAdapter for PostgreSQL via psycopg.
+
+    Args:
+        conn: An open ``psycopg.Connection``.
+    """
+
+    def __init__(self, conn: psycopg.Connection) -> None:
+        self._conn = conn
+
+    def clear_group(self, group: str, parent_path: str) -> None:
+        _check_parent_path(parent_path)
+        self._conn.execute(sql.SQL("DELETE FROM {}").format(sql.Identifier(group)))
+
+    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("PostgresAdapter does not support __document_id__")
+        with self._conn.cursor(row_factory=dict_row) as cur:
+            if not data:
+                cur.execute(sql.SQL("INSERT INTO {} DEFAULT VALUES RETURNING *").format(sql.Identifier(group)))
+            else:
+                columns = list(data.keys())
+                values = list(data.values())
+                query = sql.SQL("INSERT INTO {} ({}) VALUES ({}) RETURNING *").format(
+                    sql.Identifier(group),
+                    sql.SQL(", ").join(sql.Identifier(c) for c in columns),
+                    sql.SQL(", ").join(sql.Placeholder() * len(values)),
+                )
+                cur.execute(query, values)
+            row = cur.fetchone()
+            assert row is not None
+            return row
+
+    def read_records(self, group: str, parent_path: str) -> list[dict[str, Any]]:
+        _check_parent_path(parent_path)
+        with self._conn.cursor(row_factory=dict_row) as cur:
+            cur.execute(sql.SQL("SELECT * FROM {}").format(sql.Identifier(group)))
+            return cur.fetchall()

db_test_helpers_postgres-0.1.0/src/db_test_helpers/postgres/_adapter_test.py

@@ -0,0 +1,129 @@
+"""Tests for PostgresAdapter."""
+
+from __future__ import annotations
+
+import psycopg
+import pytest
+
+from db_test_helpers.core._errors import UnsupportedError
+from db_test_helpers.postgres._adapter import PostgresAdapter
+
+
+def _create_table(conn: psycopg.Connection, ddl: str) -> None:
+    conn.execute(ddl)
+
+
+def _insert(conn: psycopg.Connection, table: str, data: dict) -> None:
+    columns = list(data.keys())
+    values = list(data.values())
+    query = psycopg.sql.SQL("INSERT INTO {} ({}) VALUES ({})").format(
+        psycopg.sql.Identifier(table),
+        psycopg.sql.SQL(", ").join(psycopg.sql.Identifier(c) for c in columns),
+        psycopg.sql.SQL(", ").join(psycopg.sql.Placeholder() * len(values)),
+    )
+    conn.execute(query, values)
+
+
+class TestDocumentIdGuard:
+    def test_rejects_document_id(self):
+        from unittest.mock import MagicMock
+
+        adapter = PostgresAdapter(MagicMock())
+        with pytest.raises(UnsupportedError, match="PostgresAdapter 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):
+        from unittest.mock import MagicMock
+
+        adapter = PostgresAdapter(MagicMock())
+        with pytest.raises(UnsupportedError, match="does not support parent_path"):
+            adapter.clear_group("t", "some/path")
+
+    def test_write_record_rejects_non_empty_parent_path(self):
+        from unittest.mock import MagicMock
+
+        adapter = PostgresAdapter(MagicMock())
+        with pytest.raises(UnsupportedError, match="does not support parent_path"):
+            adapter.write_record("t", "some/path", {"x": 1})
+
+    def test_read_records_rejects_non_empty_parent_path(self):
+        from unittest.mock import MagicMock
+
+        adapter = PostgresAdapter(MagicMock())
+        with pytest.raises(UnsupportedError, match="does not support parent_path"):
+            adapter.read_records("t", "some/path")
+
+
+class TestClearGroup:
+    def test_clear_deletes_all_rows(self, conn):
+        _create_table(conn, "CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT)")
+        _insert(conn, "users", {"name": "Alice"})
+        _insert(conn, "users", {"name": "Bob"})
+
+        adapter = PostgresAdapter(conn)
+        adapter.clear_group("users", "")
+
+        rows = conn.execute("SELECT * FROM users").fetchall()
+        assert rows == []
+
+    def test_clear_empty_table(self, conn):
+        _create_table(conn, "CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT)")
+
+        adapter = PostgresAdapter(conn)
+        adapter.clear_group("users", "")
+
+        rows = conn.execute("SELECT * FROM users").fetchall()
+        assert rows == []
+
+
+class TestWriteRecord:
+    def test_write_inserts_row(self, conn):
+        _create_table(conn, "CREATE TABLE users (name TEXT, age INTEGER)")
+
+        adapter = PostgresAdapter(conn)
+        result = adapter.write_record("users", "", {"name": "Alice", "age": 30})
+
+        assert result["name"] == "Alice"
+        assert result["age"] == 30
+
+    def test_write_returns_db_defaults(self, conn):
+        _create_table(conn, "CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT)")
+
+        adapter = PostgresAdapter(conn)
+        result = adapter.write_record("users", "", {"name": "Alice"})
+
+        assert result["id"] is not None
+        assert result["name"] == "Alice"
+
+    def test_write_empty_data_uses_default_values(self, conn):
+        _create_table(conn, "CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT DEFAULT 'anonymous')")
+
+        adapter = PostgresAdapter(conn)
+        result = adapter.write_record("users", "", {})
+
+        assert result["id"] is not None
+        assert result["name"] == "anonymous"
+
+
+class TestReadRecords:
+    def test_read_empty_table(self, conn):
+        _create_table(conn, "CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT)")
+
+        adapter = PostgresAdapter(conn)
+        result = adapter.read_records("users", "")
+
+        assert result == []
+
+    def test_read_multiple_records(self, conn):
+        _create_table(conn, "CREATE TABLE users (name TEXT, age INTEGER)")
+        _insert(conn, "users", {"name": "Alice", "age": 30})
+        _insert(conn, "users", {"name": "Bob", "age": 25})
+
+        adapter = PostgresAdapter(conn)
+        result = adapter.read_records("users", "")
+
+        assert len(result) == 2
+        names = {r["name"] for r in result}
+        assert names == {"Alice", "Bob"}

db_test_helpers_postgres-0.1.0/src/db_test_helpers/postgres/_e2e_test.py

@@ -0,0 +1,162 @@
+"""E2E tests: set_db_data + verify_db_data with PostgreSQL."""
+
+from __future__ import annotations
+
+import pytest
+
+from db_test_helpers.core import Config, UnsupportedError, set_db_data, verify_db_data
+from db_test_helpers.postgres import PostgresAdapter
+
+
+@pytest.fixture
+def _users_table(conn):
+    conn.execute("CREATE TABLE users (name TEXT, age INTEGER, active BOOLEAN)")
+    yield
+    conn.execute("DROP TABLE IF EXISTS users")
+
+
+class TestE2eBasic:
+    @pytest.mark.usefixtures("_users_table")
+    def test_set_and_verify_order_independent(self, conn, tmp_path):
+        seed = tmp_path / "seed.yaml"
+        seed.write_text(
+            """\
+users:
+  - name: "Alice"
+    age: 30
+    active: true
+  - name: "Bob"
+    age: 25
+    active: false
+"""
+        )
+        expected = tmp_path / "expected.yaml"
+        expected.write_text(
+            """\
+users:
+  - name: "Bob"
+    age: 25
+    active: false
+  - name: "Alice"
+    age: 30
+    active: true
+"""
+        )
+        adapter = PostgresAdapter(conn)
+        set_db_data(adapter, str(seed))
+        verify_db_data(adapter, str(expected))
+
+    @pytest.mark.usefixtures("_users_table")
+    def test_set_replaces_existing(self, conn, tmp_path):
+        conn.execute("INSERT INTO users (name, age, active) VALUES ('OldUser', 99, true)")
+
+        seed = tmp_path / "seed.yaml"
+        seed.write_text(
+            """\
+users:
+  - name: "Alice"
+    age: 30
+    active: true
+"""
+        )
+        adapter = PostgresAdapter(conn)
+        set_db_data(adapter, str(seed))
+
+        rows = conn.execute("SELECT * FROM users").fetchall()
+        assert len(rows) == 1
+
+
+class TestE2eChildren:
+    @pytest.mark.usefixtures("_users_table")
+    def test_children_raises_not_implemented(self, conn, tmp_path):
+        seed = tmp_path / "seed.yaml"
+        seed.write_text(
+            """\
+users:
+  - name: "Alice"
+    age: 30
+    active: true
+    __children__:
+      posts:
+        - title: "Hello"
+"""
+        )
+        adapter = PostgresAdapter(conn)
+        with pytest.raises(UnsupportedError, match="does not support __children__"):
+            set_db_data(adapter, str(seed))
+
+
+class TestE2eDsl:
+    @pytest.mark.usefixtures("_users_table")
+    def test_var_and_any(self, conn, tmp_path):
+        seed = tmp_path / "seed.yaml"
+        seed.write_text(
+            """\
+users:
+  - name: "$var(user_name)"
+    age: 30
+    active: true
+"""
+        )
+        expected = tmp_path / "expected.yaml"
+        expected.write_text(
+            """\
+users:
+  - name: "$var(user_name)"
+    age: "$any()"
+    active: true
+"""
+        )
+        adapter = PostgresAdapter(conn)
+        config = Config(variables={"user_name": "Alice"})
+        set_db_data(adapter, str(seed), config)
+        verify_db_data(adapter, str(expected), config)
+
+    @pytest.mark.usefixtures("_users_table")
+    def test_matchers_in_verify(self, conn, tmp_path):
+        seed = tmp_path / "seed.yaml"
+        seed.write_text(
+            """\
+users:
+  - name: "Alice"
+    age: 30
+    active: true
+"""
+        )
+        expected = tmp_path / "expected.yaml"
+        expected.write_text(
+            """\
+users:
+  - name: "$eq(Alice)"
+    age: "$and($gt(0),$lt(100))"
+    active: true
+"""
+        )
+        adapter = PostgresAdapter(conn)
+        set_db_data(adapter, str(seed))
+        verify_db_data(adapter, str(expected))
+
+    @pytest.mark.usefixtures("_users_table")
+    def test_verify_failure(self, conn, tmp_path):
+        seed = tmp_path / "seed.yaml"
+        seed.write_text(
+            """\
+users:
+  - name: "Alice"
+    age: 30
+    active: true
+"""
+        )
+        expected = tmp_path / "expected.yaml"
+        expected.write_text(
+            """\
+users:
+  - name: "Bob"
+    age: 30
+    active: true
+"""
+        )
+        adapter = PostgresAdapter(conn)
+        set_db_data(adapter, str(seed))
+        with pytest.raises(AssertionError):
+            verify_db_data(adapter, str(expected))

db_test_helpers_postgres-0.1.0/src/db_test_helpers/postgres/conftest.py

@@ -0,0 +1,32 @@
+"""Shared fixtures for PostgreSQL adapter tests."""
+
+from __future__ import annotations
+
+import os
+
+import psycopg
+import pytest
+
+
+@pytest.fixture
+def conn():
+    port = os.environ.get("POSTGRES_PORT", "5432")
+    connection = psycopg.connect(
+        host="localhost",
+        port=int(port),
+        user="test",
+        password="test",
+        dbname="testdb",
+        autocommit=True,
+    )
+    yield connection
+    _drop_all_tables(connection)
+    connection.close()
+
+
+def _drop_all_tables(conn: psycopg.Connection) -> None:
+    rows = conn.execute(
+        "SELECT tablename FROM pg_tables WHERE schemaname = 'public'"
+    ).fetchall()
+    for (table,) in rows:
+        conn.execute(psycopg.sql.SQL("DROP TABLE {} CASCADE").format(psycopg.sql.Identifier(table)))