@lodashventure/medusa-login-provider 4.1.1 → 4.1.2

package/.medusa/server/src/providers/line/__tests__/utils.test.js

@@ -0,0 +1,351 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const utils_1 = require("@medusajs/framework/utils");
+const utils_2 = require("../utils");
+// Mock crypto for consistent testing
+jest.mock("crypto");
+const mockCrypto = crypto_1.default;
+describe("LINE Utils", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Reset Date.now mock
+        jest.spyOn(Date, "now").mockRestore();
+    });
+    describe("generateState", () => {
+        it("should generate a 64-character hex string", () => {
+            const mockBuffer = Buffer.from("a".repeat(32));
+            mockCrypto.randomBytes.mockReturnValue(mockBuffer);
+            const state = (0, utils_2.generateState)();
+            expect(mockCrypto.randomBytes).toHaveBeenCalledWith(32);
+            expect(state).toBe("a".repeat(64));
+            expect(state).toHaveLength(64);
+        });
+        it("should generate different values on subsequent calls", () => {
+            mockCrypto.randomBytes
+                .mockReturnValueOnce(Buffer.from("a".repeat(32)))
+                .mockReturnValueOnce(Buffer.from("b".repeat(32)));
+            const state1 = (0, utils_2.generateState)();
+            const state2 = (0, utils_2.generateState)();
+            expect(state1).not.toBe(state2);
+        });
+    });
+    describe("generateNonce", () => {
+        it("should generate a 32-character hex string", () => {
+            const mockBuffer = Buffer.from("c".repeat(16));
+            mockCrypto.randomBytes.mockReturnValue(mockBuffer);
+            const nonce = (0, utils_2.generateNonce)();
+            expect(mockCrypto.randomBytes).toHaveBeenCalledWith(16);
+            expect(nonce).toBe("c".repeat(32));
+            expect(nonce).toHaveLength(32);
+        });
+    });
+    describe("generatePlaceholderEmail", () => {
+        it("should generate email with default domain", () => {
+            const email = (0, utils_2.generatePlaceholderEmail)("U123456");
+            expect(email).toBe("line-U123456@line.local");
+        });
+        it("should generate email with custom domain", () => {
+            const email = (0, utils_2.generatePlaceholderEmail)("U123456", "example.com");
+            expect(email).toBe("line-U123456@example.com");
+        });
+        it("should handle empty LINE user ID", () => {
+            const email = (0, utils_2.generatePlaceholderEmail)("");
+            expect(email).toBe("line-@line.local");
+        });
+        it("should handle special characters in LINE user ID", () => {
+            const email = (0, utils_2.generatePlaceholderEmail)("U123-456_789");
+            expect(email).toBe("line-U123-456_789@line.local");
+        });
+    });
+    describe("parseDisplayName", () => {
+        it("should parse single name", () => {
+            const result = (0, utils_2.parseDisplayName)("John");
+            expect(result).toEqual({
+                firstName: "John",
+                lastName: "",
+            });
+        });
+        it("should parse full name", () => {
+            const result = (0, utils_2.parseDisplayName)("John Doe");
+            expect(result).toEqual({
+                firstName: "John",
+                lastName: "Doe",
+            });
+        });
+        it("should handle multiple middle names", () => {
+            const result = (0, utils_2.parseDisplayName)("John William Doe Smith");
+            expect(result).toEqual({
+                firstName: "John",
+                lastName: "William Doe Smith",
+            });
+        });
+        it("should handle empty display name", () => {
+            const result = (0, utils_2.parseDisplayName)("");
+            expect(result).toEqual({
+                firstName: "",
+                lastName: "",
+            });
+        });
+        it("should handle whitespace-only display name", () => {
+            const result = (0, utils_2.parseDisplayName)("   ");
+            expect(result).toEqual({
+                firstName: "",
+                lastName: "",
+            });
+        });
+        it("should trim whitespace", () => {
+            const result = (0, utils_2.parseDisplayName)("  John   Doe  ");
+            expect(result).toEqual({
+                firstName: "John",
+                lastName: "Doe",
+            });
+        });
+        it("should handle names with extra spaces", () => {
+            const result = (0, utils_2.parseDisplayName)("John    Doe   Smith");
+            expect(result).toEqual({
+                firstName: "John",
+                lastName: "Doe   Smith",
+            });
+        });
+    });
+    describe("validateChannelId", () => {
+        it("should validate correct 10-digit channel ID", () => {
+            expect((0, utils_2.validateChannelId)("1234567890")).toBe(true);
+            expect((0, utils_2.validateChannelId)("0000000000")).toBe(true);
+            expect((0, utils_2.validateChannelId)("9999999999")).toBe(true);
+        });
+        it("should reject channel ID with wrong length", () => {
+            expect((0, utils_2.validateChannelId)("123456789")).toBe(false); // 9 digits
+            expect((0, utils_2.validateChannelId)("12345678901")).toBe(false); // 11 digits
+            expect((0, utils_2.validateChannelId)("")).toBe(false);
+        });
+        it("should reject channel ID with non-numeric characters", () => {
+            expect((0, utils_2.validateChannelId)("123456789a")).toBe(false);
+            expect((0, utils_2.validateChannelId)("12345-6789")).toBe(false);
+            expect((0, utils_2.validateChannelId)("1234 56789")).toBe(false);
+            expect((0, utils_2.validateChannelId)("abcdefghij")).toBe(false);
+        });
+        it("should reject special characters and symbols", () => {
+            expect((0, utils_2.validateChannelId)("123456789@")).toBe(false);
+            expect((0, utils_2.validateChannelId)("123456789#")).toBe(false);
+            expect((0, utils_2.validateChannelId)("123456789$")).toBe(false);
+        });
+    });
+    describe("validateCallbackUrl", () => {
+        it("should validate HTTPS URLs", () => {
+            expect((0, utils_2.validateCallbackUrl)("https://example.com")).toBe(true);
+            expect((0, utils_2.validateCallbackUrl)("https://example.com/callback")).toBe(true);
+            expect((0, utils_2.validateCallbackUrl)("https://subdomain.example.com/path")).toBe(true);
+        });
+        it("should validate localhost URLs", () => {
+            expect((0, utils_2.validateCallbackUrl)("http://localhost:3000")).toBe(true);
+            expect((0, utils_2.validateCallbackUrl)("http://localhost")).toBe(true);
+            expect((0, utils_2.validateCallbackUrl)("https://localhost:8080")).toBe(true);
+        });
+        it("should reject HTTP URLs (non-localhost)", () => {
+            expect((0, utils_2.validateCallbackUrl)("http://example.com")).toBe(false);
+            expect((0, utils_2.validateCallbackUrl)("http://google.com")).toBe(false);
+        });
+        it("should reject invalid URLs", () => {
+            expect((0, utils_2.validateCallbackUrl)("not-a-url")).toBe(false);
+            expect((0, utils_2.validateCallbackUrl)("")).toBe(false);
+            expect((0, utils_2.validateCallbackUrl)("ftp://example.com")).toBe(false);
+            expect((0, utils_2.validateCallbackUrl)("mailto:test@example.com")).toBe(false);
+        });
+        it("should handle malformed URLs", () => {
+            expect((0, utils_2.validateCallbackUrl)("https://")).toBe(false);
+            expect((0, utils_2.validateCallbackUrl)("https:")).toBe(false);
+            expect((0, utils_2.validateCallbackUrl)("://example.com")).toBe(false);
+        });
+    });
+    describe("RateLimiter", () => {
+        let rateLimiter;
+        let mockDateNow;
+        beforeEach(() => {
+            mockDateNow = jest.spyOn(Date, "now");
+            rateLimiter = new utils_2.RateLimiter(3, 60000); // 3 attempts per minute
+        });
+        afterEach(() => {
+            mockDateNow.mockRestore();
+        });
+        it("should allow requests under the limit", () => {
+            mockDateNow.mockReturnValue(1000);
+            expect(rateLimiter.isAllowed("user1")).toBe(true);
+            expect(rateLimiter.isAllowed("user1")).toBe(true);
+            expect(rateLimiter.isAllowed("user1")).toBe(true);
+        });
+        it("should reject requests over the limit", () => {
+            mockDateNow.mockReturnValue(1000);
+            // Fill up the limit
+            expect(rateLimiter.isAllowed("user1")).toBe(true);
+            expect(rateLimiter.isAllowed("user1")).toBe(true);
+            expect(rateLimiter.isAllowed("user1")).toBe(true);
+            // This should be rejected
+            expect(rateLimiter.isAllowed("user1")).toBe(false);
+        });
+        it("should reset after time window", () => {
+            mockDateNow.mockReturnValue(1000);
+            // Fill up the limit
+            rateLimiter.isAllowed("user1");
+            rateLimiter.isAllowed("user1");
+            rateLimiter.isAllowed("user1");
+            // Should be rejected
+            expect(rateLimiter.isAllowed("user1")).toBe(false);
+            // Move time forward past window
+            mockDateNow.mockReturnValue(61001);
+            // Should be allowed again
+            expect(rateLimiter.isAllowed("user1")).toBe(true);
+        });
+        it("should track different keys separately", () => {
+            mockDateNow.mockReturnValue(1000);
+            // Fill limit for user1
+            rateLimiter.isAllowed("user1");
+            rateLimiter.isAllowed("user1");
+            rateLimiter.isAllowed("user1");
+            // user1 should be blocked, but user2 should be allowed
+            expect(rateLimiter.isAllowed("user1")).toBe(false);
+            expect(rateLimiter.isAllowed("user2")).toBe(true);
+        });
+        it("should handle partial window expiration", () => {
+            let currentTime = 1000;
+            mockDateNow.mockImplementation(() => currentTime);
+            // Make 2 requests at time 1000
+            rateLimiter.isAllowed("user1");
+            rateLimiter.isAllowed("user1");
+            // Move time forward 30 seconds and make 1 more request
+            currentTime = 31000;
+            rateLimiter.isAllowed("user1");
+            // Should be at limit now
+            expect(rateLimiter.isAllowed("user1")).toBe(false);
+            // Move time forward another 30 seconds (31 seconds past first requests)
+            currentTime = 61001;
+            // First 2 requests should have expired, should be allowed now
+            expect(rateLimiter.isAllowed("user1")).toBe(true);
+        });
+        it("should reset specific key", () => {
+            mockDateNow.mockReturnValue(1000);
+            // Fill up the limit
+            rateLimiter.isAllowed("user1");
+            rateLimiter.isAllowed("user1");
+            rateLimiter.isAllowed("user1");
+            // Should be rejected
+            expect(rateLimiter.isAllowed("user1")).toBe(false);
+            // Reset the key
+            rateLimiter.reset("user1");
+            // Should be allowed again
+            expect(rateLimiter.isAllowed("user1")).toBe(true);
+        });
+        it("should use default values", () => {
+            const defaultLimiter = new utils_2.RateLimiter();
+            mockDateNow.mockReturnValue(1000);
+            // Should allow 10 requests by default
+            for (let i = 0; i < 10; i++) {
+                expect(defaultLimiter.isAllowed("user1")).toBe(true);
+            }
+            // 11th should be rejected
+            expect(defaultLimiter.isAllowed("user1")).toBe(false);
+        });
+    });
+    describe("sanitizeInput", () => {
+        it("should remove angle brackets", () => {
+            expect((0, utils_2.sanitizeInput)("Hello <script>")).toBe("Hello script");
+            expect((0, utils_2.sanitizeInput)("<div>content</div>")).toBe("divcontent/div");
+        });
+        it("should remove javascript: protocol", () => {
+            expect((0, utils_2.sanitizeInput)("javascript:alert('xss')")).toBe("alert('xss')");
+            expect((0, utils_2.sanitizeInput)("JAVASCRIPT:alert('xss')")).toBe("alert('xss')");
+            expect((0, utils_2.sanitizeInput)("Javascript:alert('xss')")).toBe("alert('xss')");
+        });
+        it("should trim whitespace", () => {
+            expect((0, utils_2.sanitizeInput)("  hello world  ")).toBe("hello world");
+        });
+        it("should handle empty string", () => {
+            expect((0, utils_2.sanitizeInput)("")).toBe("");
+        });
+        it("should handle multiple issues", () => {
+            expect((0, utils_2.sanitizeInput)("  <script>javascript:alert('xss')</script>  ")).toBe("scriptalert('xss')/script");
+        });
+        it("should preserve safe content", () => {
+            expect((0, utils_2.sanitizeInput)("Hello World 123!@#$%^&*()")).toBe("Hello World 123!@#$%^&*()");
+        });
+    });
+    describe("createAuditLog", () => {
+        it("should create audit log with timestamp", () => {
+            const mockDate = new Date("2023-01-01T00:00:00.000Z");
+            jest.spyOn(global, "Date").mockImplementation(() => mockDate);
+            const entry = (0, utils_2.createAuditLog)({
+                event: "login_success",
+                lineUserId: "U123456",
+                customerId: "cust_123",
+                ipAddress: "192.168.1.1",
+            });
+            expect(entry).toEqual({
+                event: "login_success",
+                lineUserId: "U123456",
+                customerId: "cust_123",
+                ipAddress: "192.168.1.1",
+                timestamp: mockDate,
+            });
+            global.Date.mockRestore();
+        });
+        it("should handle minimal entry", () => {
+            const mockDate = new Date("2023-01-01T00:00:00.000Z");
+            jest.spyOn(global, "Date").mockImplementation(() => mockDate);
+            const entry = (0, utils_2.createAuditLog)({
+                event: "login_attempt",
+            });
+            expect(entry).toEqual({
+                event: "login_attempt",
+                timestamp: mockDate,
+            });
+            global.Date.mockRestore();
+        });
+        it("should handle all event types", () => {
+            const events = [
+                "login_attempt",
+                "login_success",
+                "login_failure",
+                "token_refresh",
+                "token_revoke"
+            ];
+            events.forEach(event => {
+                const entry = (0, utils_2.createAuditLog)({ event });
+                expect(entry.event).toBe(event);
+                expect(entry.timestamp).toBeInstanceOf(Date);
+            });
+        });
+    });
+    describe("handleLineApiError", () => {
+        it("should throw MedusaError for known status codes", () => {
+            const knownErrors = [
+                { status: 400, expectedMessage: "Invalid request to LINE API" },
+                { status: 401, expectedMessage: "LINE authentication failed" },
+                { status: 403, expectedMessage: "Access forbidden by LINE" },
+                { status: 429, expectedMessage: "Too many requests to LINE API" },
+                { status: 500, expectedMessage: "LINE server error" },
+                { status: 503, expectedMessage: "LINE service temporarily unavailable" },
+            ];
+            knownErrors.forEach(({ status, expectedMessage }) => {
+                expect(() => (0, utils_2.handleLineApiError)(status, "test message")).toThrow(new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `${expectedMessage}: test message`));
+            });
+        });
+        it("should throw MedusaError for unknown status codes", () => {
+            expect(() => (0, utils_2.handleLineApiError)(418, "I'm a teapot")).toThrow(new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "LINE API error: 418: I'm a teapot"));
+        });
+        it("should include custom message in error", () => {
+            expect(() => (0, utils_2.handleLineApiError)(400, "Custom error message")).toThrow(new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Invalid request to LINE API: Custom error message"));
+        });
+        it("should handle empty message", () => {
+            expect(() => (0, utils_2.handleLineApiError)(400, "")).toThrow(new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Invalid request to LINE API: "));
+        });
+        it("should never return a value", () => {
+            // This test ensures the function signature with 'never' return type
+            expect(() => (0, utils_2.handleLineApiError)(400, "test")).toThrow();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.test.js","sourceRoot":"","sources":["../../../../../../src/providers/line/__tests__/utils.test.ts"],"names":[],"mappings":"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"}