Merge pull request #1 from qaspen-python/feature/add_tests

Added tests and test actions

Author: chandr-andr

.github/workflows/CI.yml .github/workflows/release.yml.github/workflows/CI.yml renamed to .github/workflows/release.yml

@@ -2,13 +2,8 @@ name: CI
 
 on:
   push:
-    branches:
-      - main
-      - master
     tags:
       - '*'
-  pull_request:
-  workflow_dispatch:
 
 permissions:
   contents: read

.github/workflows/test.yaml

@@ -0,0 +1,85 @@
+name: 'Testing package'
+
+on:
+  pull_request:
+
+jobs:
+  py-lint:
+    strategy:
+      matrix:
+        cmd:
+          - black
+          - isort
+          - ruff
+          - mypy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.12"
+      - name: Run lint check
+        uses: pre-commit/action@v3.0.0
+        with:
+          extra_args: -a ${{ matrix.cmd }}
+  fmt:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        components: rustfmt
+        override: true
+    - name: Check code format
+      run: cargo fmt -- --check --config use_try_shorthand=true,imports_granularity=Crate
+
+  clippy:
+    permissions:
+      checks: write
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        components: clippy
+        override: true
+    - uses: actions-rs/clippy-check@v1
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        args: -p psqlpy --all-features -- -W clippy::all -W clippy::pedantic -D warnings
+  pytest:
+    name: ${{matrix.job.os}}-${{matrix.py_version}}
+    strategy:
+      matrix:
+        py_version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        job:
+            - os: ubuntu-latest
+              ssl_cmd: sudo apt-get update && sudo apt-get install libssl-dev openssl
+    runs-on: ${{matrix.job.os}}
+    steps:
+    - uses: actions/checkout@v1
+    - uses: ikalnytskyi/action-setup-postgres@v4
+      with:
+        username: postgres
+        password: postgres
+        database: psqlpy_test
+      id: postgres
+    - uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        components: clippy
+        override: true
+    - name: Setup OpenSSL
+      run: ${{matrix.job.ssl_cmd}}
+    - name: Setup python for test ${{ matrix.py_version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.py_version }}
+    - name: Install tox
+      run: pip install "tox-gh>=1.2,<2"
+    - name: Run pytest
+      run: tox -v
+

pyproject.toml

@@ -101,7 +101,7 @@ ignore = [
 ]
 exclude = [".venv/"]
 mccabe = { max-complexity = 10 }
-line-length = 88
+line-length = 79
 
 [tool.ruff.per-file-ignores]
 "python/psqlpy/*" = ["PYI021"]

python/psqlpy/__init__.py

@@ -1,9 +1,19 @@
-from ._internal import IsolationLevel, PSQLPool, QueryResult, ReadVariant, Transaction
+from ._internal import (
+    Connection,
+    Cursor,
+    IsolationLevel,
+    PSQLPool,
+    QueryResult,
+    ReadVariant,
+    Transaction,
+)
 
 __all__ = [
     "PSQLPool",
     "QueryResult",
     "Transaction",
     "IsolationLevel",
     "ReadVariant",
+    "Connection",
+    "Cursor",
 ]

python/psqlpy/_internal/__init__.pyi

@@ -1,3 +1,4 @@
+import types
 from enum import Enum
 from typing import Any, Dict, List, Optional
 
@@ -153,6 +154,13 @@ class Transaction:
     `.transaction()`.
     """
 
+    async def __aenter__(self: Self) -> Self: ...
+    async def __aexit__(
+        self: Self,
+        exception_type: type[BaseException] | None,
+        exception: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> None: ...
     async def begin(self: Self) -> None:
         """Start the transaction.
 
@@ -492,7 +500,8 @@ class PSQLPool:
                 [100],
             )
             dict_result: List[Dict[Any, Any]] = query_result.result()
