Parameterize more tests for commit

Author: pamelafox

tests/conftest.py

@@ -11,6 +11,7 @@
 from flask.ctx import AppContext
 
 from flask_sqlalchemy import SQLAlchemy
+from flask_sqlalchemy.model import Model
 
 
 @pytest.fixture
@@ -34,7 +35,7 @@ def app_ctx(app: Flask) -> t.Generator[AppContext, None, None]:
 # We defer creation of those classes until the fixture,
 # so that each test gets a fresh class with its own metadata.
 test_classes = [
-    None,
+    Model,
     (
         "BaseDeclarativeBase",
         (sa_orm.DeclarativeBase,),
@@ -63,18 +64,18 @@ def app_ctx(app: Flask) -> t.Generator[AppContext, None, None]:
 
 @pytest.fixture(params=test_classes)
 def db(app: Flask, request: pytest.FixtureRequest) -> SQLAlchemy:
-    if request.param is not None:
+    if request.param is not Model:
         return SQLAlchemy(app, model_class=types.new_class(*request.param))
     else:
         return SQLAlchemy(app)
 
 
 @pytest.fixture(params=test_classes)
 def model_class(request: pytest.FixtureRequest) -> t.Any:
-    if request.param is not None:
+    if request.param is not Model:
         return types.new_class(*request.param)
     else:
-        return None
+        return request.param
 
 
 @pytest.fixture

tests/test_engine.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os.path
+import typing as t
 import unittest.mock
 
 import pytest
@@ -20,34 +21,34 @@ def test_default_engine(app: Flask, db: SQLAlchemy) -> None:
 
 
 @pytest.mark.usefixtures("app_ctx")
-def test_engine_per_bind(app: Flask) -> None:
+def test_engine_per_bind(app: Flask, model_class: t.Any) -> None:
     app.config["SQLALCHEMY_BINDS"] = {"a": "sqlite://"}
-    db = SQLAlchemy(app)
+    db = SQLAlchemy(app, model_class=model_class)
     assert db.engines["a"] is not db.engine
 
 
 @pytest.mark.usefixtures("app_ctx")
-def test_config_engine_options(app: Flask) -> None:
+def test_config_engine_options(app: Flask, model_class: t.Any) -> None:
     app.config["SQLALCHEMY_ENGINE_OPTIONS"] = {"echo": True}
-    db = SQLAlchemy(app)
+    db = SQLAlchemy(app, model_class=model_class)
     assert db.engine.echo
 
 
 @pytest.mark.usefixtures("app_ctx")
-def test_init_engine_options(app: Flask) -> None:
+def test_init_engine_options(app: Flask, model_class: t.Any) -> None:
     app.config["SQLALCHEMY_ENGINE_OPTIONS"] = {"echo": False}
     app.config["SQLALCHEMY_BINDS"] = {"a": "sqlite://"}
-    db = SQLAlchemy(app, engine_options={"echo": True})
+    db = SQLAlchemy(app, engine_options={"echo": True}, model_class=model_class)
     # init is default
     assert db.engines["a"].echo
     # config overrides init
     assert not db.engine.echo
 
 
 @pytest.mark.usefixtures("app_ctx")
-def test_config_echo(app: Flask) -> None:
+def test_config_echo(app: Flask, model_class: t.Any) -> None:
     app.config["SQLALCHEMY_ECHO"] = True
-    db = SQLAlchemy(app)
+    db = SQLAlchemy(app, model_class=model_class)
     assert db.engine.echo
     assert db.engine.pool.echo
 
@@ -62,35 +63,35 @@ def test_config_echo(app: Flask) -> None:
         {"url": sa.engine.URL.create("sqlite")},
     ],
 )
-def test_url_type(app: Flask, value: str | sa.engine.URL) -> None:
+def test_url_type(app: Flask, model_class: t.Any, value: str | sa.engine.URL) -> None:
     app.config["SQLALCHEMY_BINDS"] = {"a": value}
-    db = SQLAlchemy(app)
+    db = SQLAlchemy(app, model_class=model_class)
     assert str(db.engines["a"].url) == "sqlite://"
 
 
-def test_no_binds_error(app: Flask) -> None:
+def test_no_binds_error(app: Flask, model_class: t.Any) -> None:
     del app.config["SQLALCHEMY_DATABASE_URI"]
 
     with pytest.raises(RuntimeError) as info:
