@paakd/api 0.0.1

package/src/products.spec.ts

@@ -0,0 +1,710 @@
+import { Code, createClient } from '@connectrpc/connect'
+import { createGrpcTransport } from '@connectrpc/connect-node'
+import { getCheckoutConfig } from '@paakd/config'
+import { createCollection, getCollectionByID } from './products'
+import {
+  createAuthenticationInterceptor,
+  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(),
+  createHeadersInterceptor: vi.fn(),
+}))
+
+vi.mock('./compressor/brotli', () => ({
+  brotliCompression: {
+    name: 'brotli',
+    compress: vi.fn(),
+    decompress: vi.fn(),
+  },
+}))
+
+vi.mock('../gen/src/proto/products/v1/service_pb', () => ({
+  ProductsService: {},
+}))
+
+const mockGetCheckoutConfig = vi.mocked(getCheckoutConfig)
+const mockCreateGrpcTransport = vi.mocked(createGrpcTransport)
+const mockCreateClient = vi.mocked(createClient)
+const mockCreateAuthenticationInterceptor = vi.mocked(
+  createAuthenticationInterceptor
+)
+const mockCreateHeadersInterceptor = vi.mocked(createHeadersInterceptor)
+
+/**
+ * Extended test context for products service
+ */
+interface ProductsTestContext extends BaseTestContext {
+  client: MockServiceClient
+}
+
+/**
+ * Setup function following @testing-library's render pattern
+ */
+function setupProductsService(): ProductsTestContext {
+  clearAllMocks()
+  const { config, interceptors, transport } = setupCommonMocks()
+
+  const client: MockServiceClient = {
+    getCollectionByID: vi.fn(),
+    createCollection: 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)
+    }
+  )
+  mockCreateClient.mockReturnValue(client as any)
+
+  return { client, config, interceptors, transport }
+}
+
+describe('Products Service', () => {
+  let consoleSpy: any
+
+  beforeEach(() => {
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+  })
+
+  describe('getCollectionByID', () => {
+    it('should successfully retrieve a collection by ID', async () => {
+      const { client } = setupProductsService()
+
+      const mockCollection = {
+        id: 'collection-1',
+        name: 'Summer Collection',
+        description: 'Summer 2024 collection',
+        productCount: 25,
+      }
+
+      client.getCollectionByID.mockResolvedValue(mockCollection)
+
+      const result = await getCollectionByID({
+        body: {
+          collectionId: 'collection-1',
+        },
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('success')
+      expect((result as any).value).toEqual(mockCollection)
+      expect(client.getCollectionByID).toHaveBeenCalledWith({
+        id: 'collection-1',
+      })
+    })
+
+    it('should return not found when collection does not exist', async () => {
+      const { client } = setupProductsService()
+
+      const error = createMockConnectError(
+        5,
+        'NOT_FOUND',
+        'Collection not found'
+      )
+      client.getCollectionByID.mockRejectedValue(error)
+
+      const result = await getCollectionByID({
+        body: {
+          collectionId: 'invalid-collection',
+        },
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+      expect((result as any).code).toBe(5)
+    })
+
+    it('should handle service unavailability', async () => {
+      const { client } = setupProductsService()
+
+      const error = createMockConnectError(
+        14,
+        'UNAVAILABLE',
+        'Service temporarily unavailable'
+      )
+      client.getCollectionByID.mockRejectedValue(error)
+
+      const result = await getCollectionByID({
+        body: {
+          collectionId: 'collection-1',
+        },
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should include custom headers in request context', async () => {
+      const { client } = setupProductsService()
+
+      client.getCollectionByID.mockResolvedValue({
+        id: 'collection-1',
+        name: 'Summer Collection',
+      })
+
+      const customHeaders = {
+        'x-shop-id': '123',
+        'x-locale': 'en-US',
+      }
+
+      await getCollectionByID({
+        body: {
+          collectionId: 'collection-1',
+        },
+        headers: customHeaders,
+      })
+
+      expect(mockCreateHeadersInterceptor).toHaveBeenCalledWith(customHeaders)
+    })
+
+    it('should use checkout configuration for enterprise URL', async () => {
+      const { client, config } = setupProductsService()
+
+      client.getCollectionByID.mockResolvedValue({
+        id: 'collection-1',
+        name: 'Summer Collection',
+      })
+
+      await getCollectionByID({
+        body: {
+          collectionId: 'collection-1',
+        },
+        headers: {},
+      })
+
+      expect(mockCreateGrpcTransport).toHaveBeenCalledWith(
+        expect.objectContaining({
+          baseUrl: config.enterpriseURL,
+        })
+      )
+    })
+
+    it('should enable compression for data transfer', async () => {
+      const { client } = setupProductsService()
+
+      client.getCollectionByID.mockResolvedValue({
+        id: 'collection-1',
+        name: 'Summer Collection',
+      })
+
+      await getCollectionByID({
+        body: {
+          collectionId: 'collection-1',
+        },
+        headers: {},
+      })
+
+      const transportConfig = (mockCreateGrpcTransport as any).mock.calls[0][0]
+      expect(transportConfig).toHaveProperty('acceptCompression')
+      expect(transportConfig).toHaveProperty('sendCompression')
+    })
+
+    it('should handle invalid collection ID format', async () => {
+      const { client } = setupProductsService()
+
+      const error = createMockConnectError(
+        3,
+        'INVALID_ARGUMENT',
+        'Invalid collection ID format'
+      )
+      client.getCollectionByID.mockRejectedValue(error)
+
+      const result = await getCollectionByID({
+        body: {
+          collectionId: '',
+        },
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should handle internal server errors gracefully', async () => {
+      const { client } = setupProductsService()
+
+      const error = createMockConnectError(
+        13,
+        'INTERNAL',
+        'Internal server error'
+      )
+      client.getCollectionByID.mockRejectedValue(error)
+
+      const result = await getCollectionByID({
+        body: {
+          collectionId: 'collection-1',
+        },
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+      expect((result as any).code).toBe(Code.Internal)
+    })
+
+    it('should support concurrent collection retrievals', async () => {
+      const { client } = setupProductsService()
+
+      client.getCollectionByID.mockResolvedValue({
+        id: 'collection-1',
+        name: 'Collection',
+      })
+
+      const results = await Promise.all([
+        getCollectionByID({
+          body: { collectionId: 'collection-1' },
+          headers: {},
+        }),
+        getCollectionByID({
+          body: { collectionId: 'collection-2' },
+          headers: {},
+        }),
+        getCollectionByID({
+          body: { collectionId: 'collection-3' },
+          headers: {},
+        }),
+      ])
+
+      expect(results).toHaveLength(3)
+      expect(results.every(r => (r as any).status === 'success')).toBe(true)
+    })
+  })
+
+  describe('createCollection', () => {
+    it('should successfully create a new collection', async () => {
+      const { client } = setupProductsService()
+
+      const newCollection = {
+        name: 'Winter Collection',
+        description: 'Winter 2024 collection',
+      }
+
+      const mockCollection = {
+        id: 'new-collection-1',
+        ...newCollection,
+      }
+
+      const mockResponse = {
+        collection: mockCollection,
+      }
+
+      client.createCollection.mockResolvedValue(mockResponse)
+
+      const result = await createCollection({
+        body: newCollection as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('success')
+      expect((result as any).value).toEqual(mockResponse)
+      expect(client.createCollection).toHaveBeenCalledWith(
+        expect.objectContaining(newCollection)
+      )
+    })
+
+    it('should reject collection creation with invalid data', async () => {
+      const { client } = setupProductsService()
+
+      const error = createMockConnectError(
+        3,
+        'INVALID_ARGUMENT',
+        'Invalid collection data'
+      )
+      client.createCollection.mockRejectedValue(error)
+
+      const result = await createCollection({
+        body: {
+          name: '',
+        } as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should handle duplicate collection names', async () => {
+      const { client } = setupProductsService()
+
+      const error = createMockConnectError(
+        6,
+        'ALREADY_EXISTS',
+        'Collection with this name already exists'
+      )
+      client.createCollection.mockRejectedValue(error)
+
+      const result = await createCollection({
+        body: {
+          name: 'Existing Collection',
+          description: 'New description',
+        } as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should reject creation without authentication', async () => {
+      const { client } = setupProductsService()
+
+      const error = createMockConnectError(
+        16,
+        'UNAUTHENTICATED',
+        'Authentication required'
+      )
+      client.createCollection.mockRejectedValue(error)
+
+      const result = await createCollection({
+        body: {
+          name: 'New Collection',
+          description: 'Description',
+        } as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should handle permission denied errors', async () => {
+      const { client } = setupProductsService()
+
+      const error = createMockConnectError(
+        7,
+        'PERMISSION_DENIED',
+        'User does not have permission to create collections'
+      )
+      client.createCollection.mockRejectedValue(error)
+
+      const result = await createCollection({
+        body: {
+          name: 'New Collection',
+          description: 'Description',
+        } as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should include authentication interceptor', async () => {
+      const { client } = setupProductsService()
+
+      client.createCollection.mockResolvedValue({
+        id: 'new-collection-1',
+        name: 'New Collection',
+      })
+
+      await createCollection({
+        body: {
+          name: 'New Collection',
+          description: 'Description',
+        } as any,
+        headers: {},
+      })
+
+      expect(mockCreateAuthenticationInterceptor).toHaveBeenCalled()
+    })
+
+    it('should handle service errors during creation', async () => {
+      const { client } = setupProductsService()
+
+      const error = createMockConnectError(
+        13,
+        'INTERNAL',
+        'Database error occurred'
+      )
+      client.createCollection.mockRejectedValue(error)
+
+      const result = await createCollection({
+        body: {
+          name: 'New Collection',
+          description: 'Description',
+        } as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+      expect(result.code).toBe(Code.Internal)
+    })
+
+    it('should handle collection limit exceeded', async () => {
+      const { client } = setupProductsService()
+
+      const error = createMockConnectError(
+        8,
+        'RESOURCE_EXHAUSTED',
+        'Collection limit exceeded'
+      )
+      client.createCollection.mockRejectedValue(error)
+
+      const result = await createCollection({
+        body: {
+          name: 'New Collection',
+          description: 'Description',
+        } as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('failed')
+    })
+
+    it('should support multiple concurrent collection creations', async () => {
+      const { client } = setupProductsService()
+
+      client.createCollection.mockResolvedValue({
+        id: 'collection-id',
+        name: 'Collection',
+      })
+
+      const results = await Promise.all([
+        createCollection({
+          body: {
+            name: 'Collection 1',
+            description: 'Desc 1',
+          } as any,
+          headers: {},
+        }),
+        createCollection({
+          body: {
+            name: 'Collection 2',
+            description: 'Desc 2',
+          } as any,
+          headers: {},
+        }),
+        createCollection({
+          body: {
+            name: 'Collection 3',
+            description: 'Desc 3',
+          } as any,
+          headers: {},
+        }),
+      ])
+
+      expect(results).toHaveLength(3)
+      expect(results.every(r => (r as any).status === 'success')).toBe(true)
+    })
+  })
+
+  describe('Products Service - Common Behavior', () => {
+    it('should apply authentication interceptor for all operations', async () => {
+      const { client } = setupProductsService()
+
+      client.getCollectionByID.mockResolvedValue({
+        id: 'collection-1',
+        name: 'Collection',
+      })
+
+      await getCollectionByID({
+        body: {
+          collectionId: 'collection-1',
+        },
+        headers: {},
+      })
+
+      expect(mockCreateAuthenticationInterceptor).toHaveBeenCalled()
+    })
+
+    it('should load configuration for each request', async () => {
+      const { client } = setupProductsService()
+
+      client.getCollectionByID.mockResolvedValue({
+        id: 'collection-1',
+        name: 'Collection',
+      })
+
+      await getCollectionByID({
+        body: {
+          collectionId: 'collection-1',
+        },
+        headers: {},
+      })
+
+      expect(mockGetCheckoutConfig).toHaveBeenCalled()
+    })
+
+    it('should create transport with compression enabled', async () => {
+      const { client } = setupProductsService()
+
+      client.getCollectionByID.mockResolvedValue({
+        id: 'collection-1',
+        name: 'Collection',
+      })
+
+      await getCollectionByID({
+        body: {
+          collectionId: 'collection-1',
+        },
+        headers: {},
+      })
+
+      expect(mockCreateGrpcTransport).toHaveBeenCalledWith(
+        expect.objectContaining({
+          acceptCompression: expect.any(Array),
+          sendCompression: expect.any(Object),
+        })
+      )
+    })
+
+    it('should handle concurrent mixed operations', async () => {
+      const { client } = setupProductsService()
+
+      client.getCollectionByID.mockResolvedValue({
+        id: 'collection-1',
+        name: 'Collection',
+      })
+      client.createCollection.mockResolvedValue({
+        id: 'new-collection',
+        name: 'New Collection',
+      })
+
+      const results = await Promise.all([
+        getCollectionByID({
+          body: { collectionId: 'collection-1' },
+          headers: {},
+        }),
+        createCollection({
+          body: {
+            name: 'New Collection',
+            description: 'Desc',
+          } as any,
+          headers: {},
+        }),
+        getCollectionByID({
+          body: { collectionId: 'collection-2' },
+          headers: {},
+        }),
+      ])
+
+      expect(results).toHaveLength(3)
+      expect(results.every(r => (r as any).status === 'success')).toBe(true)
+    })
+
+    it('should handle edge cases with special characters in collection names', async () => {
+      const { client } = setupProductsService()
+
+      const mockCollection = {
+        id: 'collection-special',
+        name: "Summer's Special Collection 2024!",
+        description: 'Special offer: 50% off - São Paulo exclusive',
+      }
+
+      client.createCollection.mockResolvedValue(mockCollection)
+
+      const result = await createCollection({
+        body: {
+          name: "Summer's Special Collection 2024!",
+          description: 'Special offer: 50% off - São Paulo exclusive',
+        } as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('success')
+      expect((result as any).value).toEqual(mockCollection)
+    })
+
+    it('should handle very long collection descriptions', async () => {
+      const { client } = setupProductsService()
+
+      const longDescription = 'A'.repeat(500)
+      const mockCollection = {
+        id: 'collection-long',
+        name: 'Collection',
+        description: longDescription,
+      }
+
+      client.createCollection.mockResolvedValue(mockCollection)
+
+      const result = await createCollection({
+        body: {
+          name: 'Collection',
+          description: longDescription,
+        } as any,
+        headers: {},
+      })
+
+      expect((result as any).status).toBe('success')
+    })
+
+    it('should handle null or undefined headers gracefully', async () => {
+      const { client } = setupProductsService()
+
+      client.getCollectionByID.mockResolvedValue({
+        id: 'collection-1',
+        name: 'Collection',
+      })
+
+      const result = await getCollectionByID({
+        body: {
+          collectionId: 'collection-1',
+        },
+        headers: {
+          'x-header': null,
+        },
+      })
+
+      expect((result as any).status).toBe('success')
+    })
+
+    it('should consistent error handling across operations', async () => {
+      const { client } = setupProductsService()
+
+      const error = createMockConnectError(
+        16,
+        'UNAUTHENTICATED',
+        'Invalid authentication'
+      )
+
+      client.getCollectionByID.mockRejectedValueOnce(error)
+      client.createCollection.mockRejectedValueOnce(error)
+
+      const results = await Promise.all([
+        getCollectionByID({
+          body: { collectionId: 'collection-1' },
+          headers: {},
+        }),
+        createCollection({
+          body: {
+            name: 'Collection',
+            description: 'Desc',
+          } as any,
+          headers: {},
+        }),
+      ])
+
+      expect(results.every(r => (r as any).status === 'failed')).toBe(true)
+      expect(results.every(r => r.code === 16)).toBe(true)
+    })
+  })
+})