@htlkg/data 0.0.14 → 0.0.16

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

@@ -0,0 +1,621 @@
+/**
+ * Integration Tests for ProductInstance Mutations
+ *
+ * Tests the mutation functions with a more realistic GraphQL client setup
+ * to verify end-to-end behavior including serialization and error handling.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+	createProductInstance,
+	updateProductInstance,
+	deleteProductInstance,
+	toggleProductInstanceEnabled,
+} 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-15T12:00:00.000Z'),
+}));
+
+/**
+ * Create a more realistic mock GraphQL client that simulates
+ * AWS Amplify's behavior
+ */
+function createMockGraphQLClient(options: {
+	createResponse?: any;
+	updateResponse?: any;
+	deleteResponse?: any;
+	shouldDelay?: boolean;
+	shouldFail?: boolean;
+}) {
+	const { createResponse, updateResponse, deleteResponse, shouldDelay = false, shouldFail = false } = options;
+
+	const mockCreate = vi.fn(async (input: any) => {
+		if (shouldDelay) await new Promise(resolve => setTimeout(resolve, 10));
+		if (shouldFail) throw new Error('Network timeout');
+
+		return createResponse || {
+			data: {
+				id: `generated-${Date.now()}`,
+				...input,
+			},
+			errors: null,
+		};
+	});
+
+	const mockUpdate = vi.fn(async (input: any) => {
+		if (shouldDelay) await new Promise(resolve => setTimeout(resolve, 10));
+		if (shouldFail) throw new Error('Network timeout');
+
+		return updateResponse || {
+			data: input,
+			errors: null,
+		};
+	});
+
+	const mockDelete = vi.fn(async (input: any) => {
+		if (shouldDelay) await new Promise(resolve => setTimeout(resolve, 10));
+		if (shouldFail) throw new Error('Network timeout');
+
+		return deleteResponse || {
+			data: { id: input.id },
+			errors: null,
+		};
+	});
+
+	return {
+		models: {
+			ProductInstance: {
+				create: mockCreate,
+				update: mockUpdate,
+				delete: mockDelete,
+			},
+		},
+		_mocks: {
+			create: mockCreate,
+			update: mockUpdate,
+			delete: mockDelete,
+		},
+	};
+}
+
+describe('ProductInstance Mutations - Integration Tests', () => {
+	const mockUserId = 'integration-user-789';
+	const mockTimestamp = '2024-01-15T12: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: [],
+		});
+		vi.useFakeTimers();
+		vi.setSystemTime(new Date(mockTimestamp));
+	});
+
+	afterEach(() => {
+		vi.useRealTimers();
+	});
+
+	describe('End-to-End Flow: Create -> Update -> Toggle -> Delete', () => {
+		it('should perform complete lifecycle of a product instance', async () => {
+			let instanceId: string;
+			const client = createMockGraphQLClient({});
+
+			// Step 1: Create
+			const created = await createProductInstance(client, {
+				productId: 'integration-product-1',
+				productName: 'Integration Test Product',
+				brandId: 'integration-brand-1',
+				accountId: 'integration-account-1',
+				enabled: true,
+				config: { testMode: true, apiKey: 'test-key' },
+				version: '1.0.0',
+			});
+
+			expect(created).toBeTruthy();
+			expect(created?.productId).toBe('integration-product-1');
+			expect(created?.updatedBy).toBe(mockUserId);
+			instanceId = created!.id;
+
+			// Step 2: Update configuration
+			const updated = await updateProductInstance(client, {
+				id: instanceId,
+				config: { testMode: false, apiKey: 'updated-key', maxRequests: 1000 },
+				version: '1.1.0',
+			});
+
+			expect(updated).toBeTruthy();
+			expect(updated?.id).toBe(instanceId);
+			expect(updated?.version).toBe('1.1.0');
+
+			// Step 3: Toggle enabled status
+			const toggled = await toggleProductInstanceEnabled(client, instanceId, false);
+
+			expect(toggled).toBeTruthy();
+			expect(toggled?.id).toBe(instanceId);
+			expect(toggled?.enabled).toBe(false);
+
+			// Step 4: Delete
+			const deleted = await deleteProductInstance(client, instanceId);
+
+			expect(deleted).toBe(true);
+
+			// Verify all operations used the correct client methods
+			expect(client._mocks.create).toHaveBeenCalledTimes(1);
+			expect(client._mocks.update).toHaveBeenCalledTimes(2); // update + toggle
+			expect(client._mocks.delete).toHaveBeenCalledTimes(1);
+		});
+	});
+
+	describe('Concurrent Operations', () => {
+		it('should handle multiple mutations in parallel', async () => {
+			const client = createMockGraphQLClient({});
+
+			const operations = [
+				createProductInstance(client, {
+					productId: 'concurrent-1',
+					productName: 'Product 1',
+					brandId: 'brand-1',
+					accountId: 'account-1',
+					enabled: true,
+				}),
+				createProductInstance(client, {
+					productId: 'concurrent-2',
+					productName: 'Product 2',
+					brandId: 'brand-1',
+					accountId: 'account-1',
+					enabled: true,
+				}),
+				createProductInstance(client, {
+					productId: 'concurrent-3',
+					productName: 'Product 3',
+					brandId: 'brand-1',
+					accountId: 'account-1',
+					enabled: true,
+				}),
+			];
+
+			const results = await Promise.all(operations);
+
+			expect(results).toHaveLength(3);
+			results.forEach(result => {
+				expect(result).toBeTruthy();
+				expect(result?.updatedBy).toBe(mockUserId);
+			});
+		});
+
+		it('should handle mixed success and failure scenarios', async () => {
+			const successClient = createMockGraphQLClient({});
+			const failClient = createMockGraphQLClient({
+				createResponse: {
+					data: null,
+					errors: [{ message: 'Validation failed' }],
+				},
+			});
+
+			const results = await Promise.allSettled([
+				createProductInstance(successClient, {
+					productId: 'success-1',
+					productName: 'Success Product',
+					brandId: 'brand-1',
+					accountId: 'account-1',
+					enabled: true,
+				}),
+				createProductInstance(failClient, {
+					productId: 'fail-1',
+					productName: 'Fail Product',
+					brandId: 'brand-1',
+					accountId: 'account-1',
+					enabled: true,
+				}),
+			]);
+
+			expect(results[0].status).toBe('fulfilled');
+			expect(results[1].status).toBe('rejected');
+			expect((results[1] as PromiseRejectedResult).reason).toBeInstanceOf(AppError);
+		});
+	});
+
+	describe('Complex Config Serialization', () => {
+		it('should handle nested objects in config', async () => {
+			const client = createMockGraphQLClient({});
+
+			const complexConfig = {
+				authentication: {
+					type: 'oauth',
+					credentials: {
+						clientId: 'test-client',
+						clientSecret: 'test-secret',
+					},
+				},
+				endpoints: {
+					production: 'https://api.example.com',
+					staging: 'https://staging.example.com',
+				},
+				features: ['feature1', 'feature2', 'feature3'],
+				metadata: {
+					createdAt: '2024-01-01',
+					tags: ['tag1', 'tag2'],
+				},
+			};
+
+			const result = await createProductInstance(client, {
+				productId: 'complex-config-test',
+				productName: 'Complex Config Product',
+				brandId: 'brand-1',
+				accountId: 'account-1',
+				enabled: true,
+				config: complexConfig,
+			});
+
+			// Verify the config was serialized
+			const createCall = client._mocks.create.mock.calls[0][0];
+			expect(typeof createCall.config).toBe('string');
+
+			// Verify it can be deserialized correctly
+			const parsedConfig = JSON.parse(createCall.config);
+			expect(parsedConfig).toEqual(complexConfig);
+			expect(parsedConfig.authentication.credentials.clientId).toBe('test-client');
+			expect(parsedConfig.features).toHaveLength(3);
+		});
+
+		it('should handle arrays in config', async () => {
+			const client = createMockGraphQLClient({});
+
+			const arrayConfig = {
+				allowedDomains: ['example.com', 'test.com', 'demo.com'],
+				ipWhitelist: ['192.168.1.1', '10.0.0.1'],
+			};
+
+			await createProductInstance(client, {
+				productId: 'array-config-test',
+				productName: 'Array Config Product',
+				brandId: 'brand-1',
+				accountId: 'account-1',
+				enabled: true,
+				config: arrayConfig,
+			});
+
+			const createCall = client._mocks.create.mock.calls[0][0];
+			const parsedConfig = JSON.parse(createCall.config);
+
+			expect(Array.isArray(parsedConfig.allowedDomains)).toBe(true);
+			expect(parsedConfig.allowedDomains).toHaveLength(3);
+			expect(parsedConfig.ipWhitelist[0]).toBe('192.168.1.1');
+		});
+
+		it('should handle special characters in config values', async () => {
+			const client = createMockGraphQLClient({});
+
+			const specialCharsConfig = {
+				apiKey: 'key-with-special-chars-!@#$%^&*()',
+				description: 'Text with "quotes" and \'apostrophes\'',
+				url: 'https://example.com?param=value&other=123',
+			};
+
+			await updateProductInstance(client, {
+				id: 'special-chars-test',
+				config: specialCharsConfig,
+			});
+
+			const updateCall = client._mocks.update.mock.calls[0][0];
+			const parsedConfig = JSON.parse(updateCall.config);
+
+			expect(parsedConfig.apiKey).toBe('key-with-special-chars-!@#$%^&*()');
+			expect(parsedConfig.description).toContain('quotes');
+			expect(parsedConfig.url).toContain('?param=value');
+		});
+	});
+
+	describe('Error Scenarios', () => {
+		it('should handle GraphQL errors with detailed context', async () => {
+			const client = createMockGraphQLClient({
+				createResponse: {
+					data: null,
+					errors: [
+						{
+							message: 'Product not found',
+							path: ['createProductInstance', 'productId'],
+							extensions: {
+								code: 'NOT_FOUND',
+								details: { productId: 'invalid-product-123' },
+							},
+						},
+					],
+				},
+			});
+
+			try {
+				await createProductInstance(client, {
+					productId: 'invalid-product-123',
+					productName: 'Invalid Product',
+					brandId: 'brand-1',
+					accountId: 'account-1',
+					enabled: true,
+				});
+
+				expect.fail('Should have thrown an error');
+			} catch (error) {
+				expect(error).toBeInstanceOf(AppError);
+				expect((error as AppError).code).toBe('PRODUCT_INSTANCE_CREATE_ERROR');
+				expect((error as AppError).message).toContain('Failed to create product instance');
+				expect((error as AppError).details).toBeDefined();
+			}
+		});
+
+		it('should handle network timeouts', async () => {
+			const client = createMockGraphQLClient({
+				shouldFail: true,
+			});
+
+			try {
+				await updateProductInstance(client, {
+					id: 'timeout-test',
+					enabled: true,
+				});
+
+				expect.fail('Should have thrown an error');
+			} catch (error) {
+				expect(error).toBeInstanceOf(AppError);
+				expect((error as AppError).code).toBe('PRODUCT_INSTANCE_UPDATE_ERROR');
+			}
+		});
+
+		it('should handle missing required fields', async () => {
+			const client = createMockGraphQLClient({
+				createResponse: {
+					data: null,
+					errors: [
+						{
+							message: 'Variable "$input" of required type "CreateProductInstanceInput!" was not provided.',
+							extensions: { code: 'BAD_USER_INPUT' },
+						},
+					],
+				},
+			});
+
+			try {
+				await createProductInstance(client, {
+					productId: '',
+					productName: '',
+					brandId: '',
+					accountId: '',
+					enabled: true,
+				});
+
+				expect.fail('Should have thrown an error');
+			} catch (error) {
+				expect(error).toBeInstanceOf(AppError);
+			}
+		});
+	});
+
+	describe('User Context and Tracking', () => {
+		it('should track different users across operations', async () => {
+			const client = createMockGraphQLClient({});
+
+			// User 1 creates
+			vi.mocked(auth.getClientUser).mockResolvedValueOnce({
+				username: 'user1',
+				email: 'user-001',
+				brandIds: [],
+				accountIds: [],
+				isAdmin: false,
+				isSuperAdmin: false,
+				roles: [],
+			});
+			await createProductInstance(client, {
+				productId: 'tracking-test-1',
+				productName: 'Tracking Product',
+				brandId: 'brand-1',
+				accountId: 'account-1',
+				enabled: true,
+			});
+
+			expect(client._mocks.create.mock.calls[0][0].updatedBy).toBe('user-001');
+
+			// User 2 updates
+			vi.mocked(auth.getClientUser).mockResolvedValueOnce({
+				username: 'user2',
+				email: 'user-002',
+				brandIds: [],
+				accountIds: [],
+				isAdmin: false,
+				isSuperAdmin: false,
+				roles: [],
+			});
+			await updateProductInstance(client, {
+				id: 'tracking-test-1',
+				enabled: false,
+			});
+
+			expect(client._mocks.update.mock.calls[0][0].updatedBy).toBe('user-002');
+
+			// User 3 toggles
+			vi.mocked(auth.getClientUser).mockResolvedValueOnce({
+				username: 'user3',
+				email: 'user-003',
+				brandIds: [],
+				accountIds: [],
+				isAdmin: false,
+				isSuperAdmin: false,
+				roles: [],
+			});
+			await toggleProductInstanceEnabled(client, 'tracking-test-1', true);
+
+			expect(client._mocks.update.mock.calls[1][0].updatedBy).toBe('user-003');
+		});
+
+		it('should handle scenarios where getClientUser returns null (unauthenticated)', async () => {
+			const client = createMockGraphQLClient({});
+
+			// Mock getClientUser to return null (user not authenticated)
+			vi.mocked(auth.getClientUser).mockResolvedValueOnce(null);
+
+			// Should still work, using "system" as fallback
+			const result = await createProductInstance(client, {
+				productId: 'auth-fail-test',
+				productName: 'Auth Fail Product',
+				brandId: 'brand-1',
+				accountId: 'account-1',
+				enabled: true,
+			});
+
+			expect(result).toBeTruthy();
+			expect(client._mocks.create.mock.calls[0][0].updatedBy).toBe('system');
+		});
+	});
+
+	describe('Performance and Edge Cases', () => {
+		it('should handle large config objects', async () => {
+			const client = createMockGraphQLClient({});
+
+			// Create a large config with 100 properties
+			const largeConfig: Record<string, any> = {};
+			for (let i = 0; i < 100; i++) {
+				largeConfig[`property${i}`] = {
+					value: `value-${i}`,
+					nested: {
+						data: Array(10).fill(i),
+					},
+				};
+			}
+
+			const result = await createProductInstance(client, {
+				productId: 'large-config-test',
+				productName: 'Large Config Product',
+				brandId: 'brand-1',
+				accountId: 'account-1',
+				enabled: true,
+				config: largeConfig,
+			});
+
+			expect(result).toBeTruthy();
+
+			const createCall = client._mocks.create.mock.calls[0][0];
+			const parsedConfig = JSON.parse(createCall.config);
+			expect(Object.keys(parsedConfig)).toHaveLength(100);
+		});
+
+		it('should handle rapid sequential updates', async () => {
+			// Use real timers for this async test
+			vi.useRealTimers();
+
+			const client = createMockGraphQLClient({ shouldDelay: true });
+
+			const instanceId = 'rapid-update-test';
+			const updates = [];
+
+			for (let i = 0; i < 5; i++) {
+				updates.push(
+					updateProductInstance(client, {
+						id: instanceId,
+						version: `1.${i}.0`,
+					})
+				);
+			}
+
+			const results = await Promise.all(updates);
+
+			expect(results).toHaveLength(5);
+			expect(client._mocks.update).toHaveBeenCalledTimes(5);
+
+			// Restore fake timers
+			vi.useFakeTimers();
+			vi.setSystemTime(new Date(mockTimestamp));
+		});
+
+		it('should handle empty config objects', async () => {
+			const client = createMockGraphQLClient({});
+
+			const result = await createProductInstance(client, {
+				productId: 'empty-config-test',
+				productName: 'Empty Config Product',
+				brandId: 'brand-1',
+				accountId: 'account-1',
+				enabled: true,
+				config: {},
+			});
+
+			expect(result).toBeTruthy();
+
+			const createCall = client._mocks.create.mock.calls[0][0];
+			expect(createCall.config).toBe('{}');
+		});
+
+		it('should handle undefined config', async () => {
+			const client = createMockGraphQLClient({});
+
+			const result = await createProductInstance(client, {
+				productId: 'no-config-test',
+				productName: 'No Config Product',
+				brandId: 'brand-1',
+				accountId: 'account-1',
+				enabled: true,
+				// No config property
+			});
+
+			expect(result).toBeTruthy();
+
+			const createCall = client._mocks.create.mock.calls[0][0];
+			expect(createCall.config).toBeUndefined();
+		});
+	});
+
+	describe('Idempotency and Retry Logic', () => {
+		it('should handle duplicate create requests gracefully', async () => {
+			const client = createMockGraphQLClient({
+				createResponse: {
+					data: null,
+					errors: [
+						{
+							message: 'Duplicate entry',
+							extensions: { code: 'DUPLICATE_ENTRY' },
+						},
+					],
+				},
+			});
+
+			const input = {
+				productId: 'duplicate-test',
+				productName: 'Duplicate Product',
+				brandId: 'brand-1',
+				accountId: 'account-1',
+				enabled: true,
+			};
+
+			await expect(createProductInstance(client, input)).rejects.toThrow(AppError);
+		});
+
+		it('should support optimistic updates', async () => {
+			const client = createMockGraphQLClient({});
+
+			const instanceId = 'optimistic-test';
+
+			// Simulate optimistic update - fire and forget pattern
+			const updatePromise = toggleProductInstanceEnabled(client, instanceId, true);
+
+			// Continue with other operations without waiting
+			expect(updatePromise).toBeInstanceOf(Promise);
+
+			// Eventually resolve
+			const result = await updatePromise;
+			expect(result?.enabled).toBe(true);
+		});
+	});
+});