@aiquants/auth-react-router 0.6.0 → 0.7.0

package/src/server/google-strategy-impl.spec.ts

@@ -1,116 +0,0 @@
-/**
- * Tests for the ported GoogleStrategy (byte-parity with @coji/remix-auth-google).
- * 移植した GoogleStrategy のテスト (@coji/remix-auth-google との byte 一致)。
- */
-import { afterEach, describe, expect, it, vi } from "vitest"
-import type { GoogleProfile } from "./google-strategy-impl"
-import { GoogleStrategy, GoogleStrategyDefaultName, GoogleStrategyDefaultScopes } from "./google-strategy-impl"
-
-// authorizationParams / accessType 等は protected/private のため、テスト用サブクラスで公開する
-class ProbeStrategy extends GoogleStrategy<{ id: string }> {
-    exposeAuthorizationParams(params: URLSearchParams, request?: Request): URLSearchParams {
-        return this.authorizationParams(params, request)
-    }
-}
-
-const noopVerify = async () => ({ id: "x" })
-
-const makeProbe = (over?: Partial<ConstructorParameters<typeof GoogleStrategy>[0]>) =>
-    new ProbeStrategy(
-        {
-            clientId: "cid",
-            clientSecret: "csec",
-            redirectURI: "http://localhost/auth/api/google/callback",
-            ...over,
-        },
-        noopVerify,
-    )
-
-afterEach(() => {
-    vi.unstubAllGlobals()
-})
-
-describe("constants", () => {
-    it("keeps the original default scopes (full URL form)", () => {
-        expect(GoogleStrategyDefaultScopes).toEqual(["openid", "https://www.googleapis.com/auth/userinfo.profile", "https://www.googleapis.com/auth/userinfo.email"])
-    })
-
-    it("uses 'google' as the strategy name", () => {
-        expect(GoogleStrategyDefaultName).toBe("google")
-        expect(makeProbe().name).toBe("google")
-    })
-})
-
-describe("authorizationParams", () => {
-    it("applies the original defaults (access_type=online, include_granted_scopes=false, no prompt)", () => {
-        const params = makeProbe().exposeAuthorizationParams(new URLSearchParams())
-        expect(params.get("access_type")).toBe("online")
-        expect(params.get("include_granted_scopes")).toBe("false")
-        expect(params.get("prompt")).toBeNull()
-        expect(params.get("hd")).toBeNull()
-        expect(params.get("login_hint")).toBeNull()
-    })
-
-    it("reflects the quants config (offline / include_granted_scopes=true / prompt=consent)", () => {
-        const params = makeProbe({ accessType: "offline", includeGrantedScopes: true, prompt: "consent" }).exposeAuthorizationParams(new URLSearchParams())
-        expect(params.get("access_type")).toBe("offline")
-        expect(params.get("include_granted_scopes")).toBe("true")
-        expect(params.get("prompt")).toBe("consent")
-        expect(params.get("scope")).toBe("openid https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email")
-    })
-
-    it("formats multiple scopes cleanly with space separation including custom scopes like drive.readonly", () => {
-        const customScopes = ["openid", "email", "https://www.googleapis.com/auth/drive.readonly"] as const
-        // biome-ignore lint/suspicious/noExplicitAny: Custom scopes for testing
-        const params = makeProbe({ scopes: customScopes as any }).exposeAuthorizationParams(new URLSearchParams())
-        expect(params.get("scope")).toBe("openid email https://www.googleapis.com/auth/drive.readonly")
-    })
-
-    it("sets hd and login_hint only when provided", () => {
-        const params = makeProbe({ hd: "example.com", loginHint: "user@example.com" }).exposeAuthorizationParams(new URLSearchParams())
-        expect(params.get("hd")).toBe("example.com")
-        expect(params.get("login_hint")).toBe("user@example.com")
-    })
-})
-
-describe("userProfile", () => {
-    const rawUserinfo = {
-        sub: "107791905418691074770",
-        name: "宏治 テスト",
-        given_name: "宏治",
-        family_name: "テスト",
-        email: "user@example.com",
-        email_verified: true,
-        picture: "https://example.com/p.png",
-        locale: "ja",
-        hd: "example.com",
-    }
-
-    it("maps the userinfo (v3) response to GoogleProfile (sub→id, picture→photos, _json=raw)", async () => {
-        const fetchMock = vi.fn(async () => new Response(JSON.stringify(rawUserinfo), { status: 200 }))
-        vi.stubGlobal("fetch", fetchMock)
-
-        const profile: GoogleProfile = await GoogleStrategy.userProfile({ accessToken: () => "at" })
-
-        expect(profile.id).toBe("107791905418691074770")
-        expect(profile.displayName).toBe("宏治 テスト")
-        expect(profile.name).toEqual({ familyName: "テスト", givenName: "宏治" })
-        expect(profile.emails).toEqual([{ value: "user@example.com" }])
-        expect(profile.photos).toEqual([{ value: "https://example.com/p.png" }])
-        // _json は生レスポンスをそのまま保持 (email_verified / hd を含む — verify コールバックが依存)
-        expect(profile._json).toEqual(rawUserinfo)
-
-        // Bearer トークンを userinfo v3 へ送っている
-        const [url, init] = fetchMock.mock.calls[0]
-        expect(url).toBe("https://www.googleapis.com/oauth2/v3/userinfo")
-        expect((init as RequestInit).headers).toEqual({ Authorization: "Bearer at" })
-    })
-
-    it("throws when the userinfo response is not ok", async () => {
-        vi.stubGlobal(
-            "fetch",
-            vi.fn(async () => new Response("nope", { status: 401, statusText: "Unauthorized" })),
-        )
-        await expect(GoogleStrategy.userProfile({ accessToken: () => "at" })).rejects.toThrow("Failed to fetch user profile: Unauthorized")
-    })
-})

