first commit

packages/cli/test/integration/webhooks.api.test.ts

@@ -0,0 +1,226 @@
+import { testDb, mockInstance, createActiveWorkflow } from '@n8n/backend-test-utils';
+import type { IWorkflowDb, User } from '@n8n/db';
+import { readFileSync } from 'fs';
+import {
+	type INode,
+	NodeConnectionTypes,
+	type INodeType,
+	type INodeTypeDescription,
+	type IWebhookFunctions,
+} from 'n8n-workflow';
+import { agent as testAgent } from 'supertest';
+
+import { NodeTypes } from '@/node-types';
+import { WebhookServer } from '@/webhooks/webhook-server';
+
+import { createUser } from './shared/db/users';
+import type { SuperAgentTest } from './shared/types';
+import { initActiveWorkflowManager } from './shared/utils';
+
+jest.unmock('node:fs');
+
+class WebhookTestingNode implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Webhook Testing Node',
+		name: 'webhook-testing-node',
+		group: ['trigger'],
+		version: 1,
+		description: '',
+		defaults: {},
+		inputs: [],
+		outputs: [NodeConnectionTypes.Main],
+		webhooks: [
+			{
+				name: 'default',
+				isFullPath: true,
+				httpMethod: '={{$parameter["httpMethod"]}}',
+				path: '={{$parameter["path"]}}',
+			},
+		],
+		properties: [
+			{
+				name: 'httpMethod',
+				type: 'string',
+				displayName: 'Method',
+				default: 'GET',
+			},
+			{
+				displayName: 'Path',
+				name: 'path',
+				type: 'string',
+				default: 'xyz',
+			},
+		],
+	};
+
+	async webhook(this: IWebhookFunctions) {
+		const { contentType, body, params, query } = this.getRequestObject();
+		const webhookResponse: Record<string, any> = { contentType, body };
+		if (Object.keys(params).length) webhookResponse.params = params;
+		if (Object.keys(query).length) webhookResponse.query = query;
+		return { webhookResponse };
+	}
+}
+
+describe('Webhook API', () => {
+	const nodeInstance = new WebhookTestingNode();
+	const node: INode = {
+		id: 'webhook-node-1',
+		name: 'Webhook',
+		type: nodeInstance.description.name,
+		typeVersion: 1,
+		position: [0, 0],
+		parameters: {},
+		webhookId: '5ccef736-be16-4d10-b7fb-feed7a61ff22',
+	};
+	const workflowData = { active: true, nodes: [node] } as Partial<IWorkflowDb>;
+
+	const nodeTypes = mockInstance(NodeTypes);
+	nodeTypes.getByName.mockReturnValue(nodeInstance);
+	nodeTypes.getByNameAndVersion.mockReturnValue(nodeInstance);
+
+	let user: User;
+	let agent: SuperAgentTest;
+
+	beforeAll(async () => {
+		await testDb.init();
+		user = await createUser();
+
+		const server = new WebhookServer();
+		await server.start();
+		agent = testAgent(server.app);
+	});
+
+	beforeEach(async () => {
+		await testDb.truncate(['WorkflowEntity']);
+		await createActiveWorkflow(workflowData, user);
+		await initActiveWorkflowManager();
+	});
+
+	afterAll(async () => {
+		await testDb.terminate();
+	});
+
+	describe('Content-Type support', () => {
+		beforeAll(async () => {
+			node.parameters = { httpMethod: 'POST', path: 'abcd' };
+		});
+
+		test('should handle JSON', async () => {
+			const response = await agent.post('/webhook/abcd').send({ test: true });
+			expect(response.statusCode).toEqual(200);
+			expect(response.body).toEqual({
+				contentType: 'application/json',
+				body: { test: true },
+			});
+		});
+
+		test('should handle XML', async () => {
+			const response = await agent
+				.post('/webhook/abcd')
+				.set('content-type', 'application/xml')
+				.send(
+					'<?xml version="1.0" encoding="UTF-8"?><Outer attr="test"><Inner>value</Inner></Outer>',
+				);
+			expect(response.statusCode).toEqual(200);
+			expect(response.body).toEqual({
+				contentType: 'application/xml',
+				body: {
+					outer: {
+						$: {
+							attr: 'test',
+						},
+						inner: 'value',
+					},
+				},
+			});
+		});
+
+		test('should handle form-urlencoded', async () => {
+			const response = await agent
+				.post('/webhook/abcd')
+				.set('content-type', 'application/x-www-form-urlencoded')
+				.send('x=5&y=str&z=false');
+			expect(response.statusCode).toEqual(200);
+			expect(response.body).toEqual({
+				contentType: 'application/x-www-form-urlencoded',
+				body: { x: '5', y: 'str', z: 'false' },
+			});
+		});
+
+		test('should handle plain text', async () => {
+			const response = await agent
+				.post('/webhook/abcd')
+				.set('content-type', 'text/plain')
+				.send('{"key": "value"}');
+			expect(response.statusCode).toEqual(200);
+			expect(response.body).toEqual({
+				contentType: 'text/plain',
+				body: '{"key": "value"}',
+			});
+		});
+
+		test('should handle multipart/form-data', async () => {
+			const response = await agent
+				.post('/webhook/abcd')
+				.field('field1', 'value1')
+				.field('field2', 'value2')
+				.field('field2', 'value3')
+				.attach('file1', Buffer.from('random-text'))
+				.attach('file2', Buffer.from('random-text'))
+				.attach('file2', Buffer.from('random-text'))
+				.set('content-type', 'multipart/form-data');
+
+			expect(response.statusCode).toEqual(200);
+			expect(response.body.contentType).toEqual('multipart/form-data');
+			const { data, files } = response.body.body;
+			expect(data).toEqual({ field1: 'value1', field2: ['value2', 'value3'] });
+
+			expect(files.file1).not.toBeInstanceOf(Array);
+			expect(files.file1.mimetype).toEqual('application/octet-stream');
+			expect(readFileSync(files.file1.filepath, 'utf-8')).toEqual('random-text');
+			expect(files.file2).toBeInstanceOf(Array);
+			expect(files.file2.length).toEqual(2);
+		});
+	});
+
+	describe('Route-parameters support', () => {
+		beforeAll(async () => {
+			node.parameters = { httpMethod: 'PATCH', path: ':variable' };
+		});
+
+		test('should handle params', async () => {
+			const response = await agent
+				.patch('/webhook/5ccef736-be16-4d10-b7fb-feed7a61ff22/test')
+				.send({ test: true });
+			expect(response.statusCode).toEqual(200);
+			expect(response.body).toEqual({
+				contentType: 'application/json',
+				body: { test: true },
+				params: {
+					variable: 'test',
+				},
+			});
+
+			await agent.post('/webhook/abcd').send({ test: true }).expect(404);
+		});
+	});
+
+	describe('Query-parameters support', () => {
+		beforeAll(async () => {
+			node.parameters = { httpMethod: 'GET', path: 'testing' };
+		});
+
+		test('should use the extended query parser', async () => {
+			const response = await agent.get('/webhook/testing?filter[field]=value');
+			expect(response.statusCode).toEqual(200);
+			expect(response.body).toEqual({
+				query: {
+					filter: {
+						field: 'value',
+					},
+				},
+			});
+		});
+	});
+});