first commit

packages/nodes-base/nodes/Aws/__tests__/AwsLambda.node.test.ts

@@ -0,0 +1,629 @@
+import { mockDeep } from 'jest-mock-extended';
+import type { IExecuteFunctions, ILoadOptionsFunctions } from 'n8n-workflow';
+import { NodeApiError } from 'n8n-workflow';
+
+import { AwsLambda } from '../AwsLambda.node';
+import * as GenericFunctions from '../GenericFunctions';
+
+describe('AwsLambda', () => {
+	let node: AwsLambda;
+	let mockExecuteFunctions: jest.Mocked<IExecuteFunctions>;
+	let mockLoadOptionsFunctions: jest.Mocked<ILoadOptionsFunctions>;
+	const awsApiRequestRESTSpy = jest.spyOn(GenericFunctions, 'awsApiRequestREST');
+
+	beforeEach(() => {
+		node = new AwsLambda();
+		mockExecuteFunctions = mockDeep<IExecuteFunctions>();
+		mockLoadOptionsFunctions = mockDeep<ILoadOptionsFunctions>();
+		jest.clearAllMocks();
+
+		mockExecuteFunctions.getInputData.mockReturnValue([{ json: {} }]);
+		mockExecuteFunctions.getNode.mockReturnValue({
+			id: 'test-node',
+			name: 'AWS Lambda',
+			type: 'n8n-nodes-base.awsLambda',
+			typeVersion: 1,
+			position: [0, 0],
+			parameters: {},
+		});
+		(mockExecuteFunctions.helpers.constructExecutionMetaData as jest.Mock).mockImplementation(
+			(data: any, meta: any) => {
+				return [
+					{
+						...data[0],
+						pairedItem: meta?.itemData?.item ?? 0,
+					},
+				];
+			},
+		);
+		(mockExecuteFunctions.helpers.returnJsonArray as jest.Mock).mockImplementation((data: any) => [
+			{ json: data },
+		]);
+	});
+
+	afterEach(() => {
+		jest.resetAllMocks();
+	});
+
+	describe('Load Options Methods', () => {
+		describe('getFunctions', () => {
+			it('should load functions without pagination', async () => {
+				const mockFunctions = {
+					Functions: [
+						{
+							FunctionName: 'test-function-1',
+							FunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:test-function-1',
+						},
+						{
+							FunctionName: 'test-function-2',
+							FunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:test-function-2',
+						},
+					],
+				};
+
+				awsApiRequestRESTSpy.mockResolvedValue(mockFunctions);
+
+				const result = await node.methods.loadOptions.getFunctions.call(mockLoadOptionsFunctions);
+
+				expect(result).toEqual([
+					{
+						name: 'test-function-1',
+						value: 'arn:aws:lambda:us-east-1:123456789012:function:test-function-1',
+					},
+					{
+						name: 'test-function-2',
+						value: 'arn:aws:lambda:us-east-1:123456789012:function:test-function-2',
+					},
+				]);
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledWith(
+					'lambda',
+					'GET',
+					'/2015-03-31/functions/',
+				);
+			});
+
+			it('should handle paginated function list', async () => {
+				const mockFirstPage = {
+					Functions: [
+						{
+							FunctionName: 'test-function-1',
+							FunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:test-function-1',
+						},
+					],
+					NextMarker: 'marker123',
+				};
+
+				const mockSecondPage = {
+					Functions: [
+						{
+							FunctionName: 'test-function-2',
+							FunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:test-function-2',
+						},
+					],
+				};
+
+				awsApiRequestRESTSpy
+					.mockResolvedValueOnce(mockFirstPage)
+					.mockResolvedValueOnce(mockSecondPage);
+
+				const result = await node.methods.loadOptions.getFunctions.call(mockLoadOptionsFunctions);
+
+				expect(result).toEqual([
+					{
+						name: 'test-function-1',
+						value: 'arn:aws:lambda:us-east-1:123456789012:function:test-function-1',
+					},
+					{
+						name: 'test-function-2',
+						value: 'arn:aws:lambda:us-east-1:123456789012:function:test-function-2',
+					},
+				]);
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledTimes(2);
+				expect(awsApiRequestRESTSpy).toHaveBeenNthCalledWith(
+					2,
+					'lambda',
+					'GET',
+					'/2015-03-31/functions/?MaxItems=50&Marker=marker123',
+				);
+			});
+
+			it('should handle multiple pages with NextMarker', async () => {
+				const mockFirstPage = {
+					Functions: [
+						{
+							FunctionName: 'function-1',
+							FunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:function-1',
+						},
+					],
+					NextMarker: 'marker1',
+				};
+
+				const mockSecondPage = {
+					Functions: [
+						{
+							FunctionName: 'function-2',
+							FunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:function-2',
+						},
+					],
+					NextMarker: 'marker2',
+				};
+
+				const mockThirdPage = {
+					Functions: [
+						{
+							FunctionName: 'function-3',
+							FunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:function-3',
+						},
+					],
+				};
+
+				awsApiRequestRESTSpy
+					.mockResolvedValueOnce(mockFirstPage)
+					.mockResolvedValueOnce(mockSecondPage)
+					.mockResolvedValueOnce(mockThirdPage);
+
+				const result = await node.methods.loadOptions.getFunctions.call(mockLoadOptionsFunctions);
+
+				expect(result).toHaveLength(3);
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledTimes(3);
+				expect(awsApiRequestRESTSpy).toHaveBeenNthCalledWith(
+					3,
+					'lambda',
+					'GET',
+					'/2015-03-31/functions/?MaxItems=50&Marker=marker2',
+				);
+			});
+
+			it('should handle empty function list', async () => {
+				const mockEmptyResponse = {
+					Functions: [],
+				};
+
+				awsApiRequestRESTSpy.mockResolvedValue(mockEmptyResponse);
+
+				const result = await node.methods.loadOptions.getFunctions.call(mockLoadOptionsFunctions);
+
+				expect(result).toEqual([]);
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledWith(
+					'lambda',
+					'GET',
+					'/2015-03-31/functions/',
+				);
+			});
+		});
+	});
+
+	describe('Execute Method', () => {
+		beforeEach(() => {
+			mockExecuteFunctions.getNodeParameter.mockImplementation((paramName) => {
+				const mockParams = {
+					operation: 'invoke',
+					function: 'arn:aws:lambda:us-east-1:123456789012:function:test-function',
+					qualifier: '$LATEST',
+					invocationType: 'RequestResponse',
+					payload: JSON.stringify({ test: 'data' }),
+				};
+				return mockParams[paramName as keyof typeof mockParams];
+			});
+		});
+
+		describe('Successful Lambda Invocation', () => {
+			it('should invoke lambda function with RequestResponse type', async () => {
+				const mockResponse = {
+					StatusCode: 200,
+					result: { success: true, data: 'processed' },
+				};
+
+				awsApiRequestRESTSpy.mockResolvedValue(mockResponse);
+
+				const result = await node.execute.call(mockExecuteFunctions);
+
+				expect(result).toEqual([
+					[
+						{
+							json: [
+								{
+									json: { result: mockResponse },
+									pairedItem: 0,
+								},
+							],
+						},
+					],
+				]);
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledWith(
+					'lambda',
+					'POST',
+					'/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:test-function/invocations?Qualifier=$LATEST',
+					JSON.stringify({ test: 'data' }),
+					{
+						'X-Amz-Invocation-Type': 'RequestResponse',
+						'Content-Type': 'application/x-amz-json-1.0',
+					},
+				);
+			});
+
+			it('should invoke lambda function with Event type', async () => {
+				mockExecuteFunctions.getNodeParameter.mockImplementation((paramName) => {
+					const mockParams = {
+						operation: 'invoke',
+						function: 'test-function',
+						qualifier: 'PROD',
+						invocationType: 'Event',
+						payload: JSON.stringify({ async: true }),
+					};
+					return mockParams[paramName as keyof typeof mockParams];
+				});
+
+				const mockResponse = {
+					StatusCode: 202,
+				};
+
+				awsApiRequestRESTSpy.mockResolvedValue(mockResponse);
+
+				const result = await node.execute.call(mockExecuteFunctions);
+
+				expect(result).toEqual([
+					[
+						{
+							json: [
+								{
+									json: { result: mockResponse },
+									pairedItem: 0,
+								},
+							],
+						},
+					],
+				]);
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledWith(
+					'lambda',
+					'POST',
+					'/2015-03-31/functions/test-function/invocations?Qualifier=PROD',
+					JSON.stringify({ async: true }),
+					{
+						'X-Amz-Invocation-Type': 'Event',
+						'Content-Type': 'application/x-amz-json-1.0',
+					},
+				);
+			});
+
+			it('should handle empty payload', async () => {
+				mockExecuteFunctions.getNodeParameter.mockImplementation((paramName) => {
+					const mockParams = {
+						operation: 'invoke',
+						function: 'test-function',
+						qualifier: '$LATEST',
+						invocationType: 'RequestResponse',
+						payload: '',
+					};
+					return mockParams[paramName as keyof typeof mockParams];
+				});
+
+				const mockResponse = { result: 'success' };
+				awsApiRequestRESTSpy.mockResolvedValue(mockResponse);
+
+				const result = await node.execute.call(mockExecuteFunctions);
+
+				expect(result).toEqual([
+					[
+						{
+							json: [
+								{
+									json: { result: mockResponse },
+									pairedItem: 0,
+								},
+							],
+						},
+					],
+				]);
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledWith(
+					'lambda',
+					'POST',
+					'/2015-03-31/functions/test-function/invocations?Qualifier=$LATEST',
+					'',
+					{
+						'X-Amz-Invocation-Type': 'RequestResponse',
+						'Content-Type': 'application/x-amz-json-1.0',
+					},
+				);
+			});
+
+			it('should process multiple input items', async () => {
+				mockExecuteFunctions.getInputData.mockReturnValue([
+					{ json: { item: 1 } },
+					{ json: { item: 2 } },
+				]);
+				mockExecuteFunctions.getNodeParameter.mockImplementation((paramName, itemIndex) => {
+					const mockParams = {
+						operation: 'invoke',
+						function: 'test-function',
+						qualifier: '$LATEST',
+						invocationType: 'RequestResponse',
+						payload: JSON.stringify({ item: itemIndex + 1 }),
+					};
+					return mockParams[paramName as keyof typeof mockParams];
+				});
+
+				const mockResponse1 = { result: 'item1-processed' };
+				const mockResponse2 = { result: 'item2-processed' };
+				awsApiRequestRESTSpy
+					.mockResolvedValueOnce(mockResponse1)
+					.mockResolvedValueOnce(mockResponse2);
+
+				const result = await node.execute.call(mockExecuteFunctions);
+
+				expect(result[0]).toHaveLength(1);
+				expect(result[0][0].json).toHaveLength(2);
+				expect(result[0][0].json[0]).toEqual({ json: { result: mockResponse1 }, pairedItem: 0 });
+				expect(result[0][0].json[1]).toEqual({ json: { result: mockResponse2 }, pairedItem: 1 });
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledTimes(2);
+			});
+		});
+
+		describe('Lambda Function Errors', () => {
+			it('should handle lambda function execution errors', async () => {
+				const mockErrorResponse = {
+					errorMessage: 'Function execution failed',
+					errorType: 'Runtime.HandlerNotFound',
+					stackTrace: ['at /var/task/index.js:10:5'],
+				};
+
+				awsApiRequestRESTSpy.mockResolvedValue(mockErrorResponse);
+
+				await expect(node.execute.call(mockExecuteFunctions)).rejects.toThrow(NodeApiError);
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledWith(
+					'lambda',
+					'POST',
+					'/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:test-function/invocations?Qualifier=$LATEST',
+					JSON.stringify({ test: 'data' }),
+					{
+						'X-Amz-Invocation-Type': 'RequestResponse',
+						'Content-Type': 'application/x-amz-json-1.0',
+					},
+				);
+			});
+
+			it('should handle API errors when continueOnFail is true', async () => {
+				const apiError = new Error('Function not found');
+				mockExecuteFunctions.continueOnFail.mockReturnValue(true);
+				awsApiRequestRESTSpy.mockRejectedValue(apiError);
+
+				const result = await node.execute.call(mockExecuteFunctions);
+
+				expect(result).toEqual([
+					[
+						{
+							json: [
+								{
+									json: { error: 'Function not found' },
+									pairedItem: 0,
+								},
+							],
+						},
+					],
+				]);
+			});
+
+			it('should throw API errors when continueOnFail is false', async () => {
+				const apiError = new Error('Invalid function name');
+				mockExecuteFunctions.continueOnFail.mockReturnValue(false);
+				awsApiRequestRESTSpy.mockRejectedValue(apiError);
+
+				await expect(node.execute.call(mockExecuteFunctions)).rejects.toThrow(
+					'Invalid function name',
+				);
+			});
+
+			it('should handle mixed success and error scenarios with continueOnFail', async () => {
+				mockExecuteFunctions.getInputData.mockReturnValue([
+					{ json: { item: 1 } },
+					{ json: { item: 2 } },
+					{ json: { item: 3 } },
+				]);
+				mockExecuteFunctions.continueOnFail.mockReturnValue(true);
+
+				const mockSuccessResponse = { result: 'success' };
+				const apiError = new Error('Function error');
+
+				awsApiRequestRESTSpy
+					.mockResolvedValueOnce(mockSuccessResponse)
+					.mockRejectedValueOnce(apiError)
+					.mockResolvedValueOnce(mockSuccessResponse);
+
+				const result = await node.execute.call(mockExecuteFunctions);
+
+				expect(result[0]).toHaveLength(1);
+				expect(result[0][0].json).toHaveLength(3);
+				expect(result[0][0].json[0]).toEqual({
+					json: { result: mockSuccessResponse },
+					pairedItem: 0,
+				});
+				expect(result[0][0].json[1]).toEqual({ json: { error: 'Function error' }, pairedItem: 1 });
+				expect(result[0][0].json[2]).toEqual({
+					json: { result: mockSuccessResponse },
+					pairedItem: 2,
+				});
+			});
+		});
+
+		describe('Different Qualifier Values', () => {
+			it('should handle custom version qualifier', async () => {
+				mockExecuteFunctions.getNodeParameter.mockImplementation((paramName) => {
+					const mockParams = {
+						operation: 'invoke',
+						function: 'test-function',
+						qualifier: '1',
+						invocationType: 'RequestResponse',
+						payload: JSON.stringify({ version: 1 }),
+					};
+					return mockParams[paramName as keyof typeof mockParams];
+				});
+
+				const mockResponse = { result: 'version-1-response' };
+				awsApiRequestRESTSpy.mockResolvedValue(mockResponse);
+
+				await node.execute.call(mockExecuteFunctions);
+
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledWith(
+					'lambda',
+					'POST',
+					'/2015-03-31/functions/test-function/invocations?Qualifier=1',
+					JSON.stringify({ version: 1 }),
+					{
+						'X-Amz-Invocation-Type': 'RequestResponse',
+						'Content-Type': 'application/x-amz-json-1.0',
+					},
+				);
+			});
+
+			it('should handle alias qualifier', async () => {
+				mockExecuteFunctions.getNodeParameter.mockImplementation((paramName) => {
+					const mockParams = {
+						operation: 'invoke',
+						function: 'test-function',
+						qualifier: 'PROD',
+						invocationType: 'RequestResponse',
+						payload: JSON.stringify({ environment: 'production' }),
+					};
+					return mockParams[paramName as keyof typeof mockParams];
+				});
+
+				const mockResponse = { result: 'prod-response' };
+				awsApiRequestRESTSpy.mockResolvedValue(mockResponse);
+
+				await node.execute.call(mockExecuteFunctions);
+
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledWith(
+					'lambda',
+					'POST',
+					'/2015-03-31/functions/test-function/invocations?Qualifier=PROD',
+					JSON.stringify({ environment: 'production' }),
+					{
+						'X-Amz-Invocation-Type': 'RequestResponse',
+						'Content-Type': 'application/x-amz-json-1.0',
+					},
+				);
+			});
+		});
+
+		describe('Payload Handling', () => {
+			it('should handle complex JSON payload', async () => {
+				const complexPayload = {
+					user: { id: 123, name: 'John Doe' },
+					data: [1, 2, 3],
+					metadata: { timestamp: '2023-01-01T00:00:00Z' },
+				};
+
+				mockExecuteFunctions.getNodeParameter.mockImplementation((paramName) => {
+					const mockParams = {
+						operation: 'invoke',
+						function: 'test-function',
+						qualifier: '$LATEST',
+						invocationType: 'RequestResponse',
+						payload: JSON.stringify(complexPayload),
+					};
+					return mockParams[paramName as keyof typeof mockParams];
+				});
+
+				const mockResponse = { result: 'complex-processed' };
+				awsApiRequestRESTSpy.mockResolvedValue(mockResponse);
+
+				await node.execute.call(mockExecuteFunctions);
+
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledWith(
+					'lambda',
+					'POST',
+					'/2015-03-31/functions/test-function/invocations?Qualifier=$LATEST',
+					JSON.stringify(complexPayload),
+					{
+						'X-Amz-Invocation-Type': 'RequestResponse',
+						'Content-Type': 'application/x-amz-json-1.0',
+					},
+				);
+			});
+
+			it('should handle string payload', async () => {
+				mockExecuteFunctions.getNodeParameter.mockImplementation((paramName) => {
+					const mockParams = {
+						operation: 'invoke',
+						function: 'test-function',
+						qualifier: '$LATEST',
+						invocationType: 'RequestResponse',
+						payload: 'plain string payload',
+					};
+					return mockParams[paramName as keyof typeof mockParams];
+				});
+
+				const mockResponse = { result: 'string-processed' };
+				awsApiRequestRESTSpy.mockResolvedValue(mockResponse);
+
+				await node.execute.call(mockExecuteFunctions);
+
+				expect(awsApiRequestRESTSpy).toHaveBeenCalledWith(
+					'lambda',
+					'POST',
+					'/2015-03-31/functions/test-function/invocations?Qualifier=$LATEST',
+					'plain string payload',
+					{
+						'X-Amz-Invocation-Type': 'RequestResponse',
+						'Content-Type': 'application/x-amz-json-1.0',
+					},
+				);
+			});
+		});
+
+		describe('Edge Cases', () => {
+			it('should handle null response from Lambda', async () => {
+				awsApiRequestRESTSpy.mockResolvedValue(null);
+
+				const result = await node.execute.call(mockExecuteFunctions);
+
+				expect(result).toEqual([
+					[
+						{
+							json: [
+								{
+									json: { result: null },
+									pairedItem: 0,
+								},
+							],
+						},
+					],
+				]);
+			});
+
+			it('should handle undefined response from Lambda', async () => {
+				awsApiRequestRESTSpy.mockResolvedValue(undefined);
+
+				const result = await node.execute.call(mockExecuteFunctions);
+
+				expect(result).toEqual([
+					[
+						{
+							json: [
+								{
+									json: { result: undefined },
+									pairedItem: 0,
+								},
+							],
+						},
+					],
+				]);
+			});
+
+			it('should handle empty input data', async () => {
+				mockExecuteFunctions.getInputData.mockReturnValue([]);
+
+				const result = await node.execute.call(mockExecuteFunctions);
+
+				expect(result).toEqual([
+					[
+						{
+							json: [],
+						},
+					],
+				]);
+				expect(awsApiRequestRESTSpy).not.toHaveBeenCalled();
+			});
+		});
+	});
+});