first commit

packages/nodes-base/nodes/Bitbucket/test/BitbucketTrigger.node.test.ts

@@ -0,0 +1,670 @@
+import { mockDeep } from 'jest-mock-extended';
+import type {
+	ICredentialsDecrypted,
+	ICredentialTestFunctions,
+	IHookFunctions,
+	ILoadOptionsFunctions,
+	INode,
+	IWebhookFunctions,
+} from 'n8n-workflow';
+
+import { BitbucketTrigger } from '../BitbucketTrigger.node';
+import * as GenericFunctions from '../GenericFunctions';
+
+describe('BitbucketTrigger', () => {
+	let bitbucketTrigger: BitbucketTrigger;
+	const bitbucketApiRequestSpy = jest.spyOn(GenericFunctions, 'bitbucketApiRequest');
+	const bitbucketApiRequestAllItemsSpy = jest.spyOn(
+		GenericFunctions,
+		'bitbucketApiRequestAllItems',
+	);
+
+	const mockNode: INode = {
+		id: 'test-node-id',
+		name: 'Bitbucket Trigger Test',
+		type: 'n8n-nodes-base.bitbucketTrigger',
+		typeVersion: 1.1,
+		position: [0, 0],
+		parameters: {},
+	};
+
+	beforeEach(() => {
+		jest.resetAllMocks();
+		bitbucketTrigger = new BitbucketTrigger();
+	});
+
+	describe('credential test', () => {
+		const mockCredentialTestFunctions = mockDeep<ICredentialTestFunctions>();
+
+		beforeEach(() => {
+			mockCredentialTestFunctions.helpers.request.mockClear();
+		});
+
+		it('should return success for valid credentials', async () => {
+			const mockCredentials: ICredentialsDecrypted = {
+				id: 'test-cred-id',
+				name: 'Test Bitbucket Credentials',
+				type: 'bitbucketApi',
+				data: {
+					username: 'testuser',
+					appPassword: 'testpassword',
+				},
+			};
+
+			const mockResponse = {
+				username: 'testuser',
+				display_name: 'Test User',
+			};
+
+			mockCredentialTestFunctions.helpers.request.mockResolvedValue(mockResponse);
+
+			const result = await bitbucketTrigger.methods.credentialTest.bitbucketApiTest.call(
+				mockCredentialTestFunctions,
+				mockCredentials,
+			);
+
+			expect(mockCredentialTestFunctions.helpers.request).toHaveBeenCalledWith({
+				method: 'GET',
+				auth: {
+					user: 'testuser',
+					password: 'testpassword',
+				},
+				uri: 'https://api.bitbucket.org/2.0/user',
+				json: true,
+				timeout: 5000,
+			});
+
+			expect(result).toEqual({
+				status: 'OK',
+				message: 'Authentication successful!',
+			});
+		});
+
+		it('should return error for invalid credentials', async () => {
+			const mockCredentials: ICredentialsDecrypted = {
+				id: 'test-cred-id',
+				name: 'Test Bitbucket Credentials',
+				type: 'bitbucketApi',
+				data: {
+					username: 'testuser',
+					appPassword: 'wrongpassword',
+				},
+			};
+
+			const mockResponse = {
+				error: 'Invalid credentials',
+			};
+
+			mockCredentialTestFunctions.helpers.request.mockResolvedValue(mockResponse);
+
+			const result = await bitbucketTrigger.methods.credentialTest.bitbucketApiTest.call(
+				mockCredentialTestFunctions,
+				mockCredentials,
+			);
+
+			expect(result).toEqual({
+				status: 'Error',
+				message: 'Token is not valid: Invalid credentials',
+			});
+		});
+
+		it('should return error when request fails', async () => {
+			const mockCredentials: ICredentialsDecrypted = {
+				id: 'test-cred-id',
+				name: 'Test Bitbucket Credentials',
+				type: 'bitbucketApi',
+				data: {
+					username: 'testuser',
+					appPassword: 'testpassword',
+				},
+			};
+
+			const mockError = new Error('Network error');
+			mockCredentialTestFunctions.helpers.request.mockRejectedValue(mockError);
+
+			const result = await bitbucketTrigger.methods.credentialTest.bitbucketApiTest.call(
+				mockCredentialTestFunctions,
+				mockCredentials,
+			);
+
+			expect(result).toEqual({
+				status: 'Error',
+				message: 'Settings are not valid: Error: Network error',
+			});
+		});
+	});
+
+	describe('load options methods', () => {
+		const mockLoadOptionsFunctions = mockDeep<ILoadOptionsFunctions>();
+
+		beforeEach(() => {
+			mockLoadOptionsFunctions.getNode.mockReturnValue(mockNode);
+		});
+
+		describe('getWorkspaceEvents', () => {
+			it('should return workspace events', async () => {
+				const mockEvents = [
+					{
+						event: 'repo:push',
+						description: 'Repository push',
+					},
+					{
+						event: 'repo:fork',
+						description: 'Repository fork',
+					},
+				];
+
+				bitbucketApiRequestAllItemsSpy.mockResolvedValue(mockEvents);
+
+				const result =
+					await bitbucketTrigger.methods.loadOptions.getWorkspaceEvents.call(
+						mockLoadOptionsFunctions,
+					);
+
+				expect(bitbucketApiRequestAllItemsSpy).toHaveBeenCalledWith(
+					'values',
+					'GET',
+					'/hook_events/workspace',
+				);
+
+				expect(result).toEqual([
+					{
+						name: 'repo:push',
+						value: 'repo:push',
+						description: 'Repository push',
+					},
+					{
+						name: 'repo:fork',
+						value: 'repo:fork',
+						description: 'Repository fork',
+					},
+				]);
+			});
+
+			it('should handle empty events list', async () => {
+				bitbucketApiRequestAllItemsSpy.mockResolvedValue([]);
+
+				const result =
+					await bitbucketTrigger.methods.loadOptions.getWorkspaceEvents.call(
+						mockLoadOptionsFunctions,
+					);
+
+				expect(result).toEqual([]);
+			});
+		});
+
+		describe('getRepositoriesEvents', () => {
+			it('should return repository events', async () => {
+				const mockEvents = [
+					{
+						event: 'repo:push',
+						description: 'Repository push',
+					},
+					{
+						event: 'pullrequest:created',
+						description: 'Pull request created',
+					},
+				];
+
+				bitbucketApiRequestAllItemsSpy.mockResolvedValue(mockEvents);
+
+				const result =
+					await bitbucketTrigger.methods.loadOptions.getRepositoriesEvents.call(
+						mockLoadOptionsFunctions,
+					);
+
+				expect(bitbucketApiRequestAllItemsSpy).toHaveBeenCalledWith(
+					'values',
+					'GET',
+					'/hook_events/repository',
+				);
+
+				expect(result).toEqual([
+					{
+						name: 'repo:push',
+						value: 'repo:push',
+						description: 'Repository push',
+					},
+					{
+						name: 'pullrequest:created',
+						value: 'pullrequest:created',
+						description: 'Pull request created',
+					},
+				]);
+			});
+		});
+
+		describe('getRepositories', () => {
+			it('should return repositories for workspace', async () => {
+				const mockRepositories = [
+					{
+						slug: 'repo1',
+						description: 'First repository',
+					},
+					{
+						slug: 'repo2',
+						description: 'Second repository',
+					},
+				];
+
+				mockLoadOptionsFunctions.getCurrentNodeParameter.mockReturnValue('test-workspace');
+				bitbucketApiRequestAllItemsSpy.mockResolvedValue(mockRepositories);
+
+				const result =
+					await bitbucketTrigger.methods.loadOptions.getRepositories.call(mockLoadOptionsFunctions);
+
+				expect(mockLoadOptionsFunctions.getCurrentNodeParameter).toHaveBeenCalledWith('workspace');
+				expect(bitbucketApiRequestAllItemsSpy).toHaveBeenCalledWith(
+					'values',
+					'GET',
+					'/repositories/test-workspace',
+				);
+
+				expect(result).toEqual([
+					{
+						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
+						name: 'repo1',
+						value: 'repo1',
+						description: 'First repository',
+					},
+					{
+						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
+						name: 'repo2',
+						value: 'repo2',
+						description: 'Second repository',
+					},
+				]);
+			});
+		});
+
+		describe('getWorkspaces', () => {
+			it('should return workspaces', async () => {
+				const mockWorkspaces = [
+					{
+						name: 'Workspace 1',
+						slug: 'workspace1',
+					},
+					{
+						name: 'Workspace 2',
+						slug: 'workspace2',
+					},
+				];
+
+				bitbucketApiRequestAllItemsSpy.mockResolvedValue(mockWorkspaces);
+
+				const result =
+					await bitbucketTrigger.methods.loadOptions.getWorkspaces.call(mockLoadOptionsFunctions);
+
+				expect(bitbucketApiRequestAllItemsSpy).toHaveBeenCalledWith('values', 'GET', '/workspaces');
+
+				expect(result).toEqual([
+					{
+						name: 'Workspace 1',
+						value: 'workspace1',
+					},
+					{
+						name: 'Workspace 2',
+						value: 'workspace2',
+					},
+				]);
+			});
+		});
+	});
+
+	describe('webhook methods', () => {
+		const mockHookFunctions = mockDeep<IHookFunctions>();
+
+		beforeEach(() => {
+			mockHookFunctions.getNode.mockReturnValue(mockNode);
+			mockHookFunctions.getNodeWebhookUrl.mockReturnValue('https://test.n8n.io/webhook/test');
+			mockHookFunctions.getWorkflowStaticData.mockReturnValue({});
+		});
+
+		describe('checkExists', () => {
+			it('should return true if webhook exists for workspace', async () => {
+				const mockHooks = {
+					values: [
+						{
+							uuid: '{12345678-1234-1234-1234-123456789012}',
+							url: 'https://test.n8n.io/webhook/test',
+							active: true,
+						},
+						{
+							uuid: '{87654321-4321-4321-4321-210987654321}',
+							url: 'https://other.webhook.url',
+							active: true,
+						},
+					],
+				};
+
+				mockHookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					if (paramName === 'resource') return 'workspace';
+					if (paramName === 'workspace') return 'test-workspace';
+					return undefined;
+				});
+
+				bitbucketApiRequestSpy.mockResolvedValue(mockHooks);
+
+				const result =
+					await bitbucketTrigger.webhookMethods.default.checkExists.call(mockHookFunctions);
+
+				expect(bitbucketApiRequestSpy).toHaveBeenCalledWith(
+					'GET',
+					'/workspaces/test-workspace/hooks',
+				);
+				expect(result).toBe(true);
+
+				// Check that webhook ID is stored
+				const staticData = mockHookFunctions.getWorkflowStaticData('node');
+				expect(staticData.webhookId).toBe('12345678-1234-1234-1234-123456789012');
+			});
+
+			it('should return true if webhook exists for repository', async () => {
+				const mockHooks = {
+					values: [
+						{
+							uuid: '{12345678-1234-1234-1234-123456789012}',
+							url: 'https://test.n8n.io/webhook/test',
+							active: true,
+						},
+					],
+				};
+
+				mockHookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					if (paramName === 'resource') return 'repository';
+					if (paramName === 'workspace') return 'test-workspace';
+					if (paramName === 'repository') return 'test-repo';
+					return undefined;
+				});
+
+				bitbucketApiRequestSpy.mockResolvedValue(mockHooks);
+
+				const result =
+					await bitbucketTrigger.webhookMethods.default.checkExists.call(mockHookFunctions);
+
+				expect(bitbucketApiRequestSpy).toHaveBeenCalledWith(
+					'GET',
+					'/repositories/test-workspace/test-repo/hooks',
+				);
+				expect(result).toBe(true);
+			});
+
+			it('should return false if webhook does not exist', async () => {
+				const mockHooks = {
+					values: [
+						{
+							uuid: '{87654321-4321-4321-4321-210987654321}',
+							url: 'https://other.webhook.url',
+							active: true,
+						},
+					],
+				};
+
+				mockHookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					if (paramName === 'resource') return 'workspace';
+					if (paramName === 'workspace') return 'test-workspace';
+					return undefined;
+				});
+
+				bitbucketApiRequestSpy.mockResolvedValue(mockHooks);
+
+				const result =
+					await bitbucketTrigger.webhookMethods.default.checkExists.call(mockHookFunctions);
+
+				expect(result).toBe(false);
+			});
+
+			it('should return false if webhook exists but is inactive', async () => {
+				const mockHooks = {
+					values: [
+						{
+							uuid: '{12345678-1234-1234-1234-123456789012}',
+							url: 'https://test.n8n.io/webhook/test',
+							active: false,
+						},
+					],
+				};
+
+				mockHookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					if (paramName === 'resource') return 'workspace';
+					if (paramName === 'workspace') return 'test-workspace';
+					return undefined;
+				});
+
+				bitbucketApiRequestSpy.mockResolvedValue(mockHooks);
+
+				const result =
+					await bitbucketTrigger.webhookMethods.default.checkExists.call(mockHookFunctions);
+
+				expect(result).toBe(false);
+			});
+		});
+
+		describe('create', () => {
+			it('should create webhook for workspace', async () => {
+				const mockResponse = {
+					uuid: '{12345678-1234-1234-1234-123456789012}',
+					url: 'https://test.n8n.io/webhook/test',
+					active: true,
+				};
+
+				mockHookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					if (paramName === 'resource') return 'workspace';
+					if (paramName === 'workspace') return 'test-workspace';
+					if (paramName === 'events') return ['repo:push', 'repo:fork'];
+					return undefined;
+				});
+
+				bitbucketApiRequestSpy.mockResolvedValue(mockResponse);
+
+				const result = await bitbucketTrigger.webhookMethods.default.create.call(mockHookFunctions);
+
+				expect(bitbucketApiRequestSpy).toHaveBeenCalledWith(
+					'POST',
+					'/workspaces/test-workspace/hooks',
+					{
+						description: 'n8n webhook',
+						url: 'https://test.n8n.io/webhook/test',
+						active: true,
+						events: ['repo:push', 'repo:fork'],
+					},
+				);
+
+				expect(result).toBe(true);
+
+				// Check that webhook ID is stored
+				const staticData = mockHookFunctions.getWorkflowStaticData('node');
+				expect(staticData.webhookId).toBe('12345678-1234-1234-1234-123456789012');
+			});
+
+			it('should create webhook for repository', async () => {
+				const mockResponse = {
+					uuid: '{12345678-1234-1234-1234-123456789012}',
+					url: 'https://test.n8n.io/webhook/test',
+					active: true,
+				};
+
+				mockHookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					if (paramName === 'resource') return 'repository';
+					if (paramName === 'workspace') return 'test-workspace';
+					if (paramName === 'repository') return 'test-repo';
+					if (paramName === 'events') return ['pullrequest:created'];
+					return undefined;
+				});
+
+				bitbucketApiRequestSpy.mockResolvedValue(mockResponse);
+
+				const result = await bitbucketTrigger.webhookMethods.default.create.call(mockHookFunctions);
+
+				expect(bitbucketApiRequestSpy).toHaveBeenCalledWith(
+					'POST',
+					'/repositories/test-workspace/test-repo/hooks',
+					{
+						description: 'n8n webhook',
+						url: 'https://test.n8n.io/webhook/test',
+						active: true,
+						events: ['pullrequest:created'],
+					},
+				);
+
+				expect(result).toBe(true);
+			});
+		});
+
+		describe('delete', () => {
+			it('should delete webhook for workspace', async () => {
+				const staticData = { webhookId: '12345678-1234-1234-1234-123456789012' };
+				mockHookFunctions.getWorkflowStaticData.mockReturnValue(staticData);
+
+				mockHookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					if (paramName === 'resource') return 'workspace';
+					if (paramName === 'workspace') return 'test-workspace';
+					return undefined;
+				});
+
+				bitbucketApiRequestSpy.mockResolvedValue({});
+
+				const result = await bitbucketTrigger.webhookMethods.default.delete.call(mockHookFunctions);
+
+				expect(bitbucketApiRequestSpy).toHaveBeenCalledWith(
+					'DELETE',
+					'/workspaces/test-workspace/hooks/12345678-1234-1234-1234-123456789012',
+				);
+
+				expect(result).toBe(true);
+				expect(staticData.webhookId).toBeUndefined();
+			});
+
+			it('should delete webhook for repository', async () => {
+				const staticData = { webhookId: '12345678-1234-1234-1234-123456789012' };
+				mockHookFunctions.getWorkflowStaticData.mockReturnValue(staticData);
+
+				mockHookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					if (paramName === 'resource') return 'repository';
+					if (paramName === 'workspace') return 'test-workspace';
+					if (paramName === 'repository') return 'test-repo';
+					return undefined;
+				});
+
+				bitbucketApiRequestSpy.mockResolvedValue({});
+
+				const result = await bitbucketTrigger.webhookMethods.default.delete.call(mockHookFunctions);
+
+				expect(bitbucketApiRequestSpy).toHaveBeenCalledWith(
+					'DELETE',
+					'/repositories/test-workspace/test-repo/hooks/12345678-1234-1234-1234-123456789012',
+				);
+
+				expect(result).toBe(true);
+				expect(staticData.webhookId).toBeUndefined();
+			});
+
+			it('should return false if delete fails', async () => {
+				const staticData = { webhookId: '12345678-1234-1234-1234-123456789012' };
+				mockHookFunctions.getWorkflowStaticData.mockReturnValue(staticData);
+
+				mockHookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					if (paramName === 'resource') return 'workspace';
+					if (paramName === 'workspace') return 'test-workspace';
+					return undefined;
+				});
+
+				bitbucketApiRequestSpy.mockRejectedValue(new Error('Delete failed'));
+
+				const result = await bitbucketTrigger.webhookMethods.default.delete.call(mockHookFunctions);
+
+				expect(result).toBe(false);
+				// Webhook ID should still be present since delete failed
+				expect(staticData.webhookId).toBe('12345678-1234-1234-1234-123456789012');
+			});
+		});
+	});
+
+	describe('webhook', () => {
+		const mockWebhookFunctions = mockDeep<IWebhookFunctions>();
+
+		beforeEach(() => {
+			mockWebhookFunctions.getNode.mockReturnValue(mockNode);
+		});
+
+		it('should process webhook with matching UUID', async () => {
+			const webhookId = '12345678-1234-1234-1234-123456789012';
+			const staticData = { webhookId };
+			const mockRequestBody = {
+				repository: {
+					name: 'test-repo',
+				},
+				push: {
+					changes: [
+						{
+							new: {
+								name: 'main',
+							},
+						},
+					],
+				},
+			};
+
+			mockWebhookFunctions.getWorkflowStaticData.mockReturnValue(staticData);
+			mockWebhookFunctions.getRequestObject.mockReturnValue({
+				body: mockRequestBody,
+			} as any);
+			mockWebhookFunctions.getHeaderData.mockReturnValue({
+				'x-hook-uuid': webhookId,
+			});
+			mockWebhookFunctions.helpers.returnJsonArray.mockReturnValue([{ json: mockRequestBody }]);
+
+			const result = await bitbucketTrigger.webhook.call(mockWebhookFunctions);
+
+			expect(result).toEqual({
+				workflowData: [[{ json: mockRequestBody }]],
+			});
+		});
+
+		it('should return empty object for non-matching UUID', async () => {
+			const webhookId = '12345678-1234-1234-1234-123456789012';
+			const staticData = { webhookId };
+
+			mockWebhookFunctions.getWorkflowStaticData.mockReturnValue(staticData);
+			mockWebhookFunctions.getHeaderData.mockReturnValue({
+				'x-hook-uuid': 'different-uuid',
+			});
+
+			const result = await bitbucketTrigger.webhook.call(mockWebhookFunctions);
+
+			expect(result).toEqual({});
+		});
+
+		it('should handle array request body', async () => {
+			const webhookId = '12345678-1234-1234-1234-123456789012';
+			const staticData = { webhookId };
+			const mockRequestBody = [
+				{
+					repository: { name: 'repo1' },
+				},
+				{
+					repository: { name: 'repo2' },
+				},
+			];
+
+			mockWebhookFunctions.getWorkflowStaticData.mockReturnValue(staticData);
+			mockWebhookFunctions.getRequestObject.mockReturnValue({
+				body: mockRequestBody,
+			} as any);
+			mockWebhookFunctions.getHeaderData.mockReturnValue({
+				'x-hook-uuid': webhookId,
+			});
+			mockWebhookFunctions.helpers.returnJsonArray.mockReturnValue([
+				{ json: mockRequestBody[0] },
+				{ json: mockRequestBody[1] },
+			]);
+
+			const result = await bitbucketTrigger.webhook.call(mockWebhookFunctions);
+
+			expect(mockWebhookFunctions.helpers.returnJsonArray).toHaveBeenCalledWith(mockRequestBody);
+			expect(result).toEqual({
+				workflowData: [[{ json: mockRequestBody[0] }, { json: mockRequestBody[1] }]],
+			});
+		});
+	});
+});