tests for sql core

Author: shaypal5

.github/workflows/ci-test.yml

@@ -22,7 +22,7 @@ jobs:
       matrix:
         python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
         os: ["ubuntu-latest", "macOS-latest", "windows-latest"]
-        backend: ["local", "mongodb"]
+        backend: ["local", "mongodb", "postgres"]
         exclude:
           # ToDo: take if back when the connection become stable
           #  or resolve using `InMemoryMongoClient`
@@ -81,6 +81,25 @@ jobs:
       - name: Speed eval
         run: python tests/speed_eval.py
 
+      - name: Start PostgreSQL in docker
+        if: matrix.backend == 'postgres'
+        run: |
+          docker run -d \
+            -e POSTGRES_USER=testuser \
+            -e POSTGRES_PASSWORD=testpass \
+            -e POSTGRES_DB=testdb \
+            -p 5432:5432 \
+            --name postgres postgres:15
+          # wait for PostgreSQL to start
+          sleep 10
+          docker ps -a
+
+      - name: Unit tests (SQL/Postgres)
+        if: matrix.backend == 'postgres'
+        env:
+          SQLALCHEMY_DATABASE_URL: postgresql://testuser:testpass@localhost:5432/testdb
+        run: pytest -m sql --cov=cachier --cov-report=term --cov-report=xml:cov.xml
+
       - name: Upload coverage to Codecov
         continue-on-error: true
         uses: codecov/codecov-action@v5

README.rst

@@ -345,6 +345,11 @@ Note, however, that ``cachier``'s in-memory core is simple, and has no monitorin
 SQLAlchemy (SQL) Core
 ---------------------
 
+.. note::
+   The SQL core requires SQLAlchemy to be installed. It is not installed by default with cachier. To use the SQL backend, run::
+
+      pip install SQLAlchemy
+
 Cachier now supports a generic SQL backend via SQLAlchemy, allowing you to use SQLite, PostgreSQL, MySQL, and other databases.
 
 **Usage Example (SQLite in-memory):**

src/cachier/cores/sql.py

@@ -5,41 +5,55 @@
 from datetime import datetime
 from typing import Any, Callable, Optional, Tuple, Union
 
-from sqlalchemy import (
-    Boolean,
-    Column,
-    DateTime,
-    Index,
-    LargeBinary,
-    String,
-    and_,
-    create_engine,
-    delete,
-    insert,
-    select,
-    update,
-)
-from sqlalchemy.engine import Engine
-from sqlalchemy.orm import declarative_base, sessionmaker
+try:
+    from sqlalchemy import (
+        Boolean,
+        Column,
+        DateTime,
+        Index,
+        LargeBinary,
+        String,
+        and_,
+        create_engine,
+        delete,
+        insert,
+        select,
+        update,
+    )
+    from sqlalchemy.engine import Engine
+    from sqlalchemy.orm import declarative_base, sessionmaker
+
+    SQLALCHEMY_AVAILABLE = True
+except ImportError:
+    SQLALCHEMY_AVAILABLE = False
+    import warnings
+
+    warnings.warn(
+        "`SQLAlchemy` was not found. SQL cores will not function.",
+        ImportWarning,
+        stacklevel=2,
+    )
 
 from .._types import HashFunc
 from ..config import CacheEntry
 from .base import RecalculationNeeded, _BaseCore, _get_func_str
 
-Base = declarative_base()
-
+if SQLALCHEMY_AVAILABLE:
+    Base = declarative_base()
 
-class CacheTable(Base):
-    __tablename__ = "cachier_cache"
-    id = Column(String, primary_key=True)
-    function_id = Column(String, index=True, nullable=False)
-    key = Column(String, index=True, nullable=False)
-    value = Column(LargeBinary, nullable=True)
-    timestamp = Column(DateTime, nullable=False)
-    stale = Column(Boolean, default=False)
-    processing = Column(Boolean, default=False)
-    completed = Column(Boolean, default=False)
-    __table_args__ = (Index("ix_func_key", "function_id", "key", unique=True),)
+    class CacheTable(Base):
+        __tablename__ = "cachier_cache"
+        id = Column(String, primary_key=True)
+        function_id = Column(String, index=True, nullable=False)
+        key = Column(String, index=True, nullable=False)
+        value = Column(LargeBinary, nullable=True)
+        timestamp = Column(DateTime, nullable=False)
+        stale = Column(Boolean, default=False)
+        processing = Column(Boolean, default=False)
+        completed = Column(Boolean, default=False)
+        __table_args__ = (
+            Index("ix_func_key", "function_id", "key", unique=True),
+        )
 
 
 class _SQLCore(_BaseCore):
@@ -50,9 +64,14 @@ class _SQLCore(_BaseCore):
     def __init__(
         self,
         hash_func: Optional[HashFunc],
-        sql_engine: Optional[Union[str, Engine, Callable[[], Engine]]],
+        sql_engine: Optional[Union[str, "Engine", Callable[[], "Engine"]]],
         wait_for_calc_timeout: Optional[int] = None,
     ):
