Apply #2182 to async code

adjust no_auth usage for async

Author: sfc-gh-pczajka

src/snowflake/connector/aio/auth/__init__.py

@@ -10,6 +10,7 @@
 from ._default import AuthByDefault
 from ._idtoken import AuthByIdToken
 from ._keypair import AuthByKeyPair
+from ._no_auth import AuthNoAuth
 from ._oauth import AuthByOAuth
 from ._okta import AuthByOkta
 from ._pat import AuthByPAT
@@ -26,6 +27,7 @@
         AuthByWebBrowser,
         AuthByIdToken,
         AuthByPAT,
+        AuthNoAuth,
     )
 )
 
@@ -38,6 +40,7 @@
     "AuthByOkta",
     "AuthByUsrPwdMfa",
     "AuthByWebBrowser",
+    "AuthNoAuth",
     "Auth",
     "AuthType",
     "FIRST_PARTY_AUTHENTICATORS",

src/snowflake/connector/aio/auth/_auth.py

@@ -43,6 +43,7 @@
     ReauthenticationRequest,
 )
 from ...sqlstate import SQLSTATE_CONNECTION_WAS_NOT_ESTABLISHED
+from ._no_auth import AuthNoAuth
 
 if TYPE_CHECKING:
     from ._by_plugin import AuthByPlugin
@@ -76,6 +77,10 @@ async def authenticate(
             )
         logger.debug("authenticate")
 
+        # For no-auth connection, authentication is no-op, and we can return early here.
+        if isinstance(auth_instance, AuthNoAuth):
+            return {}
+
         if timeout is None:
             timeout = auth_instance.timeout
 

src/snowflake/connector/aio/auth/_no_auth.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+#
+
+from __future__ import annotations
+
+from typing import Any
+
+from ...auth.no_auth import AuthNoAuth as AuthNoAuthSync
+from ._by_plugin import AuthByPlugin as AuthByPluginAsync
+
+
+class AuthNoAuth(AuthByPluginAsync, AuthNoAuthSync):
+    """No-auth Authentication.
+
+    It is a dummy auth that requires no extra connection establishment.
+    """
+
+    def __init__(self, **kwargs) -> None:
+        AuthNoAuthSync.__init__(self, **kwargs)
+
+    async def reset_secrets(self) -> None:
+        AuthNoAuthSync.reset_secrets(self)
+
+    async def prepare(self, **kwargs: Any) -> None:
+        AuthNoAuthSync.prepare(self, **kwargs)
+
+    async def reauthenticate(self, **kwargs: Any) -> dict[str, bool]:
+        return AuthNoAuthSync.reauthenticate(self, **kwargs)
+
+    async def update_body(self, body: dict[Any, Any]) -> None:
+        AuthNoAuthSync.update_body(self, body)

test/integ/aio/test_connection_async.py

@@ -1659,3 +1659,30 @@ async def test_is_valid(conn_cnx):
         assert conn
         assert await conn.is_valid() is True
     assert await conn.is_valid() is False
+
+
+async def test_no_auth_connection_negative_case():
+    # AuthNoAuth does not exist in old drivers, so we import at test level to
+    # skip importing it for old driver tests.
+    from test.integ.aio.conftest import create_connection
+
+    from snowflake.connector.aio.auth._no_auth import AuthNoAuth
+
+    no_auth = AuthNoAuth()
+
+    # Create a no-auth connection in an invalid way.
+    # We do not fail connection establishment because there is no validated way
+    # to tell whether the no-auth is a valid use case or not. But it is
+    # effectively protected because invalid no-auth will fail to run any query.
+    conn = await create_connection("default", auth_class=no_auth)
+
+    # Make sure we are indeed passing the no-auth configuration to the
+    # connection.
+    assert isinstance(conn.auth_class, AuthNoAuth)
+
+    # We expect a failure here when executing queries, because invalid no-auth
+    # connection is not able to run any query
+    with pytest.raises(DatabaseError, match="Connection is closed"):
+        await conn.execute_string("select 1")
+
+    await conn.close()

test/unit/aio/test_auth_no_auth_async.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+#
+
+from __future__ import annotations
+
+import pytest
+
+
+@pytest.mark.skipolddriver
+async def test_auth_no_auth():
+    """Simple test for AuthNoAuth."""
+
+    # AuthNoAuth does not exist in old drivers, so we import at test level to
+    # skip importing it for old driver tests.
+    from snowflake.connector.aio.auth._no_auth import AuthNoAuth
+
+    auth = AuthNoAuth()
+
+    body = {"data": {}}
+    old_body = body.copy()  # Make a copy to compare against
+    await auth.update_body(body)
+    # update_body should be no-op for NO_AUTH, therefore the body content should remain the same.
+    assert body == old_body, f"body is {body}, old_body is {old_body}"
+
+    # assertion_content should always return None in NO_AUTH.
+    assert auth.assertion_content is None, auth.assertion_content
+
+    # reauthenticate should always return success.
+    expected_reauth_response = {"success": True}
+    reauth_response = await auth.reauthenticate()
+    assert (
+        reauth_response == expected_reauth_response
+    ), f"reauthenticate() is expected to return {expected_reauth_response}, but returns {reauth_response}"
+
+    # It also returns success response even if we pass extra keyword argument(s).
+    reauth_response = await auth.reauthenticate(foo="bar")
+    assert (
+        reauth_response == expected_reauth_response
+    ), f'reauthenticate(foo="bar") is expected to return {expected_reauth_response}, but returns {reauth_response}'