Added more intergation tests and fixed unit tests

Author: faviansamatha

aws_advanced_python_wrapper/sql_alchemy_connection_provider.py

@@ -137,7 +137,6 @@ def connect(
 
         if queue_pool is None:
             raise AwsWrapperError(Messages.get_formatted("SqlAlchemyPooledConnectionProvider.PoolNone", host_info.url))
-
         return queue_pool.connect()
 
     # The pool key should always be retrieved using this method, because the username

aws_advanced_python_wrapper/tortoise/backend/base/client.py

@@ -14,7 +14,6 @@
 
 import asyncio
 import mysql.connector
-from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager
 from typing import Any, Callable, Generic
 
@@ -26,106 +25,79 @@
 
 
 class AwsWrapperAsyncConnector:
-    """Factory class for creating AWS wrapper connections."""
-    
-    _executor: ThreadPoolExecutor = ThreadPoolExecutor(
-        thread_name_prefix="AwsWrapperAsyncExecutor"
-    )
+    """Class for creating and closing AWS wrapper connections."""
 
     @staticmethod
     async def ConnectWithAwsWrapper(connect_func: Callable, **kwargs) -> AwsWrapperConnection:
         """Create an AWS wrapper connection with async cursor support."""
-        loop = asyncio.get_event_loop()
-        connection = await loop.run_in_executor(
-            AwsWrapperAsyncConnector._executor,
-            lambda: AwsWrapperConnection.connect(connect_func, **kwargs)
+        connection = await asyncio.to_thread(
+            AwsWrapperConnection.connect, connect_func, **kwargs
         )
         return AwsConnectionAsyncWrapper(connection)
 
     @staticmethod
     async def CloseAwsWrapper(connection: AwsWrapperConnection) -> None:
         """Close an AWS wrapper connection asynchronously."""
-        loop = asyncio.get_event_loop()
-        await loop.run_in_executor(
-            AwsWrapperAsyncConnector._executor,
-            connection.close
-        )
+        await asyncio.to_thread(connection.close)
 
 
 class AwsCursorAsyncWrapper:
-    """Wraps a sync cursor to provide async interface."""
-    
-    _executor: ThreadPoolExecutor = ThreadPoolExecutor(
-        thread_name_prefix="AwsCursorAsyncWrapperExecutor"
-    )
+    """Wraps sync AwsCursor cursor with async support."""
 
     def __init__(self, sync_cursor):
         self._cursor = sync_cursor
 
     async def execute(self, query, params=None):
         """Execute a query asynchronously."""
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(self._executor, self._cursor.execute, query, params)
+        return await asyncio.to_thread(self._cursor.execute, query, params)
 
     async def executemany(self, query, params_list):
         """Execute multiple queries asynchronously."""
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(self._executor, self._cursor.executemany, query, params_list)
+        return await asyncio.to_thread(self._cursor.executemany, query, params_list)
 
     async def fetchall(self):
         """Fetch all results asynchronously."""
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(self._executor, self._cursor.fetchall)
+        return await asyncio.to_thread(self._cursor.fetchall)
 
     async def fetchone(self):
         """Fetch one result asynchronously."""
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(self._executor, self._cursor.fetchone)
+        return await asyncio.to_thread(self._cursor.fetchone)
 
     async def close(self):
         """Close cursor asynchronously."""
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(self._executor, self._cursor.close)
+        return await asyncio.to_thread(self._cursor.close)
 
     def __getattr__(self, name):
         """Delegate non-async attributes to the wrapped cursor."""
         return getattr(self._cursor, name)
 
 
 class AwsConnectionAsyncWrapper(AwsWrapperConnection):
-    """AWS wrapper connection with async cursor support."""
-    
-    _executor: ThreadPoolExecutor = ThreadPoolExecutor(
-        thread_name_prefix="AwsConnectionAsyncWrapperExecutor"
-    )
+    """Wraps sync AwsConnection with async cursor support."""
 
     def __init__(self, connection: AwsWrapperConnection):
         self._wrapped_connection = connection
 
     @asynccontextmanager
     async def cursor(self):
         """Create an async cursor context manager."""
-        loop = asyncio.get_event_loop()
-        cursor_obj = await loop.run_in_executor(self._executor, self._wrapped_connection.cursor)
+        cursor_obj = await asyncio.to_thread(self._wrapped_connection.cursor)
         try:
             yield AwsCursorAsyncWrapper(cursor_obj)
         finally:
-            await loop.run_in_executor(self._executor, cursor_obj.close)
+            await asyncio.to_thread(cursor_obj.close)
 
     async def rollback(self):
         """Rollback the current transaction."""
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(self._executor, self._wrapped_connection.rollback)
+        return await asyncio.to_thread(self._wrapped_connection.rollback)
 
     async def commit(self):
         """Commit the current transaction."""
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(self._executor, self._wrapped_connection.commit)
+        return await asyncio.to_thread(self._wrapped_connection.commit)
 
     async def set_autocommit(self, value: bool):
         """Set autocommit mode."""
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(self._executor, lambda: setattr(self._wrapped_connection, 'autocommit', value))
+        return await asyncio.to_thread(setattr, self._wrapped_connection, 'autocommit', value)
 
     def __getattr__(self, name):
         """Delegate all other attributes/methods to the wrapped connection."""
@@ -209,5 +181,5 @@ async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
                 else:
                     await self.client.commit()
         finally:
+            await AwsWrapperAsyncConnector.CloseAwsWrapper(self.client._connection)
             connections.reset(self.token)
-            await AwsWrapperAsyncConnector.CloseAwsWrapper(self.client._connection)

aws_advanced_python_wrapper/tortoise/backend/mysql/client.py

@@ -117,7 +117,7 @@ def __init__(
         self.host = host
         self.port = int(port)
         self.extra = kwargs.copy()
-        
+
         # Extract MySQL-specific settings
         self.storage_engine = self.extra.pop("storage_engine", "innodb")
         self.charset = self.extra.pop("charset", "utf8mb4")
@@ -128,6 +128,12 @@ def __init__(
         self.extra.pop("autocommit", None)
         self.extra.setdefault("sql_mode", "STRICT_TRANS_TABLES")
 
+        # Ensure that timeouts are integers
+        timeout_params = ["connect_timeout", "monitoring-connect_timeout",]
+        for param in timeout_params:
+            if param in self.extra and self.extra[param] is not None:
+                self.extra[param] = int(self.extra[param])
+        
         # Initialize connection templates
         self._init_connection_templates()
 
@@ -251,7 +257,6 @@ async def _execute_script(self, query: str, with_db: bool) -> None:
         """Execute a multi-statement query by parsing and running statements sequentially."""
         async with self._acquire_connection(with_db) as connection:
             logger.debug(f"Executing script: {query}")
-            print(f"Executing script: {query}")
             async with connection.cursor() as cursor:
                 # Parse multi-statement queries since MySQL Connector doesn't handle them well
                 statements = sqlparse.split(query)

tests/integration/container/conftest.py

@@ -68,6 +68,8 @@ def pytest_runtest_setup(item):
         test_name = item.callspec.id
     else:
         TestEnvironment.get_current().set_current_driver(None)
+        # Fallback to item.name if no callspec (for non-parameterized tests)
+        test_name = getattr(item, 'name', None) or str(item)
 
     logger.info(f"Starting test preparation for: {test_name}")
 

tests/integration/container/tortoise/models/__init__.py

@@ -0,0 +1,13 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License

tests/integration/container/tortoise/test_tortoise_models.py renamed to tests/integration/container/tortoise/models/test_models.py

@@ -0,0 +1,44 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from tortoise import fields
+from tortoise.models import Model
+
+
+class User(Model):
+    id = fields.IntField(primary_key=True)
+    name = fields.CharField(max_length=50)
+    email = fields.CharField(max_length=100, unique=True)
+    
+    class Meta:
+        table = "users"
+
+
+class UniqueName(Model):
+    id = fields.IntField(primary_key=True)
+    name = fields.CharField(max_length=20, null=True, unique=True)
+    optional = fields.CharField(max_length=20, null=True)
+    other_optional = fields.CharField(max_length=20, null=True)
+    
+    class Meta:
+        table = "unique_names"
+
+
+class TableWithSleepTrigger(Model):
+    id = fields.IntField(primary_key=True)
+    name = fields.CharField(max_length=50)
+    value = fields.CharField(max_length=100)
+    
+    class Meta:
+        table = "table_with_sleep_trigger"

tests/integration/container/tortoise/models/test_models_copy.py

@@ -0,0 +1,78 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from tortoise import fields
+from tortoise.models import Model
+
+
+# One-to-One Relationship Models
+class RelTestAccount(Model):
+    id = fields.IntField(primary_key=True)
+    username = fields.CharField(max_length=50, unique=True)
+    email = fields.CharField(max_length=100)
+    
+    class Meta:
+        table = "rel_test_accounts"
+
+
+class RelTestAccountProfile(Model):
+    id = fields.IntField(primary_key=True)
+    account = fields.OneToOneField("models.RelTestAccount", related_name="profile", on_delete=fields.CASCADE)
+    bio = fields.TextField(null=True)
+    avatar_url = fields.CharField(max_length=200, null=True)
+    
+    class Meta:
+        table = "rel_test_account_profiles"
+
+
+# One-to-Many Relationship Models
+class RelTestPublisher(Model):
+    id = fields.IntField(primary_key=True)
+    name = fields.CharField(max_length=100)
+    email = fields.CharField(max_length=100, unique=True)
+    
+    class Meta:
+        table = "rel_test_publishers"
+
+
+class RelTestPublication(Model):
+    id = fields.IntField(primary_key=True)
+    title = fields.CharField(max_length=200)
+    isbn = fields.CharField(max_length=13, unique=True)
+    publisher = fields.ForeignKeyField("models.RelTestPublisher", related_name="publications", on_delete=fields.CASCADE)
+    published_date = fields.DateField(null=True)
+    
+    class Meta:
+        table = "rel_test_publications"
+
+
+# Many-to-Many Relationship Models
+class RelTestLearner(Model):
+    id = fields.IntField(primary_key=True)
+    name = fields.CharField(max_length=100)
+    learner_id = fields.CharField(max_length=20, unique=True)
+    
+    class Meta:
+        table = "rel_test_learners"
+
+
+class RelTestSubject(Model):
+    id = fields.IntField(primary_key=True)
+    name = fields.CharField(max_length=100)
+    code = fields.CharField(max_length=10, unique=True)
+    credits = fields.IntField()
+    learners = fields.ManyToManyField("models.RelTestLearner", related_name="subjects")
+    
+    class Meta:
+        table = "rel_test_subjects"

tests/integration/container/tortoise/models/test_models_relationships.py

@@ -0,0 +1,13 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License

tests/integration/container/tortoise/router/__init__.py

@@ -0,0 +1,20 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License
+
+class TestRouter:
+    def db_for_read(self, model):
+        return "default"
+    
+    def db_for_write(self, model):
+        return "default"