feat(sqlalchemy): organized provisioning for tests

danielebriggi · danielebriggi · commit eb043d90f23d · 2024-08-26T10:59:18.000Z
diff --git a/.gitignore b/.gitignore
@@ -18,3 +18,5 @@ playground.ipynb
 
 src/tests/assets/*-shm
 src/tests/assets/*-wal
+
+chinook.sqlite
diff --git a/bandit-baseline.json b/bandit-baseline.json
diff --git a/requirements-dev.txt b/requirements-dev.txt
@@ -18,3 +18,4 @@ bandit==1.7.1
 # this package is only used for testing compatibility
 # with pandas dataframe
 pandas>=1.1.5
+SQLAlchemy>=1.4.53
diff --git a/sqlalchemy-sqlitecloud/README.md b/sqlalchemy-sqlitecloud/README.md
@@ -1,44 +1,46 @@
-# SQLite Cloud dialect for SQLAlchermy (beta)
+# SQLite Cloud Dialect for SQLAlchemy (Beta)
 
-This package makes SQLAlchemy to work with SQLite Cloud.
+This package enables SQLAlchemy to work seamlessly with SQLite Cloud. The dialect is built upon the existing `sqlite` dialect in SQLAlchemy.
 
-The dialect is based on the `sqlite` dialect included in SQLAlchemy.
+## Beta Version
 
-## Beta version
+This dialect is in its early stages and is compatible with Python >= 3.6.
 
-This dialect is an early version and it works on Python >= 3.6.
+**Note:** It has been tested only `SQLAlchemy 1.4`.
 
-**Tested only on `Python 3.6` and `SQLAlchemy 1.4`.**
+The dialect has undergone testing against the SQLAlchemy `test_suite`, as outlined in the [official documentation](https://github.com/sqlalchemy/sqlalchemy/blob/rel_1_4_53/README.dialects.rst).
 
-The dialect as been tested against the SQLAlchemy `test_suite` as reported in the [documentation](https://github.com/sqlalchemy/sqlalchemy/blob/rel_1_4_53/README.dialects.rst).
+You can track the progress of the remaining test issues [in this issue](https://github.com/sqlitecloud/sqlitecloud-py/issues/21#issuecomment-2305162632).
 
-You can follow the status of the tests that are still failing [in the dedicated issue](https://github.com/sqlitecloud/sqlitecloud-py/issues/21#issuecomment-2305162632).
+_The same tests failed and passed on both Python 3.6 and Python 3.11._
 
-References:
-- [Official SQLAlchemy documentation](https://docs.sqlalchemy.org/en/14/index.html)
-- [https://www.sqlalchemy.org/](https://www.sqlalchemy.org/)
+## References
 
+- [SQLAlchemy Documentation](https://docs.sqlalchemy.org/en/14/index.html)
+- [SQLAlchemy Official Website](https://www.sqlalchemy.org/)
 
-# Install and Usage
+## Installation and Usage
+
+To install the package, use the following command:
 
 ```bash
 $ pip install sqlalchemy-sqlitecloud
 ```
 
-> Get your SQLite Cloud connection string from the SQLite Cloud dashboard or register on [sqlitecloud.io](https://sqlitecloud.io) to get one.
+> Get your SQLite Cloud connection string from the SQLite Cloud dashboard, or register at [sqlitecloud.io](https://sqlitecloud.io) to get one.
 
-Create the SQLAlchemy engine by setting the SQLite Cloud connection string. Add the prefix `sqlite+` like:
+Create an SQLAlchemy engine using the SQLite Cloud connection string::
 
 ```python
 from sqlalchemy import create_engine
 
-engine = create_engine('sqlite+sqlitecloud://mynode.sqlite.io?apikey=key1234')
+engine = create_engine('sqlitecloud://mynode.sqlite.io?apikey=key1234')
 ```
 
 
 # Run the Test Suite
 
-Install the `sqlitecloud` package with:
+To run the test suite, first install the sqlitecloud package:
 
 ```bash
 $ pip install sqlitecloud # last version
@@ -51,20 +53,24 @@ $ cd ../src # sqlitecloud src directory
 $ pip install -e .
 ```
 
-Run the test suite with:
+Then, run the test suite with:
 
 ```bash
 $ cd sqlalchemy-sqlitecloud
 $ pytest
 ```
 
-> Note:  VSCode Test Explorer and VSCode GUI debugger doesn't work because the actual implementation
-is not in the `test/test_suite.py` file. It cannot find the tests source code in the third-parties directory.
+> Note:  VSCode Test Explorer and VSCode GUI debugger doesn't work because the actual implementation of tests
+is not in the `test/test_suite.py` file. The test source code is located in a third-party directory and it's not recognized.
+
+For command-line debugging, use `pytest --pdb` with `pdb.set_trace()`.
 
-Use `pytest --pdb` with `pdb.set_trace()` to debug with command line:
+Some useful `pdb` commands include:
 
  - `s` step into
  - `n` next line
  - `r` jump to the end of the function
  - `c` continue
- - `a` print all variables
+ - `w` print stack trace
+
+ More info: [https://docs.python.org/3/library/pdb.html](https://docs.python.org/3/library/pdb.html)
diff --git a/sqlalchemy-sqlitecloud/requirements.txt b/sqlalchemy-sqlitecloud/requirements.txt
@@ -0,0 +1 @@
+sqlitecloud # latest
diff --git a/sqlalchemy-sqlitecloud/setup.cfg b/sqlalchemy-sqlitecloud/setup.cfg
@@ -8,4 +8,4 @@ profile_file=test/profiles.txt
 
 [db]
 # SQLite Cloud connection string is set in conftest.py with testing apikey
-#default=sqlite+sqlitecloud://...
+default=sqlitecloud://placeholder.sqlite.io
diff --git a/sqlalchemy-sqlitecloud/setup.py b/sqlalchemy-sqlitecloud/setup.py
@@ -1,5 +1,38 @@
-entry_points = {
-    "sqlalchemy.dialects": [
-        "sqlite.cloud = sqlalchemy_sqlitecloud.base:SQLiteCloudDialect",
-    ]
-}
+from pathlib import Path
+
+from setuptools import find_packages, setup
+
+long_description = (Path(__file__).parent / "README.md").read_text()
+
+setup(
+    name="sqlalchemy-sqlitecloud",
+    version="0.1.0",
+    author="sqlitecloud.io",
+    description="SQLAlchemy Dialect for SQLite Cloud.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/sqlitecloud/sqlitecloud-py",
+    packages=find_packages(),
+    install_requires=[
+        "sqlitecloud",
+    ],
+    keywords="SQLAlchemy SQLite Cloud",
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+    license="MIT",
+    entry_points={
+        "sqlalchemy.dialects": [
+            "sqlitecloud = sqlalchemy_sqlitecloud.base:SQLiteCloudDialect",
+        ]
+    },
+)
diff --git a/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/__init__.py b/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/__init__.py
@@ -1,5 +0,0 @@
-from sqlalchemy.dialects import registry
-
-registry.register(
-    "sqlite.sqlitecloud", "sqlalchemy_sqlitecloud.base", "SQLiteCloudDialect"
-)
diff --git a/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/base.py b/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/base.py
@@ -35,6 +35,9 @@ def result_processor(self, dialect, coltype):
 
 
 class SQLiteCloudDialect(SQLiteDialect):
+    name = "sqlitecloud"
+    driver = "sqlitecloud"
+
     default_paramstyle = "qmark"
     supports_statement_cache = False
 
@@ -46,8 +49,6 @@ class SQLiteCloudDialect(SQLiteDialect):
         },
     )
 
-    driver = "sqlitecloud"
-
     @classmethod
     def dbapi(cls):
         from sqlitecloud import dbapi2
@@ -104,8 +105,8 @@ def create_connect_args(self, url: URL):
                 "SQLite Cloud URL is required.\n"
                 "Register on https://sqlitecloud.io/ to get your free SQLite Cloud account.\n"
                 "Valid SQLite Cloud URL are:\n"
-                " sqlite+sqlitecloud:///myuser:mypass@myserver.sqlite.cloud/mydb.sqlite?non_linearizable=true\n"
-                " sqlite+sqlitecloud:///myserver.sqlite.cloud/?apikey=mykey1234"
+                " sqlitecloud:///myuser:mypass@myserver.sqlite.cloud/mydb.sqlite?non_linearizable=true\n"
+                " sqlitecloud:///myserver.sqlite.cloud/?apikey=mykey1234"
             )
 
         # TODO: this should be the list of SQLite Cloud Config params
diff --git a/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/provision.py b/sqlalchemy-sqlitecloud/sqlalchemy_sqlitecloud/provision.py
@@ -1,3 +1,7 @@
+import os
+
+from dotenv import load_dotenv
+from sqlalchemy.engine import make_url
 from sqlalchemy.pool import Pool
 from sqlalchemy.testing.provision import (
     generate_driver_url,
@@ -11,13 +15,22 @@
 }
 
 
-@generate_driver_url.for_db("sqlite")
+@generate_driver_url.for_db("sqlitecloud")
 def generate_driver_url(url, driver, query_str):
-    # eg: sqlite+sqlitecloud://mynode.sqlite.cloud/sqlalchemy_cloud.db?apikey=key123
-    return url
+    # no database specified here, it's created and used later
+    # eg: sqlitecloud://mynode.sqlite.cloud/?apikey=key123
+
+    load_dotenv("../../.env")
+
+    connection_string = os.getenv("SQLITE_CONNECTION_STRING")
+    apikey = os.getenv("SQLITE_API_KEY")
+
+    connection_string += f"?apikey={apikey}"
+
+    return make_url(connection_string)
 
 
-@post_configure_engine.for_db("sqlite")
+@post_configure_engine.for_db("sqlitecloud")
 def _sqlite_post_configure_engine(url, engine, follower_ident):
     from sqlalchemy import event
 
@@ -48,11 +61,11 @@ def _create_dbs(url, database):
         )
 
 
-@stop_test_class_outside_fixtures.for_db("sqlite")
+@stop_test_class_outside_fixtures.for_db("sqlitecloud")
 def stop_test_class_outside_fixtures(config, db, cls):
     db.dispose()
 
 
-@temp_table_keyword_args.for_db("sqlite")
+@temp_table_keyword_args.for_db("sqlitecloud")
 def _sqlite_temp_table_keyword_args(cfg, eng):
     return {"prefixes": ["TEMPORARY"]}
diff --git a/sqlalchemy-sqlitecloud/test/conftest.py b/sqlalchemy-sqlitecloud/test/conftest.py
@@ -1,29 +1,9 @@
-import os
-
 import pytest
-from dotenv import find_dotenv, load_dotenv
+from sqlalchemy.dialects import registry
 
 pytest.register_assert_rewrite("sqlalchemy.testing.assertions")
 
-from sqlalchemy.testing.plugin.pytestplugin import *  # noqa
-from sqlalchemy.testing.plugin.pytestplugin import (  # noqa
-    pytest_sessionstart as sqlalchemy_pytest_sessionstart,
-)
-
-
-def pytest_sessionstart(session):
-    """Setup connection string to SQLite Cloud with teest apikey."""
+registry.register("sqlitecloud", "sqlalchemy_sqlitecloud.base", "SQLiteCloudDialect")
 
-    load_dotenv(find_dotenv(filename="../.env", raise_error_if_not_found=True))
 
-    connection_string = os.getenv("SQLITE_CONNECTION_STRING")
-    apikey = os.getenv("SQLITE_API_KEY")
-    connection_string = connection_string.replace(
-        "sqlitecloud://", "sqlite+sqlitecloud://"
-    )
-
-    connection_string += f"?apikey={apikey}"
-
-    session.config.option.dburi = [connection_string]
-
-    sqlalchemy_pytest_sessionstart(session)
+from sqlalchemy.testing.plugin.pytestplugin import *  # noqa
diff --git a/src/setup.py b/src/setup.py
@@ -19,7 +19,7 @@
         "lz4 >= 3.1.10",
     ],
     classifiers=[
-        "Development Status :: 3 - Alpha",
+        "Development Status :: 3 - Beta",
         "Intended Audience :: Developers",
         "License :: OSI Approved :: MIT License",
         "Programming Language :: Python :: 3.6",
diff --git a/src/sqlitecloud/dbapi2.py b/src/sqlitecloud/dbapi2.py
@@ -951,7 +951,7 @@ def register_adapters_and_converters():
     """
     sqlite3 default adapters and converters.
 
-    This code is adapted from the Python standard library's sqlite3 module.
+    This code comes from the Python standard library's sqlite3 module.
     The Python standard library is licensed under the Python Software Foundation License.
     Source: https://github.com/python/cpython/blob/3.6/Lib/sqlite3/dbapi2.py
     """
diff --git a/src/tests/conftest.py b/src/tests/conftest.py
@@ -3,7 +3,7 @@
 from copy import deepcopy
 
 import pytest
-from dotenv import find_dotenv, load_dotenv
+from dotenv import load_dotenv
 
 import sqlitecloud
 from sqlitecloud.client import SQLiteCloudClient
@@ -12,7 +12,7 @@
 
 @pytest.fixture(autouse=True)
 def load_env_vars():
-    load_dotenv(find_dotenv(filename=".env", raise_error_if_not_found=True))
+    load_dotenv(".env")
 
 
 @pytest.fixture(autouse=True)
diff --git a/src/tests/integration/test_sqlalchemy.py b/src/tests/integration/test_sqlalchemy.py
@@ -0,0 +1,68 @@
+import os
+import sys
+import uuid
+
+import pytest
+import sqlalchemy as db
+from sqlalchemy import Column, ForeignKey, Integer, String
+from sqlalchemy.dialects import registry
+from sqlalchemy.orm import backref, declarative_base, relationship, sessionmaker
+
+module_dir = os.path.abspath("sqlalchemy-sqlitecloud")
+if module_dir not in sys.path:
+    sys.path.insert(0, module_dir)
+
+registry.register("sqlitecloud", "sqlalchemy_sqlitecloud.base", "SQLiteCloudDialect")
+
+Base = declarative_base()
+
+
+class Artist(Base):
+    __tablename__ = "artists"
+
+    ArtistId = Column("ArtistId", Integer, primary_key=True)
+    Name = Column("Name", String)
+    Albums = relationship("Album", backref=backref("artist"))
+
+
+class Album(Base):
+    __tablename__ = "albums"
+
+    AlbumId = Column("AlbumId", Integer, primary_key=True)
+    ArtistId = Column("ArtistId", Integer, ForeignKey("artists.ArtistId"))
+    Title = Column("Title", String)
+
+
+@pytest.fixture()
+def sqlitecloud_connection_string():
+    connection_string = os.getenv("SQLITE_CONNECTION_STRING")
+    database = os.getenv("SQLITE_DB")
+    apikey = os.getenv("SQLITE_API_KEY")
+
+    return f"{connection_string}/{database}?apikey={apikey}"
+
+
+@pytest.fixture()
+def sqlite_connection_string():
+    return "sqlite:///src/tests/assets/chinook.sqlite"
+
+
+@pytest.mark.parametrize(
+    "connection_string", ["sqlitecloud_connection_string", "sqlite_connection_string"]
+)
+def test_insert_and_select(connection_string, request):
+    connection_string = request.getfixturevalue(connection_string)
+
+    engine = db.create_engine(connection_string)
+    Session = sessionmaker(bind=engine)
+    session = Session()
+
+    name = "Mattew" + str(uuid.uuid4())
+    query = db.insert(Artist).values(Name=name)
+    result_insert = session.execute(query)
+
+    query = db.select(Artist).where(Artist.ArtistId == result_insert.lastrowid)
+    result_select = session.execute(query).fetchone()
+
+    assert result_select[0].ArtistId == result_insert.lastrowid
+    assert result_select[0].Name == name
diff --git a/src/tests/integration/test_sqlite_parity.py b/src/tests/integration/test_sqlite_parity.py
@@ -13,7 +13,7 @@
 from tests.conftest import get_sqlite3_connection, get_sqlitecloud_dbapi2_connection
 
 
-class TestSQLite3FeatureParity:
+class TestSQLiteFeatureParity:
     def test_connection_close(self, sqlitecloud_dbapi2_connection, sqlite3_connection):
         sqlitecloud_connection = sqlitecloud_dbapi2_connection
 
@@ -30,9 +30,6 @@ def test_connection_close(self, sqlitecloud_dbapi2_connection, sqlite3_connectio
 
         assert isinstance(e.value, sqlite3.ProgrammingError)
 
-    @pytest.mark.skip(
-        reason="SQLite Cloud does not convert to int a column without an explicit SQLite Type"
-    )
     def test_ping_select(self, sqlitecloud_dbapi2_connection, sqlite3_connection):
         sqlitecloud_connection = sqlitecloud_dbapi2_connection
 
