Fir 8302 implement integration tests for (#22)

* move unit tests to unit subfolder

* select test

* add tests for create, delete and insert

* add tests for errors

* add auth tests

* update github job

* fix comment

* fix merge issues

Author: stepansergeevitch

.github/workflows/python-app.yml

@@ -39,4 +39,4 @@ jobs:
 
     - name: Test with pytest
       run: |
-        pytest
+        pytest tests/unit

src/firebolt/db/cursor.py

@@ -26,7 +26,9 @@
 from firebolt.client import Client
 from firebolt.common.exception import (
     CursorClosedError,
-    QueryError,
+    DataError,
+    OperationalError,
+    ProgrammingError,
     QueryNotRunError,
 )
 from firebolt.db._types import ColType, RawColType, parse_type, parse_value
@@ -36,7 +38,7 @@
 
 ParameterType = Union[int, float, str, datetime, date, bool, Sequence]
 
-JSON_OUTPUT_FORMAT = "FB_JSONCompactLimited"
+JSON_OUTPUT_FORMAT = "JSONCompact"
 
 
 class CursorState(Enum):
@@ -208,7 +210,17 @@ def _store_query_data(self, response: Response) -> None:
             # Parse data during fetch
             self._rows = query_data["data"]
         except (KeyError, JSONDecodeError) as err:
-            raise QueryError(f"Invalid query data format: {str(err)}")
+            raise DataError(f"Invalid query data format: {str(err)}")
+
+    def _raise_if_error(self, resp: Response) -> None:
+        """Raise a proper error if any"""
+        if resp.status_code == codes.INTERNAL_SERVER_ERROR:
+            raise OperationalError(
+                f"Error executing query:\n{resp.read().decode('utf-8')}"
+            )
+        if resp.status_code == codes.FORBIDDEN:
+            raise ProgrammingError(resp.read().decode("utf-8"))
+        resp.raise_for_status()
 
     def _reset(self) -> None:
         """Clear all data stored from previous query."""
@@ -231,9 +243,7 @@ def _do_execute_request(
             content=query,
         )
 
-        if resp.status_code == codes.INTERNAL_SERVER_ERROR:
-            raise QueryError(f"Error executing query:\n{resp.read().decode('utf-8')}")
-        resp.raise_for_status()
+        self._raise_if_error(resp)
         return resp
 
     @check_not_closed
@@ -313,7 +323,7 @@ def fetchmany(self, size: Optional[int] = None) -> List[List[ColType]]:
             """
         )
         with self._query_lock.gen_rlock():
-            size = size or self.arraysize
+            size = size if size is not None else self.arraysize
             left, right = self._get_next_range(size)
             assert self._rows is not None
             rows = self._rows[left:right]

tests/client/__init__.py renamed to tests/integration/__init__.py

@@ -0,0 +1,124 @@
+from datetime import date, datetime
+from logging import getLogger
+from os import environ
+from typing import List
+
+from pytest import fixture
+
+from firebolt.db import ARRAY, Connection
+from firebolt.db._types import ColType
+from firebolt.db.cursor import Column
+
+LOGGER = getLogger(__name__)
+
+ENGINE_URL_ENV = "ENGINE_URL"
+DATABASE_NAME_ENV = "DATABASE_NAME"
+USERNAME_ENV = "USERNAME"
+PASSWORD_ENV = "PASSWORD"
+API_ENDPOINT_ENV = "API_ENDPOINT"
+
+
+def must_env(var_name: str) -> str:
+    assert var_name in environ, f"Expected {var_name} to be provided in environment"
+    LOGGER.info(f"{var_name}: {environ[var_name]}")
+    return environ[var_name]
+
+
+@fixture(scope="session")
+def engine_url() -> str:
+    return must_env(ENGINE_URL_ENV)
+
+
+@fixture(scope="session")
+def database_name() -> str:
+    return must_env(DATABASE_NAME_ENV)
+
+
+@fixture(scope="session")
+def username() -> str:
+    return must_env(USERNAME_ENV)
+
+
+@fixture(scope="session")
+def password() -> str:
+    return must_env(PASSWORD_ENV)
+
+
+@fixture(scope="session")
+def api_endpoint() -> str:
+    return must_env(API_ENDPOINT_ENV)
+
+
+@fixture
+def connection(
+    engine_url: str, database_name: str, username: str, password: str, api_endpoint: str
+) -> Connection:
+    return Connection(
+        engine_url, database_name, username, password, api_endpoint=api_endpoint
+    )
+
+
+@fixture
+def all_types_query() -> str:
+    return (
+        "select 1 as uint8, 258 as uint16, 80000 as uint32, -30000 as int32,"
+        "30000000000 as uint64, -30000000000 as int64, cast(1.23 AS FLOAT) as float32,"
+        " 1.2345678901234 as float64, 'text' as \"string\", "
+        "CAST('2021-03-28' AS DATE) as \"date\", "
+        'CAST(\'2019-07-31 01:01:01\' AS DATETIME) as "datetime", true as "bool",'
+        '[1,2,3,4] as "array", cast(null as int) as nullable'
+    )
+
+
+@fixture
+def all_types_query_description() -> List[Column]:
+    return [
+        Column("uint8", int, None, None, None, None, None),
+        Column("uint16", int, None, None, None, None, None),
+        Column("uint32", int, None, None, None, None, None),
+        Column("int32", int, None, None, None, None, None),
+        Column("uint64", int, None, None, None, None, None),
+        Column("int64", int, None, None, None, None, None),
+        Column("float32", float, None, None, None, None, None),
+        Column("float64", float, None, None, None, None, None),
+        Column("string", str, None, None, None, None, None),
+        Column("date", date, None, None, None, None, None),
+        Column("datetime", datetime, None, None, None, None, None),
+        Column("bool", int, None, None, None, None, None),
+        Column("array", ARRAY(int), None, None, None, None, None),
+        Column("nullable", str, None, None, None, None, None),
+    ]
+
+
+@fixture
+def all_types_query_response() -> List[ColType]:
+    return [
+        [
+            1,
+            258,
+            80000,
+            -30000,
+            30000000000,
+            -30000000000,
+            1.23,
+            1.23456789012,
+            "text",
+            date(2021, 3, 28),
+            datetime(2019, 7, 31, 1, 1, 1),
+            1,
+            [1, 2, 3, 4],
+            None,
+        ]
+    ]
+
+
+@fixture
+def create_drop_description() -> List[Column]:
+    return [
+        Column("host", str, None, None, None, None, None),
+        Column("port", int, None, None, None, None, None),
+        Column("status", int, None, None, None, None, None),
+        Column("error", str, None, None, None, None, None),
+        Column("num_hosts_remaining", int, None, None, None, None, None),
+        Column("num_hosts_active", int, None, None, None, None, None),
+    ]

tests/integration/dbapi/conftest.py

@@ -0,0 +1,46 @@
+from time import time
+
+from pytest import raises
+
+from firebolt.common.exception import AuthenticationError
+from firebolt.db import Connection
+
+
+def test_refresh_token(connection: Connection) -> None:
+    """Auth refreshes token on expiration/invalidation"""
+    with connection.cursor() as c:
+        # Works fine
+        c.execute("show tables")
+
+        # Invalidate the token
+        c._client.auth._token += "_"
+
+        # Still works fine
+        c.execute("show tables")
+
+        old = c._client.auth.token
+        c._client.auth._expires = int(time()) - 1
+
+        # Still works fine
+        c.execute("show tables")
+
+        assert c._client.auth.token != old, "Auth didn't update token on expiration"
+
+
+def test_credentials_invalidation(connection: Connection) -> None:
+    """Auth raises Authentication Error on credentials invalidation"""
+    with connection.cursor() as c:
+        # Works fine
+        c.execute("show tables")
+
+        # Invalidate the token
+        c._client.auth._token += "_"
+        c._client.auth.username += "_"
+        c._client.auth.password += "_"
+
+        with raises(AuthenticationError) as exc_info:
+            c.execute("show tables")
+
+        assert str(exc_info.value).startswith(
+            "Failed to authenticate"
+        ), "Invalid authentication error message"

tests/integration/dbapi/test_auth.py

@@ -0,0 +1,59 @@
+from httpx import ConnectError
+from pytest import raises
+
+from firebolt.common.exception import (
+    AuthenticationError,
+    OperationalError,
+    ProgrammingError,
+)
+from firebolt.db import Connection
+
+
+def test_invalid_credentials(
+    engine_url: str, database_name: str, username: str, password: str, api_endpoint: str
+) -> None:
+    """Connection properly reacts to invalid credentials error"""
+    connection = Connection(
+        engine_url, database_name, username + "_", password + "_", api_endpoint
+    )
+    with raises(AuthenticationError) as exc_info:
+        connection.cursor().execute("show tables")
+
+    assert str(exc_info.value).startswith(
+        "Failed to authenticate"
+    ), "Invalid authentication error message"
+
+
+def test_engine_not_exists(
+    engine_url: str, database_name: str, username: str, password: str, api_endpoint: str
+) -> None:
+    """Connection properly reacts to invalid engine url error"""
+    connection = Connection(
+        engine_url + "_", database_name, username, password, api_endpoint
+    )
+    with raises(ConnectError):
+        connection.cursor().execute("show tables")
+
+
+def test_database_not_exists(
+    engine_url: str, database_name: str, username: str, password: str, api_endpoint: str
+) -> None:
+    """Connection properly reacts to invalid database error"""
+    new_db_name = database_name + "_"
+    connection = Connection(engine_url, new_db_name, username, password, api_endpoint)
+    with raises(ProgrammingError) as exc_info:
+        connection.cursor().execute("show tables")
+
+    assert (
+        str(exc_info.value) == f"Invalid database '{new_db_name}'"
+    ), "Invalid database name error message"
+
+
+def test_sql_error(connection: Connection) -> None:
+    with connection.cursor() as c:
+        with raises(OperationalError) as exc_info:
+            c.execute("select ]")
+
+        assert str(exc_info.value).startswith(
+            "Error executing query"
+        ), "Invalid SQL error message"