Rewrite all exceptions to more readable ones

Signed-off-by: chandr-andr (Kiselev Aleksandr) <chandr@chandr.net>

Author: chandr-andr

python/psqlpy/_internal/exceptions.pyi

@@ -1,11 +1,62 @@
 class RustPSQLDriverPyBaseError(Exception):
     """Base PSQL-Rust-Engine exception."""
 
-class DBPoolError(RustPSQLDriverPyBaseError):
-    """Error if something goes wrong with Database Pool.
+class BaseConnectionPoolError(RustPSQLDriverPyBaseError):
+    """Base error for all Connection Pool errors."""
 
-    It has verbose error message.
-    """
+class ConnectionPoolBuildError(BaseConnectionPoolError):
+    """Error for errors in building connection pool."""
+
+class ConnectionPoolConfigurationError(BaseConnectionPoolError):
+    """Error in connection pool configuration."""
+
+class ConnectionPoolExecuteError(BaseConnectionPoolError):
+    """Error in connection pool execution."""
+
+class DBPoolConfigurationError(RustPSQLDriverPyBaseError):
+    """Error if configuration of the database pool is unacceptable."""
+
+class BaseConnectionError(RustPSQLDriverPyBaseError):
+    """Base error for Connection errors."""
+
+class ConnectionExecuteError(BaseConnectionError):
+    """Error in connection execution."""
+
+class BaseTransactionError(RustPSQLDriverPyBaseError):
+    """Base error for all transaction errors."""
+
+class TransactionBeginError(BaseTransactionError):
+    """Error in transaction begin."""
+
+class TransactionCommitError(BaseTransactionError):
+    """Error in transaction commit."""
+
+class TransactionRollbackError(BaseTransactionError):
+    """Error in transaction rollback."""
+
+class TransactionSavepointError(BaseTransactionError):
+    """Error in transaction savepoint."""
+
+class TransactionExecuteError(BaseTransactionError):
+    """Error in transaction execution."""
+
+class BaseCursorError(RustPSQLDriverPyBaseError):
+    """Base error for Cursor errors."""
+
+class CursorStartError(BaseCursorError):
+    """Error in cursor declare."""
+
+class CursorCloseError(BaseCursorError):
+    """Error in cursor close."""
+
+class CursorFetchError(BaseCursorError):
+    """Error in cursor fetch (any fetch)."""
+
+class UUIDValueConvertError(RustPSQLDriverPyBaseError):
+    """Error if it's impossible to convert py string UUID into rust UUID."""
+
+class MacAddr6ConversionError(RustPSQLDriverPyBaseError):
+    """Error if cannot convert MacAddr6 string value to rust type."""
 
 class RustToPyValueMappingError(RustPSQLDriverPyBaseError):
     """Error if it is not possible to covert rust type to python.
@@ -22,21 +73,3 @@ class PyToRustValueMappingError(RustPSQLDriverPyBaseError):
     You can get this exception when executing queries with parameters.
     So, if there are no parameters for the query, don't handle this error.
     """
-
-class TransactionError(RustPSQLDriverPyBaseError):
-    """Error if something goes wrong with `Transaction`.
-
-    It has verbose error message.
-    """
-
-class DBPoolConfigurationError(RustPSQLDriverPyBaseError):
-    """Error if configuration of the database pool is unacceptable."""
-
-class UUIDValueConvertError(RustPSQLDriverPyBaseError):
-    """Error if it's impossible to convert py string UUID into rust UUID."""
-
-class CursorError(RustPSQLDriverPyBaseError):
-    """Error if something goes wrong with the cursor."""
-
-class MacAddr6ConversionError(RustPSQLDriverPyBaseError):
-    """Error if cannot convert MacAddr6 string value to rust type."""

python/psqlpy/exceptions.py

