@lodashventure/medusa-login-provider 4.1.0 → 4.1.2

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

@@ -0,0 +1,438 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const service_1 = __importDefault(require("../service"));
+const utils_1 = require("@medusajs/framework/utils");
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const crypto_1 = __importDefault(require("crypto"));
+// Mock dependencies
+jest.mock("jsonwebtoken");
+jest.mock("crypto");
+// Mock fetch globally
+global.fetch = jest.fn();
+describe("LineProviderService", () => {
+    let service;
+    let mockLogger;
+    let mockCustomerService;
+    let mockAuthIdentityService;
+    let mockFetch;
+    let mockCrypto;
+    let mockJwt;
+    const defaultOptions = {
+        lineChannelId: "1234567890",
+        lineChannelSecret: "test-secret",
+        lineRedirectUrl: "https://example.com/callback",
+        autoCreateCustomer: true,
+        syncProfileData: true,
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFetch = global.fetch;
+        mockCrypto = crypto_1.default;
+        mockJwt = jsonwebtoken_1.default;
+        mockLogger = {
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            debug: jest.fn(),
+        };
+        mockCustomerService = {
+            create: jest.fn(),
+            update: jest.fn(),
+            retrieve: jest.fn(),
+            listAndCount: jest.fn(),
+        };
+        mockAuthIdentityService = {
+            create: jest.fn(),
+            update: jest.fn(),
+            retrieve: jest.fn(),
+            setState: jest.fn(),
+            getState: jest.fn(),
+        };
+        service = new service_1.default({
+            logger: mockLogger,
+            customerService: mockCustomerService,
+        }, defaultOptions);
+        // Mock crypto.randomBytes
+        const mockBuffer = Buffer.from("a".repeat(32));
+        mockCrypto.randomBytes.mockReturnValue(mockBuffer);
+    });
+    describe("validateOptions", () => {
+        it("should validate required options", () => {
+            expect(() => {
+                service_1.default.validateOptions({});
+            }).toThrow("line channel id is required");
+            expect(() => {
+                service_1.default.validateOptions({
+                    lineChannelId: "123",
+                });
+            }).toThrow("line channel secret is required");
+            expect(() => {
+                service_1.default.validateOptions({
+                    lineChannelId: "123",
+                    lineChannelSecret: "secret",
+                });
+            }).not.toThrow(); // Redirect URL is now optional
+            // Validation should pass with just channel ID and secret
+        });
+    });
+    describe("register", () => {
+        it("should throw NOT_ALLOWED error", async () => {
+            await expect(service.register({}, mockAuthIdentityService)).rejects.toThrow(utils_1.MedusaError);
+        });
+    });
+    describe("authenticate", () => {
+        it("should return redirect URL for LINE OAuth", async () => {
+            mockAuthIdentityService.setState.mockResolvedValue(undefined);
+            const result = await service.authenticate({ body: { callback_url: "https://example.com/callback" } }, mockAuthIdentityService);
+            expect(result.success).toBe(true);
+            expect(result.location).toContain("https://access.line.me/oauth2/v2.1/authorize");
+            expect(result.location).toContain("client_id=1234567890");
+            expect(result.location).toContain("scope=profile%20openid%20email");
+            expect(mockAuthIdentityService.setState).toHaveBeenCalled();
+        });
+        it("should handle authentication errors", async () => {
+            const result = await service.authenticate({
+                query: {
+                    error: "access_denied",
+                    error_description: "User denied access",
+                    error_uri: "https://example.com/error",
+                },
+            }, mockAuthIdentityService);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("User denied access");
+        });
+    });
+    describe("validateCallback", () => {
+        const mockTokenResponse = {
+            access_token: "test-access-token",
+            id_token: "test-id-token",
+            refresh_token: "test-refresh-token",
+            expires_in: 2592000,
+            scope: "profile openid",
+            token_type: "Bearer",
+        };
+        const mockProfile = {
+            userId: "U1234567890",
+            displayName: "Test User",
+            pictureUrl: "https://example.com/picture.jpg",
+        };
+        const mockIdTokenPayload = {
+            iss: "https://access.line.me",
+            sub: "U1234567890",
+            aud: "1234567890",
+            exp: Math.floor(Date.now() / 1000) + 3600,
+            iat: Math.floor(Date.now() / 1000),
+            name: "Test User",
+            picture: "https://example.com/picture.jpg",
+        };
+        it("should handle missing authorization code", async () => {
+            const result = await service.validateCallback({ query: {}, body: {} }, mockAuthIdentityService);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe("No authorization code provided");
+        });
+        it("should handle missing state", async () => {
+            const result = await service.validateCallback({ query: { code: "test-code" }, body: {} }, mockAuthIdentityService);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe("No state parameter provided");
+        });
+        it("should handle invalid state", async () => {
+            mockAuthIdentityService.getState.mockResolvedValue(null);
+            const result = await service.validateCallback({ query: { code: "test-code", state: "invalid-state" }, body: {} }, mockAuthIdentityService);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe("Invalid state or session expired");
+        });
+        it("should handle OAuth errors", async () => {
+            const result = await service.validateCallback({
+                query: {
+                    error: "invalid_request",
+                    error_description: "Invalid request",
+                },
+                body: {},
+            }, mockAuthIdentityService);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("Invalid request");
+        });
+        it("should successfully validate callback with complete flow", async () => {
+            // Setup mocks
+            mockAuthIdentityService.getState.mockResolvedValue({
+                callback_url: "https://example.com/callback",
+            });
+            // Mock token exchange
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockTokenResponse),
+            });
+            // Mock ID token verification
+            mockJwt.decode.mockReturnValue({
+                payload: mockIdTokenPayload,
+            });
+            // Mock profile fetch
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockProfile),
+            });
+            // Mock auth identity creation (new user)
+            mockAuthIdentityService.retrieve.mockRejectedValue(new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, "Not found"));
+            const mockAuthIdentity = {
+                entity_id: "U1234567890",
+                user_metadata: {
+                    line_user_id: "U1234567890",
+                    display_name: "Test User",
+                    picture_url: "https://example.com/picture.jpg",
+                    name: "Test User",
+                    picture: "https://example.com/picture.jpg",
+                },
+            };
+            mockAuthIdentityService.create.mockResolvedValue(mockAuthIdentity);
+            // Mock customer creation
+            const mockCustomer = {
+                id: "cust_123",
+                email: "line-U1234567890@line.local",
+                first_name: "Test",
+                last_name: "User",
+            };
+            mockCustomerService.create.mockResolvedValue(mockCustomer);
+            const result = await service.validateCallback({ query: { code: "test-code", state: "valid-state" }, body: {} }, mockAuthIdentityService);
+            expect(result.success).toBe(true);
+            expect(result.authIdentity).toBe(mockAuthIdentity);
+        });
+        it("should handle existing user with profile sync", async () => {
+            mockAuthIdentityService.getState.mockResolvedValue({
+                callback_url: "https://example.com/callback",
+            });
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockTokenResponse),
+            });
+            mockJwt.decode.mockReturnValue({
+                payload: mockIdTokenPayload,
+            });
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockProfile),
+            });
+            // Mock existing auth identity
+            const existingAuthIdentity = {
+                entity_id: "U1234567890",
+                user_metadata: {
+                    line_user_id: "U1234567890",
+                    display_name: "Old Name",
+                },
+            };
+            mockAuthIdentityService.retrieve.mockResolvedValue(existingAuthIdentity);
+            const updatedAuthIdentity = {
+                ...existingAuthIdentity,
+                user_metadata: {
+                    line_user_id: "U1234567890",
+                    display_name: "Test User",
+                    picture_url: "https://example.com/picture.jpg",
+                },
+            };
+            mockAuthIdentityService.update.mockResolvedValue(updatedAuthIdentity);
+            // Mock existing customer
+            mockCustomerService.listAndCount.mockResolvedValue([
+                [{
+                        id: "cust_existing",
+                        metadata: { line_user_id: "U1234567890" }
+                    }],
+                1
+            ]);
+            const result = await service.validateCallback({ query: { code: "test-code", state: "valid-state" }, body: {} }, mockAuthIdentityService);
+            expect(result.success).toBe(true);
+            expect(mockAuthIdentityService.update).toHaveBeenCalled();
+        });
+    });
+    describe("verifyIdToken", () => {
+        beforeEach(() => {
+            jest.spyOn(Date, "now").mockReturnValue(1000000);
+        });
+        afterEach(() => {
+            Date.now.mockRestore();
+        });
+        it("should verify valid ID token", async () => {
+            const payload = {
+                iss: "https://access.line.me",
+                sub: "U123456",
+                aud: "1234567890",
+                exp: 1001, // Future timestamp
+                iat: 900,
+            };
+            mockJwt.decode.mockReturnValue({
+                payload,
+            });
+            const result = await service.verifyIdToken("valid-token");
+            expect(result).toBe(payload);
+        });
+        it("should reject token with wrong audience", async () => {
+            const payload = {
+                iss: "https://access.line.me",
+                sub: "U123456",
+                aud: "wrong-channel-id",
+                exp: 1001,
+                iat: 900,
+            };
+            mockJwt.decode.mockReturnValue({
+                payload,
+            });
+            await expect(service.verifyIdToken("invalid-token")).rejects.toThrow(new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "ID token audience mismatch"));
+        });
+        it("should reject token with wrong issuer", async () => {
+            const payload = {
+                iss: "https://wrong-issuer.com",
+                sub: "U123456",
+                aud: "1234567890",
+                exp: 1001,
+                iat: 900,
+            };
+            mockJwt.decode.mockReturnValue({
+                payload,
+            });
+            await expect(service.verifyIdToken("invalid-token")).rejects.toThrow(new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "ID token issuer mismatch"));
+        });
+        it("should reject expired token", async () => {
+            const payload = {
+                iss: "https://access.line.me",
+                sub: "U123456",
+                aud: "1234567890",
+                exp: 999, // Past timestamp
+                iat: 900,
+            };
+            mockJwt.decode.mockReturnValue({
+                payload,
+            });
+            await expect(service.verifyIdToken("expired-token")).rejects.toThrow(new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "ID token has expired"));
+        });
+        it("should handle malformed ID token", async () => {
+            mockJwt.decode.mockReturnValue(null);
+            await expect(service.verifyIdToken("malformed-token")).rejects.toThrow(new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Failed to decode ID token"));
+        });
+    });
+    describe("Token Management", () => {
+        beforeEach(() => {
+            global.fetch = jest.fn();
+        });
+        describe("refreshToken", () => {
+            it("should refresh LINE access token", async () => {
+                const mockResponse = {
+                    access_token: "new-access-token",
+                    expires_in: 2592000,
+                    refresh_token: "new-refresh-token",
+                };
+                global.fetch.mockResolvedValue({
+                    ok: true,
+                    json: async () => mockResponse,
+                });
+                const result = await service.refreshToken("old-refresh-token");
+                expect(result).toEqual(mockResponse);
+                expect(global.fetch).toHaveBeenCalledWith("https://api.line.me/oauth2/v2.1/token", expect.objectContaining({
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/x-www-form-urlencoded",
+                    },
+                }));
+            });
+            it("should handle refresh token errors", async () => {
+                global.fetch.mockResolvedValue({
+                    ok: false,
+                    status: 401,
+                });
+                const result = await service.refreshToken("invalid-token");
+                expect(result).toBeNull();
+                expect(mockLogger.error).toHaveBeenCalled();
+            });
+        });
+        describe("revokeToken", () => {
+            it("should revoke LINE access token", async () => {
+                global.fetch.mockResolvedValue({
+                    ok: true,
+                });
+                const result = await service.revokeToken("access-token");
+                expect(result).toBe(true);
+                expect(global.fetch).toHaveBeenCalledWith("https://api.line.me/oauth2/v2.1/revoke", expect.objectContaining({
+                    method: "POST",
+                }));
+            });
+            it("should handle revoke token errors", async () => {
+                global.fetch.mockResolvedValue({
+                    ok: false,
+                });
+                const result = await service.revokeToken("invalid-token");
+                expect(result).toBe(false);
+            });
+        });
+    });
+    describe("Customer Management", () => {
+        it("should find existing customer by LINE ID", async () => {
+            const mockCustomer = {
+                id: "cus_123",
+                email: "test@example.com",
+                metadata: { line_user_id: "U1234567890" },
+            };
+            mockCustomerService.listAndCount.mockResolvedValue([
+                [mockCustomer],
+                1,
+            ]);
+            const result = await service.findCustomerByLineId("U1234567890");
+            expect(result).toEqual(mockCustomer);
+            expect(mockCustomerService.listAndCount).toHaveBeenCalledWith({
+                metadata: {
+                    line_user_id: "U1234567890",
+                },
+            }, {});
+        });
+        it("should return null when customer not found", async () => {
+            mockCustomerService.listAndCount.mockResolvedValue([[], 0]);
+            const result = await service.findCustomerByLineId("U1234567890");
+            expect(result).toBeNull();
+        });
+        it("should create new customer from LINE profile", async () => {
+            const mockProfile = {
+                userId: "U1234567890",
+                displayName: "John Doe",
+                pictureUrl: "https://example.com/pic.jpg",
+            };
+            const mockIdToken = {
+                email: "john@example.com",
+            };
+            const mockCustomer = {
+                id: "cus_new",
+                email: "john@example.com",
+                first_name: "John",
+                last_name: "Doe",
+            };
+            mockCustomerService.create.mockResolvedValue(mockCustomer);
+            const result = await service.createCustomerFromLineProfile(mockProfile, mockIdToken);
+            expect(result).toEqual(mockCustomer);
+            expect(mockCustomerService.create).toHaveBeenCalledWith({
+                email: "john@example.com",
+                first_name: "John",
+                last_name: "Doe",
+                metadata: expect.objectContaining({
+                    line_user_id: "U1234567890",
+                    line_display_name: "John Doe",
+                    line_picture_url: "https://example.com/pic.jpg",
+                    created_via: "line_oauth",
+                }),
+            });
+        });
+        it("should use placeholder email when not provided", async () => {
+            const mockProfile = {
+                userId: "U1234567890",
+                displayName: "Test User",
+            };
+            const mockIdToken = {};
+            mockCustomerService.create.mockResolvedValue({
+                id: "cus_new",
+                email: "line-U1234567890@line.local",
+            });
+            await service.createCustomerFromLineProfile(mockProfile, mockIdToken);
+            expect(mockCustomerService.create).toHaveBeenCalledWith(expect.objectContaining({
+                email: "line-U1234567890@line.local",
+            }));
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.test.js","sourceRoot":"","sources":["../../../../../../src/providers/line/__tests__/service.test.ts"],"names":[],"mappings":"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"}