fix: Resolved error with CI steps for coverage and test

Author: Daniel-Brai

.github/workflows/ci.yml

@@ -15,7 +15,7 @@ on:
     branches: [main]
 
 jobs:
-  test:
+  build-and-test:
     runs-on: ubuntu-latest
 
     steps:
@@ -32,48 +32,22 @@ jobs:
         with:
           python-version-file: ".python-version"
 
-
       - name: Build the project
         run: |
           docker compose build sqlnotify
 
       - name: Run tests
         run: make test
 
-      - name: Run tests with coverage
-        run: make test_coverage
-
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
-        with:
-          file: ./coverage.xml
-          fail_ci_if_error: true
-          token: ${{ secrets.CODECOV_TOKEN }}
-
-      - name: Compose down
-        run: docker compose down --remove-orphans
-
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-          cache-dependency-glob: uv.lock
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version-file: "3.14"
-
-      - name: Build the project
-        run: make build
+        run: make coverage
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
       - name: Publish to PyPI
         run: make publish
         env:
-          token: ${{ secrets.PYPI_TOKEN }}
+          PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
+
+      - name: Compose down
+        run: docker compose down --remove-orphans

Dockerfile

@@ -8,6 +8,7 @@ RUN apt-get update && apt-get install -y \
     gcc \
     build-essential \
     gettext \