+        if not SQLALCHEMY_AVAILABLE:
+            raise ImportError(
+                "SQLAlchemy is required for the SQL core. "
+                "Install with `pip install SQLAlchemy`."
+            )
         super().__init__(
             hash_func=hash_func, wait_for_calc_timeout=wait_for_calc_timeout
         )

tests/requirements.txt

@@ -14,3 +14,4 @@ pandas
 collective.checkdocs
 pygments
 SQLAlchemy
+psycopg2-binary

tests/test_sql_core.py

@@ -3,18 +3,20 @@
 from datetime import timedelta
 from random import random
 from time import sleep
+import sys
+import os
 
 import pytest
 
 from cachier import cachier
 from cachier.cores.sql import _SQLCore
 
-SQLITE_MEMORY = "sqlite:///:memory:"
+SQL_CONN_STR = os.environ.get("SQLALCHEMY_DATABASE_URL", "sqlite:///:memory:")
 
 
 @pytest.mark.sql
 def test_sql_core_basic():
-    @cachier(backend="sql", sql_engine=SQLITE_MEMORY)
+    @cachier(backend="sql", sql_engine=SQL_CONN_STR)
     def f(x, y):
         return random() + x + y
 
@@ -34,7 +36,7 @@ def f(x, y):
 
 @pytest.mark.sql
 def test_sql_core_keywords():
-    @cachier(backend="sql", sql_engine=SQLITE_MEMORY)
+    @cachier(backend="sql", sql_engine=SQL_CONN_STR)
     def f(x, y):
         return random() + x + y
 
@@ -56,7 +58,7 @@ def f(x, y):
 def test_sql_stale_after():
     @cachier(
         backend="sql",
-        sql_engine=SQLITE_MEMORY,
+        sql_engine=SQL_CONN_STR,
         stale_after=timedelta(seconds=2),
         next_time=False,
     )
@@ -74,7 +76,7 @@ def f(x, y):
 
 @pytest.mark.sql
 def test_sql_overwrite_and_skip_cache():
-    @cachier(backend="sql", sql_engine=SQLITE_MEMORY)
+    @cachier(backend="sql", sql_engine=SQL_CONN_STR)
     def f(x):
         return random() + x
 
@@ -92,7 +94,7 @@ def f(x):
 
 @pytest.mark.sql
 def test_sql_concurrency():
-    @cachier(backend="sql", sql_engine=SQLITE_MEMORY)
+    @cachier(backend="sql", sql_engine=SQL_CONN_STR)
     def slow_func(x):
         sleep(1)
         return random() + x
@@ -119,7 +121,7 @@ def call():
 
 @pytest.mark.sql
 def test_sql_clear_being_calculated():
-    @cachier(backend="sql", sql_engine=SQLITE_MEMORY)
+    @cachier(backend="sql", sql_engine=SQL_CONN_STR)
     def slow_func(x):
         sleep(1)
         return random() + x
@@ -133,7 +135,7 @@ def slow_func(x):
 
 @pytest.mark.sql
 def test_sql_missing_entry():
-    @cachier(backend="sql", sql_engine=SQLITE_MEMORY)
+    @cachier(backend="sql", sql_engine=SQL_CONN_STR)
     def f(x):
         return x
 
@@ -144,7 +146,7 @@ def f(x):
 
 @pytest.mark.sql
 def test_sql_failed_write(monkeypatch):
-    @cachier(backend="sql", sql_engine=SQLITE_MEMORY)
+    @cachier(backend="sql", sql_engine=SQL_CONN_STR)
     def f(x):
         return x
 
@@ -159,3 +161,43 @@ def fail_set_entry(self, key, func_res):
     with pytest.raises(Exception):
         f(1)
     monkeypatch.setattr(_SQLCore, "set_entry", orig)
+
+
+@pytest.mark.sql
+def test_import_cachier_without_sqlalchemy(monkeypatch):
+    """Test that importing cachier works when SQLAlchemy is missing.
+
+    This should work unless SQL core is used."""
+    # Simulate SQLAlchemy not installed
+    modules_backup = sys.modules.copy()
+    sys.modules["sqlalchemy"] = None
+    sys.modules["sqlalchemy.orm"] = None
+    sys.modules["sqlalchemy.engine"] = None
+    try:
+        import importlib  # noqa: F401
+        import cachier  # noqa: F401
+
+        # Should import fine
+    finally:
+        sys.modules.clear()
+        sys.modules.update(modules_backup)
+
+
+@pytest.mark.sql
+def test_sqlcore_importerror_without_sqlalchemy(monkeypatch):
+    """Test that using SQL core without SQLAlchemy raises an ImportError."""
+    # Simulate SQLAlchemy not installed
+    modules_backup = sys.modules.copy()
+    sys.modules["sqlalchemy"] = None
+    sys.modules["sqlalchemy.orm"] = None
+    sys.modules["sqlalchemy.engine"] = None
+    try:
+        import importlib
+
+        sql_mod = importlib.import_module("cachier.cores.sql")
+        with pytest.raises(ImportError) as excinfo:
+            sql_mod._SQLCore(hash_func=None, sql_engine="sqlite:///:memory:")
+        assert "SQLAlchemy is required" in str(excinfo.value)
+    finally:
+        sys.modules.clear()
+        sys.modules.update(modules_backup)