Checks for failing unittests

Author: gvbgduh

databases/backends/aiopg.py

@@ -63,7 +63,7 @@ def _get_connection_kwargs(self) -> dict:  # TODO move to `core.py`
 
         return kwargs
 
-    async def connect(self) -> None:  # TODO as MySQL one?
+    async def connect(self) -> None:
         assert self._pool is None, "DatabaseBackend is already running"
         kwargs = self._get_connection_kwargs()
         self._pool = await aiopg.create_pool(
@@ -72,7 +72,6 @@ async def connect(self) -> None:  # TODO as MySQL one?
             user=self._database_url.username or getpass.getuser(),
             password=self._database_url.password,
             database=self._database_url.database,
-            # autocommit=True,
             **kwargs,
         )
 
@@ -112,8 +111,6 @@ async def fetch_all(self, query: ClauseElement) -> typing.List[typing.Mapping]:
         assert self._connection is not None, "Connection is not acquired"
         query, args, context = self._compile(query)
         cursor = await self._connection.cursor()
-        # TODO
-        import pdb; pdb.set_trace()
         try:
             await cursor.execute(query, args)
             rows = await cursor.fetchall()
@@ -129,8 +126,6 @@ async def fetch_one(self, query: ClauseElement) -> typing.Optional[typing.Mappin
         assert self._connection is not None, "Connection is not acquired"
         query, args, context = self._compile(query)
         cursor = await self._connection.cursor()
-        # TODO
-        import pdb; pdb.set_trace()
         try:
             await cursor.execute(query, args)
             row = await cursor.fetchone()
@@ -145,8 +140,6 @@ async def execute(self, query: ClauseElement) -> typing.Any:
         assert self._connection is not None, "Connection is not acquired"
         query, args, context = self._compile(query)
         cursor = await self._connection.cursor()
-        # TODO
-        import pdb; pdb.set_trace()
         try:
             await cursor.execute(query, args)
             return cursor.lastrowid
@@ -156,8 +149,6 @@ async def execute(self, query: ClauseElement) -> typing.Any:
     async def execute_many(self, queries: typing.List[ClauseElement]) -> None:
         assert self._connection is not None, "Connection is not acquired"
         cursor = await self._connection.cursor()
-        # TODO
-        import pdb; pdb.set_trace()
         try:
             for single_query in queries:
                 single_query, args, context = self._compile(single_query)
@@ -171,8 +162,6 @@ async def iterate(
         assert self._connection is not None, "Connection is not acquired"
         query, args, context = self._compile(query)
         cursor = await self._connection.cursor()
-        # TODO
-        import pdb; pdb.set_trace()
         try:
             await cursor.execute(query, args)
             metadata = ResultMetaData(context, cursor.description)
@@ -217,17 +206,14 @@ def __init__(self, connection: AiopgConnection):
         self._savepoint_name = ""
 
     async def start(self, is_root: bool) -> None:
-        import pdb; pdb.set_trace()
         assert self._connection._connection is not None, "Connection is not acquired"
         self._is_root = is_root
         cursor = await self._connection._connection.cursor()
         if self._is_root:
-            # await self._connection._connection.begin()
             await cursor.execute("BEGIN")
         else:
             id = str(uuid.uuid4()).replace("-", "_")
             self._savepoint_name = f"STARLETTE_SAVEPOINT_{id}"
-            # cursor = await self._connection._connection.cursor()
             try:
                 await cursor.execute(f"SAVEPOINT {self._savepoint_name}")
             finally:
@@ -237,10 +223,8 @@ async def commit(self) -> None:
         assert self._connection._connection is not None, "Connection is not acquired"
         cursor = await self._connection._connection.cursor()
         if self._is_root:
-            # await self._connection._connection.commit()
             await cursor.execute("COMMIT")
         else:
-            # cursor = await self._connection._connection.cursor()
             try:
                 await cursor.execute(f"RELEASE SAVEPOINT {self._savepoint_name}")
             finally:
@@ -250,10 +234,8 @@ async def rollback(self) -> None:
         assert self._connection._connection is not None, "Connection is not acquired"
         cursor = await self._connection._connection.cursor()
         if self._is_root:
-            # await self._connection._connection.rollback()
             await cursor.execute("ROLLBACK")
         else:
-            # cursor = await self._connection._connection.cursor()
             try:
                 await cursor.execute(f"ROLLBACK TO SAVEPOINT {self._savepoint_name}")
             finally:

tests/test_databases.py

@@ -2,6 +2,7 @@
 import datetime
 import decimal
 import functools
+import json
 import os
 
 import pytest
@@ -300,6 +301,9 @@ async def test_execute_return_val(database_url):
             query = notes.insert()
             values = {"text": "example1", "completed": True}
             pk = await database.execute(query, values)
+            # Apparently for `aiopg` it's OID that will always 0 in this case
+            # As it's only one action within this cursor life cycle
+            # Something to triple check
             assert isinstance(pk, int)
 
             query = notes.select().where(notes.c.id == pk)
@@ -505,7 +509,15 @@ async def test_json_field(database_url):
             # execute()
             query = session.insert()
             values = {"data": {"text": "hello", "boolean": True, "int": 1}}
-            await database.execute(query, values)
+            if str(database_url).startswith("postgresql+psycopg2"):
+                await database.execute(
+                    query.values(
+                        # or wrapped with `psycopg2.extras.Json`
+                        data=json.dumps({"text": "hello", "boolean": True, "int": 1})
+                    )
+                )
+            else:
+                await database.execute(query, values)
 
             # fetch_all()
             query = session.select()
@@ -667,19 +679,19 @@ async def test_queries_with_expose_backend_connection(database_url):
                 raw_connection = connection.raw_connection
 
                 # Insert query
-                if str(database_url).startswith("mysql"):
+                if str(database_url).startswith("mysql") or str(database_url).startswith("postgresql+psycopg2"):
                     insert_query = "INSERT INTO notes (text, completed) VALUES (%s, %s)"
                 else:
                     insert_query = "INSERT INTO notes (text, completed) VALUES ($1, $2)"
 
                 # execute()
                 values = ("example1", True)
 
-                if str(database_url).startswith("postgresql"):
-                    await raw_connection.execute(insert_query, *values)
-                elif str(database_url).startswith("mysql"):
+                if str(database_url).startswith("mysql") or str(database_url).startswith("postgresql+psycopg2"):
                     cursor = await raw_connection.cursor()
                     await cursor.execute(insert_query, values)
+                elif str(database_url).startswith("postgresql"):
+                    await raw_connection.execute(insert_query, *values)
                 elif str(database_url).startswith("sqlite"):
                     await raw_connection.execute(insert_query, values)
 
@@ -689,19 +701,24 @@ async def test_queries_with_expose_backend_connection(database_url):
                 if str(database_url).startswith("mysql"):
                     cursor = await raw_connection.cursor()
                     await cursor.executemany(insert_query, values)
+                elif str(database_url).startswith("postgresql+psycopg2"):
+                    cursor = await raw_connection.cursor()
+                    # No async support for `executemany`
+                    for value in values:
+                        await cursor.execute(insert_query, value)
                 else:
                     await raw_connection.executemany(insert_query, values)
 
                 # Select query
                 select_query = "SELECT notes.id, notes.text, notes.completed FROM notes"
 
                 # fetch_all()
-                if str(database_url).startswith("postgresql"):
-                    results = await raw_connection.fetch(select_query)
-                elif str(database_url).startswith("mysql"):
+                if str(database_url).startswith("mysql") or str(database_url).startswith("postgresql+psycopg2"):
                     cursor = await raw_connection.cursor()
                     await cursor.execute(select_query)
                     results = await cursor.fetchall()
+                elif str(database_url).startswith("postgresql"):
+                    results = await raw_connection.fetch(select_query)
                 elif str(database_url).startswith("sqlite"):
                     results = await raw_connection.execute_fetchall(select_query)
 
@@ -713,9 +730,9 @@ async def test_queries_with_expose_backend_connection(database_url):
                 assert results[1][2] == False
                 assert results[2][1] == "example3"
                 assert results[2][2] == True
-
+                
                 # fetch_one()
-                if str(database_url).startswith("postgresql"):
+                if str(database_url).startswith("postgresql") and not str(database_url).startswith("postgresql+psycopg2"):
                     result = await raw_connection.fetchrow(select_query)
                 else:
                     cursor = await raw_connection.cursor()