sql-testing-library 0.11.0__tar.gz → 0.12.0__tar.gz

{sql_testing_library-0.11.0 → sql_testing_library-0.12.0}/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.12.0 (2025-06-25)
+
+### Feat
+
+- **athena/trino**: add support for struct/ROW types (#102)
+- **snowflake**: add key-pair authentication for MFA support (#103)
+
 ## 0.11.0 (2025-06-16)
 
 ### Feat

{sql_testing_library-0.11.0 → sql_testing_library-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sql-testing-library
-Version: 0.11.0
+Version: 0.12.0
 Summary: A powerful Python framework for unit testing SQL queries across BigQuery, Snowflake, Redshift, Athena, and Trino with mock data
 License: MIT
 Keywords: sql,testing,unit-testing,mock-data,database-testing,bigquery,snowflake,redshift,athena,trino,data-engineering,etl-testing,sql-validation,query-testing
@@ -137,16 +137,16 @@ The library supports different data types across database engines. All checkmark
 | **Decimal Array** | `List[Decimal]` | ✅ | ✅ | ✅ | ✅ | ✅ |
 | **Optional Array** | `Optional[List[T]]` | ✅ | ✅ | ✅ | ✅ | ✅ |
 | **Map/Dict** | `Dict[K, V]` | ✅ | ✅ | ✅ | ✅ | ✅ |
-| **Struct/Record** | `dataclass` | ❌ | ❌ | ❌ | ❌ | ❌ |
+| **Struct/Record** | `dataclass` | ❌ | ✅ | ❌ | ✅ | ❌ |
 | **Nested Arrays** | `List[List[T]]` | ❌ | ❌ | ❌ | ❌ | ❌ |
 
 ### Database-Specific Notes
 
-- **BigQuery**: NULL arrays become empty arrays `[]`; uses scientific notation for large decimals; dict/map types stored as JSON strings
-- **Athena**: 256KB query size limit; supports arrays and maps using `ARRAY[]` and `MAP(ARRAY[], ARRAY[])` syntax
-- **Redshift**: Arrays and maps implemented via SUPER type (JSON parsing); 16MB query size limit
-- **Trino**: Memory catalog for testing; excellent decimal precision; supports arrays and maps
-- **Snowflake**: Column names normalized to lowercase; 1MB query size limit; dict/map types implemented via VARIANT type (JSON parsing)
+- **BigQuery**: NULL arrays become empty arrays `[]`; uses scientific notation for large decimals; dict/map types stored as JSON strings; struct types not yet supported
+- **Athena**: 256KB query size limit; supports arrays and maps using `ARRAY[]` and `MAP(ARRAY[], ARRAY[])` syntax; supports struct types using `ROW` with named fields (dataclasses and Pydantic models)
+- **Redshift**: Arrays and maps implemented via SUPER type (JSON parsing); 16MB query size limit; struct types not yet supported
+- **Trino**: Memory catalog for testing; excellent decimal precision; supports arrays, maps, and struct types using `ROW` with named fields (dataclasses and Pydantic models)
+- **Snowflake**: Column names normalized to lowercase; 1MB query size limit; dict/map types implemented via VARIANT type (JSON parsing); struct types not yet supported
 
 ## Execution Modes Support
 
@@ -399,11 +399,18 @@ credentials_path = <path to credentials json>
 # [sql_testing.snowflake]
 # account = <account-identifier>
 # user = <snowflake_user>
-# password = <snowflake_password>
 # database = <test_database>
 # schema = <PUBLIC>  # Optional: default schema is 'PUBLIC'
 # warehouse = <compute_wh>  # Required: specify a warehouse
 # role = <role_name>  # Optional: specify a role
+#
+# # Authentication (choose one):
+# # Option 1: Key-pair authentication (recommended for MFA)
+# private_key_path = </path/to/private_key.pem>
+# # Or use environment variable SNOWFLAKE_PRIVATE_KEY
+#
+# # Option 2: Password authentication (for accounts without MFA)
+# password = <snowflake_password>
 ```
 
 ### Database Context Understanding
@@ -565,6 +572,125 @@ def test_pattern_3():
     )
 ```
 
+### Working with Struct Types (Athena and Trino)
+
+The library supports struct/record types using Python dataclasses or Pydantic models for Athena and Trino:
+
+```python
+from dataclasses import dataclass
+from decimal import Decimal
+from pydantic import BaseModel
+from sql_testing_library import sql_test, TestCase
+from sql_testing_library.mock_table import BaseMockTable
+
+# Define nested structs using dataclasses
+@dataclass
+class Address:
+    street: str
+    city: str
+    state: str
+    zip_code: str
+
+@dataclass
+class Employee:
+    id: int
+    name: str
+    salary: Decimal
+    address: Address  # Nested struct
+    is_active: bool = True
+
+# Or use Pydantic models
+class AddressPydantic(BaseModel):
+    street: str
+    city: str
+    state: str
+    zip_code: str
+
+class EmployeeResultPydantic(BaseModel):
+    id: int
+    name: str
+    city: str  # Extracted from nested struct
+
+# Mock table with struct data
+class EmployeesMockTable(BaseMockTable):
+    def get_database_name(self) -> str:
+        return "test_db"
+
+    def get_table_name(self) -> str:
+        return "employees"
+
+# Test with struct types
+@sql_test(
+    adapter_type="athena",  # or "trino"
+    mock_tables=[
+        EmployeesMockTable([
+            Employee(
+                id=1,
+                name="Alice Johnson",
+                salary=Decimal("120000.00"),
+                address=Address(
+                    street="123 Tech Lane",
+                    city="San Francisco",
+                    state="CA",
+                    zip_code="94105"
+                ),
+                is_active=True
+            ),
+            Employee(
+                id=2,
+                name="Bob Smith",
+                salary=Decimal("95000.00"),
+                address=Address(
+                    street="456 Oak Ave",
+                    city="New York",
+                    state="NY",
+                    zip_code="10001"
+                ),
+                is_active=False
+            )
+        ])
+    ],
+    result_class=EmployeeResultPydantic
+)
+def test_struct_with_dot_notation():
+    return TestCase(
+        query="""
+            SELECT
+                id,
+                name,
+                address.city as city  -- Access nested field with dot notation
+            FROM employees
+            WHERE address.state = 'CA'  -- Use struct fields in WHERE clause
+        """,
+        default_namespace="test_db"
+    )
+
+# You can also query entire structs
+@sql_test(
+    adapter_type="trino",
+    mock_tables=[EmployeesMockTable([...])],
+    result_class=dict  # Returns full struct as dict
+)
+def test_query_full_struct():
+    return TestCase(
+        query="SELECT id, name, address FROM employees",
+        default_namespace="test_db"
+    )
+```
+
+**Struct Type Features:**
+- **Nested Structures**: Support for deeply nested structs using dataclasses or Pydantic models
+- **Dot Notation**: Access struct fields using `struct.field` syntax in queries
+- **Type Safety**: Full type conversion between Python objects and SQL ROW types
+- **NULL Handling**: Proper handling of optional struct fields
+- **WHERE Clause**: Use struct fields in filtering conditions
+- **List of Structs**: Full support for `List[StructType]` with array operations
+
+**SQL Type Mapping:**
+- Python dataclass/Pydantic model → SQL `ROW(field1 type1, field2 type2, ...)`
+- Nested structs are fully supported
+- All struct values are properly cast to ensure type consistency
+
 3. **Run with pytest**:
 
 ```bash

{sql_testing_library-0.11.0 → sql_testing_library-0.12.0}/README.md

@@ -80,16 +80,16 @@ The library supports different data types across database engines. All checkmark
 | **Decimal Array** | `List[Decimal]` | ✅ | ✅ | ✅ | ✅ | ✅ |
 | **Optional Array** | `Optional[List[T]]` | ✅ | ✅ | ✅ | ✅ | ✅ |
 | **Map/Dict** | `Dict[K, V]` | ✅ | ✅ | ✅ | ✅ | ✅ |
-| **Struct/Record** | `dataclass` | ❌ | ❌ | ❌ | ❌ | ❌ |
+| **Struct/Record** | `dataclass` | ❌ | ✅ | ❌ | ✅ | ❌ |
 | **Nested Arrays** | `List[List[T]]` | ❌ | ❌ | ❌ | ❌ | ❌ |
 
 ### Database-Specific Notes
 
-- **BigQuery**: NULL arrays become empty arrays `[]`; uses scientific notation for large decimals; dict/map types stored as JSON strings
-- **Athena**: 256KB query size limit; supports arrays and maps using `ARRAY[]` and `MAP(ARRAY[], ARRAY[])` syntax
-- **Redshift**: Arrays and maps implemented via SUPER type (JSON parsing); 16MB query size limit
-- **Trino**: Memory catalog for testing; excellent decimal precision; supports arrays and maps
-- **Snowflake**: Column names normalized to lowercase; 1MB query size limit; dict/map types implemented via VARIANT type (JSON parsing)
+- **BigQuery**: NULL arrays become empty arrays `[]`; uses scientific notation for large decimals; dict/map types stored as JSON strings; struct types not yet supported
+- **Athena**: 256KB query size limit; supports arrays and maps using `ARRAY[]` and `MAP(ARRAY[], ARRAY[])` syntax; supports struct types using `ROW` with named fields (dataclasses and Pydantic models)
+- **Redshift**: Arrays and maps implemented via SUPER type (JSON parsing); 16MB query size limit; struct types not yet supported
+- **Trino**: Memory catalog for testing; excellent decimal precision; supports arrays, maps, and struct types using `ROW` with named fields (dataclasses and Pydantic models)
+- **Snowflake**: Column names normalized to lowercase; 1MB query size limit; dict/map types implemented via VARIANT type (JSON parsing); struct types not yet supported
 
 ## Execution Modes Support
 
@@ -342,11 +342,18 @@ credentials_path = <path to credentials json>
 # [sql_testing.snowflake]
 # account = <account-identifier>
 # user = <snowflake_user>
-# password = <snowflake_password>
 # database = <test_database>
 # schema = <PUBLIC>  # Optional: default schema is 'PUBLIC'
 # warehouse = <compute_wh>  # Required: specify a warehouse
 # role = <role_name>  # Optional: specify a role
+#
+# # Authentication (choose one):
+# # Option 1: Key-pair authentication (recommended for MFA)
+# private_key_path = </path/to/private_key.pem>
+# # Or use environment variable SNOWFLAKE_PRIVATE_KEY
+#
+# # Option 2: Password authentication (for accounts without MFA)
+# password = <snowflake_password>
 ```
 
 ### Database Context Understanding
@@ -508,6 +515,125 @@ def test_pattern_3():
     )
 ```
 
+### Working with Struct Types (Athena and Trino)
+
+The library supports struct/record types using Python dataclasses or Pydantic models for Athena and Trino:
+
+```python
+from dataclasses import dataclass
+from decimal import Decimal
+from pydantic import BaseModel
+from sql_testing_library import sql_test, TestCase
+from sql_testing_library.mock_table import BaseMockTable
+
+# Define nested structs using dataclasses
+@dataclass
+class Address:
+    street: str
+    city: str
+    state: str
+    zip_code: str
+
+@dataclass
+class Employee:
+    id: int
+    name: str
+    salary: Decimal
+    address: Address  # Nested struct
+    is_active: bool = True
+
+# Or use Pydantic models
+class AddressPydantic(BaseModel):
+    street: str
+    city: str
+    state: str
+    zip_code: str
+
+class EmployeeResultPydantic(BaseModel):
+    id: int
+    name: str
+    city: str  # Extracted from nested struct
+
+# Mock table with struct data
+class EmployeesMockTable(BaseMockTable):
+    def get_database_name(self) -> str:
+        return "test_db"
+
+    def get_table_name(self) -> str:
+        return "employees"
+
+# Test with struct types
+@sql_test(
+    adapter_type="athena",  # or "trino"
+    mock_tables=[
+        EmployeesMockTable([
+            Employee(
+                id=1,
+                name="Alice Johnson",
+                salary=Decimal("120000.00"),
+                address=Address(
+                    street="123 Tech Lane",
+                    city="San Francisco",
+                    state="CA",
+                    zip_code="94105"
+                ),
+                is_active=True
+            ),
+            Employee(
+                id=2,
+                name="Bob Smith",
+                salary=Decimal("95000.00"),
+                address=Address(
+                    street="456 Oak Ave",
+                    city="New York",
+                    state="NY",
+                    zip_code="10001"
+                ),
+                is_active=False
+            )
+        ])
+    ],
+    result_class=EmployeeResultPydantic
+)
+def test_struct_with_dot_notation():
+    return TestCase(
+        query="""
+            SELECT
+                id,
+                name,
+                address.city as city  -- Access nested field with dot notation
+            FROM employees
+            WHERE address.state = 'CA'  -- Use struct fields in WHERE clause
+        """,
+        default_namespace="test_db"
+    )
+
+# You can also query entire structs
+@sql_test(
+    adapter_type="trino",
+    mock_tables=[EmployeesMockTable([...])],
+    result_class=dict  # Returns full struct as dict
+)
+def test_query_full_struct():
+    return TestCase(
+        query="SELECT id, name, address FROM employees",
+        default_namespace="test_db"
+    )
+```
+
+**Struct Type Features:**
+- **Nested Structures**: Support for deeply nested structs using dataclasses or Pydantic models
+- **Dot Notation**: Access struct fields using `struct.field` syntax in queries
+- **Type Safety**: Full type conversion between Python objects and SQL ROW types
+- **NULL Handling**: Proper handling of optional struct fields
+- **WHERE Clause**: Use struct fields in filtering conditions
+- **List of Structs**: Full support for `List[StructType]` with array operations
+
+**SQL Type Mapping:**
+- Python dataclass/Pydantic model → SQL `ROW(field1 type1, field2 type2, ...)`
+- Nested structs are fully supported
+- All struct values are properly cast to ensure type consistency
+
 3. **Run with pytest**:
 
 ```bash

{sql_testing_library-0.11.0 → sql_testing_library-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "sql-testing-library"
-version = "0.11.0"
+version = "0.12.0"
 description = "A powerful Python framework for unit testing SQL queries across BigQuery, Snowflake, Redshift, Athena, and Trino with mock data"
 authors = ["Gurmeet Saran <gurmeetx@gmail.com>", "Kushal Thakkar <kushal.thakkar@gmail.com>"]
 maintainers = ["Gurmeet Saran <gurmeetx@gmail.com>", "Kushal Thakkar <kushal.thakkar@gmail.com>"]
@@ -193,6 +193,8 @@ unfixable = ["T201", "T203"]
 # Allow print statements in test files for debugging and output
 "tests/test_*.py" = ["T201"]
 "tests/*/test_*.py" = ["T201"]
+# Allow print statements in example files
+"examples/*.py" = ["T201"]
 
 [tool.ruff.lint.isort]
 lines-after-imports = 2

{sql_testing_library-0.11.0 → sql_testing_library-0.12.0}/src/sql_testing_library/_adapters/presto.py

@@ -6,7 +6,7 @@ from decimal import Decimal
 from typing import Any, List, Tuple, Type, Union, get_args
 
 from .._mock_table import BaseMockTable
-from .._types import BaseTypeConverter
+from .._types import BaseTypeConverter, is_struct_type
 from .base import DatabaseAdapter
 
 
@@ -78,6 +78,8 @@ class PrestoBaseAdapter(DatabaseAdapter):
 
     def _get_sql_type(self, python_type: Type) -> str:
         """Convert Python type to SQL type string."""
+        from .._sql_utils import get_sql_type_string
+
         # Handle Optional types
         if hasattr(python_type, "__origin__") and python_type.__origin__ is Union:
             # Extract the non-None type from Optional[T]
@@ -85,10 +87,14 @@ class PrestoBaseAdapter(DatabaseAdapter):
             if non_none_types:
                 python_type = non_none_types[0]
 
+        # Handle struct types (dataclass or Pydantic model)
+        if is_struct_type(python_type):
+            return get_sql_type_string(python_type, self.get_sqlglot_dialect())
+
         # Handle List types
         if hasattr(python_type, "__origin__") and python_type.__origin__ is list:
             element_type = get_args(python_type)[0] if get_args(python_type) else str
-            element_sql_type = self.TYPE_MAPPING.get(element_type, "VARCHAR")
+            element_sql_type = self._get_sql_type(element_type)  # Recursive call for nested types
             return f"ARRAY({element_sql_type})"
 
         # Handle Dict/Map types
@@ -96,12 +102,20 @@ class PrestoBaseAdapter(DatabaseAdapter):
             type_args = get_args(python_type)
             key_type = type_args[0] if type_args else str
             value_type = type_args[1] if len(type_args) > 1 else str
-            key_sql_type = self.TYPE_MAPPING.get(key_type, "VARCHAR")
-            value_sql_type = self.TYPE_MAPPING.get(value_type, "VARCHAR")
+            key_sql_type = self._get_sql_type(key_type)  # Recursive call for nested types
+            value_sql_type = self._get_sql_type(value_type)  # Recursive call for nested types
             return f"MAP({key_sql_type}, {value_sql_type})"
 
-        # Regular types
-        return self.TYPE_MAPPING.get(python_type, "VARCHAR")
+        # Regular types - use the mapping
+        dialect = self.get_sqlglot_dialect()
+        return get_sql_type_string(python_type, dialect)
+
+    def _get_struct_sql_type(self, struct_type: Type) -> str:
+        """Get SQL ROW type definition for a struct (dataclass or Pydantic model)."""
+        from .._sql_utils import get_sql_type_string
+
+        dialect = self.get_sqlglot_dialect()
+        return get_sql_type_string(struct_type, dialect)
 
     def _generate_column_definitions(self, column_types: dict) -> str:
         """Generate SQL column definitions from column types."""

{sql_testing_library-0.11.0 → sql_testing_library-0.12.0}/src/sql_testing_library/_adapters/snowflake.py

@@ -1,10 +1,11 @@
 """Snowflake adapter implementation."""
 
 import logging
+import os
 import time
 from datetime import date, datetime
 from decimal import Decimal
-from typing import TYPE_CHECKING, Any, List, Optional, Tuple, Type, Union, get_args
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Type, Union, get_args
 
 
 if TYPE_CHECKING:
@@ -67,11 +68,13 @@ class SnowflakeAdapter(DatabaseAdapter):
         self,
         account: str,
         user: str,
-        password: str,
-        database: str,
+        password: Optional[str] = None,
+        database: str = "",
         schema: str = "PUBLIC",
         warehouse: Optional[str] = None,
         role: Optional[str] = None,
+        private_key_path: Optional[str] = None,
+        private_key_passphrase: Optional[str] = None,
     ) -> None:
         if not has_snowflake:
             raise ImportError(
@@ -88,7 +91,77 @@ class SnowflakeAdapter(DatabaseAdapter):
         self.schema = schema
         self.warehouse = warehouse
         self.role = role
+        self.private_key_path = private_key_path
+        self.private_key_passphrase = private_key_passphrase
         self.conn: Optional[Any] = None
+        self._private_key: Optional[bytes] = None
+
+    def _load_private_key(self) -> bytes:
+        """Load private key from file or environment variable and convert to DER format."""
+        if self._private_key:
+            return self._private_key
+
+        # Try to load from file path
+        if self.private_key_path and os.path.exists(self.private_key_path):
+            with open(self.private_key_path, "rb") as key_file:
+                private_key_data = key_file.read()
+        # Try to load from environment variable
+        elif os.environ.get("SNOWFLAKE_PRIVATE_KEY"):
+            private_key_data = os.environ["SNOWFLAKE_PRIVATE_KEY"].encode()
+        else:
+            raise ValueError(
+                "Private key not found. Provide private_key_path or "
+                "set SNOWFLAKE_PRIVATE_KEY environment variable"
+            )
+
+        # Import cryptography modules
+        from cryptography.hazmat.backends import default_backend
+        from cryptography.hazmat.primitives import serialization
+        from cryptography.hazmat.primitives.serialization import (
+            load_der_private_key,
+            load_pem_private_key,
+        )
+
+        # Determine if we have a passphrase
+        passphrase_str = self.private_key_passphrase or os.environ.get(
+            "SNOWFLAKE_PRIVATE_KEY_PASSPHRASE"
+        )
+        passphrase = passphrase_str.encode() if passphrase_str else None
+
+        try:
+            # Check if it's already in DER format
+            if not private_key_data.startswith(b"-----"):
+                # Already in DER format, try to load it
+                try:
+                    private_key_obj = load_der_private_key(
+                        private_key_data, password=passphrase, backend=default_backend()
+                    )
+                    private_key = private_key_data
+                except Exception:
+                    # Not valid DER, treat as PEM
+                    pass
+
+            # Load PEM private key (handles both PKCS#1 and PKCS#8)
+            if private_key_data.startswith(b"-----"):
+                private_key_obj = load_pem_private_key(
+                    private_key_data, password=passphrase, backend=default_backend()
+                )
+
+                # Convert to DER format (PKCS#8) for Snowflake
+                private_key = private_key_obj.private_bytes(
+                    encoding=serialization.Encoding.DER,
+                    format=serialization.PrivateFormat.PKCS8,
+                    encryption_algorithm=serialization.NoEncryption(),
+                )
+        except Exception as e:
+            raise ValueError(
+                f"Failed to load private key: {e}. "
+                "Ensure the key is in PEM format (PKCS#1 or PKCS#8) "
+                "and the passphrase (if any) is correct."
+            ) from e
+
+        self._private_key = private_key
+        return private_key
 
     def _get_connection(self) -> Any:
         """Get or create a connection to Snowflake."""
@@ -96,14 +169,31 @@ class SnowflakeAdapter(DatabaseAdapter):
 
         # Create a new connection if needed
         if self.conn is None:
-            conn_params = {
+            conn_params: Dict[str, Any] = {
                 "account": self.account,
                 "user": self.user,
-                "password": self.password,
-                "database": self.database,
-                "schema": self.schema,
             }
 
+            # Add optional parameters
+            if self.database:
+                conn_params["database"] = self.database
+
+            if self.schema:
+                conn_params["schema"] = self.schema
+
+            # Handle authentication
+            if self.private_key_path or os.environ.get("SNOWFLAKE_PRIVATE_KEY"):
+                # Use key-pair authentication
+                conn_params["private_key"] = self._load_private_key()
+            elif self.password:
+                conn_params["password"] = self.password
+            else:
+                raise ValueError(
+                    "No authentication method provided. Please provide one of: "
+                    "1) password, 2) private_key_path, or "
+                    "3) set SNOWFLAKE_PRIVATE_KEY environment variable"
+                )
+
             if self.warehouse:
                 conn_params["warehouse"] = self.warehouse
 

{sql_testing_library-0.11.0 → sql_testing_library-0.12.0}/src/sql_testing_library/_pytest_plugin.py

@@ -176,19 +176,34 @@ class SQLTestDecorator:
             schema = adapter_config.get("schema", "PUBLIC")
             warehouse = adapter_config.get("warehouse")
             role = adapter_config.get("role")
+            private_key_path = adapter_config.get("private_key_path")
+            private_key_passphrase = adapter_config.get("private_key_passphrase")
+
+            # Check required fields based on authentication method
+            has_private_key = private_key_path or os.environ.get("SNOWFLAKE_PRIVATE_KEY")
+
+            if has_private_key:
+                # For key-pair auth, we just need account and user
+                if not all([account, user]):
+                    raise ValueError(
+                        "Snowflake adapter with key-pair authentication requires "
+                        "'account' and 'user' in configuration"
+                    )
+            else:
+                # For password-based auth, we need password
+                if not all([account, user, password]):
+                    raise ValueError(
+                        "Snowflake adapter requires 'account', 'user', and 'password' "
+                        "in configuration (or use key-pair authentication for CI/CD)"
+                    )
 
-            if not all([account, user, password, database, warehouse]):
-                raise ValueError(
-                    "Snowflake adapter requires 'account', 'user', 'password', "
-                    "'database', and 'warehouse' in configuration"
-                )
+            # Database and warehouse are recommended but not always required
+            if not database:
+                database = ""  # Let adapter handle empty database
 
-            # All required values are now guaranteed to exist
+            # Ensure non-None values for required parameters
             assert account is not None
             assert user is not None
-            assert password is not None
-            assert database is not None
-            assert warehouse is not None
 
             database_adapter = SnowflakeAdapter(
                 account=account,
@@ -198,6 +213,8 @@ class SQLTestDecorator:
                 schema=schema,
                 warehouse=warehouse,
                 role=role,
+                private_key_path=private_key_path,
+                private_key_passphrase=private_key_passphrase,
             )
         else:
             raise ValueError(f"Unsupported adapter type: {adapter_type}")