@htlkg/data 0.0.14 → 0.0.16

package/src/mutations/productInstances/productInstances.test.ts

@@ -0,0 +1,680 @@
+/**
+ * Unit Tests for ProductInstance Mutations
+ *
+ * Tests the mutation functions for creating, updating, and deleting product instances.
+ * Verifies proper authentication, error handling, and data transformation.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+	createProductInstance,
+	updateProductInstance,
+	deleteProductInstance,
+	toggleProductInstanceEnabled,
+	type CreateProductInstanceInput,
+	type UpdateProductInstanceInput,
+} from './productInstances';
+import { AppError } from '@htlkg/core/errors';
+import * as auth from '@htlkg/core/auth';
+
+// Mock the auth module
+vi.mock('@htlkg/core/auth', () => ({
+	getClientUser: vi.fn(),
+}));
+
+// Mock the utils module
+vi.mock('@htlkg/core/utils', () => ({
+	getCurrentTimestamp: vi.fn(() => '2024-01-15T10:00:00.000Z'),
+}));
+
+describe('ProductInstance Mutations', () => {
+	const mockUserId = 'test-user-123';
+	const mockTimestamp = '2024-01-15T10:00:00.000Z';
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		// Mock getClientUser to return a user with the expected email
+		vi.mocked(auth.getClientUser).mockResolvedValue({
+			username: 'testuser',
+			email: mockUserId,
+			brandIds: [],
+			accountIds: [],
+			isAdmin: false,
+			isSuperAdmin: false,
+			roles: [],
+		});
+		// Mock Date for consistent timestamps
+		vi.useFakeTimers();
+		vi.setSystemTime(new Date(mockTimestamp));
+	});
+
+	afterEach(() => {
+		vi.useRealTimers();
+	});
+
+	describe('createProductInstance', () => {
+		const validInput: CreateProductInstanceInput = {
+			productId: 'product-123',
+			productName: 'Test Product',
+			brandId: 'brand-456',
+			accountId: 'account-789',
+			enabled: true,
+			config: { apiKey: 'test-key', maxRequests: 100 },
+			version: '1.0.0',
+		};
+
+		it('should successfully create a product instance', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						create: vi.fn().mockResolvedValue({
+							data: {
+								id: 'instance-001',
+								...validInput,
+								config: JSON.stringify(validInput.config),
+								lastUpdated: mockTimestamp,
+								updatedBy: mockUserId,
+							},
+							errors: null,
+						}),
+					},
+				},
+			};
+
+			const result = await createProductInstance(mockClient, validInput);
+
+			expect(result).toBeTruthy();
+			expect(result?.id).toBe('instance-001');
+			expect(result?.productId).toBe('product-123');
+			expect(result?.updatedBy).toBe(mockUserId);
+		});
+
+		it('should call getClientUser to get the user identifier', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						create: vi.fn().mockResolvedValue({
+							data: { id: 'test-id' },
+							errors: null,
+						}),
+					},
+				},
+			};
+
+			await createProductInstance(mockClient, validInput);
+
+			expect(auth.getClientUser).toHaveBeenCalledTimes(1);
+		});
+
+		it('should NOT pass authMode to the GraphQL client', async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: 'test-id' },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						create: mockCreate,
+					},
+				},
+			};
+
+			await createProductInstance(mockClient, validInput);
+
+			// Verify create was called with ONLY one argument (no authMode)
+			expect(mockCreate).toHaveBeenCalledTimes(1);
+			expect(mockCreate).toHaveBeenCalledWith(
+				expect.objectContaining({
+					productId: 'product-123',
+					productName: 'Test Product',
+					brandId: 'brand-456',
+					accountId: 'account-789',
+					enabled: true,
+					version: '1.0.0',
+					lastUpdated: mockTimestamp,
+					updatedBy: mockUserId,
+				})
+			);
+
+			// Verify NO second parameter with authMode
+			expect(mockCreate.mock.calls[0]).toHaveLength(1);
+		});
+
+		it('should serialize config as JSON string', async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: 'test-id' },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						create: mockCreate,
+					},
+				},
+			};
+
+			const configInput = { apiKey: 'test', nested: { value: 123 } };
+			await createProductInstance(mockClient, {
+				...validInput,
+				config: configInput,
+			});
+
+			const callArgs = mockCreate.mock.calls[0][0];
+			expect(callArgs.config).toBe(JSON.stringify(configInput));
+			expect(typeof callArgs.config).toBe('string');
+		});
+
+		it('should use current timestamp when lastUpdated is not provided', async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: 'test-id' },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						create: mockCreate,
+					},
+				},
+			};
+
+			await createProductInstance(mockClient, validInput);
+
+			const callArgs = mockCreate.mock.calls[0][0];
+			expect(callArgs.lastUpdated).toBe(mockTimestamp);
+		});
+
+		it('should use provided updatedBy if specified', async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: 'test-id' },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						create: mockCreate,
+					},
+				},
+			};
+
+			const customUserId = 'custom-user-456';
+			await createProductInstance(mockClient, {
+				...validInput,
+				updatedBy: customUserId,
+			});
+
+			const callArgs = mockCreate.mock.calls[0][0];
+			expect(callArgs.updatedBy).toBe(customUserId);
+			// getClientUser should not be called since updatedBy is provided
+			expect(auth.getClientUser).not.toHaveBeenCalled();
+		});
+
+		it('should throw AppError when GraphQL returns errors', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						create: vi.fn().mockResolvedValue({
+							data: null,
+							errors: [
+								{ message: 'Validation error', path: ['input', 'productId'] },
+							],
+						}),
+					},
+				},
+			};
+
+			await expect(
+				createProductInstance(mockClient, validInput)
+			).rejects.toThrow(AppError);
+
+			try {
+				await createProductInstance(mockClient, validInput);
+			} catch (error) {
+				expect(error).toBeInstanceOf(AppError);
+				expect((error as AppError).code).toBe('PRODUCT_INSTANCE_CREATE_ERROR');
+				expect((error as AppError).statusCode).toBe(500);
+			}
+		});
+
+		it('should wrap non-AppError exceptions in AppError', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						create: vi.fn().mockRejectedValue(new Error('Network error')),
+					},
+				},
+			};
+
+			await expect(
+				createProductInstance(mockClient, validInput)
+			).rejects.toThrow(AppError);
+
+			try {
+				await createProductInstance(mockClient, validInput);
+			} catch (error) {
+				expect(error).toBeInstanceOf(AppError);
+				expect((error as AppError).code).toBe('PRODUCT_INSTANCE_CREATE_ERROR');
+			}
+		});
+
+		it('should handle Vue Proxy objects in config', async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: 'test-id' },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						create: mockCreate,
+					},
+				},
+			};
+
+			// Simulate Vue Proxy-like object
+			const proxyConfig = { apiKey: 'test', __v_isProxy: true };
+			await createProductInstance(mockClient, {
+				...validInput,
+				config: proxyConfig,
+			});
+
+			const callArgs = mockCreate.mock.calls[0][0];
+			// Should be properly serialized despite proxy
+			expect(typeof callArgs.config).toBe('string');
+			const parsed = JSON.parse(callArgs.config);
+			expect(parsed.apiKey).toBe('test');
+		});
+	});
+
+	describe('updateProductInstance', () => {
+		const validInput: UpdateProductInstanceInput = {
+			id: 'instance-123',
+			enabled: false,
+			config: { apiKey: 'updated-key', maxRequests: 200 },
+			version: '1.1.0',
+		};
+
+		it('should successfully update a product instance', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						update: vi.fn().mockResolvedValue({
+							data: {
+								...validInput,
+								config: JSON.stringify(validInput.config),
+								lastUpdated: mockTimestamp,
+								updatedBy: mockUserId,
+							},
+							errors: null,
+						}),
+					},
+				},
+			};
+
+			const result = await updateProductInstance(mockClient, validInput);
+
+			expect(result).toBeTruthy();
+			expect(result?.id).toBe('instance-123');
+			expect(result?.enabled).toBe(false);
+		});
+
+		it('should NOT pass authMode to the GraphQL client', async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: 'test-id' },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						update: mockUpdate,
+					},
+				},
+			};
+
+			await updateProductInstance(mockClient, validInput);
+
+			// Verify NO second parameter with authMode
+			expect(mockUpdate.mock.calls[0]).toHaveLength(1);
+		});
+
+		it('should add timestamp and user metadata', async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: 'test-id' },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						update: mockUpdate,
+					},
+				},
+			};
+
+			await updateProductInstance(mockClient, validInput);
+
+			const callArgs = mockUpdate.mock.calls[0][0];
+			expect(callArgs.lastUpdated).toBe(mockTimestamp);
+			expect(callArgs.updatedBy).toBe(mockUserId);
+		});
+
+		it('should serialize config as JSON string', async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: 'test-id' },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						update: mockUpdate,
+					},
+				},
+			};
+
+			await updateProductInstance(mockClient, validInput);
+
+			const callArgs = mockUpdate.mock.calls[0][0];
+			expect(typeof callArgs.config).toBe('string');
+			const parsed = JSON.parse(callArgs.config);
+			expect(parsed.apiKey).toBe('updated-key');
+		});
+
+		it('should throw AppError on GraphQL errors', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						update: vi.fn().mockResolvedValue({
+							data: null,
+							errors: [{ message: 'Not found' }],
+						}),
+					},
+				},
+			};
+
+			await expect(
+				updateProductInstance(mockClient, validInput)
+			).rejects.toThrow(AppError);
+
+			try {
+				await updateProductInstance(mockClient, validInput);
+			} catch (error) {
+				expect((error as AppError).code).toBe('PRODUCT_INSTANCE_UPDATE_ERROR');
+			}
+		});
+
+		it('should preserve existing AppError instances', async () => {
+			const originalError = new AppError('Original error', 'CUSTOM_CODE', 400);
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						update: vi.fn().mockRejectedValue(originalError),
+					},
+				},
+			};
+
+			await expect(
+				updateProductInstance(mockClient, validInput)
+			).rejects.toThrow(originalError);
+		});
+	});
+
+	describe('deleteProductInstance', () => {
+		const testId = 'instance-to-delete-123';
+
+		it('should successfully delete a product instance', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						delete: vi.fn().mockResolvedValue({
+							data: { id: testId },
+							errors: null,
+						}),
+					},
+				},
+			};
+
+			const result = await deleteProductInstance(mockClient, testId);
+
+			expect(result).toBe(true);
+			expect(mockClient.models.ProductInstance.delete).toHaveBeenCalledWith({
+				id: testId,
+			});
+		});
+
+		it('should NOT pass authMode to the GraphQL client', async () => {
+			const mockDelete = vi.fn().mockResolvedValue({
+				data: { id: testId },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						delete: mockDelete,
+					},
+				},
+			};
+
+			await deleteProductInstance(mockClient, testId);
+
+			// Verify delete was called with ONLY one argument
+			expect(mockDelete.mock.calls[0]).toHaveLength(1);
+			expect(mockDelete).toHaveBeenCalledWith({ id: testId });
+		});
+
+		it('should throw AppError on GraphQL errors', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						delete: vi.fn().mockResolvedValue({
+							data: null,
+							errors: [{ message: 'Permission denied' }],
+						}),
+					},
+				},
+			};
+
+			await expect(
+				deleteProductInstance(mockClient, testId)
+			).rejects.toThrow(AppError);
+
+			try {
+				await deleteProductInstance(mockClient, testId);
+			} catch (error) {
+				expect((error as AppError).code).toBe('PRODUCT_INSTANCE_DELETE_ERROR');
+				expect((error as AppError).statusCode).toBe(500);
+			}
+		});
+
+		it('should wrap non-AppError exceptions in AppError', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						delete: vi.fn().mockRejectedValue(new Error('Database error')),
+					},
+				},
+			};
+
+			await expect(
+				deleteProductInstance(mockClient, testId)
+			).rejects.toThrow(AppError);
+		});
+	});
+
+	describe('toggleProductInstanceEnabled', () => {
+		const testId = 'instance-toggle-123';
+
+		it('should successfully enable a product instance', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						update: vi.fn().mockResolvedValue({
+							data: {
+								id: testId,
+								enabled: true,
+								lastUpdated: mockTimestamp,
+								updatedBy: mockUserId,
+							},
+							errors: null,
+						}),
+					},
+				},
+			};
+
+			const result = await toggleProductInstanceEnabled(mockClient, testId, true);
+
+			expect(result).toBeTruthy();
+			expect(result?.enabled).toBe(true);
+			expect(result?.updatedBy).toBe(mockUserId);
+		});
+
+		it('should successfully disable a product instance', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						update: vi.fn().mockResolvedValue({
+							data: {
+								id: testId,
+								enabled: false,
+								lastUpdated: mockTimestamp,
+								updatedBy: mockUserId,
+							},
+							errors: null,
+						}),
+					},
+				},
+			};
+
+			const result = await toggleProductInstanceEnabled(mockClient, testId, false);
+
+			expect(result).toBeTruthy();
+			expect(result?.enabled).toBe(false);
+		});
+
+		it('should NOT pass authMode to the GraphQL client', async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: testId, enabled: true },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						update: mockUpdate,
+					},
+				},
+			};
+
+			await toggleProductInstanceEnabled(mockClient, testId, true);
+
+			// Verify NO second parameter with authMode
+			expect(mockUpdate.mock.calls[0]).toHaveLength(1);
+			expect(mockUpdate).toHaveBeenCalledWith({
+				id: testId,
+				enabled: true,
+				lastUpdated: mockTimestamp,
+				updatedBy: mockUserId,
+			});
+		});
+
+		it('should call getClientUser for user tracking', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						update: vi.fn().mockResolvedValue({
+							data: { id: testId, enabled: true },
+							errors: null,
+						}),
+					},
+				},
+			};
+
+			await toggleProductInstanceEnabled(mockClient, testId, true);
+
+			expect(auth.getClientUser).toHaveBeenCalledTimes(1);
+		});
+
+		it('should throw AppError on GraphQL errors', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						update: vi.fn().mockResolvedValue({
+							data: null,
+							errors: [{ message: 'Instance not found' }],
+						}),
+					},
+				},
+			};
+
+			await expect(
+				toggleProductInstanceEnabled(mockClient, testId, true)
+			).rejects.toThrow(AppError);
+
+			try {
+				await toggleProductInstanceEnabled(mockClient, testId, true);
+			} catch (error) {
+				expect((error as AppError).code).toBe('PRODUCT_INSTANCE_TOGGLE_ERROR');
+			}
+		});
+
+		it('should wrap non-AppError exceptions in AppError', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						update: vi.fn().mockRejectedValue(new Error('Connection error')),
+					},
+				},
+			};
+
+			await expect(
+				toggleProductInstanceEnabled(mockClient, testId, true)
+			).rejects.toThrow(AppError);
+		});
+	});
+
+	describe('Authentication and Authorization', () => {
+		it('all mutations should use Cognito user pool auth (no apiKey)', async () => {
+			const mockClient = {
+				models: {
+					ProductInstance: {
+						create: vi.fn().mockResolvedValue({ data: { id: '1' }, errors: null }),
+						update: vi.fn().mockResolvedValue({ data: { id: '1' }, errors: null }),
+						delete: vi.fn().mockResolvedValue({ data: { id: '1' }, errors: null }),
+					},
+				},
+			};
+
+			// Test create
+			await createProductInstance(mockClient, {
+				productId: 'p1',
+				productName: 'Product',
+				brandId: 'b1',
+				accountId: 'a1',
+				enabled: true,
+			});
+
+			// Test update
+			await updateProductInstance(mockClient, {
+				id: 'i1',
+				enabled: true,
+			});
+
+			// Test delete
+			await deleteProductInstance(mockClient, 'i1');
+
+			// Test toggle
+			await toggleProductInstanceEnabled(mockClient, 'i1', true);
+
+			// Verify none of them passed authMode as second parameter
+			expect(mockClient.models.ProductInstance.create.mock.calls[0]).toHaveLength(1);
+			expect(mockClient.models.ProductInstance.update.mock.calls[0]).toHaveLength(1);
+			expect(mockClient.models.ProductInstance.update.mock.calls[1]).toHaveLength(1);
+			expect(mockClient.models.ProductInstance.delete.mock.calls[0]).toHaveLength(1);
+		});
+	});
+});