package/src/server/google-strategy.spec.ts

@@ -1,271 +0,0 @@
-/**
- * Tests for the Google verify callback (order, error mapping, profile shape).
- * Google verify コールバックのテスト (検証順序・エラー写像・プロファイル形状)。
- *
- * GoogleStrategy をコンストラクタ捕捉でフェイク化し、verify コールバックを直接起動する。
- */
-import type { MyGoogleProfile } from "@aiquants/auth-core"
-import { defaultAuthMessages } from "@aiquants/auth-core"
-import { beforeEach, describe, expect, it, vi } from "vitest"
-import type { AuthServerConfig, LoggerPort } from "./ports"
-
-type VerifyFn = (args: { request: Request; tokens: { data: Record<string, unknown> } }) => Promise<MyGoogleProfile>
-
-const captured: { options?: Record<string, unknown>; verify?: VerifyFn } = {}
-const userProfileMock = vi.hoisted(() => vi.fn())
-
-vi.mock("./google-strategy-impl", () => {
-    /** コンストラクタ引数を捕捉するフェイク GoogleStrategy。 */
-    class FakeGoogleStrategy {
-        static userProfile = userProfileMock
-        name = "google"
-        constructor(options: Record<string, unknown>, verify: VerifyFn) {
-            captured.options = options
-            captured.verify = verify
-        }
-    }
-    return { GoogleStrategy: FakeGoogleStrategy }
-})
-
-const { createGoogleAuthenticator } = await import("./google-strategy")
-
-const silentLogger: LoggerPort = { info: () => {}, warn: () => {}, error: () => {} }
-
-const googleProfile = () => ({
-    id: "107791905418691074770",
-    displayName: "宏治",
-    name: { familyName: "F", givenName: "G" },
-    emails: [{ value: "user@example.com" }],
-    photos: [{ value: "photo-url" }],
-    _json: {
-        sub: "107791905418691074770",
-        email: "user@example.com",
-        picture: "https://example.com/p.png",
-        email_verified: true,
-        hd: "example.com",
-    },
-})
-
-const tokens = (over?: Record<string, unknown>) => ({
-    data: { access_token: "at", refresh_token: "rt", expires_in: 3600, scope: "openid email profile", id_token: "idt", ...over },
-})
-
-const makeConfig = (over?: Partial<AuthServerConfig>): AuthServerConfig => ({
-    google: { clientId: "cid", clientSecret: "csec", redirectURI: "http://localhost/cb" },
-    session: { secrets: ["s"] },
-    isEmailAllowed: () => true,
-    logger: silentLogger,
-    ...over,
-})
-
-/** verify を起動して throw された Response の Location を返すヘルパー。 */
-const expectLoginRedirect = async (promise: Promise<unknown>): Promise<string> => {
-    try {
-        await promise
-        expect.unreachable("should have thrown a redirect")
-    } catch (error) {
-        expect(error).toBeInstanceOf(Response)
-        const location = (error as Response).headers.get("Location")
-        expect(location).not.toBeNull()
-        return location as string
-    }
-    return ""
-}
-
-beforeEach(() => {
-    userProfileMock.mockReset()
-    userProfileMock.mockResolvedValue(googleProfile())
-})
-
-describe("createGoogleAuthenticator options", () => {
-    it("passes injected google options with original defaults", () => {
-        createGoogleAuthenticator(makeConfig())
-        expect(captured.options).toMatchObject({
-            clientId: "cid",
-            clientSecret: "csec",
-            redirectURI: "http://localhost/cb",
-            accessType: "offline",
-            includeGrantedScopes: true,
-            prompt: "consent",
-        })
-    })
-
-    it("passes custom scopes through (sanledge 差分の吸収)", () => {
-        createGoogleAuthenticator(makeConfig({ google: { clientId: "c", clientSecret: "s", redirectURI: "u", scopes: ["openid", "email", "profile", "directory.readonly"] } }))
-        expect(captured.options?.scopes).toEqual(["openid", "email", "profile", "directory.readonly"])
-    })
-})
-
-describe("verify callback", () => {
-    it("runs backend verify → allowlist → signup in order and returns the profile with photo", async () => {
-        const order: string[] = []
-        const config = makeConfig({
-            backendAuth: {
-                verify: vi.fn(async () => {
-                    order.push("verify")
-                    return true
-                }),
-                signup: vi.fn(async () => {
-                    order.push("signup")
-                    return {}
-                }),
-            },
-            isEmailAllowed: (email) => {
-                order.push(`allowlist:${email}`)
-                return true
-            },
-        })
-        createGoogleAuthenticator(config)
-
-        const before = Date.now()
-        const user = await captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() })
-
-        // 検証順序: backend verify → allowlist → backend signup (原本と同一)
-        expect(order).toEqual(["verify", "allowlist:user@example.com", "signup"])
-        expect(config.backendAuth?.verify).toHaveBeenCalledWith("google", "at")
-        expect(config.backendAuth?.signup).toHaveBeenCalledWith("google", "at")
-        // プロファイル形状: _json/photos を含まず photo=picture、payload 付き
-        expect(user).toMatchObject({
-            id: "107791905418691074770",
-            displayName: "宏治",
-            emails: [{ value: "user@example.com" }],
-            accessToken: "at",
-            refreshToken: "rt",
-            provider: "google",
-            photo: "https://example.com/p.png",
-        })
-        expect(user && "_json" in user).toBe(false)
-        expect(user && "photos" in user).toBe(false)
-        expect(user?.expirationDateMs).toBeGreaterThanOrEqual(before + 3600 * 1000)
-    })
-
-    it("redirects with emailNotVerified when a field is missing AND email_verified is false (原本セマンティクス)", async () => {
-        // 原本の分岐は「必須フィールド欠落 (undefined) の場合」に限り email_verified===false を
-        // 判別してメッセージを出し分ける (email_verified: false 単独では発火しない) — bug-for-bug 保存
-        userProfileMock.mockResolvedValue({ ...googleProfile(), _json: { ...googleProfile()._json, email: undefined, email_verified: false } })
-        createGoogleAuthenticator(makeConfig())
-        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() }) as Promise<unknown>)
-        expect(location).toBe(`/auth/login?error=${encodeURIComponent(defaultAuthMessages.emailNotVerified)}`)
-    })
-
-    it("redirects with googleFailed when the refresh token is missing", async () => {
-        createGoogleAuthenticator(makeConfig())
-        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens({ refresh_token: undefined }) }) as Promise<unknown>)
-        expect(location).toBe(`/auth/login?error=${encodeURIComponent(defaultAuthMessages.googleFailed)}`)
-    })
-
-    it("redirects with backendFailed when backend verify returns false", async () => {
-        createGoogleAuthenticator(makeConfig({ backendAuth: { verify: async () => false, signup: async () => ({}) } }))
-        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() }) as Promise<unknown>)
-        expect(location).toBe(`/auth/login?error=${encodeURIComponent(defaultAuthMessages.backendFailed)}`)
-    })
-
-    it("redirects with backendUnreachable on getaddrinfo ENOTFOUND cause", async () => {
-        createGoogleAuthenticator(
-            makeConfig({
-                backendAuth: {
-                    verify: async () => {
-                        throw new Error("Network or Interface Error", { cause: new Error("getaddrinfo ENOTFOUND api.example.com") })
-                    },
-                    signup: async () => ({}),
-                },
-            }),
-        )
-        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() }) as Promise<unknown>)
-        expect(location).toBe(`/auth/login?error=${encodeURIComponent(defaultAuthMessages.backendUnreachable)}`)
-    })
-
-    it("redirects with notAllowed when the allowlist rejects the email", async () => {
-        const signup = vi.fn(async () => ({}))
-        createGoogleAuthenticator(makeConfig({ isEmailAllowed: () => false, backendAuth: { verify: async () => true, signup } }))
-        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() }) as Promise<unknown>)
-        expect(location).toBe(`/auth/login?error=${encodeURIComponent(defaultAuthMessages.notAllowed)}`)
-        // allowlist 拒否時は signup に到達しない (fail-closed)
-        expect(signup).not.toHaveBeenCalled()
-    })
-
-    // ⚠️ 回帰ガード: `isEmailAllowed` は非同期実装を許すため、呼び出し側の `await` が外れると
-    //    `!Promise` が常に false となり **許可判定を素通り (fail-open)** する。型検査では検出できない。
-    it("REGRESSION GUARD: an ASYNC deny predicate must still block (missing await would fail OPEN)", async () => {
-        const signup = vi.fn(async () => ({}))
-        createGoogleAuthenticator(makeConfig({ isEmailAllowed: async () => false, backendAuth: { verify: async () => true, signup } }))
-        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() }) as Promise<unknown>)
-        expect(location).toBe(`/auth/login?error=${encodeURIComponent(defaultAuthMessages.notAllowed)}`)
-        expect(signup).not.toHaveBeenCalled()
-    })
-
-    it("an ASYNC allow predicate lets the login through (await resolves the value, not the Promise)", async () => {
-        const allowlist = vi.fn(async () => true)
-        createGoogleAuthenticator(makeConfig({ isEmailAllowed: allowlist }))
-        const user = await captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() })
-        expect(user?.photo).toBe("https://example.com/p.png")
-        expect(allowlist).toHaveBeenCalledWith("user@example.com")
-    })
-
-    it("a REJECTING allowlist (e.g. database unreachable) fails CLOSED", async () => {
-        const signup = vi.fn(async () => ({}))
-        createGoogleAuthenticator(
-            makeConfig({
-                isEmailAllowed: async () => {
-                    throw new Error("ECONNREFUSED sql")
-                },
-                backendAuth: { verify: async () => true, signup },
-            }),
-        )
-        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() }) as Promise<unknown>)
-        // 許可されない以上ログインは成立しない (メッセージは汎用エラー)
-        expect(location).toContain("/auth/login?error=")
-        expect(signup).not.toHaveBeenCalled()
-    })
-
-    it("REGRESSION GUARD: a DEACTIVATED account cannot sign in even when the allowlist permits it", async () => {
-        const signup = vi.fn(async () => ({}))
-        createGoogleAuthenticator(makeConfig({ isEmailAllowed: () => true, isUserActive: async () => false, backendAuth: { verify: async () => true, signup } }))
-        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() }) as Promise<unknown>)
-        expect(location).toBe(`/auth/login?error=${encodeURIComponent(defaultAuthMessages.notAllowed)}`)
-        expect(signup).not.toHaveBeenCalled()
-    })
-
-    it("an ACTIVE account signs in normally, and the port receives the profile", async () => {
-        const isUserActive = vi.fn(async () => true)
-        createGoogleAuthenticator(makeConfig({ isUserActive }))
-        const user = await captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() })
-        expect(user?.photo).toBe("https://example.com/p.png")
-        expect(isUserActive).toHaveBeenCalledWith(expect.objectContaining({ emails: [{ value: "user@example.com" }] }))
-    })
-
-    it("omitting isUserActive keeps the previous behaviour", async () => {
-        createGoogleAuthenticator(makeConfig({}))
-        const user = await captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() })
-        expect(user?.photo).toBe("https://example.com/p.png")
-    })
-
-    it("redirects with unexpected on generic signup failure", async () => {
-        createGoogleAuthenticator(
-            makeConfig({
-                backendAuth: {
-                    verify: async () => true,
-                    signup: async () => {
-                        throw new Error("boom")
-                    },
-                },
-            }),
-        )
-        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() }) as Promise<unknown>)
-        expect(location).toBe(`/auth/login?error=${encodeURIComponent(defaultAuthMessages.unexpected)}`)
-    })
-
-    it("skips backend verify/signup when backendAuth is omitted but still enforces the allowlist", async () => {
-        const allowlist = vi.fn(() => true)
-        createGoogleAuthenticator(makeConfig({ isEmailAllowed: allowlist }))
-        const user = await captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() })
-        expect(user?.photo).toBe("https://example.com/p.png")
-        expect(allowlist).toHaveBeenCalledWith("user@example.com")
-    })
-
-    it("honors message overrides", async () => {
-        createGoogleAuthenticator(makeConfig({ isEmailAllowed: () => false, messages: { notAllowed: "立入禁止" } }))
-        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() }) as Promise<unknown>)
-        expect(location).toBe(`/auth/login?error=${encodeURIComponent("立入禁止")}`)
-    })
-})

