@jmlq/auth 0.0.1-alpha.1

package/dist/tests/infrastructure/jwt/strategies/rsa-signature-strategy..spec.js

@@ -0,0 +1,156 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = __importStar(require("crypto"));
+const infrastructure_1 = require("src/infrastructure");
+const shared_1 = require("src/shared");
+describe("RcaSignatureStrategy", () => {
+    // 🔑 Función auxiliar para generar un par de claves RSA
+    const makeKeys = (modulusLength = 2048) => crypto.generateKeyPairSync("rsa", {
+        modulusLength, // Tamaño de la clave (bits)
+        publicKeyEncoding: { type: "spki", format: "pem" },
+        privateKeyEncoding: { type: "pkcs8", format: "pem" },
+    });
+    // Datos base para firmar
+    const baseData = "header.payload";
+    // Vectores de prueba para cada algoritmo HMAC
+    const vectors = [
+        { alg: shared_1.algorithms.rsa.RS256, hash: "sha256" },
+        { alg: shared_1.algorithms.rsa.RS384, hash: "sha384" },
+        { alg: shared_1.algorithms.rsa.RS512, hash: "sha512" },
+    ];
+    // Casos positivos
+    it.each(vectors)("sign/verify OK para %s", ({ alg }) => {
+        // Genera par de claves
+        const { publicKey, privateKey } = makeKeys(2048);
+        // Crea la estrategia
+        const encoder = new shared_1.Base64UrlEncoder();
+        // Crea la estrategia
+        const strat = new infrastructure_1.RsaSignatureStrategy(alg, encoder);
+        // Firma
+        const sig = strat.sign(baseData, privateKey);
+        // Debe ser Base64URL (sin +, /, =)
+        expect(sig).toMatch(/^[A-Za-z0-9\-_]+$/);
+        // verify OK con los mismos datos/clave
+        expect(strat.verify(baseData, sig, publicKey)).toBe(true);
+    });
+    // Casos negativos
+    it.each(vectors)("verify=false si los datos se alteran (%s)", ({ alg }) => {
+        // Genera par de claves
+        const { publicKey, privateKey } = makeKeys();
+        // Crea la estrategia
+        const encoder = new shared_1.Base64UrlEncoder();
+        // Crea la estrategia
+        const strat = new infrastructure_1.RsaSignatureStrategy(alg, encoder);
+        // Firma
+        const sig = strat.sign(baseData, privateKey);
+        // verify debe fallar si se alteran los datos
+        expect(strat.verify(baseData + ".tampered", sig, publicKey)).toBe(false);
+    });
+    // Casos negativos - firma alterada
+    it.each(vectors)("verify=false si la firma se altera (%s)", ({ alg }) => {
+        // Genera par de claves
+        const { publicKey, privateKey } = makeKeys();
+        // Crea la estrategia
+        const encoder = new shared_1.Base64UrlEncoder();
+        // Crea la estrategia
+        const strat = new infrastructure_1.RsaSignatureStrategy(alg, encoder);
+        // Firma
+        const sig = strat.sign(baseData, privateKey);
+        // Decodificamos a base64 estándar y luego a bytes
+        const stdB64 = encoder.decode(sig);
+        const buf = Buffer.from(stdB64, "base64");
+        // Flip de un byte en el medio (afecta r/s con alta probabilidad)
+        const i = Math.floor(buf.length / 2);
+        buf[i] ^= 0x01;
+        // Re-encode a base64url para pasar por la API pública de la estrategia
+        const tampered = encoder.encode(Buffer.from(buf).toString("base64"));
+        expect(strat.verify(baseData, tampered, publicKey)).toBe(false);
+    });
+    // Pruebas adicionales
+    it("getSupportedAlgorithm() devuelve el algoritmo configurado", () => {
+        // Crea la estrategia
+        const encoder = new shared_1.Base64UrlEncoder();
+        // Crea la estrategia
+        const strat = new infrastructure_1.RsaSignatureStrategy(shared_1.algorithms.rsa.RS256, encoder);
+        // Debe devolver el algoritmo configurado
+        expect(strat.getSupportedAlgorithm()).toBe("RS256");
+    });
+    // Casos de error - algoritmo no soportado
+    it("sign lanza y verify devuelve false para algoritmo no soportado", () => {
+        // Crea la estrategia con un algoritmo inválido
+        const badAlg = "RS999";
+        // Crea la estrategia
+        const encoder = new shared_1.Base64UrlEncoder();
+        // Crea la estrategia
+        const strat = new infrastructure_1.RsaSignatureStrategy(badAlg, encoder);
+        // Genera par de claves válidas
+        const { publicKey, privateKey } = makeKeys(2048);
+        // sign debe lanzar error
+        expect(() => strat.sign(baseData, privateKey)).toThrow(/Unsupported RSA algorithm/i);
+        // verify debe devolver false
+        expect(strat.verify(baseData, "abc", publicKey)).toBe(false);
+    });
+    // Prueba que se usa el encoder correctamente
+    it("usa el encoder para encode (sign) y decode (verify)", () => {
+        // Mocks del encoder
+        const encoder = {
+            encode: jest.fn((b64) => b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")),
+            decode: jest.fn((b64url) => {
+                const pad = b64url.length % 4;
+                let std = b64url.replace(/-/g, "+").replace(/_/g, "/");
+                if (pad)
+                    std += "=".repeat(4 - pad);
+                return std;
+            }),
+        };
+        // Genera par de claves válidas
+        const { publicKey, privateKey } = makeKeys(2048);
+        // Crea la estrategia
+        const strat = new infrastructure_1.RsaSignatureStrategy(shared_1.algorithms.rsa.RS256, encoder);
+        // Firma
+        const sig = strat.sign(baseData, privateKey);
+        // Verifica que se llamó al encoder
+        expect(encoder.encode).toHaveBeenCalledTimes(1);
+        // El resultado debe ser string
+        expect(typeof sig).toBe("string");
+        // Verifica
+        const ok = strat.verify(baseData, sig, publicKey);
+        // Verifica que se llamó al decoder
+        expect(encoder.decode).toHaveBeenCalledTimes(1);
+        // El resultado debe ser true
+        expect(ok).toBe(true);
+    });
+});

package/dist/tests/infrastructure/jwt/token/actions/jwt-token-generator.spec.d.ts

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

package/dist/tests/infrastructure/jwt/token/actions/jwt-token-generator.spec.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Mocks
+jest.mock("src/shared", () => {
+    // Mantiene el resto del módulo original
+    const actual = jest.requireActual("src/shared");
+    return {
+        // Mantiene todo lo anterior
+        ...actual,
+        // Mockeamos solo TimeParser
+        TimeParser: {
+            parseToMilliseconds: jest.fn(),
+        },
+    };
+});
+const infrastructure_1 = require("src/infrastructure");
+const shared_1 = require("src/shared");
+const make_jwt_user_1 = require("../../../../helpers/make-jwt-user");
+// Types:  Simplificados para test no necesitamos toda la implementación solo la firma del método sign()
+// y el encoder Base64UrlEncoder
+// type JwtSigner = { sign: (input: string, secret: string) => string };
+// type Base64UrlEncoder = { encode: (input: string) => string };
+// Config type para los tests
+// type JwtTokenServiceConfig = {
+//   accessTokenSecret: string;
+//   refreshTokenSecret: string;
+//   accessTokenExpirationMs: number;
+//   refreshTokenExpirationMs: number;
+//   issuer: string;
+//   audience: string;
+//   algorithm?: string;
+// };
+const FIXED_NOW_MS = Date.UTC(2025, 0, 1, 0, 0, 0, 0);
+const FIXED_NOW_SECONDS = Math.floor(FIXED_NOW_MS / 1000);
+// encoder como jest.fn para poder leer mock.calls
+const encoderMock = {
+    encode: jest.fn((input) => {
+        if (input.includes('"typ":"JWT"'))
+            return "encodedHeader";
+        return "encodedPayload";
+    }),
+    decode: function (str) {
+        throw new Error("Function not implemented.");
+    },
+};
+// signer como jest.fn para poder leer mock.calls
+const signerMock = {
+    sign: jest.fn().mockImplementation((data, key, algorithm) => {
+        return `signed(${data})`;
+    }),
+    verifySignature: jest.fn().mockImplementation((data, signature, key) => {
+        return signature === `signed(${data})`;
+    }),
+};
+// Config base para los tests
+const baseConfig = {
+    accessTokenSecret: "ACCESS_SECRET_ABC",
+    refreshTokenSecret: "REFRESH_SECRET_DEF",
+    accessTokenExpirationMs: 60 * 60 * 1000, // 1h
+    refreshTokenExpirationMs: 7 * 24 * 60 * 60 * 1000, // 7d
+    issuer: "my-issuer",
+    audience: "my-audience",
+    algorithm: "HS256",
+};
+// Util: normaliza roles a string[]
+function normalizeRole(r) {
+    if (typeof r === "string")
+        return r;
+    if (r && typeof r === "object") {
+        const o = r;
+        return String(o.role ?? o.name ?? o.value);
+    }
+    return String(r);
+}
+// Regex simple para UUID v4 (aceptable para test)
+const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+describe("JwtTokenGenerator", () => {
+    // la instancia a testear
+    let generator;
+    // fija la fecha actual para tests consistentes
+    beforeAll(() => {
+        jest.useFakeTimers().setSystemTime(FIXED_NOW_MS);
+    });
+    // resetea mocks y crea nueva instancia antes de cada test
+    beforeEach(() => {
+        jest.clearAllMocks();
+        generator = new infrastructure_1.JwtTokenGenerator(encoderMock, signerMock);
+    });
+    // restaura timers reales
+    afterAll(() => {
+        jest.useRealTimers();
+    });
+    // Testea generación de Access Token
+    test("generateAccessToken: usa accessTokenSecret y expiración por defecto del config cuando no hay expiresIn", () => {
+        // crea un user de prueba
+        const user = (0, make_jwt_user_1.makeJwtSubject)();
+        // genera el token
+        const token = generator.generateAccessToken({
+            user: user,
+            config: { ...baseConfig, algorithm: "HS256" },
+        });
+        expect(signerMock.sign).toHaveBeenCalledWith("encodedHeader.encodedPayload", baseConfig.accessTokenSecret, baseConfig.algorithm);
+        expect(token).toBe("encodedHeader.encodedPayload.signed(encodedHeader.encodedPayload)");
+        const encodeCalls = encoderMock.encode.mock.calls;
+        const payloadJson = encodeCalls[1][0];
+        const payload = JSON.parse(payloadJson);
+        // jti no debe ser fijo: validamos que sea string y UUID-ish
+        expect(typeof payload.jti).toBe("string");
+        // Si tu runtime no garantiza v4, cambia a expect.any(String)
+        expect(payload.jti).toMatch(UUID_V4);
+        // normalizamos roles y comparamos
+        const roleNames = payload.roles.map(normalizeRole);
+        expect(roleNames).toEqual(["ADMIN", "USER"]);
+        expect(payload).toMatchObject({
+            sub: "user-123",
+            customClaims: {},
+            iat: FIXED_NOW_SECONDS,
+            exp: FIXED_NOW_SECONDS + 60 * 60,
+            iss: "my-issuer",
+            aud: "my-audience",
+        });
+        const headerJson = encodeCalls[0][0];
+        const header = JSON.parse(headerJson);
+        expect(header).toEqual({ alg: "HS256", typ: "JWT" });
+    });
+    test("generateAccessToken: respeta expiresIn string (usa TimeParser.parseToMilliseconds)", () => {
+        const user = (0, make_jwt_user_1.makeJwtSubject)();
+        shared_1.TimeParser.parseToMilliseconds.mockReturnValueOnce(15 * 60 * 1000); // 15m
+        const token = generator.generateAccessToken({
+            user: user,
+            config: baseConfig,
+            expiresIn: "15m",
+            customClaims: { plan: "pro" },
+        });
+        expect(token).toBe("encodedHeader.encodedPayload.signed(encodedHeader.encodedPayload)");
+        expect(shared_1.TimeParser.parseToMilliseconds).toHaveBeenCalledWith("15m");
+        const payloadJson = encoderMock.encode.mock.calls[1][0];
+        const payload = JSON.parse(payloadJson);
+        const roleNames = payload.roles.map(normalizeRole);
+        expect(roleNames).toEqual(["ADMIN", "USER"]);
+        expect(payload.exp).toBe(FIXED_NOW_SECONDS + 15 * 60);
+        expect(payload.customClaims).toEqual({ plan: "pro" });
+    });
+    test("generateRefreshToken: usa refreshTokenSecret y expiración por defecto de refresh", () => {
+        const user = (0, make_jwt_user_1.makeJwtSubject)();
+        const token = generator.generateRefreshToken({
+            user: user,
+            config: { ...baseConfig, algorithm: "ES256" },
+        });
+        expect(signerMock.sign).toHaveBeenCalledWith("encodedHeader.encodedPayload", baseConfig.refreshTokenSecret, "ES256");
+        expect(token).toBe("encodedHeader.encodedPayload.signed(encodedHeader.encodedPayload)");
+        const headerJson = encoderMock.encode.mock.calls[0][0];
+        const header = JSON.parse(headerJson);
+        expect(header).toEqual({ alg: "ES256", typ: "JWT" });
+        const payloadJson = encoderMock.encode.mock.calls[1][0];
+        const payload = JSON.parse(payloadJson);
+        expect(payload.exp).toBe(FIXED_NOW_SECONDS + 7 * 24 * 60 * 60);
+    });
+    test("cuando no hay customClaims en props, se usa {}", () => {
+        const user = (0, make_jwt_user_1.makeJwtSubject)();
+        generator.generateAccessToken({
+            user: user,
+            config: baseConfig,
+        });
+        const payloadJson = encoderMock.encode.mock.calls[1][0];
+        const payload = JSON.parse(payloadJson);
+        expect(payload.customClaims).toEqual({});
+    });
+    test("firma exactamente 'header.payload' y concatena '.signature'", () => {
+        const user = (0, make_jwt_user_1.makeJwtSubject)();
+        const token = generator.generateAccessToken({
+            user: user,
+            config: baseConfig,
+        });
+        expect(signerMock.sign).toHaveBeenCalledTimes(1);
+        expect(signerMock.sign).toHaveBeenCalledWith("encodedHeader.encodedPayload", baseConfig.accessTokenSecret, baseConfig.algorithm);
+        expect(token).toBe("encodedHeader.encodedPayload.signed(encodedHeader.encodedPayload)");
+    });
+});

package/dist/tests/infrastructure/jwt/token/actions/jwt-token-verifier.spec.d.ts

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

package/dist/tests/infrastructure/jwt/token/actions/jwt-token-verifier.spec.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("src/domain/errors");
+const infrastructure_1 = require("src/infrastructure");
+describe("JwtTokenVerifier", () => {
+    let signer;
+    let parser;
+    let verifier;
+    let config;
+    const algorithm = "HS256";
+    const NOW_MS = Date.UTC(2025, 0, 1, 0, 0, 0); // 2025-01-01T00:00:00Z
+    const NOW_SECONDS = Math.floor(NOW_MS / 1000);
+    beforeAll(() => {
+        jest.useFakeTimers().setSystemTime(NOW_MS);
+    });
+    beforeEach(() => {
+        signer = {
+            verifySignature: jest.fn(),
+        };
+        parser = {
+            extractParts: jest.fn(),
+            parseAndValidatePayload: jest.fn(),
+            parsePayload: jest.fn(),
+        };
+        verifier = new infrastructure_1.JwtTokenVerifier(signer, // no nos importa la implementación real aquí
+        parser, algorithm);
+        config = {
+            accessTokenSecret: "ACCESS_SECRET",
+            refreshTokenSecret: "REFRESH_SECRET",
+            accessTokenExpirationMs: 15 * 60 * 1000,
+            refreshTokenExpirationMs: 7 * 24 * 60 * 60 * 1000,
+            issuer: "test-issuer",
+            audience: "test-audience",
+            algorithm: "HS256",
+        };
+    });
+    afterAll(() => {
+        jest.useRealTimers();
+    });
+    test("verifyAccessToken: firma válida y token no expirado devuelve payload normalizado", () => {
+        const token = "headerPart.payloadPart.signaturePart";
+        parser.extractParts.mockReturnValue([
+            "headerPart",
+            "payloadPart",
+            "signaturePart",
+        ]);
+        const rawPayload = {
+            sub: "user-123",
+            roles: [{ role: "ADMIN" }, { role: "USER" }],
+            customClaims: { foo: "bar" },
+            iat: NOW_SECONDS,
+            exp: NOW_SECONDS + 60 * 60, // +1h
+            jti: "jti-123",
+            iss: "test-issuer",
+            aud: "test-audience",
+        };
+        signer.verifySignature.mockReturnValue(true);
+        parser.parseAndValidatePayload.mockReturnValue(rawPayload);
+        const result = verifier.verifyAccessToken(token, config);
+        // Verifica que use el accessTokenSecret
+        expect(signer.verifySignature).toHaveBeenCalledWith("headerPart.payloadPart", "signaturePart", "ACCESS_SECRET", "HS256");
+        expect(parser.extractParts).toHaveBeenCalledWith(token);
+        expect(parser.parseAndValidatePayload).toHaveBeenCalledWith("payloadPart");
+        // Verifica el payload normalizado
+        expect(result).toEqual({
+            sub: "user-123",
+            roles: [
+                {
+                    role: "ADMIN",
+                },
+                {
+                    role: "USER",
+                },
+            ],
+            customClaims: { foo: "bar" },
+            iat: rawPayload.iat,
+            exp: rawPayload.exp,
+            jti: rawPayload.jti,
+            iss: rawPayload.iss,
+            aud: rawPayload.aud,
+        });
+    });
+    test("verifyRefreshToken: usa refreshTokenSecret para verificar la firma", () => {
+        const token = "h.p.s";
+        parser.extractParts.mockReturnValue(["h64", "p64", "s64"]);
+        signer.verifySignature.mockReturnValue(true);
+        parser.parseAndValidatePayload.mockReturnValue({
+            userId: "user-123",
+            role: [],
+            customClaims: {},
+            iat: NOW_SECONDS,
+            exp: NOW_SECONDS + 10,
+            jti: "jti",
+            iss: "test-issuer",
+            aud: "test-audience",
+        });
+        verifier.verifyRefreshToken(token, config);
+        expect(signer.verifySignature).toHaveBeenCalledWith("h64.p64", "s64", "REFRESH_SECRET", "HS256");
+    });
+    test("verifyAccessToken: firma inválida lanza InvalidSignatureError", () => {
+        const token = "h.p.s";
+        parser.extractParts.mockReturnValue(["h64", "p64", "s64"]);
+        signer.verifySignature.mockReturnValue(false);
+        expect(() => verifier.verifyAccessToken(token, config)).toThrow(errors_1.InvalidSignatureError);
+        // No debería intentar parsear el payload si la firma es inválida
+        expect(parser.parseAndValidatePayload).not.toHaveBeenCalled();
+    });
+    test("verifyAccessToken: token expirado lanza TokenExpiredError", () => {
+        const token = "h.p.s";
+        parser.extractParts.mockReturnValue(["h64", "p64", "s64"]);
+        signer.verifySignature.mockReturnValue(true);
+        const expiredPayload = {
+            userId: "user-123",
+            role: ["USER"],
+            customClaims: {},
+            iat: NOW_SECONDS - 10,
+            exp: NOW_SECONDS - 1, // ya expirado
+            jti: "jti-expired",
+            iss: "test-issuer",
+            aud: "test-audience",
+        };
+        parser.parseAndValidatePayload.mockReturnValue(expiredPayload);
+        expect(() => verifier.verifyAccessToken(token, config)).toThrow(errors_1.TokenExpiredError);
+    });
+    test("getTokenExpiration: devuelve la fecha basada en el exp del payload", () => {
+        const token = "header.payload.signature";
+        parser.parsePayload.mockReturnValue({
+            // Solo necesitamos exp aquí
+            exp: NOW_SECONDS + 3600,
+            iat: NOW_SECONDS,
+            jti: "jti",
+            iss: "iss",
+            aud: "aud",
+            sub: "user-123",
+            roles: [],
+            customClaims: {},
+        });
+        const expiresAt = verifier.getTokenExpiration(token);
+        expect(parser.parsePayload).toHaveBeenCalledWith(token);
+        expect(expiresAt.getTime()).toBe((NOW_SECONDS + 3600) * 1000);
+    });
+});

package/dist/tests/infrastructure/jwt/token/jwt-signer.spec.d.ts

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

package/dist/tests/infrastructure/jwt/token/jwt-signer.spec.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jwt_1 = require("src/infrastructure/jwt");
+const token_1 = require("src/infrastructure/jwt/token");
+const shared_1 = require("src/shared");
+// ────────────────────────────────────────────────────────────────
+// Mock de SignatureStrategyFactory y su comportamiento
+// ────────────────────────────────────────────────────────────────
+jest.mock("src/infrastructure/jwt/signature-strategy.factory");
+describe("JwtSigner", () => {
+    // Variables comunes para las pruebas
+    let signer;
+    let factoryMock;
+    let encoder;
+    // ────────────────────────────────────────────────────────────────
+    // Configuración antes de cada prueba
+    // ────────────────────────────────────────────────────────────────
+    beforeEach(() => {
+        // Instancia real del codificador
+        encoder = new shared_1.Base64UrlEncoder();
+        // Mock de factory.create() → devuelve una estrategia con sign/verify falsos
+        factoryMock = {
+            create: jest.fn(),
+        };
+        // Forzar el constructor de SignatureStrategyFactory para devolver nuestro mock
+        jwt_1.SignatureStrategyFactory.mockImplementation(() => factoryMock);
+        // Crea la instancia de JwtSigner que vamos a probar
+        signer = new token_1.JwtSigner(encoder);
+    });
+    // Limpia los mocks después de cada prueba
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    // ────────────────────────────────────────────────────────────────
+    // sign()
+    // ────────────────────────────────────────────────────────────────
+    describe("sign", () => {
+        // Prueba básica de firma
+        test("firma datos usando la estrategia devuelta por la fábrica", () => {
+            // Prepara la estrategia mock
+            const fakeSignature = "signed-data";
+            const mockStrategy = { sign: jest.fn().mockReturnValue(fakeSignature) };
+            factoryMock.create.mockReturnValue(mockStrategy);
+            // Llama al método a probar
+            const result = signer.sign("header.payload", "secret-key", "HS256");
+            // Verificaciones
+            // Asegura que la fábrica fue llamada con el algoritmo correcto
+            expect(factoryMock.create).toHaveBeenCalledWith("HS256");
+            // Asegura que la estrategia firmó los datos correctamente
+            expect(mockStrategy.sign).toHaveBeenCalledWith("header.payload", "secret-key");
+            // Asegura que el resultado es el esperado
+            expect(result).toBe(fakeSignature);
+        });
+        // Prueba el valor por defecto del algoritmo
+        test("usa 'HS256' como algoritmo por defecto si no se especifica", () => {
+            // Prepara la estrategia mock
+            const mockStrategy = { sign: jest.fn().mockReturnValue("sig") };
+            factoryMock.create.mockReturnValue(mockStrategy);
+            // Llama al método sin especificar algoritmo
+            signer.sign("abc.def", "key");
+            // Verifica que se usó el algoritmo por defecto
+            expect(factoryMock.create).toHaveBeenCalledWith("HS256");
+            // Asegura que la estrategia fue llamada una vez
+            expect(mockStrategy.sign).toHaveBeenCalledTimes(1);
+        });
+    });
+    // ────────────────────────────────────────────────────────────────
+    // verifySignature()
+    // ────────────────────────────────────────────────────────────────
+    describe("verifySignature", () => {
+        // Prueba básica de verificación
+        test("verifica correctamente usando la estrategia devuelta por la fábrica", () => {
+            // Prepara la estrategia mock
+            const mockStrategy = { verify: jest.fn().mockReturnValue(true) };
+            factoryMock.create.mockReturnValue(mockStrategy);
+            // Llama al método a probar
+            const result = signer.verifySignature("header.payload", "signature", "secret", "HS512");
+            // Verificaciones
+            // Asegura que la fábrica fue llamada con el algoritmo correcto
+            expect(factoryMock.create).toHaveBeenCalledWith("HS512");
+            // Asegura que la estrategia verificó los datos correctamente
+            expect(mockStrategy.verify).toHaveBeenCalledWith("header.payload", "signature", "secret");
+            // Asegura que el resultado es el esperado
+            expect(result).toBe(true);
+        });
+        // Prueba cuando la verificación falla
+        test("retorna false si verify devuelve false", () => {
+            // Prepara la estrategia mock
+            const mockStrategy = { verify: jest.fn().mockReturnValue(false) };
+            factoryMock.create.mockReturnValue(mockStrategy);
+            // Llama al método a probar
+            const result = signer.verifySignature("data", "sig", "key");
+            // Verifica que el resultado sea false
+            expect(result).toBe(false);
+        });
+        // Prueba el valor por defecto del algoritmo
+        test("usa 'HS256' como algoritmo por defecto si no se pasa parámetro", () => {
+            // Prepara la estrategia mock
+            const mockStrategy = { verify: jest.fn().mockReturnValue(true) };
+            factoryMock.create.mockReturnValue(mockStrategy);
+            // Llama al método sin especificar algoritmo
+            signer.verifySignature("abc.def", "sig", "key");
+            // Verifica que se usó el algoritmo por defecto
+            expect(factoryMock.create).toHaveBeenCalledWith("HS256");
+            // Asegura que la estrategia fue llamada una vez
+            expect(mockStrategy.verify).toHaveBeenCalledTimes(1);
+        });
+    });
+    // ────────────────────────────────────────────────────────────────
+    // integración mínima (sin mock) - opcional
+    // ────────────────────────────────────────────────────────────────
+    describe("integración mínima", () => {
+        // Prueba que JwtSigner crea una instancia real de SignatureStrategyFactory
+        test("crea internamente una instancia real de SignatureStrategyFactory", () => {
+            // Borra el historial de llamadas acumulado por el beforeEach del describe padre
+            jwt_1.SignatureStrategyFactory.mockClear();
+            // Crea una nueva instancia de JwtSigner
+            const localSigner = new token_1.JwtSigner(encoder);
+            // Verifica que se creó una instancia de JwtSigner y que la fábrica fue instanciada
+            expect(localSigner).toBeInstanceOf(token_1.JwtSigner);
+            // Asegura que el constructor de SignatureStrategyFactory fue llamado una vez
+            expect(jwt_1.SignatureStrategyFactory).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/dist/tests/infrastructure/jwt/token/jwt-token-parser.spec.d.ts

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