@@ -1,23 +1,49 @@
 from ._internal.exceptions import (
-    CursorError,
+    BaseConnectionError,
+    BaseConnectionPoolError,
+    BaseCursorError,
+    BaseTransactionError,
+    ConnectionExecuteError,
+    ConnectionPoolBuildError,
+    ConnectionPoolConfigurationError,
+    ConnectionPoolExecuteError,
+    CursorCloseError,
+    CursorFetchError,
+    CursorStartError,
     DBPoolConfigurationError,
-    DBPoolError,
     MacAddr6ConversionError,
     PyToRustValueMappingError,
     RustPSQLDriverPyBaseError,
     RustToPyValueMappingError,
-    TransactionError,
+    TransactionBeginError,
+    TransactionCommitError,
+    TransactionExecuteError,
+    TransactionRollbackError,
+    TransactionSavepointError,
     UUIDValueConvertError,
 )
 
 __all__ = [
+    "BaseConnectionPoolError",
+    "ConnectionPoolBuildError",
+    "ConnectionPoolConfigurationError",
+    "ConnectionPoolExecuteError",
+    "BaseConnectionError",
+    "ConnectionExecuteError",
+    "BaseTransactionError",
+    "TransactionBeginError",
+    "TransactionCommitError",
+    "TransactionRollbackError",
+    "TransactionSavepointError",
+    "TransactionExecuteError",
+    "BaseCursorError",
+    "CursorStartError",
+    "CursorCloseError",
+    "CursorFetchError",
     "RustPSQLDriverPyBaseError",
-    "DBPoolError",
     "RustToPyValueMappingError",
     "PyToRustValueMappingError",
-    "TransactionError",
     "DBPoolConfigurationError",
     "UUIDValueConvertError",
-    "CursorError",
     "MacAddr6ConversionError",
 ]

python/tests/test_connection.py

@@ -6,7 +6,7 @@
 from tests.helpers import count_rows_in_test_table
 
 from psqlpy import ConnectionPool, QueryResult, Transaction
-from psqlpy.exceptions import RustPSQLDriverPyBaseError, TransactionError
+from psqlpy.exceptions import ConnectionExecuteError, TransactionExecuteError
 
 pytestmark = pytest.mark.anyio
 
@@ -72,7 +72,7 @@ async def test_connection_execute_many(
             f"INSERT INTO {table_name} VALUES ($1, $2)",
             insert_values,
         )
