@soapjs/soap-auth 0.4.0 → 1.0.0

package/build/strategies/__tests__/credential-auth.strategy.test.js

@@ -1,266 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestCredentialAuthStrategy = void 0;
-const Soap = __importStar(require("@soapjs/soap"));
-const errors_1 = require("../../../src/errors");
-const credential_auth_strategy_1 = require("../credential-auth.strategy");
-jest.mock("../../session/session-handler");
-jest.mock("../jwt/jwt.strategy");
-class TestCredentialAuthStrategy extends credential_auth_strategy_1.CredentialAuthStrategy {
-    name = "test-credential";
-    constructor(config, session, jwt, logger) {
-        super(config, session, jwt, logger);
-    }
-    async verifyCredentials(identifier, password) {
-        return true;
-    }
-    async extractCredentials(context) {
-        return { identifier: "testUser", password: "testPass" };
-    }
-    async fetchUser(credentials) {
-        return { id: "1", name: "Test User" };
-    }
-}
-exports.TestCredentialAuthStrategy = TestCredentialAuthStrategy;
-describe("CredentialAuthStrategy", () => {
-    let strategy;
-    let config;
-    let mockSession;
-    let mockJwt;
-    let mockLogger;
-    const mockUser = { id: "user123", username: "testuser" };
-    const context = { headers: {}, body: {} };
-    beforeEach(() => {
-        mockLogger = {
-            info: jest.fn(),
-            warn: jest.fn(),
-            error: jest.fn(),
-        };
-        mockSession = {
-            logoutSession: jest.fn().mockResolvedValue(undefined),
-            issueSession: jest.fn().mockResolvedValue("session-id"),
-            getSessionId: jest.fn().mockReturnValue("session-id"),
-            getSessionData: jest
-                .fn()
-                .mockResolvedValue({ user: { id: "1", name: "Test" } }),
-        };
-        mockJwt = {
-            authenticate: jest.fn(),
-            issueTokens: jest.fn().mockResolvedValue({
-                accessToken: "fakeAccess",
-                refreshToken: "fakeRefresh",
-            }),
-        };
-        config = {
-            failedAttempts: {
-                incrementFailedAttempts: jest.fn(),
-                resetFailedAttempts: jest.fn(),
-                getFailedAttempts: jest.fn(),
-            },
-            role: {
-                authorizeByRoles: jest.fn().mockResolvedValue(true),
-                roles: ["user"],
-            },
-            rateLimit: {
-                checkRateLimit: jest.fn().mockResolvedValue(false),
-            },
-            mfa: {
-                isMfaRequired: jest.fn().mockReturnValue(false),
-            },
-            passwordPolicy: {
-                updatePassword: jest.fn(),
-                generateResetToken: jest.fn(),
-                validatePasswordResetToken: jest.fn(),
-                sendPasswordResetEmail: jest.fn(),
-            },
-            security: {
-                maxFailedLoginAttempts: 3,
-                lockoutDuration: 10,
-                notifyOnLockout: jest.fn(),
-            },
-            lock: {
-                isAccountLocked: jest.fn(),
-            },
-            user: {
-                fetchUser: jest.fn(),
-            },
-        };
-        strategy = new TestCredentialAuthStrategy(config, mockSession, mockJwt, mockLogger);
-    });
-    describe("authenticate", () => {
-        it("should use JWT if available and return its result", async () => {
-            mockJwt.authenticate.mockResolvedValue({
-                user: { id: "1", name: "JWT User" },
-            });
-            const result = await strategy.authenticate(context);
-            expect(mockJwt.authenticate).toHaveBeenCalledWith(context);
-            expect(result).toEqual({
-                user: { id: "1", name: "JWT User" },
-            });
-        });
-        it("should fall back to authenticateWithSession if JWT throws an error", async () => {
-            mockJwt.authenticate.mockRejectedValue(new Error("JWT error"));
-            const result = await strategy.authenticate(context);
-            expect(mockLogger.warn).toHaveBeenCalledWith("JWT authentication failed, falling back to session.");
-            expect(result.user).toEqual({ id: "1", name: "Test" });
-        });
-        it("should use session if JWT is not defined but session is available", async () => {
-            strategy = new TestCredentialAuthStrategy(config, mockSession, undefined, mockLogger);
-            const result = await strategy.authenticate(context);
-            expect(result.user).toEqual({ id: "1", name: "Test" });
-        });
-        it("should return user=null if no JWT/session and allowGuest = true", async () => {
-            config.allowGuest = true;
-            strategy = new TestCredentialAuthStrategy(config, undefined, undefined, mockLogger);
-            const result = await strategy.authenticate(context);
-            expect(mockLogger.warn).toHaveBeenCalledWith("No authentication method found. Proceeding as guest.");
-            expect(result.user).toBeNull();
-        });
-        it("should throw UserNotFoundError if no JWT/session and allowGuest = false", async () => {
-            config.allowGuest = false;
-            strategy = new TestCredentialAuthStrategy(config, undefined, undefined, mockLogger);
-            await expect(strategy.authenticate(context)).rejects.toThrow(errors_1.UserNotFoundError);
-        });
-    });
-    describe("login", () => {
-        it("should throw MissingCredentialsError if credentials are missing", async () => {
-            jest
-                .spyOn(strategy, "extractCredentials")
-                .mockResolvedValueOnce(undefined);
-            await expect(strategy.login(context)).rejects.toThrow(errors_1.MissingCredentialsError);
-        });
-        it("should throw InvalidCredentialsError if verifyCredentials returns false", async () => {
-            jest
-                .spyOn(strategy, "verifyCredentials")
-                .mockResolvedValueOnce(false);
-            await expect(strategy.login(context)).rejects.toThrow(errors_1.InvalidCredentialsError);
-        });
-        it("should throw ExpiredPasswordError if the password is expired", async () => {
-            jest
-                .spyOn(strategy.password, "isPasswordChangeRequired")
-                .mockResolvedValueOnce(true);
-            await expect(strategy.login(context)).rejects.toThrow(errors_1.ExpiredPasswordError);
-        });
-        it("should return user, tokens, and session on success", async () => {
-            const result = await strategy.login(context);
-            expect(result.user).toBeDefined();
-            expect(result.tokens).toBeDefined();
-            expect(result.session).toBeDefined();
-        });
-    });
-    describe("logout", () => {
-        it("should call session.logoutSession and onSuccess", async () => {
-            const onSuccessSpy = jest.spyOn(strategy, "onSuccess");
-            await strategy.logout(context);
-            expect(mockSession.logoutSession).toHaveBeenCalledWith(context);
-            expect(onSuccessSpy).toHaveBeenCalledWith("logout", context);
-        });
-        it("should call onFailure and rethrow the error if session.logoutSession fails", async () => {
-            const onFailureSpy = jest.spyOn(strategy, "onFailure");
-            mockSession.logoutSession.mockRejectedValueOnce(new Error("Session error"));
-            await expect(strategy.logout(context)).rejects.toThrow("Session error");
-            expect(onFailureSpy).toHaveBeenCalledWith("logout", {
-                error: expect.any(Error),
-            });
-        });
-    });
-    describe("requestPasswordReset", () => {
-        it("should throw NotImplementedError if generateResetToken is not configured", async () => {
-            config.passwordPolicy.generateResetToken = undefined;
-            await expect(strategy.requestPasswordResetLink("testUser")).rejects.toThrow(Soap.NotImplementedError);
-        });
-        it("should call generateResetToken and sendResetEmail (if email is provided)", async () => {
-            config.passwordPolicy.generateResetToken = jest
-                .fn()
-                .mockResolvedValue("mockToken");
-            config.passwordPolicy.sendPasswordResetEmail = jest
-                .fn()
-                .mockResolvedValue(undefined);
-            await strategy.requestPasswordResetLink("testUser", "test@example.com");
-            expect(config.passwordPolicy.generateResetToken).toHaveBeenCalledWith("testUser");
-            expect(config.passwordPolicy.sendPasswordResetEmail).toHaveBeenCalledWith("test@example.com", "mockToken");
-        });
-        it("should call onSuccess with the correct data", async () => {
-            config.passwordPolicy.generateResetToken = jest
-                .fn()
-                .mockResolvedValue("mockToken");
-            const onSuccessSpy = jest.spyOn(strategy, "onSuccess");
-            await strategy.requestPasswordResetLink("testUser");
-            expect(onSuccessSpy).toHaveBeenCalledWith("request_password_reset", {
-                identifier: "testUser",
-                tokens: { reset: "mockToken" },
-            });
-        });
-    });
-    describe("resetPassword", () => {
-        it("should throw NotImplementedError if validateResetToken or updatePassword are not configured", async () => {
-            config.passwordPolicy.updatePassword = undefined;
-            await expect(strategy.resetPasswordWithToken("testUser", "token", "newPass")).rejects.toThrow(Soap.NotImplementedError);
-        });
-        it("should throw ExpiredResetTokenError if validateResetToken returns false", async () => {
-            config.passwordPolicy.validatePasswordResetToken = jest
-                .fn()
-                .mockResolvedValue(false);
-            config.passwordPolicy.updatePassword = jest.fn();
-            await expect(strategy.resetPasswordWithToken("testUser", "token", "newPass")).rejects.toThrow(errors_1.ExpiredResetTokenError);
-        });
-        it("should call updatePassword if the token is valid", async () => {
-            config.passwordPolicy.validatePasswordResetToken = jest
-                .fn()
-                .mockResolvedValue(true);
-            config.passwordPolicy.updatePassword = jest
-                .fn()
-                .mockResolvedValue(undefined);
-            await strategy.resetPasswordWithToken("testUser", "validToken", "newPass");
-            expect(config.passwordPolicy.updatePassword).toHaveBeenCalledWith("testUser", "newPass", undefined);
-        });
-    });
-    describe("changePassword", () => {
-        it("should throw NotImplementedError if updatePassword is not configured", async () => {
-            config.passwordPolicy.updatePassword = undefined;
-            await expect(strategy.replacePassword("testUser", "oldPass", "newPass")).rejects.toThrow(Soap.NotImplementedError);
-        });
-        it("should throw InvalidCredentialsError if verifyCredentials returns false", async () => {
-            config.passwordPolicy.updatePassword = jest
-                .fn()
-                .mockResolvedValue(undefined);
-            jest
-                .spyOn(strategy, "verifyCredentials")
-                .mockResolvedValueOnce(false);
-            await expect(strategy.replacePassword("testUser", "oldPass", "newPass")).rejects.toThrow(errors_1.InvalidCredentialsError);
-        });
-        it("should call updatePassword with new password if old credentials are correct", async () => {
-            config.passwordPolicy.updatePassword = jest
-                .fn()
-                .mockResolvedValue(undefined);
-            jest
-                .spyOn(strategy, "verifyCredentials")
-                .mockResolvedValueOnce(true);
-            await strategy.replacePassword("testUser", "oldPass", "newPass");
-            expect(config.passwordPolicy.updatePassword).toHaveBeenCalledWith("testUser", "newPass", undefined);
-        });
-    });
-});

