@paakd/api 0.0.1

package/src/profile.spec.ts

@@ -0,0 +1,626 @@
+import { Code, createClient } from '@connectrpc/connect'
+import { createGrpcTransport } from '@connectrpc/connect-node'
+import { getCheckoutConfig } from '@paakd/config'
+import {
+  getBasicProfile,
+  getProfile,
+  updateProfile,
+  type UpdateProfileProps,
+} from './profile'
+import {
+  createAuthenticationInterceptor,
+  createCustomerAuthenticationInterceptor,
+  createHeadersInterceptor,
+} from './interceptors'
+import {
+  type BaseTestContext,
+  type MockServiceClient,
+  clearAllMocks,
+  createMockConnectError,
+  setupCommonMocks,
+} from './test-utils'
+
+// Mock dependencies
+vi.mock('@connectrpc/connect', async () => {
+  const actual = await vi.importActual('@connectrpc/connect')
+  return {
+    ...actual,
+    createClient: vi.fn(),
+  }
+})
+
+vi.mock('@connectrpc/connect-node', () => ({
+  createGrpcTransport: vi.fn(),
+}))
+
+vi.mock('@paakd/config', () => ({
+  getCheckoutConfig: vi.fn(),
+}))
+
+vi.mock('./interceptors', () => ({
+  createAuthenticationInterceptor: vi.fn(),
+  createCustomerAuthenticationInterceptor: vi.fn(),
+  createHeadersInterceptor: vi.fn(),
+}))
+
+vi.mock('./compressor/brotli', () => ({
+  brotliCompression: {
+    name: 'brotli',
+    compress: vi.fn(),
+    decompress: vi.fn(),
+  },
+}))
+
+vi.mock('../gen/src/proto/customers/v1/service_pb', () => ({
+  CustomerService: {},
+}))
+
+const mockGetCheckoutConfig = vi.mocked(getCheckoutConfig)
+const mockCreateGrpcTransport = vi.mocked(createGrpcTransport)
+const mockCreateClient = vi.mocked(createClient)
+const mockCreateAuthenticationInterceptor = vi.mocked(
+  createAuthenticationInterceptor
+)
+const mockCreateCustomerAuthenticationInterceptor = vi.mocked(
+  createCustomerAuthenticationInterceptor
+)
+const mockCreateHeadersInterceptor = vi.mocked(createHeadersInterceptor)
+
+/**
+ * Extended test context for profile service
+ */
+interface ProfileTestContext extends BaseTestContext {
+  client: MockServiceClient
+}
+
+function setupProfileService(): ProfileTestContext {
+  clearAllMocks()
+  const { config, interceptors, transport } = setupCommonMocks()
+
+  const client: MockServiceClient = {
+    basicProfile: vi.fn(),
+    profile: vi.fn(),
+    updateProfile: vi.fn(),
+  }
+
+  mockGetCheckoutConfig.mockResolvedValue(config)
+  mockCreateGrpcTransport.mockReturnValue(transport)
+  mockCreateHeadersInterceptor.mockImplementation(() => next => async req => {
+    return await next(req)
+  })
+  mockCreateAuthenticationInterceptor.mockImplementation(
+    () => next => async req => {
+      return await next(req)
+    }
+  )
+  mockCreateCustomerAuthenticationInterceptor.mockImplementation(
+    () => next => async req => {
+      return await next(req)
+    }
+  )
+  mockCreateClient.mockReturnValue(client as any)
+
+  return {
+    client,
+    config,
+    interceptors,
+    transport,
+  }
+}
+
+describe('Profile Service', () => {
+  let consoleSpy: any
+
+  beforeEach(() => {
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+  })
+
+  describe('getBasicProfile', () => {
+    it('should successfully fetch basic profile for customer', async () => {
+      const { client } = setupProfileService()
+
+      const mockProfile = {
+        customerId: 'cust-1',
+        email: 'user@example.com',
+        firstName: 'John',
+        lastName: 'Doe',
+      }
+
+      client.basicProfile.mockResolvedValue(mockProfile)
+
+      const result = await getBasicProfile({
+        body: {
+          customerId: 'cust-1',
+          jwt: 'token-123',
+        },
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('success')
+      expect((result as any).value).toEqual(mockProfile)
+    })
+
+    it('should reject request without authentication', async () => {
+      const { client } = setupProfileService()
+
+      const error = createMockConnectError(
+        16,
+        'UNAUTHENTICATED',
+        'Invalid JWT token'
+      )
+      client.basicProfile.mockRejectedValue(error)
+
+      const result = await getBasicProfile({
+        body: {
+          customerId: 'cust-1',
+          jwt: 'invalid-token',
+        },
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should handle customer not found error', async () => {
+      const { client } = setupProfileService()
+
+      const error = createMockConnectError(5, 'NOT_FOUND', 'Customer not found')
+      client.basicProfile.mockRejectedValue(error)
+
+      const result = await getBasicProfile({
+        body: {
+          customerId: 'invalid-cust',
+          jwt: 'token-123',
+        },
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+      expect((result as any).code).toBe(5)
+    })
+
+    it('should apply customer authentication interceptor', async () => {
+      const { client } = setupProfileService()
+      const jwt = 'user-jwt-token'
+
+      client.basicProfile.mockResolvedValue({
+        customerId: 'cust-1',
+        email: 'user@example.com',
+      })
+
+      await getBasicProfile({
+        body: {
+          customerId: 'cust-1',
+          jwt,
+        },
+        headers: {},
+      })
+
+      expect(mockCreateCustomerAuthenticationInterceptor).toHaveBeenCalledWith(
+        jwt
+      )
+    })
+  })
+
+  describe('getProfile', () => {
+    it('should successfully fetch full profile for customer', async () => {
+      const { client } = setupProfileService()
+
+      const mockProfile = {
+        customerId: 'cust-1',
+        email: 'user@example.com',
+        firstName: 'John',
+        lastName: 'Doe',
+        phone: '555-1234',
+        dateOfBirth: '1990-01-01',
+        preferences: {
+          newsletter: true,
+          sms: false,
+        },
+      }
+
+      client.profile.mockResolvedValue(mockProfile)
+
+      const result = await getProfile({
+        body: {
+          customerId: 'cust-1',
+          jwt: 'token-123',
+        },
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('success')
+      expect((result as any).value).toEqual(mockProfile)
+    })
+
+    it('should reject unauthenticated requests', async () => {
+      const { client } = setupProfileService()
+
+      const error = createMockConnectError(
+        16,
+        'UNAUTHENTICATED',
+        'Session expired'
+      )
+      client.profile.mockRejectedValue(error)
+
+      const result = await getProfile({
+        body: {
+          customerId: 'cust-1',
+          jwt: 'expired-token',
+        },
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should handle service unavailability', async () => {
+      const { client } = setupProfileService()
+
+      const error = createMockConnectError(
+        14,
+        'UNAVAILABLE',
+        'Service temporarily unavailable'
+      )
+      client.profile.mockRejectedValue(error)
+
+      const result = await getProfile({
+        body: {
+          customerId: 'cust-1',
+          jwt: 'token-123',
+        },
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should use checkout config for enterprise URL', async () => {
+      const { client, config } = setupProfileService()
+
+      client.profile.mockResolvedValue({
+        customerId: 'cust-1',
+        email: 'user@example.com',
+      })
+
+      await getProfile({
+        body: {
+          customerId: 'cust-1',
+          jwt: 'token-123',
+        },
+        headers: {},
+      })
+
+      expect(mockCreateGrpcTransport).toHaveBeenCalledWith(
+        expect.objectContaining({
+          baseUrl: config.enterpriseURL,
+        })
+      )
+    })
+  })
+
+  describe('updateProfile', () => {
+    it('should successfully update customer profile', async () => {
+      const { client } = setupProfileService()
+
+      const updateData: UpdateProfileProps = {
+        body: {
+          customerId: 'cust-1',
+          firstName: 'Jane',
+          lastName: 'Doe',
+          email: 'jane@example.com',
+          otherNames: 'Jane Marie',
+          dateOfBirth: '1990-01-01',
+          gender: 'female',
+          phone: '555-1234',
+          jwt: 'token-123',
+        } as any,
+        headers: {},
+      }
+
+      const mockResponse = {
+        customerId: 'cust-1',
+        firstName: 'Jane',
+        lastName: 'Smith',
+        email: 'user@example.com',
+      }
+
+      client.updateProfile.mockResolvedValue(mockResponse)
+
+      const result = await updateProfile(updateData)
+
+      expect((result as any).status).toBe('success')
+      expect((result as any).value).toEqual(mockResponse)
+    })
+
+    it('should reject invalid profile data', async () => {
+      const { client } = setupProfileService()
+
+      const error = createMockConnectError(
+        3,
+        'INVALID_ARGUMENT',
+        'Invalid profile data'
+      )
+      client.updateProfile.mockRejectedValue(error)
+
+      const result = await updateProfile({
+        body: {
+          customerId: 'cust-1',
+          firstName: '',
+          jwt: 'token-123',
+        } as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should reject update without authentication', async () => {
+      const { client } = setupProfileService()
+
+      const error = createMockConnectError(16, 'UNAUTHENTICATED', 'Invalid JWT')
+      client.updateProfile.mockRejectedValue(error)
+
+      const result = await updateProfile({
+        body: {
+          customerId: 'cust-1',
+          firstName: 'John',
+          jwt: 'invalid-token',
+        } as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should handle permission denied error', async () => {
+      const { client } = setupProfileService()
+
+      const error = createMockConnectError(
+        7,
+        'PERMISSION_DENIED',
+        'Cannot update profile for another customer'
+      )
+      client.updateProfile.mockRejectedValue(error)
+
+      const result = await updateProfile({
+        body: {
+          customerId: 'other-cust',
+          firstName: 'Jane',
+          jwt: 'user-jwt',
+        } as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should not include JWT in service request body', async () => {
+      const { client } = setupProfileService()
+
+      client.updateProfile.mockResolvedValue({
+        customerId: 'cust-1',
+        firstName: 'Jane',
+      })
+
+      const jwt = 'user-jwt-token'
+      const updateData: UpdateProfileProps = {
+        body: {
+          customerId: 'cust-1',
+          firstName: 'Jane',
+          lastName: 'Doe',
+          email: 'jane@example.com',
+          otherNames: 'Jane Marie',
+          dateOfBirth: '1990-01-01',
+          gender: 'female',
+          phone: '555-1234',
+          jwt,
+        } as any,
+        headers: {},
+      }
+
+      await updateProfile(updateData)
+
+      const callArgs = client.updateProfile.mock.calls[0][0]
+      expect(callArgs).not.toHaveProperty('jwt')
+    })
+
+    it('should apply three interceptors in correct order', async () => {
+      const { client } = setupProfileService()
+
+      client.updateProfile.mockResolvedValue({
+        customerId: 'cust-1',
+        firstName: 'Jane',
+      })
+
+      const headers = {
+        'x-shop-id': '123',
+      }
+      const jwt = 'user-jwt-token'
+
+      await updateProfile({
+        body: {
+          customerId: 'cust-1',
+          firstName: 'Jane',
+          lastName: 'Doe',
+          email: 'jane@example.com',
+          otherNames: 'Jane Marie',
+          dateOfBirth: '1990-01-01',
+          gender: 'female',
+          phone: '555-1234',
+          jwt,
+        } as any,
+        headers,
+      })
+
+      expect(mockCreateHeadersInterceptor).toHaveBeenCalledWith(headers)
+      expect(mockCreateAuthenticationInterceptor).toHaveBeenCalled()
+      expect(mockCreateCustomerAuthenticationInterceptor).toHaveBeenCalledWith(
+        jwt
+      )
+    })
+
+    it('should handle database errors gracefully', async () => {
+      const { client } = setupProfileService()
+
+      const error = createMockConnectError(13, 'INTERNAL', 'Database error')
+      client.updateProfile.mockRejectedValue(error)
+
+      const result = await updateProfile({
+        body: {
+          customerId: 'cust-1',
+          firstName: 'Jane',
+          jwt: 'token-123',
+        } as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+      expect((result as any).code).toBe(Code.Internal)
+    })
+  })
+
+  describe('Profile Service - Common Behavior', () => {
+    it('should load configuration for each request', async () => {
+      const { client } = setupProfileService()
+
+      client.basicProfile.mockResolvedValue({
+        customerId: 'cust-1',
+        email: 'user@example.com',
+      })
+
+      await getBasicProfile({
+        body: {
+          customerId: 'cust-1',
+          firstName: 'John',
+          lastName: 'Doe',
+          email: 'john@example.com',
+          otherNames: 'John Michael',
+          dateOfBirth: '1985-05-15',
+          gender: 'male',
+          phone: '555-5678',
+          jwt: 'token-123',
+        } as any,
+        headers: {},
+      })
+
+      expect(mockGetCheckoutConfig).toHaveBeenCalled()
+    })
+
+    it('should enable compression for all operations', async () => {
+      const { client } = setupProfileService()
+
+      client.basicProfile.mockResolvedValue({
+        customerId: 'cust-1',
+        email: 'user@example.com',
+      })
+
+      await getBasicProfile({
+        body: {
+          customerId: 'cust-1',
+          firstName: 'John',
+          lastName: 'Doe',
+          email: 'john@example.com',
+          otherNames: 'John Michael',
+          dateOfBirth: '1985-05-15',
+          gender: 'male',
+          phone: '555-5678',
+          jwt: 'token-123',
+        } as any,
+        headers: {},
+      })
+
+      const transportConfig = (mockCreateGrpcTransport as any).mock.calls[0][0]
+      expect(transportConfig).toHaveProperty('acceptCompression')
+      expect(transportConfig).toHaveProperty('sendCompression')
+    })
+
+    it('should handle concurrent profile operations', async () => {
+      const { client } = setupProfileService()
+
+      const mockProfile1 = {
+        customerId: 'cust-1',
+        email: 'user1@example.com',
+        firstName: 'John',
+      }
+
+      const mockProfile2 = {
+        customerId: 'cust-2',
+        email: 'user2@example.com',
+        firstName: 'Jane',
+      }
+
+      client.basicProfile.mockResolvedValueOnce(mockProfile1)
+      client.basicProfile.mockResolvedValueOnce(mockProfile2)
+
+      const results = await Promise.all([
+        getBasicProfile({
+          body: {
+            customerId: 'cust-1',
+            jwt: 'token-1',
+          },
+          headers: {},
+        }),
+        getBasicProfile({
+          body: {
+            customerId: 'cust-2',
+            jwt: 'token-2',
+          },
+          headers: {},
+        }),
+      ])
+
+      expect(results).toHaveLength(2)
+      expect(results.every(r => (r as any).status === 'success')).toBe(true)
+    })
+
+    it('should handle edge cases with special characters in data', async () => {
+      const { client } = setupProfileService()
+
+      const mockProfile = {
+        customerId: 'cust-1',
+        email: 'user+tag@example.com',
+        firstName: "O'Connor",
+        lastName: 'François',
+      }
+
+      client.basicProfile.mockResolvedValue(mockProfile)
+
+      const result = await getBasicProfile({
+        body: {
+          customerId: 'cust-1',
+          jwt: 'token-123',
+        },
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('success')
+      expect((result as any).value).toEqual(mockProfile)
+    })
+
+    it('should handle null or undefined headers gracefully', async () => {
+      const { client } = setupProfileService()
+
+      client.basicProfile.mockResolvedValue({
+        customerId: 'cust-1',
+        email: 'user@example.com',
+      })
+
+      const result = await getBasicProfile({
+        body: {
+          customerId: 'cust-1',
+          jwt: 'token-123',
+        },
+        headers: {
+          'x-header': null,
+        },
+      })
+
+      expect((result as any).status).toBe('success')
+    })
+  })
+})