+    gnupg \
     musl-dev \
     sqlite3 \
     && rm -rf /var/lib/apt/lists/*
@@ -23,6 +24,7 @@ ENV UV_COMPILE_BYTECODE=1
 RUN uv venv .venv
 ENV VIRTUAL_ENV=/app/.venv
 ENV PATH="/app/.venv/bin:$PATH"
+RUN pip install --no-cache-dir codecov-cli
 ENV PYTHONPATH=/app/
 ENV PYTHONUNBUFFERED=1
 

Makefile

@@ -1,6 +1,7 @@
 UV := uv
+CODECOV_CLI := codecovcli
 
-.PHONY: test test_unit test_sqlite test_postgres test_coverage test_all build publish release
+.PHONY: test build publish release coverage
 
 
 build:
@@ -11,41 +12,23 @@ build:
 
 publish:
 	@echo "Publishing to PyPI..."
-	@$(UV) publish -t $(token)
+	@$(UV) publish -t $(PYPI_TOKEN)
 	@echo "Published successfully"
 
 
+coverage:
+	@echo "Running coverage..."
+	@$(UV) run pytest --cov=sqlnotify --cov-report=xml
+	@$(CODECOV_CLI) upload-process -t $(CODECOV_TOKEN) -f coverage.xml
+	@echo "Coverage report generated at coverage.xml"
+
+
 release: build
 	@echo "Running release script..."
 	@bash scripts/release.sh $(ARGS)
 
 
-test_all: test test_coverage
-	@echo "All tests and coverage completed"
-
-test_coverage:
-	@echo "Running tests coverage for sqlnotify..."
-	@docker compose run --remove-orphans sqlnotify bash -c "$(UV) run pytest --cov=sqlnotify --cov-report=xml"
-	@echo "Test coverage report generated at coverage.xml"
-
-
-test: test_unit test_postgres test_sqlite
+test:
+	@echo "Running all tests for sqlnotify..."
+	@docker compose run --remove-orphans sqlnotify bash -c "$(UV) run pytest"
 	@echo "All tests completed"
-
-
-test_unit:
-	@echo "Running all unit tests for sqlnotify..."
-	@docker compose run --remove-orphans sqlnotify bash -c "$(UV) run pytest tests/test_watcher.py"
-	@echo "All Unit tests completed"
-
-
-test_sqlite:
-	@echo "Running tests for sqlnotify sqlite..."
-	@docker compose run --remove-orphans sqlnotify bash -c "$(UV) run pytest tests/test_sqlite_*.py --db=sqlite"
-	@echo "All SQLite tests completed"
-
-
-test_postgres:
-	@echo "Running tests for sqlnotify postgres..."
-	@docker compose run --remove-orphans sqlnotify bash -c "$(UV) run pytest tests/test_postgres_*.py --db=postgresql"
-	@echo "All PostgreSQL tests completed"

tests/conftest.py

@@ -11,47 +11,63 @@
 
 patch.dict(
     os.environ,
-    {
-        "POSTGRES_HOST": "postgres"
-    },
+    {"POSTGRES_HOST": "postgres"},
 ).start()  # noqa
 
 
-def pytest_addoption(parser):
-    parser.addoption(
-        "--db",
-        action="store",
-        default="postgresql",
-        help="Database type to use for tests: postgresql or sqlite",
-    )
+def pytest_collection_modifyitems(config, items):
+    required = set()
 
+    for item in items:
+        fname = os.path.basename(str(item.fspath)).lower()
+        if fname.startswith("test_sqlite"):
+            required.add("sqlite")
+        if fname.startswith("test_postgres") or fname.startswith("test_postgresql"):
+            required.add("postgresql")
 
-@pytest.fixture(scope="session")
+    if not required:
+        required.add(os.getenv("TEST_DB", "postgresql"))
+
+    config._required_db_types = required
+
+
+@pytest.fixture
 def db_type(request) -> str:
-    return request.config.getoption("--db")
+    fname = os.path.basename(str(request.node.fspath)).lower()
+    if fname.startswith("test_sqlite"):
+        return "sqlite"
+    if fname.startswith("test_postgres") or fname.startswith("test_postgresql"):
+        return "postgresql"
+    return os.getenv("TEST_DB", "postgresql")
 
 
 @pytest.fixture(scope="session")
-def database_manager(db_type: str) -> DatabaseManager:
-    return DatabaseManager(db_type=db_type)
+def database_manager() -> DatabaseManager:
+    return DatabaseManager()
 
 
 @pytest.fixture(scope="session", autouse=True)
-def manage_test_database(database_manager: DatabaseManager):
-    database_manager.create_test_database()
+def manage_test_database(request, database_manager: DatabaseManager):
+    required = getattr(request.config, "_required_db_types", None)
+    if not required:
+        required = {os.getenv("TEST_DB", "postgresql")}
+    for db in required:
+        database_manager.create_test_database(db_type=db)
 
     yield
 
-    database_manager.drop_test_database()
+    for db in required:
+        database_manager.drop_test_database(db_type=db)
 
 
-@pytest.fixture(scope="function")
+@pytest.fixture
 async def async_engine(
     database_manager: DatabaseManager,
+    db_type: str,
 ) -> AsyncGenerator[AsyncEngine, None]:
-    engine = database_manager.create_async_engine()
+    engine = database_manager.create_async_engine(db_type=db_type)
 
-    await database_manager.create_tables_async(engine)
+    await database_manager.create_tables_async(engine, db_type=db_type)
 
     yield engine
 
@@ -83,11 +99,13 @@ async def async_session_factory(async_engine: AsyncEngine):
     )
 
 
-@pytest.fixture(scope="session")
-def sync_engine(database_manager: DatabaseManager) -> Generator[Engine, None, None]:
-    engine = database_manager.create_sync_engine()
+@pytest.fixture(scope="function")
+def sync_engine(
+    database_manager: DatabaseManager, db_type: str
+) -> Generator[Engine, None, None]:
+    engine = database_manager.create_sync_engine(db_type=db_type)
 
-    database_manager.create_tables_sync(engine)
+    database_manager.create_tables_sync(engine, db_type=db_type)
 
     yield engine
 

tests/database.py

@@ -15,15 +15,18 @@
 
 class DatabaseManager:
 
-    def __init__(self, db_type: str = "postgresql"):
+    def __init__(self, db_type: str | None = None):
         self.db_type = db_type
         self._engine: Engine | AsyncEngine | None = None
         self._async_session_factory = None
         self._sync_session_factory = None
 
-    def get_database_url(self, async_driver: bool = False) -> str:
+    def get_database_url(
+        self, async_driver: bool = False, db_type: str | None = None
+    ) -> str:
+        db_type = db_type or self.db_type or os.getenv("TEST_DB", "postgresql")
 
-        if self.db_type == "sqlite":
+        if db_type == "sqlite":
             if async_driver:
                 return (
                     f"sqlite+aiosqlite:///{os.getenv('SQLITE_DB', 'test_sqlnotify.db')}"
@@ -44,8 +47,9 @@ def get_database_url(self, async_driver: bool = False) -> str:
 
             return f"postgresql+psycopg://{user}:{password}@{host}:{port}/{db_name}"
 
-    def get_base_connection_url(self) -> str:
-        if self.db_type == "sqlite":
+    def get_base_connection_url(self, db_type: str | None = None) -> str:
+        db_type = db_type or self.db_type or os.getenv("TEST_DB", "postgresql")
+        if db_type == "sqlite":
             return ""  # SQLite doesn't need base connection
 
         user = os.getenv("POSTGRES_USER", "postgres")
@@ -55,15 +59,16 @@ def get_base_connection_url(self) -> str:
 
         return f"postgresql+psycopg://{user}:{password}@{host}:{port}/postgres"
 
-    def create_test_database(self) -> None:
+    def create_test_database(self, db_type: str | None = None) -> None:
+        db_type = db_type or self.db_type or os.getenv("TEST_DB", "postgresql")
 
-        if self.db_type == "sqlite":
+        if db_type == "sqlite":
             return
 
         worker_id = os.environ.get("PYTEST_XDIST_WORKER", "master")
         db_name = f"{os.getenv('POSTGRES_DB', 'sqlnotify_test')}_{worker_id}"
 
-        base_url = self.get_base_connection_url()
+        base_url = self.get_base_connection_url(db_type=db_type)
         admin_engine = create_engine(base_url, isolation_level="AUTOCOMMIT")
 
         with admin_engine.connect() as conn:
@@ -72,9 +77,10 @@ def create_test_database(self) -> None:
 
         admin_engine.dispose()
 
-    def drop_test_database(self) -> None:
+    def drop_test_database(self, db_type: str | None = None) -> None:
+        db_type = db_type or self.db_type or os.getenv("TEST_DB", "postgresql")
 
-        if self.db_type == "sqlite":
+        if db_type == "sqlite":
             db_file = os.getenv("SQLITE_DB", "test_sqlnotify.db")
 
             if os.path.exists(db_file):
@@ -85,28 +91,29 @@ def drop_test_database(self) -> None:
         worker_id = os.environ.get("PYTEST_XDIST_WORKER", "master")
         db_name = f"{os.getenv('POSTGRES_DB', 'sqlnotify_test')}_{worker_id}"
 
-        base_url = self.get_base_connection_url()
+        base_url = self.get_base_connection_url(db_type=db_type)
         admin_engine = create_engine(base_url, isolation_level="AUTOCOMMIT")
 
         with admin_engine.connect() as conn:
             conn.execute(text(f"DROP DATABASE IF EXISTS {db_name} WITH (FORCE)"))
 
         admin_engine.dispose()
 
-    def create_async_engine(self) -> AsyncEngine:
-
-        url = self.get_database_url(async_driver=True)
+    def create_async_engine(self, db_type: str | None = None) -> AsyncEngine:
+        url = self.get_database_url(async_driver=True, db_type=db_type)
         return create_async_engine(url, echo=False)
 
-    def create_sync_engine(self) -> Engine:
-
-        url = self.get_database_url(async_driver=False)
+    def create_sync_engine(self, db_type: str | None = None) -> Engine:
+        url = self.get_database_url(async_driver=False, db_type=db_type)
         return create_engine(url, echo=False)
 
-    async def create_tables_async(self, engine: AsyncEngine) -> None:
+    async def create_tables_async(
+        self, engine: AsyncEngine, db_type: str | None = None
+    ) -> None:
+        db_type = db_type or self.db_type or os.getenv("TEST_DB", "postgresql")
 
         async with engine.begin() as conn:
-            if self.db_type == "sqlite":
+            if db_type == "sqlite":
 
                 def create_filtered_tables(connection):
                     tables_to_create = [
@@ -121,8 +128,9 @@ def create_filtered_tables(connection):
                 await conn.execute(text("CREATE SCHEMA IF NOT EXISTS analytics"))
                 await conn.run_sync(SQLModel.metadata.create_all)
 
-    def create_tables_sync(self, engine: Engine) -> None:
-        if self.db_type == "sqlite":
+    def create_tables_sync(self, engine: Engine, db_type: str | None = None) -> None:
+        db_type = db_type or self.db_type or os.getenv("TEST_DB", "postgresql")
+        if db_type == "sqlite":
             tables_to_create = [
                 table
                 for table in SQLModel.metadata.sorted_tables
@@ -135,10 +143,13 @@ def create_tables_sync(self, engine: Engine) -> None:
 
             SQLModel.metadata.create_all(engine)
 
-    async def drop_tables_async(self, engine: AsyncEngine) -> None:
+    async def drop_tables_async(
+        self, engine: AsyncEngine, db_type: str | None = None
+    ) -> None:
+        db_type = db_type or self.db_type or os.getenv("TEST_DB", "postgresql")
 
         async with engine.begin() as conn:
-            if self.db_type == "sqlite":
+            if db_type == "sqlite":
 
                 def drop_filtered_tables(connection):
                     tables_to_drop = [
@@ -152,8 +163,9 @@ def drop_filtered_tables(connection):
             else:
                 await conn.run_sync(SQLModel.metadata.drop_all)
 
-    def drop_tables_sync(self, engine: Engine) -> None:
-        if self.db_type == "sqlite":
+    def drop_tables_sync(self, engine: Engine, db_type: str | None = None) -> None:
+        db_type = db_type or self.db_type or os.getenv("TEST_DB", "postgresql")
+        if db_type == "sqlite":
             tables_to_drop = [
                 table
                 for table in SQLModel.metadata.sorted_tables

tests/test_postgres_dialect.py

@@ -33,7 +33,7 @@ def test_get_postgres_dialect_sync(self, sync_engine):
     def skip_if_not_postgres(self, db_type):
 
         if db_type != "postgresql":
-            pytest.skip("PostgreSQL functionality tests require --db=postgresql")
+            pytest.skip("PostgreSQL functionality tests require a postgresql test run")
 
     @pytest.fixture
     def watcher(self):