package/build/strategies/__tests__/token-auth.strategy.test.d.ts

@@ -1,29 +0,0 @@
-import * as Soap from "@soapjs/soap";
-import { TokenAuthStrategy } from "../token-auth.strategy";
-import { SessionHandler } from "../../session";
-import { TokenAuthStrategyConfig } from "../../../src/types";
-export interface MockUser {
-    id: string;
-    name: string;
-}
-export interface MockContext {
-    accessToken?: string;
-    refreshToken?: string;
-}
-export declare class TestTokenAuthStrategy extends TokenAuthStrategy<MockContext, MockUser> {
-    readonly name = "test-token";
-    protected invalidateAccessToken(token: string, context?: MockContext): Promise<void>;
-    protected invalidateRefreshToken(token: string, context?: MockContext): Promise<void>;
-    constructor(config: TokenAuthStrategyConfig<MockContext, MockUser>, session?: SessionHandler, logger?: Soap.Logger);
-    protected fetchUser(payload: any): Promise<MockUser | null>;
-    protected extractAccessToken(context: MockContext): string | undefined;
-    protected extractRefreshToken(context: MockContext): string | undefined;
-    protected verifyAccessToken(token: string): Promise<any>;
-    protected verifyRefreshToken(token: string): Promise<any>;
-    protected generateAccessToken(user: MockUser, context: MockContext): Promise<string>;
-    protected generateRefreshToken(user: MockUser, context: MockContext): Promise<string>;
-    protected storeAccessToken(token: string): Promise<void>;
-    protected storeRefreshToken(token: string): Promise<void>;
-    protected embedAccessToken(token: string, context: MockContext): void;
-    protected embedRefreshToken(token: string, context: MockContext): void;
-}

