fix: tests improved for flask & fastapi frameworks and oauth

Author: Koman Rudden

testv2/testv2_auth/test_oauth.py

@@ -131,6 +131,110 @@ def mock_get_side_effect(key):
         self.oauth._framework = self.mock_framework
 
 
+    # -- Invitation code tests --
+
+    def test_generate_auth_url_with_invitation_code(self):
+        """invitation_code is included as a query parameter in the auth URL."""
+        result = run_async(self.oauth.generate_auth_url(
+            login_options={LoginOptions.INVITATION_CODE: "abc123"}
+        ))
+        params = parse_qs(urlparse(result["url"]).query)
+        self.assertEqual(params["invitation_code"], ["abc123"])
+
+    def test_generate_auth_url_invitation_code_auto_sets_is_invitation(self):
+        """is_invitation is automatically set to 'true' when invitation_code is present."""
+        result = run_async(self.oauth.generate_auth_url(
+            login_options={LoginOptions.INVITATION_CODE: "abc123"}
+        ))
+        params = parse_qs(urlparse(result["url"]).query)
+        self.assertEqual(params["is_invitation"], ["true"])
+
+    def test_generate_auth_url_invitation_code_with_explicit_is_invitation(self):
+        """Explicit is_invitation=True is honoured alongside invitation_code."""
+        result = run_async(self.oauth.generate_auth_url(
+            login_options={
+                LoginOptions.INVITATION_CODE: "abc123",
+                LoginOptions.IS_INVITATION: True,
+            }
+        ))
+        params = parse_qs(urlparse(result["url"]).query)
+        self.assertEqual(params["invitation_code"], ["abc123"])
+        self.assertEqual(params["is_invitation"], ["true"])
+
+    def test_generate_auth_url_invitation_code_overrides_false_is_invitation(self):
+        """invitation_code forces is_invitation='true' even when explicitly set to False."""
+        result = run_async(self.oauth.generate_auth_url(
+            login_options={
+                LoginOptions.INVITATION_CODE: "abc123",
+                LoginOptions.IS_INVITATION: False,
+            }
+        ))
+        params = parse_qs(urlparse(result["url"]).query)
+        self.assertEqual(params["is_invitation"], ["true"])
+
+    def test_generate_auth_url_is_invitation_alone(self):
+        """is_invitation=True works independently of invitation_code."""
+        result = run_async(self.oauth.generate_auth_url(
+            login_options={LoginOptions.IS_INVITATION: True}
+        ))
+        params = parse_qs(urlparse(result["url"]).query)
+        self.assertEqual(params["is_invitation"], ["true"])
+        self.assertNotIn("invitation_code", params)
+
+    def test_generate_auth_url_no_invitation_params_by_default(self):
+        """Neither invitation_code nor is_invitation appear when not specified."""
+        result = run_async(self.oauth.generate_auth_url(login_options={}))
+        params = parse_qs(urlparse(result["url"]).query)
+        self.assertNotIn("invitation_code", params)
+        self.assertNotIn("is_invitation", params)
+
+    def test_generate_auth_url_empty_invitation_code_ignored(self):
+        """An empty invitation_code does not add is_invitation."""
+        result = run_async(self.oauth.generate_auth_url(
+            login_options={LoginOptions.INVITATION_CODE: ""}
+        ))
+        params = parse_qs(urlparse(result["url"]).query)
+        self.assertNotIn("is_invitation", params)
+
+    def test_generate_auth_url_none_invitation_code_ignored(self):
+        """invitation_code=None is ignored entirely."""
+        result = run_async(self.oauth.generate_auth_url(
+            login_options={LoginOptions.INVITATION_CODE: None}
+        ))
+        params = parse_qs(urlparse(result["url"]).query)
+        self.assertNotIn("invitation_code", params)
+        self.assertNotIn("is_invitation", params)
+
+    def test_login_passes_invitation_code(self):
+        """login() forwards invitation_code to the generated auth URL."""
+        url = run_async(self.oauth.login(
+            login_options={LoginOptions.INVITATION_CODE: "inv_xyz"}
+        ))
+        params = parse_qs(urlparse(url).query)
+        self.assertEqual(params["invitation_code"], ["inv_xyz"])
+        self.assertEqual(params["is_invitation"], ["true"])
+
+    def test_login_without_invitation_code(self):
+        """login() without invitation options produces no invitation params."""
+        url = run_async(self.oauth.login())
+        params = parse_qs(urlparse(url).query)
+        self.assertNotIn("invitation_code", params)
+        self.assertNotIn("is_invitation", params)
+
+    def test_invitation_code_coexists_with_org_code(self):
+        """invitation_code and org_code can be used together."""
+        result = run_async(self.oauth.generate_auth_url(
+            login_options={
+                LoginOptions.INVITATION_CODE: "abc123",
+                LoginOptions.ORG_CODE: "org_456",
+            }
+        ))
+        params = parse_qs(urlparse(result["url"]).query)
+        self.assertEqual(params["invitation_code"], ["abc123"])
+        self.assertEqual(params["is_invitation"], ["true"])
+        self.assertEqual(params["org_code"], ["org_456"])
+
+
 class TestOAuthMethodSignatures(unittest.TestCase):
     """Test OAuth method signatures to verify the fix for incorrect request parameter passing."""
 

