@paakd/api 0.0.1 → 0.0.2

package/src/address.spec.ts

@@ -1,662 +0,0 @@
-import { Code, createClient } from '@connectrpc/connect'
-import { createGrpcTransport } from '@connectrpc/connect-node'
-import { getCheckoutConfig } from '@paakd/config'
-import {
-  addAddress,
-  deleteAddress,
-  getAddress,
-  getAddresses,
-  updateAddress,
-} from './address'
-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 mockCreateHeadersInterceptor = vi.mocked(createHeadersInterceptor)
-const mockCreateAuthenticationInterceptor = vi.mocked(
-  createAuthenticationInterceptor
-)
-const mockCreateCustomerAuthenticationInterceptor = vi.mocked(
-  createCustomerAuthenticationInterceptor
-)
-
-/**
- * Extended test context for address service
- */
-interface AddressTestContext extends BaseTestContext {
-  client: MockServiceClient
-}
-
-function setupAddressService(): AddressTestContext {
-  clearAllMocks()
-  const { config, interceptors, transport } = setupCommonMocks()
-
-  const client: MockServiceClient = {
-    getAddresses: vi.fn(),
-    getAddress: vi.fn(),
-    addAddress: vi.fn(),
-    updateAddress: vi.fn(),
-    deleteAddress: 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('Address Service', () => {
-  let consoleSpy: any
-
-  beforeEach(() => {
-    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
-  })
-
-  afterEach(() => {
-    consoleSpy.mockRestore()
-  })
-
-  describe('getAddresses', () => {
-    it('should successfully fetch all addresses for a customer', async () => {
-      const { client } = setupAddressService()
-
-      const mockAddresses = [
-        {
-          id: 'addr-1',
-          customerId: 'cust-1',
-          street: '123 Main St',
-          city: 'New York',
-        },
-        {
-          id: 'addr-2',
-          customerId: 'cust-1',
-          street: '456 Oak Ave',
-          city: 'Los Angeles',
-        },
-      ]
-
-      client.getAddresses.mockResolvedValue({ addresses: mockAddresses })
-
-      const result = await getAddresses({
-        body: {
-          customerId: 'cust-1',
-          jwt: 'token-123',
-        },
-        headers: {},
-      })
-
-      expect(result.status === 'success' && result.value).toBe(mockAddresses)
-    })
-
-    it('should handle customer not found error', async () => {
-      const { client } = setupAddressService()
-
-      const error = createMockConnectError(5, 'NOT_FOUND', 'Customer not found')
-      client.getAddresses.mockRejectedValue(error)
-
-      const result = await getAddresses({
-        body: {
-          customerId: 'invalid-customer',
-          jwt: 'token-123',
-        },
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('failed')
-      expect((result as any).code).toBe(5)
-    })
-
-    it('should reject request with invalid JWT', async () => {
-      const { client } = setupAddressService()
-
-      const error = createMockConnectError(
-        16,
-        'UNAUTHENTICATED',
-        'Invalid JWT token'
-      )
-      client.getAddresses.mockRejectedValue(error)
-
-      const result = await getAddresses({
-        body: {
-          customerId: 'cust-1',
-          jwt: 'invalid-token',
-        },
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('failed')
-    })
-
-    it('should return empty list when customer has no addresses', async () => {
-      const { client } = setupAddressService()
-
-      client.getAddresses.mockResolvedValue({ addresses: [] })
-
-      const result = await getAddresses({
-        body: {
-          customerId: 'cust-1',
-          jwt: 'token-123',
-        },
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('success')
-      expect((result as any).value).toEqual([])
-    })
-  })
-
-  describe('getAddress', () => {
-    it('should successfully fetch a single address', async () => {
-      const { client } = setupAddressService()
-
-      const mockAddress = {
-        id: 'addr-1',
-        customerId: 'cust-1',
-        street: '123 Main St',
-        city: 'New York',
-        state: 'NY',
-        zipCode: '10001',
-      }
-
-      client.getAddress.mockResolvedValue(mockAddress)
-
-      const result = await getAddress({
-        body: {
-          customerId: 'cust-1',
-          addressId: 'addr-1',
-          jwt: 'token-123',
-        },
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('success')
-      expect((result as any).value).toEqual(mockAddress)
-    })
-
-    it('should return not found when address does not exist', async () => {
-      const { client } = setupAddressService()
-
-      const error = createMockConnectError(5, 'NOT_FOUND', 'Address not found')
-      client.getAddress.mockRejectedValue(error)
-
-      const result = await getAddress({
-        body: {
-          customerId: 'cust-1',
-          addressId: 'invalid-addr',
-          jwt: 'token-123',
-        },
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('failed')
-    })
-
-    it('should require valid JWT', async () => {
-      const { client } = setupAddressService()
-
-      const error = createMockConnectError(
-        16,
-        'UNAUTHENTICATED',
-        'Unauthenticated'
-      )
-      client.getAddress.mockRejectedValue(error)
-
-      const result = await getAddress({
-        body: {
-          customerId: 'cust-1',
-          addressId: 'addr-1',
-          jwt: '',
-        },
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('failed')
-    })
-  })
-
-  describe('addAddress', () => {
-    it('should successfully add a new address', async () => {
-      const { client } = setupAddressService()
-
-      const newAddress = {
-        customerId: 'cust-1',
-        firstName: 'Jane',
-        lastName: 'Doe',
-        address1: '789 Pine St',
-        address2: '',
-        address3: '',
-        city: 'Chicago',
-        zipCode: '60601',
-        country: 'US',
-        phoneNumber: '555-9999',
-      }
-
-      const mockResponse = {
-        address: {
-          id: 'addr-3',
-          ...newAddress,
-        },
-      }
-
-      client.addAddress.mockResolvedValue(mockResponse)
-
-      const result = await addAddress({
-        body: {
-          ...newAddress,
-          jwt: 'token-123',
-        } as any,
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('success')
-      expect((result as any).value).toEqual(mockResponse.address)
-    })
-
-    it('should reject invalid address data', async () => {
-      const { client } = setupAddressService()
-
-      const error = createMockConnectError(
-        3,
-        'INVALID_ARGUMENT',
-        'Invalid address data'
-      )
-      client.addAddress.mockRejectedValue(error)
-
-      const result = await addAddress({
-        body: {
-          customerId: 'cust-1',
-          firstName: 'Jane',
-          lastName: 'Doe',
-          address1: '',
-          address2: '',
-          address3: '',
-          city: '',
-          zipCode: '',
-          country: 'US',
-          phoneNumber: '555-1234',
-          jwt: 'token-123',
-        } as any,
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('failed')
-    })
-
-    it('should reject requests without authentication', async () => {
-      const { client } = setupAddressService()
-
-      const error = createMockConnectError(
-        16,
-        'UNAUTHENTICATED',
-        'Authentication required'
-      )
-      client.addAddress.mockRejectedValue(error)
-
-      const result = await addAddress({
-        body: {
-          customerId: 'cust-1',
-          firstName: 'Jane',
-          lastName: 'Doe',
-          address1: '789 Pine St',
-          address2: '',
-          address3: '',
-          city: 'Chicago',
-          zipCode: '60601',
-          country: 'US',
-          phoneNumber: '555-1234',
-          jwt: 'invalid-token',
-        } as any,
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('failed')
-    })
-  })
-
-  describe('updateAddress', () => {
-    it('should successfully update an existing address', async () => {
-      const { client } = setupAddressService()
-
-      const updateData = {
-        id: 'addr-1',
-        customerId: 'cust-1',
-        firstName: 'John',
-        lastName: 'Doe',
-        address1: '123 Main St Updated',
-        address2: '',
-        address3: '',
-        city: 'New York',
-        zipCode: '10001',
-        country: 'US',
-        phoneNumber: '555-1234',
-      }
-
-      const mockResponse = {
-        address: {
-          ...updateData,
-          zipCode: '10001',
-        },
-      }
-
-      client.updateAddress.mockResolvedValue(mockResponse)
-
-      const result = await updateAddress({
-        body: {
-          ...updateData,
-          jwt: 'token-123',
-        } as any,
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('success')
-      expect((result as any).value).toEqual(mockResponse.address)
-    })
-
-    it('should return not found for non-existent address', async () => {
-      const { client } = setupAddressService()
-
-      const error = createMockConnectError(5, 'NOT_FOUND', 'Address not found')
-      client.updateAddress.mockRejectedValue(error)
-
-      const result = await updateAddress({
-        body: {
-          id: 'addr-1',
-          customerId: 'cust-1',
-          firstName: 'John',
-          lastName: 'Doe',
-          addressId: 'addr-1',
-          street: 'Some St',
-          address1: 'Some St',
-          address2: '',
-          city: 'Some City',
-          state: 'NY',
-          zipCode: '10001',
-          country: 'US',
-          phoneNumber: '555-1234',
-          jwt: 'token-123',
-        } as any,
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('failed')
-    })
-
-    it('should reject updates with invalid data', async () => {
-      const { client } = setupAddressService()
-
-      const error = createMockConnectError(
-        3,
-        'INVALID_ARGUMENT',
-        'Invalid update data'
-      )
-      client.updateAddress.mockRejectedValue(error)
-
-      const result = await updateAddress({
-        body: {
-          id: 'addr-1',
-          customerId: 'cust-1',
-          street: '',
-          city: '',
-          jwt: 'token-123',
-        } as any,
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('failed')
-    })
-  })
-
-  describe('deleteAddress', () => {
-    it('should successfully delete an address', async () => {
-      const { client } = setupAddressService()
-
-      const mockResponse = {
-        success: true,
-      }
-
-      client.deleteAddress.mockResolvedValue(mockResponse)
-
-      const result = await deleteAddress({
-        body: {
-          customerId: 'cust-1',
-          addressId: 'addr-1',
-          jwt: 'token-123',
-        },
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('success')
-      expect((result as any).value).toEqual(mockResponse)
-    })
-
-    it('should return not found when address does not exist', async () => {
-      const { client } = setupAddressService()
-
-      const error = createMockConnectError(5, 'NOT_FOUND', 'Address not found')
-      client.deleteAddress.mockRejectedValue(error)
-
-      const result = await deleteAddress({
-        body: {
-          customerId: 'cust-1',
-          addressId: 'invalid-addr',
-          jwt: 'token-123',
-        },
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('failed')
-    })
-
-    it('should reject deletion without authentication', async () => {
-      const { client } = setupAddressService()
-
-      const error = createMockConnectError(
-        16,
-        'UNAUTHENTICATED',
-        'Authentication required'
-      )
-      client.deleteAddress.mockRejectedValue(error)
-
-      const result = await deleteAddress({
-        body: {
-          customerId: 'cust-1',
-          addressId: 'addr-1',
-          jwt: 'invalid-token',
-        },
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('failed')
-    })
-
-    it('should handle service errors gracefully', async () => {
-      const { client } = setupAddressService()
-
-      const error = createMockConnectError(
-        13,
-        'INTERNAL',
-        'Internal server error'
-      )
-      client.deleteAddress.mockRejectedValue(error)
-
-      const result = await deleteAddress({
-        body: {
-          customerId: 'cust-1',
-          addressId: 'addr-1',
-          jwt: 'token-123',
-        },
-        headers: {},
-      })
-
-      expect((result as any).status).toBe('failed')
-      expect((result as any).code).toBe(Code.Internal)
-    })
-  })
-
-  describe('Address Service - Common Behavior', () => {
-    it('should apply all interceptors correctly', async () => {
-      const { client } = setupAddressService()
-
-      client.getAddresses.mockResolvedValue({ addresses: [] })
-
-      const headers = {
-        'x-shop-id': '123',
-        'x-locale': 'en-US',
-      }
-
-      await getAddresses({
-        body: {
-          customerId: 'cust-1',
-          jwt: 'token-123',
-        },
-        headers,
-      })
-
-      expect(mockCreateHeadersInterceptor).toHaveBeenCalledWith(headers)
-      expect(mockCreateAuthenticationInterceptor).toHaveBeenCalled()
-      expect(mockCreateCustomerAuthenticationInterceptor).toHaveBeenCalledWith(
-        'token-123'
-      )
-    })
-
-    it('should load configuration for each request', async () => {
-      const { client } = setupAddressService()
-
-      client.getAddresses.mockResolvedValue({ addresses: [] })
-
-      await getAddresses({
-        body: {
-          customerId: 'cust-1',
-          jwt: 'token-123',
-        },
-        headers: {},
-      })
-
-      expect(mockGetCheckoutConfig).toHaveBeenCalled()
-    })
-
-    it('should create transport with compression enabled', async () => {
-      const { client } = setupAddressService()
-
-      client.getAddresses.mockResolvedValue({ addresses: [] })
-
-      await getAddresses({
-        body: {
-          customerId: 'cust-1',
-          jwt: 'token-123',
-        },
-        headers: {},
-      })
-
-      expect(mockCreateGrpcTransport).toHaveBeenCalledWith(
-        expect.objectContaining({
-          acceptCompression: expect.any(Array),
-          sendCompression: expect.any(Object),
-        })
-      )
-    })
-
-    it('should handle concurrent requests independently', async () => {
-      const { client } = setupAddressService()
-
-      const mockAddresses = [
-        { id: 'addr-1', customerId: 'cust-1', street: '123 Main St' },
-      ]
-
-      client.getAddresses.mockResolvedValue({ addresses: mockAddresses })
-
-      const results = await Promise.all([
-        getAddresses({
-          body: {
-            customerId: 'cust-1',
-            jwt: 'token-1',
-          },
-          headers: {},
-        }),
-        getAddresses({
-          body: {
-            customerId: 'cust-2',
-            jwt: 'token-2',
-          },
-          headers: {},
-        }),
-        getAddresses({
-          body: {
-            customerId: 'cust-3',
-            jwt: 'token-3',
-          },
-          headers: {},
-        }),
-      ])
-
-      expect(results).toHaveLength(3)
-      expect(results.every(r => (r as any).status === 'success')).toBe(true)
-    })
-  })
-})