test: Fix tests and add test for NoSessionError exception

Author: daireto

tests/test_active_record.py

@@ -51,7 +51,7 @@ def setUpClass(cls):
     def tearDownClass(cls):
         if hasattr(cls, 'conn'):
             logger.info('Closing DB connection...')
-            asyncio.run(cls.conn.close(BaseModel))
+            asyncio.run(cls.conn.close())
 
     async def test_context_manager(self):
         """Test for ``__enter__`` and ``__exit__`` methods."""

tests/test_async_query.py

@@ -26,7 +26,7 @@ def setUpClass(cls):
     def tearDownClass(cls):
         if hasattr(cls, 'conn'):
             logger.info('Closing DB connection...')
-            asyncio.run(cls.conn.close(BaseModel))
+            asyncio.run(cls.conn.close())
 
     async def test_init(self):
         """Test for ``fill`` function."""

tests/test_db_connection.py

@@ -1,10 +1,15 @@
 import unittest
 
+from sqlalchemy.exc import UnboundExecutionError
+
 from sqlactive.base_model import ActiveRecordBaseModel
-from sqlactive.conn import DBConnection
+# from sqlactive.conn import DBConnection
 
 from ._logger import logger
-from ._models import BaseModel
+# from ._models import BaseModel
+from ._models import BaseModel, User
+from sqlalchemy.sql import func, select
+from sqlactive.conn import DBConnection, execute
 
 
 class TestDBConnection(unittest.IsolatedAsyncioTestCase):
@@ -24,4 +29,8 @@ async def test_all(self):
         self.assertIsNotNone(BaseModel._session)
 
         logger.info('Testing "close" function...')
-        await conn.close(BaseModel)
+        await conn.close()
+
+        with self.assertRaises(UnboundExecutionError):
+            query = select(User.age, func.count(User.id)).group_by(User.age)
+            await execute(conn.async_scoped_session, query)

tests/test_execute.py

@@ -29,33 +29,13 @@ def setUpClass(cls):
     def tearDownClass(cls):
         if hasattr(cls, 'conn'):
             logger.info('Closing DB connection...')
-            asyncio.run(cls.conn.close(BaseModel))
+            asyncio.run(cls.conn.close())
 
     async def test_execute(self):
         """Test for ``sqlactive.conn.execute`` function."""
         logger.info('Testing "execute" function...')
         query = select(User.age, func.count(User.id)).group_by(User.age)
-        result = await execute(query, BaseModel)
-        self.assertEqual((19, 1), next(result))
-        self.assertEqual((24, 1), next(result))
-        self.assertEqual((25, 2), next(result))
-        self.assertEqual((26, 2), next(result))
-        self.assertEqual((27, 3), next(result))
-        with self.assertRaises(NoSessionError):
-            query = select(User.age, func.count(User.id)).group_by(User.age)
-            await execute(query)
-
-    async def test_execute_without_base_model(self):
-        """Test for ``sqlactive.conn.execute`` function
-        without passing a base model.
-        """
-        logger.info('Testing "execute" function without base model...')
-        with self.assertRaises(NoSessionError):
-            query = select(User.age, func.count(User.id)).group_by(User.age)
-            await execute(query)
-        ActiveRecordBaseModel.set_session(self.conn.async_scoped_session)
-        query = select(User.age, func.count(User.id)).group_by(User.age)
-        result = await execute(query)
+        result = await execute(self.conn.async_scoped_session, query)
         self.assertEqual((19, 1), next(result))
         self.assertEqual((24, 1), next(result))
         self.assertEqual((25, 2), next(result))

tests/test_inspection.py

@@ -26,7 +26,7 @@ def setUpClass(cls):
     def tearDownClass(cls):
         if hasattr(cls, 'conn'):
             logger.info('Closing DB connection...')
-            asyncio.run(cls.conn.close(BaseModel))
+            asyncio.run(cls.conn.close())
 
     async def test_repr(self):
         """Test for ``__repr__`` function."""

tests/test_serialization.py

@@ -27,7 +27,7 @@ def setUpClass(cls):
     def tearDownClass(cls):
         if hasattr(cls, 'conn'):
             logger.info('Closing DB connection...')
-            asyncio.run(cls.conn.close(BaseModel))
+            asyncio.run(cls.conn.close())
 
     async def test_to_dict(self):
         """Test for ``to_dict`` function."""

tests/test_session.py

@@ -0,0 +1,17 @@
+import unittest
+
+from sqlactive.exceptions import NoSessionError
+from sqlactive.session import SessionMixin
+
+
+class TestModel(SessionMixin):
+    pass
+
+
+class TestSessionMixin(unittest.IsolatedAsyncioTestCase):
+    """Tests for ``sqlactive.session.SessionMixin``."""
+
+    async def test_no_session_error(self):
+        """Test for ``NoSessionError`` exception."""
+        with self.assertRaises(NoSessionError):
+            TestModel.AsyncSession

tests/test_smart_query.py

@@ -41,7 +41,7 @@ def setUpClass(cls):
     def tearDownClass(cls):
         if hasattr(cls, 'conn'):
             logger.info('Closing DB connection...')
-            asyncio.run(cls.conn.close(BaseModel))
+            asyncio.run(cls.conn.close())
 
     async def test_operators(self):
         """Test for operators."""

tests/test_utils.py

@@ -34,7 +34,7 @@ def setUpClass(cls):
     def tearDownClass(cls):
         if hasattr(cls, 'conn'):
             logger.info('Closing DB connection...')
-            asyncio.run(cls.conn.close(BaseModel))
+            asyncio.run(cls.conn.close())
 
     def test_get_query_root_cls(self):
         """Test for ``get_query_root_cls`` function."""