-    except TransactionError:
+    except TransactionExecuteError:
         assert not insert_values
     else:
         assert await count_rows_in_test_table(
@@ -99,7 +99,7 @@ async def test_connection_fetch_row_more_than_one_row(
     table_name: str,
 ) -> None:
     connection = await psql_pool.connection()
-    with pytest.raises(RustPSQLDriverPyBaseError):
+    with pytest.raises(ConnectionExecuteError):
         await connection.fetch_row(
             f"SELECT * FROM  {table_name}",
             [],
@@ -123,7 +123,7 @@ async def test_connection_fetch_val_more_than_one_row(
     table_name: str,
 ) -> None:
     connection = await psql_pool.connection()
-    with pytest.raises(RustPSQLDriverPyBaseError):
+    with pytest.raises(ConnectionExecuteError):
         await connection.fetch_row(
             f"SELECT * FROM  {table_name}",
             [],

python/tests/test_transaction.py

@@ -6,7 +6,12 @@
 from tests.helpers import count_rows_in_test_table
 
 from psqlpy import ConnectionPool, Cursor, IsolationLevel, ReadVariant
-from psqlpy.exceptions import RustPSQLDriverPyBaseError, TransactionError
+from psqlpy.exceptions import (
+    RustPSQLDriverPyBaseError,
+    TransactionBeginError,
+    TransactionExecuteError,
+    TransactionSavepointError,
+)
 
 pytestmark = pytest.mark.anyio
 
@@ -55,7 +60,7 @@ async def test_transaction_begin(
     connection = await psql_pool.connection()
     transaction = connection.transaction()
 
-    with pytest.raises(expected_exception=TransactionError):
+    with pytest.raises(expected_exception=TransactionBeginError):
         await transaction.execute(
             f"SELECT * FROM {table_name}",
         )
@@ -157,7 +162,7 @@ async def test_transaction_rollback(
 
     await transaction.rollback()
 
-    with pytest.raises(expected_exception=TransactionError):
+    with pytest.raises(expected_exception=TransactionBeginError):
         await transaction.execute(
             f"SELECT * FROM {table_name} WHERE name = $1",
             parameters=[test_name],
@@ -184,7 +189,7 @@ async def test_transaction_release_savepoint(
 
     await transaction.create_savepoint(sp_name_1)
 
-    with pytest.raises(expected_exception=TransactionError):
+    with pytest.raises(expected_exception=TransactionSavepointError):
         await transaction.create_savepoint(sp_name_1)
 
     await transaction.create_savepoint(sp_name_2)
@@ -242,7 +247,7 @@ async def test_transaction_execute_many(
                 f"INSERT INTO {table_name} VALUES ($1, $2)",
                 insert_values,
             )
-        except TransactionError:
+        except TransactionExecuteError:
             assert not insert_values
         else:
             assert await count_rows_in_test_table(

src/exceptions/python_errors.rs

@@ -85,7 +85,11 @@ create_exception!(
 );
 
 // Cursor exceptions
-create_exception!(psqlpy.exceptions, BaseCursorError, BaseTransactionError);
+create_exception!(
+    psqlpy.exceptions,
+    BaseCursorError,
+    RustPSQLDriverPyBaseError
+);
 create_exception!(psqlpy.exceptions, CursorStartError, BaseCursorError);
 create_exception!(psqlpy.exceptions, CursorCloseError, BaseCursorError);
 create_exception!(psqlpy.exceptions, CursorFetchError, BaseCursorError);
@@ -115,7 +119,7 @@ create_exception!(
 
 create_exception!(
     psqlpy.exceptions,
-    MacAddr6ConversionError,
+    MacAddrConversionError,
     RustPSQLDriverPyBaseError
 );
 
@@ -131,6 +135,63 @@ pub fn python_exceptions_module(py: Python<'_>, pymod: &Bound<'_, PyModule>) ->
         "RustPSQLDriverPyBaseError",
         py.get_type_bound::<RustPSQLDriverPyBaseError>(),
     )?;
+
+    pymod.add(
+        "BaseConnectionPoolError",
+        py.get_type_bound::<BaseConnectionPoolError>(),
+    )?;
+    pymod.add(
+        "ConnectionPoolBuildError",
+        py.get_type_bound::<ConnectionPoolBuildError>(),
+    )?;
+    pymod.add(
+        "ConnectionPoolConfigurationError",
+        py.get_type_bound::<ConnectionPoolConfigurationError>(),
+    )?;
+    pymod.add(
+        "ConnectionPoolExecuteError",
+        py.get_type_bound::<ConnectionPoolExecuteError>(),
+    )?;
+
+    pymod.add(
+        "BaseConnectionError",
+        py.get_type_bound::<BaseConnectionError>(),
+    )?;
+    pymod.add(
+        "ConnectionExecuteError",
+        py.get_type_bound::<ConnectionExecuteError>(),
+    )?;
+
+    pymod.add(
+        "BaseTransactionError",
+        py.get_type_bound::<BaseTransactionError>(),
+    )?;
+    pymod.add(
+        "TransactionBeginError",
+        py.get_type_bound::<TransactionBeginError>(),
+    )?;
+    pymod.add(
+        "TransactionCommitError",
+        py.get_type_bound::<TransactionCommitError>(),
+    )?;
+    pymod.add(
+        "TransactionRollbackError",
+        py.get_type_bound::<TransactionRollbackError>(),
+    )?;
+    pymod.add(
+        "TransactionSavepointError",
+        py.get_type_bound::<TransactionSavepointError>(),
+    )?;
+    pymod.add(
+        "TransactionExecuteError",
+        py.get_type_bound::<TransactionExecuteError>(),
+    )?;
+
+    pymod.add("BaseCursorError", py.get_type_bound::<BaseCursorError>())?;
+    pymod.add("CursorStartError", py.get_type_bound::<CursorStartError>())?;
+    pymod.add("CursorCloseError", py.get_type_bound::<CursorCloseError>())?;
+    pymod.add("CursorFetchError", py.get_type_bound::<CursorFetchError>())?;
+
     pymod.add(
         "RustToPyValueMappingError",
         py.get_type_bound::<RustToPyValueMappingError>(),
@@ -149,11 +210,11 @@ pub fn python_exceptions_module(py: Python<'_>, pymod: &Bound<'_, PyModule>) ->
     )?;
     pymod.add(
         "MacAddr6ConversionError",
-        py.get_type_bound::<MacAddr6ConversionError>(),
+        py.get_type_bound::<MacAddrConversionError>(),
     )?;
     pymod.add(
         "RustRuntimeJoinError",
-        py.get_type_bound::<MacAddr6ConversionError>(),
+        py.get_type_bound::<MacAddrConversionError>(),
     )?;
     Ok(())
 }