ci: Using service account (#214)

Author: ptiurin

tests/integration/conftest.py

@@ -4,6 +4,7 @@
 from pytest import fixture
 from pytest_asyncio import fixture as async_fixture
 
+from firebolt.client.auth import ServiceAccount, UsernamePassword
 from firebolt.service.manager import Settings
 
 LOGGER = getLogger(__name__)
@@ -90,3 +91,13 @@ def service_id() -> str:
 @fixture(scope="session")
 def service_secret() -> str:
     return must_env(SERVICE_SECRET_ENV)
+
+
+@fixture
+def service_auth(service_id, service_secret) -> ServiceAccount:
+    return ServiceAccount(service_id, service_secret)
+
+
+@fixture
+def password_auth(username, password) -> UsernamePassword:
+    return UsernamePassword(username, password)

tests/integration/dbapi/async/conftest.py

@@ -1,41 +1,39 @@
 from pytest_asyncio import fixture as async_fixture
 
 from firebolt.async_db import Connection, connect
-from firebolt.client.auth import ServiceAccount, UsernamePassword
+from firebolt.client.auth.base import Auth
 
 
 @async_fixture
-async def connection(
+async def username_password_connection(
     engine_url: str,
     database_name: str,
-    username: str,
-    password: str,
+    password_auth: Auth,
     account_name: str,
     api_endpoint: str,
 ) -> Connection:
     async with await connect(
         engine_url=engine_url,
         database=database_name,
-        auth=UsernamePassword(username, password),
+        auth=password_auth,
         account_name=account_name,
         api_endpoint=api_endpoint,
     ) as connection:
         yield connection
 
 
 @async_fixture
-async def service_account_connection(
+async def connection(
     engine_url: str,
     database_name: str,
-    service_id: str,
-    service_secret: str,
+    service_auth: Auth,
     account_name: str,
     api_endpoint: str,
 ) -> Connection:
     async with await connect(
         engine_url=engine_url,
         database=database_name,
-        auth=ServiceAccount(service_id, service_secret),
+        auth=service_auth,
         account_name=account_name,
         api_endpoint=api_endpoint,
     ) as connection:
@@ -46,17 +44,15 @@ async def service_account_connection(
 async def connection_engine_name(
     engine_name: str,
     database_name: str,
-    username: str,
-    password: str,
+    service_auth: Auth,
     account_name: str,
     api_endpoint: str,
 ) -> Connection:
 
     async with await connect(
         engine_name=engine_name,
         database=database_name,
-        username=username,
-        password=password,
+        auth=service_auth,
         account_name=account_name,
         api_endpoint=api_endpoint,
     ) as connection:
@@ -66,16 +62,14 @@ async def connection_engine_name(
 @async_fixture
 async def connection_no_engine(
     database_name: str,
-    username: str,
-    password: str,
+    service_auth: Auth,
     account_name: str,
     api_endpoint: str,
 ) -> Connection:
 
     async with await connect(
         database=database_name,
-        username=username,
-        password=password,
+        auth=service_auth,
         account_name=account_name,
         api_endpoint=api_endpoint,
     ) as connection:

tests/integration/dbapi/async/test_auth_async.py

@@ -29,11 +29,11 @@ async def test_refresh_token(connection: Connection) -> None:
 
 
 async def test_credentials_invalidation(
-    connection: Connection, service_account_connection: Connection
+    connection: Connection, username_password_connection: Connection
 ) -> None:
     """Auth raises authentication error on credentials invalidation"""
     # Can't pytest.parametrize it due to nested event loop error
-    for conn in [connection, service_account_connection]:
+    for conn in [connection, username_password_connection]:
         with conn.cursor() as c:
             # Works fine
             await c.execute("show tables")

tests/integration/dbapi/async/test_errors_async.py

@@ -2,40 +2,20 @@
 from pytest import mark, raises
 
 from firebolt.async_db import Connection, connect
+from firebolt.client.auth import ServiceAccount, UsernamePassword
 from firebolt.utils.exception import (
     AccountNotFoundError,
-    AuthenticationError,
     EngineNotRunningError,
     FireboltDatabaseError,
     FireboltEngineError,
     OperationalError,
 )
 
 
-async 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."""
-    async with await connect(
-        engine_url=engine_url,
-        database=database_name,
-        username=username + "_",
-        password=password + "_",
-        api_endpoint=api_endpoint,
-    ) as connection:
-        with raises(AuthenticationError) as exc_info:
-            await connection.cursor().execute("show tables")
-
-        assert str(exc_info.value).startswith(
-            "Failed to authenticate"
-        ), "Invalid authentication error message."
-
-
 async def test_invalid_account(
     database_name: str,
     engine_name: str,
-    username: str,
-    password: str,
+    password_auth: UsernamePassword,
     api_endpoint: str,
 ) -> None:
     """Connection properly reacts to invalid account error."""
@@ -44,8 +24,7 @@ async def test_invalid_account(
         async with await connect(
             database=database_name,
             engine_name=engine_name,  # Omit engine_url to force account_id lookup.
-            username=username,
-            password=password,
+            auth=password_auth,
             account_name=account_name,
             api_endpoint=api_endpoint,
         ) as connection:
@@ -59,17 +38,15 @@ async def test_invalid_account(
 async def test_engine_url_not_exists(
     engine_url: str,
     database_name: str,
-    username: str,
-    password: str,
+    service_auth: ServiceAccount,
     account_name: str,
     api_endpoint: str,
 ) -> None:
     """Connection properly reacts to invalid engine url error."""
     async with await connect(
         engine_url=engine_url + "_",
         database=database_name,
-        username=username,
-        password=password,
+        auth=service_auth,
         account_name=account_name,
         api_endpoint=api_endpoint,
     ) as connection:
@@ -80,8 +57,7 @@ async def test_engine_url_not_exists(
 async def test_engine_name_not_exists(
     engine_name: str,
     database_name: str,
-    username: str,
-    password: str,
+    service_auth: ServiceAccount,
     account_name: str,
     api_endpoint: str,
 ) -> None:
@@ -90,8 +66,7 @@ async def test_engine_name_not_exists(
         async with await connect(
             engine_name=engine_name + "_________",
             database=database_name,
-            username=username,
-            password=password,
+            auth=service_auth,
             account_name=account_name,
             api_endpoint=api_endpoint,
         ) as connection:
@@ -101,8 +76,7 @@ async def test_engine_name_not_exists(
 async def test_engine_stopped(
     stopped_engine_url: str,
     database_name: str,
-    username: str,
-    password: str,
+    service_auth: ServiceAccount,
     account_name: str,
     api_endpoint: str,
 ) -> None:
@@ -111,8 +85,7 @@ async def test_engine_stopped(
         async with await connect(
             engine_url=stopped_engine_url,
             database=database_name,
-            username=username,
-            password=password,
+            auth=service_auth,
             account_name=account_name,
             api_endpoint=api_endpoint,
         ) as connection:
@@ -121,15 +94,14 @@ async def test_engine_stopped(
 
 @mark.skip(reason="Behaviour is different in prod vs dev")
 async def test_database_not_exists(
-    engine_url: str, database_name: str, username: str, password: str, api_endpoint: str
+    engine_url: str, database_name: str, service_auth: ServiceAccount, api_endpoint: str
 ) -> None:
     """Connection properly reacts to invalid database error."""
     new_db_name = database_name + "_"
     async with await connect(
         engine_url=engine_url,
         database=new_db_name,
-        username=username,
-        password=password,
+        auth=service_auth,
         api_endpoint=api_endpoint,
     ) as connection:
         with raises(FireboltDatabaseError) as exc_info:

tests/integration/dbapi/sync/conftest.py

@@ -1,22 +1,21 @@
 from pytest import fixture
 
-from firebolt.client.auth import ServiceAccount, UsernamePassword
+from firebolt.client.auth.base import Auth
 from firebolt.db import Connection, connect
 
 
 @fixture
-def connection(
+def username_password_connection(
     engine_url: str,
     database_name: str,
-    username: str,
-    password: str,
+    password_auth: Auth,
     account_name: str,
     api_endpoint: str,
 ) -> Connection:
     connection = connect(
         engine_url=engine_url,
         database=database_name,
-        auth=UsernamePassword(username, password),
+        auth=password_auth,
         account_name=account_name,
         api_endpoint=api_endpoint,
     )
@@ -25,18 +24,17 @@ def connection(
 
 
 @fixture
-async def service_account_connection(
+async def connection(
     engine_url: str,
     database_name: str,
-    service_id: str,
-    service_secret: str,
+    service_auth: Auth,
     account_name: str,
     api_endpoint: str,
 ) -> Connection:
     connection = connect(
         engine_url=engine_url,
         database=database_name,
-        auth=ServiceAccount(service_id, service_secret),
+        auth=service_auth,
         account_name=account_name,
         api_endpoint=api_endpoint,
     )
@@ -48,16 +46,14 @@ async def service_account_connection(
 def connection_engine_name(
     engine_name: str,
     database_name: str,
-    username: str,
-    password: str,
+    service_auth: Auth,
     account_name: str,
     api_endpoint: str,
 ) -> Connection:
     connection = connect(
         engine_name=engine_name,
         database=database_name,
-        username=username,
-        password=password,
+        auth=service_auth,
         account_name=account_name,
         api_endpoint=api_endpoint,
     )
@@ -68,15 +64,13 @@ def connection_engine_name(
 @fixture
 def connection_no_engine(
     database_name: str,
-    username: str,
-    password: str,
+    service_auth: Auth,
     account_name: str,
     api_endpoint: str,
 ) -> Connection:
     connection = connect(
         database=database_name,
-        username=username,
-        password=password,
+        auth=service_auth,
         account_name=account_name,
         api_endpoint=api_endpoint,
     )

tests/integration/dbapi/sync/test_auth.py

@@ -28,7 +28,7 @@ def test_refresh_token(connection: Connection) -> None:
         assert c._client.auth.token != old, "Auth didn't update token on expiration"
 
 
-@mark.parametrize("connection_fixture", ["connection", "service_account_connection"])
+@mark.parametrize("connection_fixture", ["connection", "username_password_connection"])
 def test_credentials_invalidation(connection_fixture: str, request) -> None:
     """Auth raises Authentication Error on credentials invalidation"""
     with request.getfixturevalue(connection_fixture).cursor() as c: