sqlalchemyseed 2.2.0__tar.gz → 2.4.0__tar.gz

{sqlalchemyseed-2.2.0/src/sqlalchemyseed.egg-info → sqlalchemyseed-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemyseed
-Version: 2.2.0
+Version: 2.4.0
 Summary: SQLAlchemy Seeder
 Author-email: Jedy Matt Tabasco <hello@jedymatt.dev>
 License-Expression: MIT
@@ -9,13 +9,12 @@ Project-URL: Documentation, https://sqlalchemyseed.readthedocs.io/
 Project-URL: Source, https://github.com/jedymatt/sqlalchemyseed
 Project-URL: Tracker, https://github.com/jedymatt/sqlalchemyseed/issues
 Keywords: sqlalchemy,orm,seed,seeder,json,yaml
-Classifier: Programming Language :: Python :: 3.9
 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: Programming Language :: Python :: 3.14
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: SQLAlchemy>=2.0
@@ -123,6 +122,73 @@ The same command is available as a module:
 python -m sqlalchemyseed data.json --url sqlite:///app.db
 ```
 
+## Testing with pytest
+
+Installing `sqlalchemyseed` alongside `pytest` registers a plugin that loads
+fixture files into a transactionally-isolated session. Provide one `engine`
+fixture in your `conftest.py`; the plugin supplies `sqlalchemyseed_session`
+(rolled back after every test) and a `seed` factory.
+
+```python
+# conftest.py
+import pytest
+from sqlalchemy import create_engine, event
+from sqlalchemy.pool import StaticPool
+
+from myapp.models import Base
+
+
+@pytest.fixture(scope="session")
+def engine():
+    # StaticPool keeps a single in-memory connection alive so the schema you
+    # create is visible to the test session. A file-based or server database
+    # needs no such tweak — just return your usual engine.
+    engine = create_engine(
+        "sqlite://",
+        connect_args={"check_same_thread": False},
+        poolclass=StaticPool,
+    )
+
+    # SQLite only: hand transaction control to SQLAlchemy so an explicit
+    # commit() inside a test lands on a savepoint and is rolled back with the
+    # outer transaction. Left to itself the pysqlite driver commits straight to
+    # the database and the per-test rollback cannot undo it. Other databases
+    # (PostgreSQL, MySQL) need neither listener.
+    @event.listens_for(engine, "connect")
+    def _sqlite_no_driver_begin(dbapi_connection, connection_record):
+        dbapi_connection.isolation_level = None
+
+    @event.listens_for(engine, "begin")
+    def _sqlite_emit_begin(connection):
+        connection.exec_driver_sql("BEGIN")
+
+    Base.metadata.create_all(engine)
+    return engine
+```
+
+```python
+# test_people.py
+from myapp.models import Person
+
+
+def test_people_are_seeded(seed, sqlalchemyseed_session):
+    seeder = seed("tests/data/people.yaml")
+    assert sqlalchemyseed_session.query(Person).count() == 2
+    assert seeder.instances[0].name == "Alice"
+```
+
+`seed()` accepts the same inputs as the library: `.json`, `.yaml`/`.yml`, and
+`.csv` files. CSV is not self-describing, so pass the model:
+`seed("people.csv", model="myapp.models.Person")`. Use `seeder="hybrid"` for the
+`HybridSeeder`, and `ref_prefix=...` to override the relationship reference
+prefix. Every test runs inside a transaction that is rolled back afterward, so
+tests never see each other's rows.
+
+> **Note:** the plugin registers fixtures named `engine`, `sqlalchemyseed_session`,
+> and `seed`. Defining your own `engine` fixture is how you plug in your database;
+> if you already use those names for something else, your definitions take
+> precedence (pytest resolves conftest fixtures over plugin fixtures).
+
 ## Documentation
 
 <https://sqlalchemyseed.readthedocs.io/>

{sqlalchemyseed-2.2.0 → sqlalchemyseed-2.4.0}/README.md

@@ -98,6 +98,73 @@ The same command is available as a module:
 python -m sqlalchemyseed data.json --url sqlite:///app.db
 ```
 
+## Testing with pytest
+
+Installing `sqlalchemyseed` alongside `pytest` registers a plugin that loads
+fixture files into a transactionally-isolated session. Provide one `engine`
+fixture in your `conftest.py`; the plugin supplies `sqlalchemyseed_session`
+(rolled back after every test) and a `seed` factory.
+
+```python
+# conftest.py
+import pytest
+from sqlalchemy import create_engine, event
+from sqlalchemy.pool import StaticPool
+
+from myapp.models import Base
+
+
+@pytest.fixture(scope="session")
+def engine():
+    # StaticPool keeps a single in-memory connection alive so the schema you
+    # create is visible to the test session. A file-based or server database
+    # needs no such tweak — just return your usual engine.
+    engine = create_engine(
+        "sqlite://",
+        connect_args={"check_same_thread": False},
+        poolclass=StaticPool,
+    )
+
+    # SQLite only: hand transaction control to SQLAlchemy so an explicit
+    # commit() inside a test lands on a savepoint and is rolled back with the
+    # outer transaction. Left to itself the pysqlite driver commits straight to
+    # the database and the per-test rollback cannot undo it. Other databases
+    # (PostgreSQL, MySQL) need neither listener.
+    @event.listens_for(engine, "connect")
+    def _sqlite_no_driver_begin(dbapi_connection, connection_record):
+        dbapi_connection.isolation_level = None
+
+    @event.listens_for(engine, "begin")
+    def _sqlite_emit_begin(connection):
+        connection.exec_driver_sql("BEGIN")
+
+    Base.metadata.create_all(engine)
+    return engine
+```
+
+```python
+# test_people.py
+from myapp.models import Person
+
+
+def test_people_are_seeded(seed, sqlalchemyseed_session):
+    seeder = seed("tests/data/people.yaml")
+    assert sqlalchemyseed_session.query(Person).count() == 2
+    assert seeder.instances[0].name == "Alice"
+```
+
+`seed()` accepts the same inputs as the library: `.json`, `.yaml`/`.yml`, and
+`.csv` files. CSV is not self-describing, so pass the model:
+`seed("people.csv", model="myapp.models.Person")`. Use `seeder="hybrid"` for the
+`HybridSeeder`, and `ref_prefix=...` to override the relationship reference
+prefix. Every test runs inside a transaction that is rolled back afterward, so
+tests never see each other's rows.
+
+> **Note:** the plugin registers fixtures named `engine`, `sqlalchemyseed_session`,
+> and `seed`. Defining your own `engine` fixture is how you plug in your database;
+> if you already use those names for something else, your definitions take
+> precedence (pytest resolves conftest fixtures over plugin fixtures).
+
 ## Documentation
 
 <https://sqlalchemyseed.readthedocs.io/>

{sqlalchemyseed-2.2.0 → sqlalchemyseed-2.4.0}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "sqlalchemyseed"
 description = "SQLAlchemy Seeder"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [
@@ -10,7 +10,6 @@ authors = [
 ]
 keywords = ["sqlalchemy", "orm", "seed", "seeder", "json", "yaml"]
 classifiers = [
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -30,6 +29,9 @@ yaml = [
 [project.scripts]
 sqlalchemyseed = "sqlalchemyseed.cli:main"
 
+[project.entry-points.pytest11]
+sqlalchemyseed = "sqlalchemyseed.pytest_plugin"
+
 [project.urls]
 Homepage = "https://github.com/jedymatt/sqlalchemyseed"
 Documentation = "https://sqlalchemyseed.readthedocs.io/"
@@ -38,7 +40,9 @@ Tracker = "https://github.com/jedymatt/sqlalchemyseed/issues"
 
 [dependency-groups]
 dev = [
-    "pytest>=7.0",
+    # 9.0.3 fixes GHSA-6w46-j5rx-g56g (tmpdir handling); it needs Python >=3.10,
+    # which is now the floor.
+    "pytest>=9.0.3",
     "coverage>=6.2",
     "PyYAML>=6.0",
 ]

{sqlalchemyseed-2.2.0 → sqlalchemyseed-2.4.0}/src/sqlalchemyseed/__init__.py

@@ -11,7 +11,7 @@ from . import util
 from . import attribute
 
 
-__version__ = "2.2.0"
+__version__ = "2.4.0"
 
 if __name__ == '__main__':
     pass

{sqlalchemyseed-2.2.0 → sqlalchemyseed-2.4.0}/src/sqlalchemyseed/cli.py

@@ -11,13 +11,6 @@ from sqlalchemy.orm import Session
 from . import loader
 from .seeder import HybridSeeder, Seeder
 
-_JSON_EXTENSIONS = {".json"}
-_YAML_EXTENSIONS = {".yaml", ".yml"}
-_CSV_EXTENSIONS = {".csv"}
-# Only self-describing formats are auto-discovered inside a directory. CSV
-# needs an explicit --model, so a CSV must be named as an individual file.
-_DISCOVERABLE_EXTENSIONS = _JSON_EXTENSIONS | _YAML_EXTENSIONS
-
 
 def build_parser() -> argparse.ArgumentParser:
     """Build the argument parser for the ``sqlalchemyseed`` command."""
@@ -55,6 +48,11 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="seed within a transaction but roll back instead of committing",
     )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="re-raise errors with a full traceback instead of a one-line message",
+    )
     return parser
 
 
@@ -79,7 +77,7 @@ def _discover_directory(directory: Path) -> list:
     """Return the JSON/YAML files inside a directory, sorted by name."""
     discovered = sorted(
         child for child in directory.iterdir()
-        if child.suffix.lower() in _DISCOVERABLE_EXTENSIONS
+        if child.suffix.lower() in loader.DISCOVERABLE_EXTENSIONS
     )
     if not discovered:
         raise FileNotFoundError(
@@ -88,25 +86,6 @@ def _discover_directory(directory: Path) -> list:
     return discovered
 
 
-def load_file(path: Path, model=None) -> dict:
-    """Load entities from a single data file, dispatching on its extension."""
-    suffix = path.suffix.lower()
-    if suffix in _JSON_EXTENSIONS:
-        return loader.load_entities_from_json(str(path))
-    if suffix in _YAML_EXTENSIONS:
-        return loader.load_entities_from_yaml(str(path))
-    if suffix in _CSV_EXTENSIONS:
-        return _load_csv(path, model)
-    raise ValueError(f"unsupported file type: {path}")
-
-
-def _load_csv(path: Path, model) -> dict:
-    """Load entities from a CSV file, which requires an explicit model."""
-    if model is None:
-        raise ValueError(f"CSV input requires --model to name the target class: {path}")
-    return loader.load_entities_from_csv(str(path), model)
-
-
 def _make_seeder(name, session, ref_prefix):
     """Return the seeder implementation selected on the command line."""
     if name == "hybrid":
@@ -118,7 +97,7 @@ def _seed_all(seeder, files, model) -> int:
     """Seed every file through the seeder and return the entity count."""
     seeded = 0
     for path in files:
-        seeder.seed(load_file(path, model))
+        seeder.seed(loader.load_path(path, model))
         seeded += len(seeder.instances)
     return seeded
 
@@ -141,17 +120,17 @@ def main(argv=None) -> int:
     except FileNotFoundError as error:
         parser.error(str(error))
 
-    engine = sqlalchemy.create_engine(url)
-    with Session(engine) as session:
-        seeder = _make_seeder(args.seeder, session, args.ref_prefix)
-        try:
+    try:
+        engine = sqlalchemy.create_engine(url)
+        with Session(engine) as session:
+            seeder = _make_seeder(args.seeder, session, args.ref_prefix)
             seeded = _seed_all(seeder, files, args.model)
-        except Exception as error:  # noqa: BLE001 - report any seeding failure as a clean exit
-            session.rollback()
-            print(f"error: {error}", file=sys.stderr)
-            return 1
-
-        return _finish(session, seeded, len(files), args.dry_run)
+            return _finish(session, seeded, len(files), args.dry_run)
+    except Exception as error:  # noqa: BLE001 - top-level boundary: report any failure as exit code 1
+        if args.debug:
+            raise
+        print(f"error: {type(error).__name__}: {error}", file=sys.stderr)
+        return 1
 
 
 def _finish(session, seeded, file_count, dry_run) -> int:

sqlalchemyseed-2.4.0/src/sqlalchemyseed/loader.py

@@ -0,0 +1,87 @@
+"""
+Text file loader module
+"""
+
+import csv
+import json
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+except ModuleNotFoundError:  # pragma: no cover
+    pass
+
+
+def load_entities_from_json(json_filepath) -> dict:
+    """
+    Get entities from json
+    """
+    with open(json_filepath, 'r', encoding='utf-8') as file:
+        entities = json.loads(file.read())
+
+    return entities
+
+
+def load_entities_from_yaml(yaml_filepath):
+    """
+    Get entities from yaml
+    """
+    if 'yaml' not in sys.modules:
+        raise ModuleNotFoundError(
+            'PyYAML is not installed and is required to run this function. '
+            'To use this function, py -m pip install "sqlalchemyseed[yaml]"'
+        )
+
+    with open(yaml_filepath, 'r', encoding='utf-8') as file:
+        entities = yaml.load(file.read(), Loader=yaml.SafeLoader)
+
+    return entities
+
+
+def load_entities_from_csv(csv_filepath: str, model) -> dict:
+    """Load entities from csv file
+
+    :param csv_filepath: string csv file path
+    :param model: either str or class
+    :return: dict of entities
+    """
+    with open(csv_filepath, 'r', encoding='utf-8') as file:
+        source_data = list(
+            map(dict, csv.DictReader(file, skipinitialspace=True)))
+        if isinstance(model, str):
+            model_name = model
+        else:
+            model_name = '.'.join([model.__module__, model.__name__])
+
+        entities = {'model': model_name, 'data': source_data}
+
+    return entities
+
+
+_JSON_EXTENSIONS = {".json"}
+_YAML_EXTENSIONS = {".yaml", ".yml"}
+_CSV_EXTENSIONS = {".csv"}
+# Formats that are self-describing (carry their own model) and so can be
+# auto-discovered inside a directory. CSV needs an explicit model.
+DISCOVERABLE_EXTENSIONS = _JSON_EXTENSIONS | _YAML_EXTENSIONS
+
+
+def load_path(path, model=None) -> dict:
+    """Load entities from a single data file, dispatching on its extension."""
+    path = Path(path)
+    suffix = path.suffix.lower()
+    if suffix in _JSON_EXTENSIONS:
+        return load_entities_from_json(str(path))
+    if suffix in _YAML_EXTENSIONS:
+        return load_entities_from_yaml(str(path))
+    if suffix in _CSV_EXTENSIONS:
+        return _load_csv(path, model)
+    raise ValueError(f"unsupported file type: {path}")
+
+
+def _load_csv(path, model) -> dict:
+    """Load entities from a CSV file, which requires an explicit model."""
+    if model is None:
+        raise ValueError(f"CSV input requires a model to name the target class: {path}")
+    return load_entities_from_csv(str(path), model)

sqlalchemyseed-2.4.0/src/sqlalchemyseed/pytest_plugin.py

@@ -0,0 +1,66 @@
+"""pytest plugin: file-based SQLAlchemy fixtures with per-test rollback.
+
+Registered via the ``pytest11`` entry point. Defines fixtures only — importing
+this module has no side effects, and it is never imported by the package's
+``__init__`` so production imports never pull in pytest.
+"""
+
+import pytest
+from sqlalchemy.orm import Session
+
+from .loader import load_path
+from .seeder import HybridSeeder, Seeder
+
+_MISSING_ENGINE_MESSAGE = (
+    "sqlalchemyseed's pytest plugin requires an 'engine' fixture. Define one in "
+    "your conftest.py that returns a SQLAlchemy Engine with your schema created, "
+    "e.g.:\n\n"
+    "    @pytest.fixture(scope='session')\n"
+    "    def engine():\n"
+    "        engine = create_engine('sqlite:///test.db')\n"
+    "        Base.metadata.create_all(engine)\n"
+    "        return engine\n\n"
+    "For an in-memory SQLite database, and to have an explicit commit() rolled "
+    "back per test, see the docs for the full engine setup.\n"
+)
+
+
+@pytest.fixture
+def engine():
+    """Placeholder the user overrides in their conftest with a real Engine."""
+    raise RuntimeError(_MISSING_ENGINE_MESSAGE)
+
+
+@pytest.fixture
+def sqlalchemyseed_session(engine):
+    """A Session in an open transaction that is rolled back after the test."""
+    connection = engine.connect()
+    transaction = connection.begin()
+    session = Session(bind=connection, join_transaction_mode="create_savepoint")
+    try:
+        yield session
+    finally:
+        # Nested so connection.close() always runs even if an earlier step
+        # raises — a leaked connection would otherwise exhaust the pool and
+        # surface as a failure in an unrelated later test.
+        try:
+            session.close()
+        finally:
+            try:
+                transaction.rollback()
+            finally:
+                connection.close()
+
+
+@pytest.fixture
+def seed(sqlalchemyseed_session):
+    """Return a callable that seeds a data file into the test session."""
+    def _seed(path, *, model=None, seeder="basic", ref_prefix="!"):
+        entities = load_path(path, model)
+        seeder_cls = HybridSeeder if seeder == "hybrid" else Seeder
+        instance = seeder_cls(sqlalchemyseed_session, ref_prefix=ref_prefix)
+        instance.seed(entities)
+        sqlalchemyseed_session.flush()
+        return instance
+
+    return _seed

{sqlalchemyseed-2.2.0 → sqlalchemyseed-2.4.0/src/sqlalchemyseed.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemyseed
-Version: 2.2.0
+Version: 2.4.0
 Summary: SQLAlchemy Seeder
 Author-email: Jedy Matt Tabasco <hello@jedymatt.dev>
 License-Expression: MIT
@@ -9,13 +9,12 @@ Project-URL: Documentation, https://sqlalchemyseed.readthedocs.io/
 Project-URL: Source, https://github.com/jedymatt/sqlalchemyseed
 Project-URL: Tracker, https://github.com/jedymatt/sqlalchemyseed/issues
 Keywords: sqlalchemy,orm,seed,seeder,json,yaml
-Classifier: Programming Language :: Python :: 3.9
 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: Programming Language :: Python :: 3.14
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: SQLAlchemy>=2.0
@@ -123,6 +122,73 @@ The same command is available as a module:
 python -m sqlalchemyseed data.json --url sqlite:///app.db
 ```
 
+## Testing with pytest
+
+Installing `sqlalchemyseed` alongside `pytest` registers a plugin that loads
+fixture files into a transactionally-isolated session. Provide one `engine`
+fixture in your `conftest.py`; the plugin supplies `sqlalchemyseed_session`
+(rolled back after every test) and a `seed` factory.
+
+```python
+# conftest.py
+import pytest
+from sqlalchemy import create_engine, event
+from sqlalchemy.pool import StaticPool
+
+from myapp.models import Base
+
+
+@pytest.fixture(scope="session")
+def engine():
+    # StaticPool keeps a single in-memory connection alive so the schema you
+    # create is visible to the test session. A file-based or server database
+    # needs no such tweak — just return your usual engine.
+    engine = create_engine(
+        "sqlite://",
+        connect_args={"check_same_thread": False},
+        poolclass=StaticPool,
+    )
+
+    # SQLite only: hand transaction control to SQLAlchemy so an explicit
+    # commit() inside a test lands on a savepoint and is rolled back with the
+    # outer transaction. Left to itself the pysqlite driver commits straight to
+    # the database and the per-test rollback cannot undo it. Other databases
+    # (PostgreSQL, MySQL) need neither listener.
+    @event.listens_for(engine, "connect")
+    def _sqlite_no_driver_begin(dbapi_connection, connection_record):
+        dbapi_connection.isolation_level = None
+
+    @event.listens_for(engine, "begin")
+    def _sqlite_emit_begin(connection):
+        connection.exec_driver_sql("BEGIN")
+
+    Base.metadata.create_all(engine)
+    return engine
+```
+
+```python
+# test_people.py
+from myapp.models import Person
+
+
+def test_people_are_seeded(seed, sqlalchemyseed_session):
+    seeder = seed("tests/data/people.yaml")
+    assert sqlalchemyseed_session.query(Person).count() == 2
+    assert seeder.instances[0].name == "Alice"
+```
+
+`seed()` accepts the same inputs as the library: `.json`, `.yaml`/`.yml`, and
+`.csv` files. CSV is not self-describing, so pass the model:
+`seed("people.csv", model="myapp.models.Person")`. Use `seeder="hybrid"` for the
+`HybridSeeder`, and `ref_prefix=...` to override the relationship reference
+prefix. Every test runs inside a transaction that is rolled back afterward, so
+tests never see each other's rows.
+
+> **Note:** the plugin registers fixtures named `engine`, `sqlalchemyseed_session`,
+> and `seed`. Defining your own `engine` fixture is how you plug in your database;
+> if you already use those names for something else, your definitions take
+> precedence (pytest resolves conftest fixtures over plugin fixtures).
+
 ## Documentation
 
 <https://sqlalchemyseed.readthedocs.io/>

{sqlalchemyseed-2.2.0 → sqlalchemyseed-2.4.0}/src/sqlalchemyseed.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/sqlalchemyseed/dynamic_seeder.py
 src/sqlalchemyseed/errors.py
 src/sqlalchemyseed/json.py
 src/sqlalchemyseed/loader.py
+src/sqlalchemyseed/pytest_plugin.py
 src/sqlalchemyseed/seeder.py
 src/sqlalchemyseed/util.py
 src/sqlalchemyseed/validator.py
@@ -24,6 +25,7 @@ src/sqlalchemyseed/_future/seeder.py
 tests/test_cli.py
 tests/test_json.py
 tests/test_loader.py
+tests/test_pytest_plugin.py
 tests/test_seeder.py
 tests/test_temp_seeder.py
 tests/test_validator.py

{sqlalchemyseed-2.2.0 → sqlalchemyseed-2.4.0}/src/sqlalchemyseed.egg-info/entry_points.txt

@@ -1,2 +1,5 @@
 [console_scripts]
 sqlalchemyseed = sqlalchemyseed.cli:main
+
+[pytest11]
+sqlalchemyseed = sqlalchemyseed.pytest_plugin

{sqlalchemyseed-2.2.0 → sqlalchemyseed-2.4.0}/tests/test_cli.py

@@ -68,7 +68,7 @@ def test_csv_without_model_fails(tmp_path, db_url, capsys):
     csv_file.write_text("name\nDave\n", encoding="utf-8")
 
     assert cli.main([str(csv_file), "--url", db_url]) == 1
-    assert "requires --model" in capsys.readouterr().err
+    assert "requires a model" in capsys.readouterr().err
     assert count_persons(db_url) == 0
 
 
@@ -131,3 +131,19 @@ def test_unsupported_file_type(tmp_path, db_url):
     bad_file.write_text("nope", encoding="utf-8")
 
     assert cli.main([str(bad_file), "--url", db_url]) == 1
+
+
+def test_error_message_includes_exception_type(tmp_path, db_url, capsys):
+    bad_file = tmp_path / "people.txt"
+    bad_file.write_text("nope", encoding="utf-8")
+
+    assert cli.main([str(bad_file), "--url", db_url]) == 1
+    assert "ValueError" in capsys.readouterr().err
+
+
+def test_debug_flag_reraises_with_traceback(tmp_path, db_url):
+    bad_file = tmp_path / "people.txt"
+    bad_file.write_text("nope", encoding="utf-8")
+
+    with pytest.raises(ValueError):
+        cli.main([str(bad_file), "--url", db_url, "--debug"])

sqlalchemyseed-2.4.0/tests/test_loader.py

@@ -0,0 +1,77 @@
+import unittest
+
+import pytest
+
+from sqlalchemyseed import loader
+from sqlalchemyseed import load_entities_from_json
+from sqlalchemyseed import load_entities_from_yaml
+from sqlalchemyseed import load_entities_from_csv
+
+
+def test_load_path_reads_json(tmp_path):
+    data_file = tmp_path / "d.json"
+    data_file.write_text('{"model": "m.M", "data": []}', encoding="utf-8")
+    assert loader.load_path(data_file) == {"model": "m.M", "data": []}
+
+
+def test_load_path_reads_yaml(tmp_path):
+    data_file = tmp_path / "d.yml"
+    data_file.write_text("model: m.M\ndata: []\n", encoding="utf-8")
+    assert loader.load_path(data_file) == {"model": "m.M", "data": []}
+
+
+def test_load_path_rejects_unknown_extension(tmp_path):
+    bad = tmp_path / "d.txt"
+    bad.write_text("nope", encoding="utf-8")
+    with pytest.raises(ValueError):
+        loader.load_path(bad)
+
+
+def test_load_path_csv_requires_model(tmp_path):
+    csv_file = tmp_path / "d.csv"
+    csv_file.write_text("name\nAlice\n", encoding="utf-8")
+    with pytest.raises(ValueError):
+        loader.load_path(csv_file)
+
+
+def test_discoverable_extensions_are_json_and_yaml():
+    assert loader.DISCOVERABLE_EXTENSIONS == {".json", ".yaml", ".yml"}
+
+
+class TestLoader(unittest.TestCase):
+    def test_load_entities_from_json(self):
+        entities = load_entities_from_json('tests/res/data.json')
+        self.assertEqual(len(entities), 6)
+
+    def test_load_entities_from_json_file_not_found(self):
+        self.assertRaises(FileNotFoundError,
+                          lambda: load_entities_from_json('tests/res/non-existent-file'))
+
+    def test_load_entities_from_yaml(self):
+        entities = load_entities_from_yaml('tests/res/data.yml')
+        self.assertEqual(len(entities), 2)
+
+    def test_load_entities_from_yaml_file_not_found(self):
+        self.assertRaises(FileNotFoundError,
+                          lambda: load_entities_from_yaml('tests/res/non-existent-file'))
+
+    def test_load_entities_from_csv_input_class(self):
+        from tests.models import Company
+        entities = load_entities_from_csv(
+            'tests/res/companies.csv', Company)
+        self.assertEqual(len(entities['data']), 3)
+
+    def test_load_entities_from_csv_input_model_string(self):
+        self.assertIsNotNone(load_entities_from_csv(
+            'tests/res/companies.csv', "tests.models.Company"))
+
+    def test_loader_yaml_not_installed(self):
+        yaml_module = loader.sys.modules.pop('yaml')
+        try:
+            self.assertRaises(
+                ModuleNotFoundError,
+                lambda: load_entities_from_yaml('tests/res/data.yml')
+            )
+        finally:
+            loader.sys.modules['yaml'] = yaml_module
+        

sqlalchemyseed-2.4.0/tests/test_pytest_plugin.py

@@ -0,0 +1,331 @@
+"""Tests for the bundled pytest plugin, exercised via the pytester fixture."""
+
+# A self-contained conftest for the inner pytest runs. StaticPool keeps a
+# single in-memory SQLite connection alive so create_all and the session share
+# one database.
+CONFTEST = '''
+import pytest
+from sqlalchemy import create_engine, event
+from sqlalchemy.pool import StaticPool
+
+from models import Base
+
+
+@pytest.fixture(scope="session")
+def engine():
+    eng = create_engine(
+        "sqlite://",
+        connect_args={"check_same_thread": False},
+        poolclass=StaticPool,
+    )
+
+    # Hand transaction control to SQLAlchemy so an explicit commit() inside a
+    # test lands on a savepoint and is rolled back with the outer transaction.
+    # Left to itself the pysqlite driver commits straight to the database and
+    # the per-test rollback cannot undo it.
+    @event.listens_for(eng, "connect")
+    def _sqlite_no_driver_begin(dbapi_connection, connection_record):
+        dbapi_connection.isolation_level = None
+
+    @event.listens_for(eng, "begin")
+    def _sqlite_emit_begin(connection):
+        connection.exec_driver_sql("BEGIN")
+
+    Base.metadata.create_all(eng)
+    return eng
+'''
+
+MODELS = '''
+from sqlalchemy import Column, ForeignKey, Integer, String
+from sqlalchemy.orm import declarative_base, relationship
+
+Base = declarative_base()
+
+
+class Person(Base):
+    __tablename__ = "persons"
+    id = Column(Integer, primary_key=True)
+    name = Column(String(50))
+
+
+class Company(Base):
+    __tablename__ = "companies"
+    id = Column(Integer, primary_key=True)
+    name = Column(String(50))
+    employees = relationship("Employee", back_populates="company")
+
+
+class Employee(Base):
+    __tablename__ = "employees"
+    id = Column(Integer, primary_key=True)
+    name = Column(String(50))
+    company_id = Column(Integer, ForeignKey("companies.id"))
+    company = relationship("Company", back_populates="employees")
+'''
+
+
+def _scaffold(pytester):
+    """Write the shared conftest + models module into the inner project."""
+    pytester.makeconftest(CONFTEST)
+    pytester.makepyfile(models=MODELS)
+
+
+def test_seed_json(pytester):
+    _scaffold(pytester)
+    pytester.makefile(
+        ".json",
+        people='{"model": "models.Person", "data": [{"name": "Alice"}, {"name": "Bob"}]}',
+    )
+    pytester.makepyfile(
+        test_seed_json='''
+        from models import Person
+
+        def test_it(seed, sqlalchemyseed_session):
+            seeder = seed("people.json")
+            assert sqlalchemyseed_session.query(Person).count() == 2
+            assert seeder.instances[0].name == "Alice"
+        '''
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_seed_yaml(pytester):
+    _scaffold(pytester)
+    pytester.makefile(
+        ".yaml",
+        people="model: models.Person\ndata:\n  - name: Carol\n",
+    )
+    pytester.makepyfile(
+        test_seed_yaml='''
+        from models import Person
+
+        def test_it(seed, sqlalchemyseed_session):
+            seed("people.yaml")
+            assert sqlalchemyseed_session.query(Person).count() == 1
+        '''
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_seed_csv_with_model(pytester):
+    _scaffold(pytester)
+    pytester.makefile(".csv", people="name\nDave\nErin\n")
+    pytester.makepyfile(
+        test_seed_csv='''
+        from models import Person
+
+        def test_it(seed, sqlalchemyseed_session):
+            seed("people.csv", model="models.Person")
+            assert sqlalchemyseed_session.query(Person).count() == 2
+        '''
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_hybrid_seeder(pytester):
+    _scaffold(pytester)
+    pytester.makefile(
+        ".json",
+        people='{"model": "models.Person", "data": [{"name": "Alice"}]}',
+    )
+    pytester.makepyfile(
+        test_hybrid='''
+        from models import Person
+
+        def test_it(seed, sqlalchemyseed_session):
+            seeder = seed("people.json", seeder="hybrid")
+            assert sqlalchemyseed_session.query(Person).count() == 1
+            assert seeder.instances[0].name == "Alice"
+        '''
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_rollback_isolation(pytester):
+    _scaffold(pytester)
+    pytester.makefile(
+        ".json",
+        people='{"model": "models.Person", "data": [{"name": "Alice"}, {"name": "Bob"}]}',
+    )
+    pytester.makepyfile(
+        test_isolation='''
+        from models import Person
+
+        def test_first_seeds(seed, sqlalchemyseed_session):
+            seed("people.json")
+            assert sqlalchemyseed_session.query(Person).count() == 2
+
+        def test_second_sees_empty_db(sqlalchemyseed_session):
+            # The prior test's rows were rolled back with its transaction.
+            assert sqlalchemyseed_session.query(Person).count() == 0
+        '''
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=2)
+
+
+def test_committed_writes_still_roll_back(pytester):
+    # The point of join_transaction_mode="create_savepoint": even an explicit
+    # commit() lands on a savepoint inside the outer transaction and is unwound
+    # by the teardown rollback. This pins the documented contract that the
+    # flush-only seed path (test_rollback_isolation) does not exercise.
+    _scaffold(pytester)
+    pytester.makefile(
+        ".json",
+        people='{"model": "models.Person", "data": [{"name": "Alice"}]}',
+    )
+    pytester.makepyfile(
+        test_commit_isolation='''
+        from models import Person
+
+        def test_first_commits(seed, sqlalchemyseed_session):
+            seed("people.json")
+            sqlalchemyseed_session.commit()
+            assert sqlalchemyseed_session.query(Person).count() == 1
+
+        def test_second_sees_empty_db(sqlalchemyseed_session):
+            # The committed row was still rolled back with the outer transaction.
+            assert sqlalchemyseed_session.query(Person).count() == 0
+        '''
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=2)
+
+
+def test_reference_resolution_default_prefix(pytester):
+    # A "!"-prefixed key is a relationship reference; the seeder wires the
+    # nested Company onto the Employee. Guards the default ref_prefix.
+    _scaffold(pytester)
+    pytester.makefile(
+        ".json",
+        employee=(
+            '{"model": "models.Employee", "data": {"name": "Juan", '
+            '"!company": {"model": "models.Company", "data": {"name": "Acme"}}}}'
+        ),
+    )
+    pytester.makepyfile(
+        test_reference='''
+        from models import Company, Employee
+
+        def test_it(seed, sqlalchemyseed_session):
+            seed("employee.json")
+            employee = sqlalchemyseed_session.query(Employee).one()
+            assert employee.company.name == "Acme"
+            assert sqlalchemyseed_session.query(Company).count() == 1
+        '''
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_custom_ref_prefix(pytester):
+    # A non-default prefix ("@") must be threaded through to the seeder so the
+    # "@company" key is treated as a reference rather than a column.
+    _scaffold(pytester)
+    pytester.makefile(
+        ".json",
+        employee=(
+            '{"model": "models.Employee", "data": {"name": "Mia", '
+            '"@company": {"model": "models.Company", "data": {"name": "Globex"}}}}'
+        ),
+    )
+    pytester.makepyfile(
+        test_prefix='''
+        from models import Employee
+
+        def test_it(seed, sqlalchemyseed_session):
+            seed("employee.json", ref_prefix="@")
+            employee = sqlalchemyseed_session.query(Employee).one()
+            assert employee.company.name == "Globex"
+        '''
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_multiple_seed_calls_accumulate(pytester):
+    # Seeding several files in one test is a first-class use case; each call
+    # builds a fresh seeder on the shared session and flushes.
+    _scaffold(pytester)
+    pytester.makefile(
+        ".json",
+        alice='{"model": "models.Person", "data": [{"name": "Alice"}]}',
+        others='{"model": "models.Person", "data": [{"name": "Bob"}, {"name": "Carol"}]}',
+    )
+    pytester.makepyfile(
+        test_multi='''
+        from models import Person
+
+        def test_it(seed, sqlalchemyseed_session):
+            seed("alice.json")
+            seed("others.json")
+            assert sqlalchemyseed_session.query(Person).count() == 3
+        '''
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_missing_engine_gives_actionable_error(pytester):
+    # Deliberately no conftest / engine fixture.
+    pytester.makepyfile(
+        test_no_engine='''
+        def test_it(seed):
+            pass
+        '''
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(errors=1)
+    result.stdout.fnmatch_lines(["*requires an 'engine' fixture*"])
+
+
+def test_user_can_override_session(pytester):
+    _scaffold(pytester)
+    pytester.makefile(
+        ".json",
+        people='{"model": "models.Person", "data": [{"name": "Zoe"}]}',
+    )
+    # Override the plugin's session fixture; seed must use the override.
+    # A minimal session suffices here — this test proves override precedence,
+    # not the production fixture's transaction handling.
+    pytester.makepyfile(
+        test_override='''
+        import pytest
+        from sqlalchemy.orm import Session
+        from models import Person
+
+        @pytest.fixture
+        def sqlalchemyseed_session(engine):
+            session = Session(bind=engine)
+            session.info["overridden"] = True
+            yield session
+            session.close()
+
+        def test_it(seed, sqlalchemyseed_session):
+            seed("people.json")
+            assert sqlalchemyseed_session.info.get("overridden") is True
+            assert sqlalchemyseed_session.query(Person).count() == 1
+        '''
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_unsupported_file_type_fails_loudly(pytester):
+    _scaffold(pytester)
+    pytester.makefile(".txt", data="nope")
+    pytester.makepyfile(
+        test_unsupported='''
+        import pytest
+
+        def test_it(seed):
+            with pytest.raises(ValueError):
+                seed("data.txt")
+        '''
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)

sqlalchemyseed-2.2.0/src/sqlalchemyseed/loader.py

@@ -1,64 +0,0 @@
-"""
-Text file loader module
-"""
-
-import csv
-import json
-import sys
-
-try:
-    import yaml
-except ModuleNotFoundError:  # pragma: no cover
-    pass
-
-
-def load_entities_from_json(json_filepath) -> dict:
-    """
-    Get entities from json
-    """
-    try:
-        with open(json_filepath, 'r', encoding='utf-8') as file:
-            entities = json.loads(file.read())
-    except FileNotFoundError as error:
-        raise FileNotFoundError from error
-
-    return entities
-
-
-def load_entities_from_yaml(yaml_filepath):
-    """
-    Get entities from yaml
-    """
-    if 'yaml' not in sys.modules:
-        raise ModuleNotFoundError(
-            'PyYAML is not installed and is required to run this function. '
-            'To use this function, py -m pip install "sqlalchemyseed[yaml]"'
-        )
-
-    try:
-        with open(yaml_filepath, 'r', encoding='utf-8') as file:
-            entities = yaml.load(file.read(), Loader=yaml.SafeLoader)
-    except FileNotFoundError as error:
-        raise FileNotFoundError from error
-
-    return entities
-
-
-def load_entities_from_csv(csv_filepath: str, model) -> dict:
-    """Load entities from csv file
-
-    :param csv_filepath: string csv file path
-    :param model: either str or class
-    :return: dict of entities
-    """
-    with open(csv_filepath, 'r', encoding='utf-8') as file:
-        source_data = list(
-            map(dict, csv.DictReader(file, skipinitialspace=True)))
-        if isinstance(model, str):
-            model_name = model
-        else:
-            model_name = '.'.join([model.__module__, model.__name__])
-
-        entities = {'model': model_name, 'data': source_data}
-
-    return entities

sqlalchemyseed-2.2.0/tests/test_loader.py

@@ -1,41 +0,0 @@
-import unittest
-from sqlalchemyseed import loader
-
-from src.sqlalchemyseed import load_entities_from_json
-from src.sqlalchemyseed import load_entities_from_yaml
-from src.sqlalchemyseed import load_entities_from_csv
-
-class TestLoader(unittest.TestCase):
-    def test_load_entities_from_json(self):
-        entities = load_entities_from_json('tests/res/data.json')
-        self.assertEqual(len(entities), 6)
-
-    def test_load_entities_from_json_file_not_found(self):
-        self.assertRaises(FileNotFoundError,
-                          lambda: load_entities_from_json('tests/res/non-existent-file'))
-
-    def test_load_entities_from_yaml(self):
-        entities = load_entities_from_yaml('tests/res/data.yml')
-        self.assertEqual(len(entities), 2)
-
-    def test_load_entities_from_yaml_file_not_found(self):
-        self.assertRaises(FileNotFoundError,
-                          lambda: load_entities_from_yaml('tests/res/non-existent-file'))
-
-    def test_load_entities_from_csv_input_class(self):
-        from tests.models import Company
-        entities = load_entities_from_csv(
-            'tests/res/companies.csv', Company)
-        self.assertEqual(len(entities['data']), 3)
-
-    def test_load_entities_from_csv_input_model_string(self):
-        self.assertIsNotNone(load_entities_from_csv(
-            'tests/res/companies.csv', "tests.models.Company"))
-
-    def test_loader_yaml_not_installed(self):
-        loader.sys.modules.pop('yaml')
-        self.assertRaises(
-            ModuleNotFoundError,
-            lambda: load_entities_from_yaml('tests/res/data.yml')
-        )
-