-            # you don't need to close the pool, it will be dropped on Rust side.
+            # you don't need to close the pool,
+            # it will be dropped on Rust side.
         ```
         """
     async def connection(self: Self) -> Connection:

python/psqlpy/exceptions.py

@@ -18,4 +18,5 @@
     "DBPoolConfigurationError",
     "UUIDValueConvertError",
     "CursorError",
+    "DBTransactionError",
 ]

python/tests/conftest.py

@@ -1,7 +1,13 @@
+import os
+import random
+from typing import AsyncGenerator
+
 import pytest
 
+from psqlpy import PSQLPool
+
 
-@pytest.fixture(scope="session")
+@pytest.fixture()
 def anyio_backend() -> str:
     """
     Anyio backend.
@@ -10,3 +16,83 @@ def anyio_backend() -> str:
     :return: backend name.
     """
     return "asyncio"
+
+
+def random_string(length: int = 10) -> str:
+    return "".join(random.choice("AbCdEfG") for _ in range(length))
+
+
+@pytest.fixture()
+def postgres_host() -> str:
+    return os.environ.get("POSTGRES_HOST", "localhost")
+
+
+@pytest.fixture()
+def postgres_user() -> str:
+    return os.environ.get("POSTGRES_USER", "postgres")
+
+
+@pytest.fixture()
+def postgres_password() -> str:
+    return os.environ.get("POSTGRES_PASSWORD", "postgres")
+
+
+@pytest.fixture()
+def postgres_port() -> int:
+    return int(os.environ.get("POSTGRES_PORT", 5432))
+
+
+@pytest.fixture()
+def postgres_dbname() -> str:
+    return os.environ.get("POSTGRES_DBNAME", "psqlpy_test")
+
+
+@pytest.fixture()
+def table_name() -> str:
+    return random_string()
+
+
+@pytest.fixture()
+def number_database_records() -> int:
+    return random.randint(10, 35)
+
+
+@pytest.fixture()
+async def psql_pool(
+    postgres_host: str,
+    postgres_user: str,
+    postgres_password: str,
+    postgres_port: int,
+    postgres_dbname: str,
+) -> AsyncGenerator[PSQLPool, None]:
+    pg_pool = PSQLPool(
+        username=postgres_user,
+        password=postgres_password,
+        host=postgres_host,
+        port=postgres_port,
+        db_name=postgres_dbname,
+    )
+    await pg_pool.startup()
+    yield pg_pool
+
+
+@pytest.fixture(autouse=True)
+async def create_deafult_data_for_tests(
+    psql_pool: PSQLPool,
+    table_name: str,
+    number_database_records: int,
+) -> AsyncGenerator[None, None]:
+    await psql_pool.execute(
+        f"CREATE TABLE {table_name} (id SERIAL, name VARCHAR(255))",
+    )
+
+    for table_id in range(1, number_database_records + 1):
+        new_name = random_string()
+        await psql_pool.execute(
+            querystring=f"INSERT INTO {table_name} VALUES ($1, $2)",
+            parameters=[table_id, new_name],
+        )
+    yield
+    await psql_pool.execute(
+        f"DROP TABLE {table_name}",
+    )

python/tests/test_connection.py

@@ -0,0 +1,30 @@
+import pytest
+
+from psqlpy import PSQLPool, QueryResult, Transaction
+
+
+@pytest.mark.anyio
+async def test_connection_execute(
+    psql_pool: PSQLPool,
+    table_name: str,
+    number_database_records: int,
+) -> None:
+    """Test that single connection can execute queries."""
+    connection = await psql_pool.connection()
+
+    conn_result = await connection.execute(
+        querystring=f"SELECT * FROM {table_name}",
+    )
+    assert isinstance(conn_result, QueryResult)
+    assert len(conn_result.result()) == number_database_records
+
+
+@pytest.mark.anyio
+async def test_connection_transaction(
+    psql_pool: PSQLPool,
+) -> None:
+    """Test that connection can create transactions."""
+    connection = await psql_pool.connection()
+    transaction = connection.transaction()
+
+    assert isinstance(transaction, Transaction)

python/tests/test_connection_pool.py

@@ -0,0 +1,30 @@
+import pytest
+
+from psqlpy import Connection, PSQLPool, QueryResult
+
+
+@pytest.mark.anyio
+async def test_pool_execute(
+    psql_pool: PSQLPool,
+    table_name: str,
+    number_database_records: int,
+) -> None:
+    """Test that PSQLPool can execute queries."""
+    select_result = await psql_pool.execute(
+        f"SELECT * FROM {table_name}",
+    )
+
+    assert type(select_result) == QueryResult
+
+    inner_result = select_result.result()
+    assert isinstance(inner_result, list)
+    assert len(inner_result) == number_database_records
+
+
+@pytest.mark.anyio
+async def test_pool_connection(
+    psql_pool: PSQLPool,
+) -> None:
+    """Test that PSQLPool can return single connection from the pool."""
+    connection = await psql_pool.connection()
+    assert isinstance(connection, Connection)

python/tests/test_cursor.py

@@ -0,0 +1,19 @@
+import pytest
+
+from psqlpy import PSQLPool
+
+
+@pytest.mark.anyio
+async def test_cursor_fetch(
+    psql_pool: PSQLPool,
+    table_name: str,
+    number_database_records: int,
+) -> None:
+    connection = await psql_pool.connection()
+    transaction = connection.transaction()
+    await transaction.begin()
+    await transaction.cursor(
+        querystring=f"SELECT * FROM {table_name}",
+    )
+
+    await transaction.commit()