@jmlq/auth 0.0.1-alpha.1 → 0.0.1-alpha.3

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

@@ -1,142 +0,0 @@
-"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

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

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

@@ -1,125 +0,0 @@
-"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

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

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

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const domain_1 = require("src/domain");
-const token_1 = require("src/infrastructure/jwt/token");
-// ───────────────────────────────────────────────────────────────────────────────
-// Helpers: Base64URL encode/decode (solo para el fake encoder y payloads)
-// ───────────────────────────────────────────────────────────────────────────────
-const b64urlEncode = (utf8) => {
-    const b64 = Buffer.from(utf8, "utf8").toString("base64");
-    return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
-};
-const b64urlDecode = (b64url) => {
-    let base64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
-    const pad = base64.length % 4;
-    if (pad)
-        base64 += "=".repeat(4 - pad);
-    return Buffer.from(base64, "base64").toString("utf8");
-};
-// Fake encoder mínimo que respeta la firma esperada
-class FakeBase64UrlEncoder {
-    decode(input) {
-        return b64urlDecode(input);
-    }
-}
-describe("JwtTokenParser", () => {
-    let parser;
-    beforeEach(() => {
-        parser = new token_1.JwtTokenParser(new FakeBase64UrlEncoder());
-    });
-    // ────────────────────────────────────────────────────────────────────────────
-    // extractParts
-    // ────────────────────────────────────────────────────────────────────────────
-    describe("extractParts", () => {
-        test("devuelve [header, payload, signature] con 3 segmentos", () => {
-            const token = "aaa.bbb.ccc";
-            expect(parser.extractParts(token)).toEqual(["aaa", "bbb", "ccc"]);
-        });
-        test("con puntos de más, retorna los 3 primeros segmentos", () => {
-            const token = "a.b.c.d.e";
-            expect(parser.extractParts(token)).toEqual(["a", "b", "c"]);
-        });
-        test("con menos de 3 segmentos, rellena con undefined", () => {
-            const token = "a.b";
-            const [h, p, s] = parser.extractParts(token);
-            expect(h).toBe("a");
-            expect(p).toBe("b");
-            expect(s).toBeUndefined(); // comportamiento actual del método
-        });
-    });
-    // ────────────────────────────────────────────────────────────────────────────
-    // parsePayload
-    // ────────────────────────────────────────────────────────────────────────────
-    describe("parsePayload", () => {
-        test("decodifica y parsea el payload a objeto (sin verificar firma/tiempos)", () => {
-            const payloadObj = { sub: "123", exp: 1700000000 };
-            const header = b64urlEncode(JSON.stringify({ alg: "HS256", typ: "JWT" }));
-            const payload = b64urlEncode(JSON.stringify(payloadObj));
-            const signature = "signaturePartNoCheck";
-            const token = `${header}.${payload}.${signature}`;
-            const result = parser.parsePayload(token);
-            expect(result).toEqual(payloadObj);
-        });
-        test("si el payload no es JSON válido, lanza (propaga error de JSON.parse)", () => {
-            // payloadPart inválido (decodifica a texto no-JSON)
-            const header = "aaa";
-            const payload = b64urlEncode("not-a-json");
-            const signature = "ccc";
-            const token = `${header}.${payload}.${signature}`;
-            expect(() => parser.parsePayload(token)).toThrow(SyntaxError);
-        });
-    });
-    // ────────────────────────────────────────────────────────────────────────────
-    // parseAndValidatePayload
-    // ────────────────────────────────────────────────────────────────────────────
-    describe("parseAndValidatePayload", () => {
-        test("retorna objeto para payload válido", () => {
-            const payloadObj = { userId: "u1", roles: ["admin"] };
-            const payloadPart = b64urlEncode(JSON.stringify(payloadObj));
-            const result = parser.parseAndValidatePayload(payloadPart);
-            expect(result).toEqual(payloadObj);
-        });
-        test("si el encoding/JSON es inválido, lanza InvalidTokenFormatError (mensaje: Invalid token payload encoding)", () => {
-            // Usamos un fragmento que al decodificar no produce JSON válido
-            const payloadPart = b64urlEncode("not-json-here");
-            expect(() => parser.parseAndValidatePayload(payloadPart)).toThrow(domain_1.InvalidTokenFormatError);
-            expect(() => parser.parseAndValidatePayload(payloadPart)).toThrow(/invalid token payload encoding/i);
-        });
-        test('si el payload es string ("hola"), lanza InvalidTokenFormatError (must be an object)', () => {
-            const payloadPart = b64urlEncode(JSON.stringify("hola"));
-            expect(() => parser.parseAndValidatePayload(payloadPart)).toThrow(/payload must be an object/i);
-        });
-        test("si el payload es número (123), lanza InvalidTokenFormatError", () => {
-            const payloadPart = b64urlEncode(JSON.stringify(123));
-            expect(() => parser.parseAndValidatePayload(payloadPart)).toThrow(/payload must be an object/i);
-        });
-        test("si el payload es array ([]), lanza InvalidTokenFormatError", () => {
-            const payloadPart = b64urlEncode(JSON.stringify([]));
-            expect(() => parser.parseAndValidatePayload(payloadPart)).toThrow(/payload must be an object/i);
-        });
-        test("si el payload es null, lanza InvalidTokenFormatError", () => {
-            const payloadPart = b64urlEncode("null");
-            expect(() => parser.parseAndValidatePayload(payloadPart)).toThrow(/payload must be an object/i);
-        });
-        test("llama al encoder.decode con el payloadPart recibido", () => {
-            const spyDecode = jest.spyOn(FakeBase64UrlEncoder.prototype, "decode");
-            const obj = { a: 1 };
-            const payloadPart = b64urlEncode(JSON.stringify(obj));
-            const localParser = new token_1.JwtTokenParser(new FakeBase64UrlEncoder());
-            const result = localParser.parseAndValidatePayload(payloadPart);
-            expect(result).toEqual(obj);
-            expect(spyDecode).toHaveBeenCalledTimes(1);
-            expect(spyDecode).toHaveBeenCalledWith(payloadPart);
-            spyDecode.mockRestore();
-        });
-    });
-});

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

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

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

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// tests/infrastructure/jwt/token/jwt-token-validator.spec.ts
-const errors_1 = require("src/domain/errors");
-const token_1 = require("src/infrastructure/jwt/token");
-describe("JwtTokenValidator.validateTokenInput", () => {
-    let validator;
-    beforeEach(() => {
-        validator = new token_1.JwtTokenValidator();
-    });
-    const expectInvalid = (token, message) => {
-        const act = () => validator.validateTokenInput(token);
-        expect(act).toThrow(errors_1.InvalidTokenFormatError);
-        if (message)
-            expect(act).toThrow(message);
-    };
-    // Casos válidos
-    describe("casos válidos", () => {
-        test("acepta un JWT bien formado (Base64URL, 3 segmentos, 2 puntos)", () => {
-            const validJwt = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
-            expect(() => validator.validateTokenInput(validJwt)).not.toThrow();
-        });
-        test("acepta tokens largos con guiones y guiones bajos válidos", () => {
-            const validJwt = "abc_DEF-123.ghi_JKL-456.mno_PQR-789xyz";
-            expect(() => validator.validateTokenInput(validJwt)).not.toThrow();
-        });
-    });
-    // Casos inválidos básicos
-    describe("validateBasicFormat", () => {
-        test("lanza si token es null", () => {
-            expectInvalid(null, /cannot be null or undefined/i);
-        });
-        test("lanza si token es undefined", () => {
-            expectInvalid(undefined, /cannot be null or undefined/i);
-        });
-        test("lanza si token no es string (number)", () => {
-            expectInvalid(123, /Token must be a string/i);
-        });
-        test("lanza si token no es string (objeto)", () => {
-            expectInvalid({}, /Token must be a string/i);
-        });
-        test("lanza si cadena está vacía", () => {
-            expectInvalid("", /cannot be empty/i);
-        });
-        test("lanza si solo contiene espacios", () => {
-            expectInvalid("   ", /only whitespace/i);
-        });
-        test("lanza si tiene espacios al inicio o final", () => {
-            expectInvalid(" abc.def.ghi ", /leading or trailing whitespace/i);
-        });
-    });
-    // Casos inválidos de estructura JWT
-    describe("validateJwtStructure", () => {
-        test("lanza si longitud < 10", () => {
-            expectInvalid("a.b.c", /too short/i);
-        });
-        test("lanza si no tiene puntos", () => {
-            expectInvalid("abcdefghijk", /expected 2 dots, found 0/i);
-        });
-        test("lanza si tiene solo 1 punto", () => {
-            expectInvalid("abcdefghij.klmnop", /expected 2 dots, found 1/i);
-        });
-        test("lanza si tiene más de 2 puntos", () => {
-            expectInvalid("abcd.efgh.ijkl.mnop", /expected 2 dots, found 3/i);
-        });
-    });
-    // Casos inválidos de caracteres Base64URL
-    describe("validateCharacters (Base64URL)", () => {
-        test("lanza si contiene '+'", () => {
-            expectInvalid("abcde+123.fghi_JKL.mnop-QR", /invalid characters/i);
-        });
-        test("lanza si contiene '/'", () => {
-            expectInvalid("abcde/123.fghi_JKL.mnop-QR", /invalid characters/i);
-        });
-        test("lanza si contiene '=' (padding)", () => {
-            expectInvalid("abcde=123.fghi_JKL.mnop-QR", /invalid characters/i);
-        });
-        test("lanza si algún segmento está vacío (..)", () => {
-            expectInvalid("abcde..klmnopqr", /invalid characters/i);
-        });
-        test("lanza si hay espacios internos", () => {
-            expectInvalid("abcde .fghi_JKL.mnop-QR", /invalid characters/i);
-        });
-        test("lanza si hay caracteres fuera del alfabeto Base64URL", () => {
-            expectInvalid("abcde%.fghi_JKL.mnop-QR", /invalid characters/i);
-        });
-    });
-});

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

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

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

@@ -1,126 +0,0 @@
-"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/factory");
-describe("JwtSigner", () => {
-    // Variables comunes para las pruebas
-    let signer;
-    let factoryMock;
-    let encoder;
-    const algorithm = "HS256";
-    // ────────────────────────────────────────────────────────────────
-    // 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", algorithm);
-            // 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", algorithm);
-            // 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", algorithm);
-            // 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/tools/jwt-token-parser.spec.d.ts

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