package/src/server/handlers.spec.ts

@@ -1,154 +0,0 @@
-/**
- * Tests for the auth route handlers (login/logout/callback).
- * 認証ルートハンドラ (login/logout/callback) のテスト。
- */
-import type { MyGoogleProfile } from "@aiquants/auth-core"
-import type { Authenticator } from "remix-auth"
-import { describe, expect, it } from "vitest"
-import { createAuthHandlers } from "./handlers"
-import type { AuthServerConfig, LoggerPort } from "./ports"
-import { createAuthSessionStorage } from "./session"
-
-const silentLogger: LoggerPort = { info: () => {}, warn: () => {}, error: () => {} }
-
-const config: AuthServerConfig = {
-    google: { clientId: "cid", clientSecret: "csec", redirectURI: "http://localhost/cb" },
-    session: { secrets: ["test-secret"] },
-    isEmailAllowed: () => true,
-    logger: silentLogger,
-}
-
-const googleProfile: MyGoogleProfile = {
-    id: "107791905418691074770",
-    displayName: "宏治",
-    name: { familyName: "F", givenName: "G" },
-    emails: [{ value: "u@example.com" }],
-    photo: "https://example.com/p.png",
-    accessToken: "at",
-    refreshToken: "rt",
-    expirationDateMs: 1750000000000,
-    provider: "google",
-}
-
-const fakeAuthenticator = (result: MyGoogleProfile | Error): Authenticator<MyGoogleProfile> =>
-    ({
-        authenticate: async () => {
-            if (result instanceof Error) throw result
-            return result
-        },
-    }) as unknown as Authenticator<MyGoogleProfile>
-
-const setup = (authResult: MyGoogleProfile | Error = googleProfile) => {
-    const storage = createAuthSessionStorage(config.session)
-    const handlers = createAuthHandlers(config, storage, fakeAuthenticator(authResult), silentLogger)
-    return { storage, handlers }
-}
-
-describe("loginLoader", () => {
-    it("returns the error query param for unauthenticated users", async () => {
-        const { handlers } = setup()
-        const data = await handlers.loginLoader({ request: new Request("http://localhost/auth/login?error=oops") })
-        expect(data).toEqual({ error: "oops" })
-    })
-
-    it("redirects authenticated users to the post-login path", async () => {
-        const { handlers, storage } = setup()
-        const cookie = await storage.saveSession(new Request("http://localhost/"), googleProfile)
-        try {
-            await handlers.loginLoader({ request: new Request("http://localhost/auth/login", { headers: { Cookie: cookie } }) })
-            expect.unreachable("should have thrown a redirect")
-        } catch (error) {
-            expect((error as Response).headers.get("Location")).toBe("/")
-        }
-    })
-})
-
-describe("loginAction", () => {
-    it("authenticates on the Google form action", async () => {
-        const { handlers } = setup()
-        const form = new FormData()
-        form.set("_action", "Sign In with Google")
-        const user = await handlers.loginAction({ request: new Request("http://localhost/auth/login", { method: "POST", body: form }) })
-        expect(user).toEqual(googleProfile)
-    })
-
-    it("returns null for unknown actions", async () => {
-        const { handlers } = setup()
-        const form = new FormData()
-        form.set("_action", "Something Else")
-        const user = await handlers.loginAction({ request: new Request("http://localhost/auth/login", { method: "POST", body: form }) })
-        expect(user).toBeNull()
-    })
-})
-
-describe("logoutLoader", () => {
-    it("destroys the session and redirects with Set-Cookie", async () => {
-        const { handlers, storage } = setup()
-        const cookie = await storage.saveSession(new Request("http://localhost/"), googleProfile)
-        try {
-            await handlers.logoutLoader({ request: new Request("http://localhost/auth/logout", { headers: { Cookie: cookie } }) })
-            expect.unreachable("should have thrown a redirect")
-        } catch (error) {
-            const res = error as Response
-            expect(res.headers.get("Location")).toBe("/")
-            expect(res.headers.get("Set-Cookie")).toContain("__session=")
-        }
-    })
-})
-
-describe("googleCallbackLoader", () => {
-    it("saves a byte-compatible SessionProfile (no photo) and redirects home", async () => {
-        const { handlers, storage } = setup()
-        try {
-            await handlers.googleCallbackLoader({ request: new Request("http://localhost/auth/api/google/callback?code=x") })
-            expect.unreachable("should have thrown a redirect")
-        } catch (error) {
-            const res = error as Response
-            expect(res.headers.get("Location")).toBe("/")
-            const setCookie = res.headers.get("Set-Cookie")
-            expect(setCookie).toContain("__session=")
-
-            // 保存されたセッションを読み戻し、photo を含まない byte 互換形状を検証
-            const user = await storage.getSessionUser(new Request("http://localhost/", { headers: { Cookie: setCookie ?? "" } }))
-            expect(user).toEqual({
-                id: googleProfile.id,
-                displayName: googleProfile.displayName,
-                name: googleProfile.name,
-                emails: googleProfile.emails,
-                accessToken: "at",
-                refreshToken: "rt",
-                expirationDateMs: 1750000000000,
-                provider: "google",
-                role: undefined,
-            })
-            expect(user && "photo" in user).toBe(false)
-        }
-    })
-
-    it("redirects to the login page on authenticator errors", async () => {
-        const { handlers } = setup(new Error("access_denied"))
-        try {
-            await handlers.googleCallbackLoader({ request: new Request("http://localhost/auth/api/google/callback") })
-            expect.unreachable("should have thrown a redirect")
-        } catch (error) {
-            expect((error as Response).headers.get("Location")).toBe("/auth/login")
-        }
-    })
-
-    it("re-throws Response errors from the authenticator as-is", async () => {
-        const redirectResponse = new Response(null, { status: 302, headers: { Location: "/auth/login?error=x" } })
-        const storage = createAuthSessionStorage(config.session)
-        const authenticator = {
-            authenticate: async () => {
-                throw redirectResponse
-            },
-        } as unknown as Authenticator<MyGoogleProfile>
-        const handlers = createAuthHandlers(config, storage, authenticator, silentLogger)
-        try {
-            await handlers.googleCallbackLoader({ request: new Request("http://localhost/auth/api/google/callback") })
-            expect.unreachable("should have thrown the response")
-        } catch (error) {
-            expect(error).toBe(redirectResponse)
-        }
-    })
-})