testv2/testv2_framework/test_fastapi_framework.py

@@ -0,0 +1,63 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from fastapi import FastAPI
+from starlette.testclient import TestClient
+from starlette.middleware.sessions import SessionMiddleware
+
+from kinde_fastapi.framework.fastapi_framework import FastAPIFramework
+
+
+class TestFastAPIFramework(unittest.TestCase):
+    """Tests for the FastAPI framework implementation."""
+
+    def setUp(self):
+        self.app = FastAPI()
+        self.app.add_middleware(SessionMiddleware, secret_key="test-secret")
+
+        self.framework = FastAPIFramework(app=self.app)
+
+        # Mock OAuth so no real auth happens
+        self.mock_oauth = MagicMock()
+        self.mock_oauth.login = AsyncMock(return_value="https://kinde.example.com/authorize")
+        self.framework._oauth = self.mock_oauth
+
+        # Register routes
+        self.framework._register_kinde_routes()
+
+        self.client = TestClient(self.app, follow_redirects=False)
+
+    def test_login_with_invitation_code(self):
+        """invitation_code query param is forwarded to oauth.login()."""
+        resp = self.client.get("/login?invitation_code=inv_abc123")
+
+        self.mock_oauth.login.assert_called_once()
+        login_options = self.mock_oauth.login.call_args[0][0]
+        self.assertEqual(login_options["invitation_code"], "inv_abc123")
+
+    def test_login_without_invitation_code(self):
+        """No invitation_code means oauth.login() gets an empty dict."""
+        resp = self.client.get("/login")
+
+        self.mock_oauth.login.assert_called_once()
+        login_options = self.mock_oauth.login.call_args[0][0]
+        self.assertNotIn("invitation_code", login_options)
+
+    def test_login_with_empty_invitation_code(self):
+        """An empty invitation_code query param is not forwarded."""
+        resp = self.client.get("/login?invitation_code=")
+
+        self.mock_oauth.login.assert_called_once()
+        login_options = self.mock_oauth.login.call_args[0][0]
+        self.assertNotIn("invitation_code", login_options)
+
+    def test_login_redirects_to_oauth_url(self):
+        """The route returns a redirect to the URL from oauth.login()."""
+        resp = self.client.get("/login?invitation_code=inv_xyz")
+
+        self.assertEqual(resp.status_code, 307)
+        self.assertEqual(resp.headers["location"], "https://kinde.example.com/authorize")
+
+
+if __name__ == "__main__":
+    unittest.main()

testv2/testv2_framework/test_flask_framework.py

@@ -0,0 +1,66 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock, patch
+from flask import Flask
+
+from kinde_flask.framework.flask_framework import FlaskFramework
+
+
+class TestFlaskFramework(unittest.TestCase):
+    """Tests for the Flask framework implementation."""
+
+    def setUp(self):
+        self.app = Flask(__name__)
+        self.app.config["SECRET_KEY"] = "test-secret"
+        self.app.config["TESTING"] = True
+
+        self.framework = FlaskFramework(app=self.app)
+
+        # Mock OAuth so no real auth happens
+        self.mock_oauth = MagicMock()
+        self.mock_oauth.login = AsyncMock(return_value="https://kinde.example.com/authorize")
+        self.framework._oauth = self.mock_oauth
+
+        # Register routes
+        self.framework._initialized = False
+        self.framework._register_kinde_routes()
+
+        self.client = self.app.test_client()
+
+    def test_login_with_invitation_code(self):
+        """invitation_code query param is forwarded to oauth.login()."""
+        with self.app.test_request_context():
+            resp = self.client.get("/login?invitation_code=inv_abc123")
+
+        self.mock_oauth.login.assert_called_once()
+        login_options = self.mock_oauth.login.call_args[0][0]
+        self.assertEqual(login_options["invitation_code"], "inv_abc123")
+
+    def test_login_without_invitation_code(self):
+        """No invitation_code means oauth.login() gets an empty dict."""
+        with self.app.test_request_context():
+            resp = self.client.get("/login")
+
+        self.mock_oauth.login.assert_called_once()
+        login_options = self.mock_oauth.login.call_args[0][0]
+        self.assertNotIn("invitation_code", login_options)
+
+    def test_login_with_empty_invitation_code(self):
+        """An empty invitation_code query param is not forwarded."""
+        with self.app.test_request_context():
+            resp = self.client.get("/login?invitation_code=")
+
+        self.mock_oauth.login.assert_called_once()
+        login_options = self.mock_oauth.login.call_args[0][0]
+        self.assertNotIn("invitation_code", login_options)
+
+    def test_login_redirects_to_oauth_url(self):
+        """The route returns a redirect to the URL from oauth.login()."""
+        with self.app.test_request_context():
+            resp = self.client.get("/login?invitation_code=inv_xyz")
+
+        self.assertEqual(resp.status_code, 302)
+        self.assertEqual(resp.headers["Location"], "https://kinde.example.com/authorize")
+
+
+if __name__ == "__main__":
+    unittest.main()