-        SQLAlchemy(app)
+        SQLAlchemy(app, model_class=model_class)
 
     e = "Either 'SQLALCHEMY_DATABASE_URI' or 'SQLALCHEMY_BINDS' must be set."
     assert str(info.value) == e
 
 
 @pytest.mark.usefixtures("app_ctx")
-def test_no_default_url(app: Flask) -> None:
+def test_no_default_url(app: Flask, model_class: t.Any) -> None:
     del app.config["SQLALCHEMY_DATABASE_URI"]
     app.config["SQLALCHEMY_BINDS"] = {"a": "sqlite://"}
-    db = SQLAlchemy(app, engine_options={"echo": True})
+    db = SQLAlchemy(app, model_class=model_class, engine_options={"echo": True})
     assert None not in db.engines
     assert "a" in db.engines
 
 
 @pytest.mark.usefixtures("app_ctx")
-def test_sqlite_relative_path(app: Flask) -> None:
+def test_sqlite_relative_path(app: Flask, model_class: t.Any) -> None:
     app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///test.db"
-    db = SQLAlchemy(app)
+    db = SQLAlchemy(app, model_class=model_class)
     db.create_all()
     assert not isinstance(db.engine.pool, sa.pool.StaticPool)
     db_path = db.engine.url.database
@@ -99,9 +100,9 @@ def test_sqlite_relative_path(app: Flask) -> None:
 
 
 @pytest.mark.usefixtures("app_ctx")
-def test_sqlite_driver_level_uri(app: Flask) -> None:
+def test_sqlite_driver_level_uri(app: Flask, model_class: t.Any) -> None:
     app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///file:test.db?uri=true"
-    db = SQLAlchemy(app)
+    db = SQLAlchemy(app, model_class=model_class)
     db.create_all()
     db_path = db.engine.url.database
     assert db_path is not None
@@ -110,17 +111,21 @@ def test_sqlite_driver_level_uri(app: Flask) -> None:
 
 
 @unittest.mock.patch.object(SQLAlchemy, "_make_engine", autospec=True)
-def test_sqlite_memory_defaults(make_engine: unittest.mock.Mock, app: Flask) -> None:
-    SQLAlchemy(app)
+def test_sqlite_memory_defaults(
+    make_engine: unittest.mock.Mock, app: Flask, model_class: t.Any
+) -> None:
+    SQLAlchemy(app, model_class=model_class)
     options = make_engine.call_args[0][2]
     assert options["poolclass"] is sa.pool.StaticPool
     assert options["connect_args"]["check_same_thread"] is False
 
 
 @unittest.mock.patch.object(SQLAlchemy, "_make_engine", autospec=True)
-def test_mysql_defaults(make_engine: unittest.mock.Mock, app: Flask) -> None:
+def test_mysql_defaults(
+    make_engine: unittest.mock.Mock, app: Flask, model_class: t.Any
+) -> None:
     app.config["SQLALCHEMY_DATABASE_URI"] = "mysql:///test"
-    SQLAlchemy(app)
+    SQLAlchemy(app, model_class=model_class)
     options = make_engine.call_args[0][2]
     assert options["pool_recycle"] == 7200
     assert options["url"].query["charset"] == "utf8mb4"

tests/test_metadata.py

@@ -55,7 +55,7 @@ class Base(sa_orm.DeclarativeBase):
 
 
 def test_metadata_from_custom_model(model_class: t.Any) -> None:
-    if model_class is not None:
+    if model_class is not Model:
         # In 2.x, SQLAlchemy creates the metadata attribute
         base = model_class
     else:
@@ -77,17 +77,14 @@ def test_custom_metadata_overrides_custom_model_legacy() -> None:
 
 def test_metadata_per_bind(app: Flask, model_class: t.Any) -> None:
     app.config["SQLALCHEMY_BINDS"] = {"a": "sqlite://"}
-    if model_class is not None:
-        db = SQLAlchemy(app, model_class=model_class)
-    else:
-        db = SQLAlchemy(app)
+    db = SQLAlchemy(app, model_class=model_class)
     assert db.metadatas["a"] is not db.metadata
     assert db.metadatas["a"].info["bind_key"] == "a"
 
 
 def test_copy_naming_convention(app: Flask, model_class: t.Any) -> None:
     app.config["SQLALCHEMY_BINDS"] = {"a": "sqlite://"}
-    if model_class is not None:
+    if model_class is not Model:
         model_class.metadata = sa.MetaData(
             naming_convention={"pk": "spk_%(table_name)s"}
         )