package/build/strategies/__tests__/token-auth.strategy.test.js

@@ -1,299 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestTokenAuthStrategy = void 0;
-const token_auth_strategy_1 = require("../token-auth.strategy");
-const errors_1 = require("../../../src/errors");
-class TestTokenAuthStrategy extends token_auth_strategy_1.TokenAuthStrategy {
-    name = "test-token";
-    async invalidateAccessToken(token, context) {
-        context.accessToken = undefined;
-    }
-    async invalidateRefreshToken(token, context) {
-        context.refreshToken = undefined;
-    }
-    constructor(config, session, logger) {
-        super(config, session, logger);
-    }
-    async fetchUser(payload) {
-        return { id: "testUserId", name: "Test User" };
-    }
-    extractAccessToken(context) {
-        return context.accessToken;
-    }
-    extractRefreshToken(context) {
-        return context.refreshToken;
-    }
-    async verifyAccessToken(token) {
-        return { userId: "testUserId" };
-    }
-    async verifyRefreshToken(token) {
-        return { userId: "testUserId" };
-    }
-    async generateAccessToken(user, context) {
-        return "newAccessToken";
-    }
-    async generateRefreshToken(user, context) {
-        return "newRefreshToken";
-    }
-    async storeAccessToken(token) {
-    }
-    async storeRefreshToken(token) {
-    }
-    embedAccessToken(token, context) {
-        context.accessToken = token;
-    }
-    embedRefreshToken(token, context) {
-        context.refreshToken = token;
-    }
-}
-exports.TestTokenAuthStrategy = TestTokenAuthStrategy;
-const jsonwebtoken_1 = require("jsonwebtoken");
-describe("TokenAuthStrategy", () => {
-    let config;
-    let strategy;
-    let mockSession;
-    let mockLogger;
-    let mockRateLimitService;
-    let mockRoleService;
-    let mockThrottleService;
-    let mockAccountLockService;
-    let mockMfaService;
-    let context;
-    beforeEach(() => {
-        config = {
-            refreshToken: {
-                enabled: true,
-            },
-        };
-        mockSession = {
-            logoutSession: jest.fn().mockResolvedValue(undefined),
-        };
-        mockLogger = {
-            warn: jest.fn(),
-            error: jest.fn(),
-            info: jest.fn(),
-        };
-        mockRateLimitService = {
-            checkRateLimit: jest.fn().mockResolvedValue(undefined),
-        };
-        mockRoleService = {
-            isAuthorized: jest.fn().mockResolvedValue(true),
-        };
-        mockThrottleService = {};
-        mockAccountLockService = {};
-        mockMfaService = {};
-        context = {
-            accessToken: undefined,
-            refreshToken: undefined,
-        };
-        strategy = new TestTokenAuthStrategy(config, mockSession, mockLogger);
-        strategy.rateLimit = mockRateLimitService;
-        strategy.role = mockRoleService;
-        strategy.throttle = mockThrottleService;
-        strategy.accountLock = mockAccountLockService;
-        strategy.mfa = mockMfaService;
-    });
-    describe("authenticate", () => {
-        it("should throw MissingTokenError if no access token and refreshToken is disabled in config", async () => {
-            config.refreshToken = undefined;
-            await expect(strategy.authenticate(context)).rejects.toThrowError(errors_1.MissingTokenError);
-            expect(mockRateLimitService.checkRateLimit).toHaveBeenCalledWith(context);
-        });
-        it("should verify access token if present and return user + tokens if valid", async () => {
-            context.accessToken = "validAccessToken";
-            const result = await strategy.authenticate(context);
-            expect(result.user).toEqual({ id: "testUserId", name: "Test User" });
-            expect(result.tokens).toEqual({ accessToken: "validAccessToken" });
-            expect(mockRoleService.isAuthorized).toHaveBeenCalledWith({
-                id: "testUserId",
-                name: "Test User",
-            });
-            expect(mockLogger.warn).not.toHaveBeenCalled();
-        });
-        it("should fallback to refresh token if access token is invalid or expired", async () => {
-            context.accessToken = "invalidAccessToken";
-            context.refreshToken = "validRefreshToken";
-            jest
-                .spyOn(strategy, "verifyAccessToken")
-                .mockRejectedValue(new jsonwebtoken_1.TokenExpiredError("expired", new Date()));
-            const refreshSpy = jest
-                .spyOn(strategy, "refreshTokens")
-                .mockResolvedValue({
-                user: { id: "testUserId", name: "Refreshed User" },
-                tokens: {
-                    accessToken: "refreshedAccess",
-                    refreshToken: "refreshedRefresh",
-                },
-            });
-            const result = await strategy.authenticate(context);
-            expect(mockLogger.warn).toHaveBeenCalledWith("Access token expired, attempting refresh...");
-            expect(refreshSpy).toHaveBeenCalledWith(context);
-            expect(result).toEqual({
-                user: { id: "testUserId", name: "Refreshed User" },
-                tokens: {
-                    accessToken: "refreshedAccess",
-                    refreshToken: "refreshedRefresh",
-                },
-            });
-        });
-        it("should throw MissingTokenError if no access token and no refresh token provided", async () => {
-            context.accessToken = undefined;
-            context.refreshToken = undefined;
-            await expect(strategy.authenticate(context)).rejects.toThrow(errors_1.MissingTokenError);
-        });
-    });
-    describe("refreshTokens", () => {
-        it("should throw an error if refresh tokens are not enabled in config", async () => {
-            config.refreshToken = undefined;
-            await expect(strategy.refreshTokens(context)).rejects.toThrowError("Refresh tokens are not enabled.");
-        });
-        it("should throw MissingTokenError if no refresh token is provided", async () => {
-            config.refreshToken = {};
-            await expect(strategy.refreshTokens(context)).rejects.toThrow(errors_1.MissingTokenError);
-        });
-        it("should throw InvalidTokenError if refresh token is invalid", async () => {
-            context.refreshToken = "invalidRefreshToken";
-            jest
-                .spyOn(strategy, "verifyRefreshToken")
-                .mockRejectedValue(new errors_1.InvalidTokenError("Refresh"));
-            await expect(strategy.refreshTokens(context)).rejects.toThrow(errors_1.InvalidTokenError);
-        });
-        it("should throw UserNotFoundError if user retrieval returns null", async () => {
-            context.refreshToken = "validRefresh";
-            jest.spyOn(strategy, "fetchUser").mockResolvedValueOnce(null);
-            await expect(strategy.refreshTokens(context)).rejects.toThrow(errors_1.UserNotFoundError);
-        });
-        it("should return new access token (and refresh token) on success", async () => {
-            context.refreshToken = "validRefresh";
-            jest
-                .spyOn(strategy, "verifyRefreshToken")
-                .mockResolvedValueOnce({ userId: "testUserId" });
-            jest
-                .spyOn(strategy, "generateAccessToken")
-                .mockResolvedValueOnce("newAccessToken");
-            jest
-                .spyOn(strategy, "generateRefreshToken")
-                .mockResolvedValueOnce("newRefreshToken");
-            const storeAccessSpy = jest.spyOn(strategy, "storeAccessToken");
-            const storeRefreshSpy = jest.spyOn(strategy, "storeRefreshToken");
-            const result = await strategy.refreshTokens(context);
-            expect(storeAccessSpy).toHaveBeenCalledWith("newAccessToken");
-            expect(storeRefreshSpy).toHaveBeenCalledWith("newRefreshToken");
-            expect(result).toEqual({
-                user: { id: "testUserId", name: "Test User" },
-                tokens: {
-                    accessToken: "newAccessToken",
-                    refreshToken: "newRefreshToken",
-                },
-            });
-        });
-        describe("absoluteExpiry", () => {
-            it("should log a warning and throw InvalidTokenError if absolute expiry is exceeded (onExpiry=error)", async () => {
-                config.refreshToken = {
-                    absoluteExpiry: {
-                        payloadField: "absoluteExp",
-                        onExpiry: "error",
-                    },
-                };
-                context.refreshToken = "validRefresh";
-                jest
-                    .spyOn(strategy, "verifyRefreshToken")
-                    .mockResolvedValueOnce({
-                    userId: "testUserId",
-                    absoluteExp: Math.floor(Date.now() / 1000) - 1000,
-                });
-                await expect(strategy.refreshTokens(context)).rejects.toThrow(errors_1.InvalidTokenError);
-                expect(mockLogger.warn).toHaveBeenCalledWith("Absolute expiry exceeded for refresh token.");
-            });
-            it("should call logoutSession and throw if onExpiry=logout", async () => {
-                config.refreshToken = {
-                    absoluteExpiry: {
-                        payloadField: "absoluteExp",
-                        onExpiry: "logout",
-                    },
-                };
-                context.refreshToken = "validRefresh";
-                jest
-                    .spyOn(strategy, "verifyRefreshToken")
-                    .mockResolvedValueOnce({
-                    userId: "testUserId",
-                    absoluteExp: Math.floor(Date.now() / 1000) - 1000,
-                });
-                await expect(strategy.refreshTokens(context)).rejects.toThrow(errors_1.InvalidTokenError);
-                expect(mockSession.logoutSession).toHaveBeenCalledWith(context);
-            });
-        });
-        describe("rotation", () => {
-            beforeEach(() => {
-                config.refreshToken = {
-                    enabled: true,
-                    rotation: {
-                        maxRotations: 3,
-                        getRotationCount: jest.fn().mockResolvedValue(1),
-                        isLimitReached: jest
-                            .fn()
-                            .mockImplementation((count, max) => count >= max),
-                        rotateToken: jest.fn().mockResolvedValue({
-                            newToken: "rotatedRefreshToken",
-                        }),
-                        afterRotation: jest.fn(),
-                    },
-                };
-                context.refreshToken = "someOldRefreshToken";
-            });
-            it("should throw TokenRotationLimitReachedError if limit is reached", async () => {
-                config.refreshToken.rotation.getRotationCount.mockResolvedValueOnce(3);
-                await expect(strategy.refreshTokens(context)).rejects.toThrow(errors_1.TokenRotationLimitReachedError);
-            });
-            it("should rotate the refresh token and call afterRotation if limit not reached", async () => {
-                config.refreshToken.rotation.getRotationCount.mockResolvedValueOnce(2);
-                jest
-                    .spyOn(strategy, "verifyRefreshToken")
-                    .mockResolvedValueOnce({ userId: "testUserId" });
-                jest
-                    .spyOn(strategy, "generateAccessToken")
-                    .mockResolvedValueOnce("newAccessToken");
-                const afterRotationSpy = config.refreshToken.rotation
-                    .afterRotation;
-                const result = await strategy.refreshTokens(context);
-                expect(config.refreshToken.rotation.rotateToken).toHaveBeenCalledWith("someOldRefreshToken", { id: "testUserId", name: "Test User" }, context);
-                expect(afterRotationSpy).toHaveBeenCalledWith("someOldRefreshToken", "rotatedRefreshToken", { id: "testUserId", name: "Test User" }, context, 3);
-                expect(result).toEqual({
-                    user: { id: "testUserId", name: "Test User" },
-                    tokens: {
-                        accessToken: "newAccessToken",
-                        refreshToken: "rotatedRefreshToken",
-                    },
-                });
-            });
-            it("should warn if rotation is enabled but rotateToken is not provided", async () => {
-                config.refreshToken.rotation.rotateToken = undefined;
-                jest
-                    .spyOn(strategy, "verifyRefreshToken")
-                    .mockResolvedValueOnce({ userId: "testUserId" });
-                jest
-                    .spyOn(strategy, "generateAccessToken")
-                    .mockResolvedValueOnce("newAccessToken");
-                const result = await strategy.refreshTokens(context);
-                expect(mockLogger.warn).toHaveBeenCalledWith("Rotation enabled but rotateToken not provided.");
-                expect(result).toEqual({
-                    user: { id: "testUserId", name: "Test User" },
-                    tokens: { accessToken: "newAccessToken" },
-                });
-            });
-        });
-    });
-    describe("error handling", () => {
-        it("should call onFailure", async () => {
-            const onFailureSpy = jest.spyOn(strategy, "onFailure");
-            jest
-                .spyOn(strategy, "verifyAccessToken")
-                .mockRejectedValue(new Error());
-            context.accessToken = "someToken";
-            await expect(strategy.authenticate(context)).rejects.toThrow(errors_1.InvalidTokenError);
-            expect(onFailureSpy).toHaveBeenCalledWith("authenticate", {
-                error: expect.any(Error),
-            });
-        });
-    });
-});

package/build/strategies/api-key/__tests__/api-key.strategy.test.d.ts

@@ -1 +0,0 @@
-export {};