n8n/packages/workflow/test/NodeErrors.test.ts
Jon 1e310f40f7
Some checks are pending
Test Master / install-and-build (push) Waiting to run
Test Master / Unit tests (18.x) (push) Blocked by required conditions
Test Master / Unit tests (20.x) (push) Blocked by required conditions
Test Master / Unit tests (22.4) (push) Blocked by required conditions
Test Master / Lint (push) Blocked by required conditions
Test Master / Notify Slack on failure (push) Blocked by required conditions
fix: Fix issue with some errors not being handled correctly (no-changelog) (#10371)
2024-08-13 18:09:07 +01:00

282 lines
9.4 KiB
TypeScript

import type { INode, JsonObject } from '@/Interfaces';
import { NodeOperationError } from '@/errors';
import { NodeApiError } from '@/errors/node-api.error';
import { UNKNOWN_ERROR_DESCRIPTION, UNKNOWN_ERROR_MESSAGE } from '../src/Constants';
const node: INode = {
id: '1',
name: 'Postgres node',
typeVersion: 2,
type: 'n8n-nodes-base.postgres',
position: [60, 760],
parameters: {
operation: 'executeQuery',
},
};
describe('NodeErrors tests', () => {
it('should return unknown error message', () => {
const nodeApiError = new NodeApiError(node, {});
expect(nodeApiError.message).toEqual(UNKNOWN_ERROR_MESSAGE);
});
it('should return the error message', () => {
const nodeApiError = new NodeApiError(node, { message: 'test error message' });
expect(nodeApiError.message).toEqual('test error message');
});
it('should return the error message defined in reason', () => {
const nodeApiError = new NodeApiError(node, { reason: { message: 'test error message' } });
expect(nodeApiError.message).toEqual('test error message');
});
it('should return the error message defined in options', () => {
const nodeApiError = new NodeApiError(node, {}, { message: 'test error message' });
expect(nodeApiError.message).toEqual('test error message');
});
it('should return description error message', () => {
const nodeApiError = new NodeApiError(node, { description: 'test error description' });
expect(nodeApiError.message).toEqual('test error description');
});
it('should return description as error message defined in reason', () => {
const nodeApiError = new NodeApiError(node, {
reason: { description: 'test error description' },
});
expect(nodeApiError.message).toEqual('test error description');
});
it('should return description as error message defined in options', () => {
const nodeApiError = new NodeApiError(node, {}, { description: 'test error description' });
expect(nodeApiError.message).toEqual('test error description');
});
it('should return default message for ECONNREFUSED', () => {
const nodeApiError = new NodeApiError(node, {
message: 'ECONNREFUSED',
});
expect(nodeApiError.message).toEqual(
'The service refused the connection - perhaps it is offline',
);
});
it('should return default message for 502', () => {
const nodeApiError = new NodeApiError(node, {
message: '502 Bad Gateway',
});
expect(nodeApiError.message).toEqual('Bad gateway - the service failed to handle your request');
});
it('should return default message for ENOTFOUND, NodeOperationError', () => {
const nodeOperationError = new NodeOperationError(node, 'ENOTFOUND test error message');
expect(nodeOperationError.message).toEqual(
'The connection cannot be established, this usually occurs due to an incorrect host (domain) value',
);
});
it('should return default message for ENOTFOUND, NodeApiError', () => {
const nodeApiError = new NodeApiError(node, { message: 'ENOTFOUND test error message' });
expect(nodeApiError.message).toEqual(
'The connection cannot be established, this usually occurs due to an incorrect host (domain) value',
);
});
it('should return default message for EEXIST based on code, NodeApiError', () => {
const nodeApiError = new NodeApiError(node, {
message: 'test error message',
code: 'EEXIST',
});
expect(nodeApiError.message).toEqual('The file or directory already exists');
});
it('should update description GETADDRINFO, NodeOperationError', () => {
const nodeOperationError = new NodeOperationError(node, 'GETADDRINFO test error message', {
description: 'test error description',
});
expect(nodeOperationError.message).toEqual('The server closed the connection unexpectedly');
//description should not include error message
expect(nodeOperationError.description).toEqual('test error description');
});
it('should remove description if it is equal to message, NodeOperationError', () => {
const nodeOperationError = new NodeOperationError(node, 'some text', {
description: 'some text',
});
expect(nodeOperationError.message).toEqual('some text');
expect(nodeOperationError.description).toEqual(undefined);
});
it('should remove description if it is equal to message, message provided in options take precedence over original, NodeApiError', () => {
const nodeApiError = new NodeApiError(
node,
{
message: 'original message',
},
{ message: 'new text', description: 'new text' },
);
expect(nodeApiError.message).toEqual('new text');
expect(nodeApiError.description).toEqual(undefined);
});
it('should return mapped message for MYMAPPEDMESSAGE, NodeOperationError', () => {
const nodeOperationError = new NodeOperationError(node, 'MYMAPPEDMESSAGE test error message', {
messageMapping: {
MYMAPPEDMESSAGE: 'test error message',
},
});
expect(nodeOperationError.message).toEqual('test error message');
});
it('should return mapped message for MYMAPPEDMESSAGE, NodeApiError', () => {
const nodeApiError = new NodeApiError(
node,
{ message: 'MYMAPPEDMESSAGE test error message' },
{
messageMapping: {
MYMAPPEDMESSAGE: 'test error message',
},
},
);
expect(nodeApiError.message).toEqual('test error message');
});
it('should return default message for EACCES, custom mapping not found, NodeOperationError', () => {
const nodeOperationError = new NodeOperationError(node, 'EACCES test error message', {
messageMapping: {
MYMAPPEDMESSAGE: 'test error message',
},
});
expect(nodeOperationError.message).toEqual(
'Forbidden by access permissions, make sure you have the right permissions',
);
});
});
describe('NodeApiError message and description logic', () => {
it('case: customMessage && customDescription, result: message === customMessage; description === customDescription', () => {
const apiError = { message: 'Original message', code: 404 };
const nodeApiError = new NodeApiError(node, apiError, {
message: 'Custom message',
description: 'Custom description',
});
expect(nodeApiError.message).toEqual('Custom message');
expect(nodeApiError.description).toEqual('Custom description');
expect(nodeApiError.messages).toContain('Original message');
});
it('case: customMessage && !customDescription && extractedMessage, result: message === customMessage; description === extractedMessage', () => {
const apiError = {
message: 'Original message',
code: 404,
response: { data: { error: { message: 'Extracted message' } } },
};
const nodeApiError = new NodeApiError(node, apiError, {
message: 'Custom message',
});
expect(nodeApiError.message).toEqual('Custom message');
expect(nodeApiError.description).toEqual('Extracted message');
expect(nodeApiError.messages).toContain('Original message');
});
it('case: customMessage && !customDescription && !extractedMessage, result: message === customMessage; !description', () => {
const apiError = {
message: '',
code: 404,
response: { data: { error: { foo: 'Extracted message' } } },
};
const nodeApiError = new NodeApiError(node, apiError, {
message: 'Custom message',
});
expect(nodeApiError.message).toEqual('Custom message');
expect(nodeApiError.description).toBeFalsy();
expect(nodeApiError.messages.length).toBe(0);
});
it('case: !customMessage && httpCodeMapping && extractedMessage, result: message === httpCodeMapping; description === extractedMessage', () => {
const apiError = {
message: 'Original message',
code: 404,
response: { data: { error: { message: 'Extracted message' } } },
};
const nodeApiError = new NodeApiError(node, apiError);
expect(nodeApiError.message).toEqual('The resource you are requesting could not be found');
expect(nodeApiError.description).toEqual('Extracted message');
expect(nodeApiError.messages).toContain('Original message');
});
it('case: !customMessage && httpCodeMapping && !extractedMessage, result: message === httpCodeMapping; !description', () => {
const apiError = {
message: '',
code: 500,
};
const nodeApiError = new NodeApiError(node, apiError);
expect(nodeApiError.message).toEqual('The service was not able to process your request');
expect(nodeApiError.description).toBeFalsy();
});
it('case: !customMessage && !httpCodeMapping && extractedMessage, result: message === extractedMessage; !description', () => {
const apiError = {
message: '',
code: 300,
response: { data: { error: { message: 'Extracted message' } } },
};
const nodeApiError = new NodeApiError(node, apiError);
expect(nodeApiError.message).toEqual('Extracted message');
expect(nodeApiError.description).toBeFalsy();
});
it('case: !customMessage && !httpCodeMapping && !extractedMessage, result: message === UNKNOWN_ERROR_MESSAGE; description === UNKNOWN_ERROR_DESCRIPTION', () => {
const apiError = {};
const nodeApiError = new NodeApiError(node, apiError);
expect(nodeApiError.message).toEqual(UNKNOWN_ERROR_MESSAGE);
expect(nodeApiError.description).toEqual(UNKNOWN_ERROR_DESCRIPTION);
});
it('case: Error code sent as "any"', () => {
const error = {
code: 400,
message: "Invalid value 'test' for viewId parameter.",
status: 'INVALID_ARGUMENT',
};
const [message, ...rest] = error.message.split('\n');
const description = rest.join('\n');
const httpCode = error.code as any;
const nodeApiError = new NodeApiError(node, error as JsonObject, {
message,
description,
httpCode,
});
expect(nodeApiError.message).toEqual(error.message);
});
});