Fix unit test

Author: MarceloRGonc

packages/server/api/test/integration/cloud/cloud/cloud-auth.test.ts

@@ -1,10 +1,6 @@
-import { IdentityClient } from '@frontegg/client';
-import { IEntityWithRoles } from '@frontegg/client/dist/src/clients/identity/types';
 import { FastifyRequest } from 'fastify';
-import {
-  getCloudToken,
-  getCloudUser,
-} from '../../../../src/app/user-info/cloud-auth';
+import jwt from 'jsonwebtoken';
+import { getVerifiedUser } from '../../../../src/app/user-info/cloud-auth';
 
 type MockFastifyRequest = FastifyRequest & {
   cookies: Record<string, string>;
@@ -41,75 +37,62 @@ function createMockRequest(options: {
   } as unknown as MockFastifyRequest;
 }
 
-describe('cloud-auth', () => {
-  describe('getCloudToken', () => {
-    it('should extract token from Authorization header', () => {
-      const mockRequest = createMockRequest({
-        headers: { authorization: 'Bearer test-token' },
-        cookies: {},
-      });
+describe('getVerifiedUser', () => {
+  const publicKey = 'test-public-key';
 
-      expect(getCloudToken(mockRequest)).toBe('test-token');
-    });
+  beforeEach(() => {
+    jest.spyOn(jwt, 'verify').mockReset();
+  });
 
-    it('should get token from cookie when Authorization header is missing', () => {
-      const mockRequest = createMockRequest({
-        headers: {},
-        cookies: { 'cloud-token': 'cookie-token' },
-      });
+  it('should return undefined when no token is present (no header, no cookie)', () => {
+    const mockRequest = createMockRequest({ headers: {}, cookies: {} });
 
-      expect(getCloudToken(mockRequest)).toBe('cookie-token');
-    });
+    const result = getVerifiedUser(mockRequest, publicKey);
 
-    it('should return undefined when no token is present', () => {
-      const mockRequest = createMockRequest({
-        headers: {},
-        cookies: {},
-      });
+    expect(result).toBeUndefined();
+    expect(jwt.verify).not.toHaveBeenCalled();
+  });
 
-      expect(getCloudToken(mockRequest)).toBeUndefined();
+  it('should verify token from Authorization header', () => {
+    const payload = { sub: '123' } as any;
+    (jwt.verify as jest.Mock).mockReturnValue(payload);
+    const mockRequest = createMockRequest({
+      headers: { authorization: 'Bearer header-token' },
+      cookies: {},
     });
-  });
 
-  describe('getCloudUser', () => {
-    let mockIdentityClient: jest.Mocked<IdentityClient>;
+    const result = getVerifiedUser(mockRequest, publicKey);
 
-    beforeEach(() => {
-      mockIdentityClient = {
-        validateIdentityOnToken: jest.fn(),
-      } as never;
-    });
+    expect(jwt.verify).toHaveBeenCalledWith('header-token', publicKey);
+    expect(result).toEqual(payload);
+  });
 
-    it('should return null when no token is provided', async () => {
-      const result = await getCloudUser(mockIdentityClient);
-      expect(result).toBeNull();
+  it('should verify token from cookie when Authorization header is missing', () => {
+    const payload = { sub: 'abc' } as any;
+    (jwt.verify as jest.Mock).mockReturnValue(payload);
+    const mockRequest = createMockRequest({
+      headers: {},
+      cookies: { 'cloud-token': 'cookie-token' },
     });
 
-    it('should return user when validation succeeds', async () => {
-      const mockUser = { id: '123', roles: [] };
-      mockIdentityClient.validateIdentityOnToken.mockResolvedValue(
-        mockUser as unknown as IEntityWithRoles,
-      );
+    const result = getVerifiedUser(mockRequest, publicKey);
 
-      const result = await getCloudUser(mockIdentityClient, 'valid-token');
+    expect(jwt.verify).toHaveBeenCalledWith('cookie-token', publicKey);
+    expect(result).toEqual(payload);
+  });
 
-      expect(result).toEqual(mockUser);
-      expect(mockIdentityClient.validateIdentityOnToken).toHaveBeenCalledWith(
-        'valid-token',
-      );
+  it('should return undefined when verification fails (throws)', () => {
+    (jwt.verify as jest.Mock).mockImplementation(() => {
+      throw new Error('invalid');
+    });
+    const mockRequest = createMockRequest({
+      headers: { authorization: 'Bearer bad-token' },
+      cookies: {},
     });
 
-    it('should return null when validation fails', async () => {
-      mockIdentityClient.validateIdentityOnToken.mockRejectedValue(
-        new Error('Invalid token'),
-      );
-
-      const result = await getCloudUser(mockIdentityClient, 'invalid-token');
+    const result = getVerifiedUser(mockRequest, publicKey);
 
-      expect(result).toBeNull();
-      expect(mockIdentityClient.validateIdentityOnToken).toHaveBeenCalledWith(
-        'invalid-token',
-      );
-    });
+    expect(result).toBeUndefined();
+    expect(jwt.verify).toHaveBeenCalledWith('bad-token', publicKey);
   });
 });