n8n-nodes-everest-tms
Version:
Everest TMS n8n integration
673 lines • 30.4 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Everest_node_1 = require("../nodes/Everest/Everest.node");
// Mock functions
const mockGetNodeParameter = jest.fn();
const mockGetInputData = jest.fn();
const mockGetCredentials = jest.fn();
const mockHelpersRequest = jest.fn();
const mockHelpersReturnJsonArray = jest.fn();
const mockGetNode = jest.fn();
const mockContinueOnFail = jest.fn();
// Create a mock that includes both IExecuteFunctions and Everest methods
const mockExecuteFunctions = {
getNodeParameter: mockGetNodeParameter,
getInputData: mockGetInputData,
getCredentials: mockGetCredentials,
helpers: {
request: mockHelpersRequest,
returnJsonArray: mockHelpersReturnJsonArray,
},
getNode: mockGetNode,
continueOnFail: mockContinueOnFail,
};
describe('Everest Node', () => {
let everestNode;
beforeEach(() => {
everestNode = new Everest_node_1.Everest();
jest.clearAllMocks();
});
describe('Mission Operations', () => {
it('should get platform information', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('general') // resource
.mockReturnValueOnce('getPlatformInfo'); // operation
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' }) // auth response
.mockResolvedValueOnce({ platform: { title: 'Test Platform' } }); // actual response
mockHelpersReturnJsonArray.mockReturnValue([{ platform: { title: 'Test Platform' } }]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledTimes(2); // Auth + actual request
});
it('should create a mission', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('mission') // resource
.mockReturnValueOnce('create') // operation
.mockReturnValueOnce(1) // service_id
.mockReturnValueOnce('Start Address') // address_start
.mockReturnValueOnce('End Address') // address_end
.mockReturnValue({}); // other parameters
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockMission = { ref: 'TEST123', status: 'created' };
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce({ mission: mockMission });
mockHelpersReturnJsonArray.mockReturnValue([mockMission]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/missions/create',
body: expect.objectContaining({
service_id: 1,
address_start: 'Start Address',
address_end: 'End Address',
}),
}));
});
it('should get a mission by reference', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('mission') // resource
.mockReturnValueOnce('get') // operation
.mockReturnValueOnce('TEST123'); // ref
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockMission = { ref: 'TEST123', status: 'pending' };
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce({ mission: mockMission });
mockHelpersReturnJsonArray.mockReturnValue([mockMission]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/missions/get',
body: { ref: 'TEST123' },
}));
});
});
describe('Client Operations', () => {
it('should create a client', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('client') // resource
.mockReturnValueOnce('create') // operation
.mockReturnValueOnce('test@example.com') // email
.mockReturnValueOnce('John') // first_name
.mockReturnValueOnce('Doe') // last_name
.mockReturnValueOnce('password123') // password
.mockReturnValueOnce('password123') // password_repeat
.mockReturnValue({}); // other parameters
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockClient = { id: 1, email: 'test@example.com', first_name: 'John', last_name: 'Doe' };
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce({ client: mockClient });
mockHelpersReturnJsonArray.mockReturnValue([mockClient]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/clients/create',
body: expect.objectContaining({
email: 'test@example.com',
first_name: 'John',
last_name: 'Doe',
password: 'password123',
password_repeat: 'password123',
}),
}));
});
});
describe('Alert Operations', () => {
it('should create an alert', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('alert') // resource
.mockReturnValueOnce('create') // operation
.mockReturnValueOnce('invoice') // icon
.mockReturnValueOnce('danger') // category
.mockReturnValueOnce('Invoice awaiting payment') // text
.mockReturnValueOnce('client:123') // created_for
.mockReturnValue({}); // additionalFields
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockAlert = {
id: 1,
icon: 'invoice',
category: 'danger',
text: 'Invoice awaiting payment',
created_for: 'client:123',
status: 0
};
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce({ alert: mockAlert });
mockHelpersReturnJsonArray.mockReturnValue([mockAlert]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/alerts/create',
body: expect.objectContaining({
icon: 'invoice',
category: 'danger',
text: 'Invoice awaiting payment',
created_for: 'client:123',
}),
}));
});
it('should get many alerts', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('alert') // resource
.mockReturnValueOnce('getMany') // operation
.mockReturnValueOnce({
limit: 10,
search: 'invoice',
status: 0
});
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockAlerts = [
{ id: 1, icon: 'invoice', category: 'danger', text: 'Invoice awaiting payment', status: 0 },
{ id: 2, icon: 'invoice', category: 'warning', text: 'Invoice due soon', status: 0 }
];
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce({ alerts: mockAlerts, total: 2 });
mockHelpersReturnJsonArray.mockReturnValue(mockAlerts);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/alerts',
body: expect.objectContaining({
limit_start: 0,
limit_end: 10,
search: 'invoice',
status: 0,
}),
}));
});
});
describe('Walter Operations', () => {
it('should send prompt to Walter', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('walter') // resource
.mockReturnValueOnce('prompt') // operation
.mockReturnValueOnce('Show me today\'s missions') // question
.mockReturnValueOnce(0) // user_id
.mockReturnValueOnce(true); // save_to_history
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockResponse = {
success: true,
response: {
role: 'assistant',
content: 'Here are today\'s missions...',
commands: []
}
};
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce(mockResponse);
mockHelpersReturnJsonArray.mockReturnValue([mockResponse]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/walter/prompt',
body: expect.objectContaining({
question: 'Show me today\'s missions',
save_to_history: true,
}),
}));
});
it('should send prompt to Walter with user_id', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('walter') // resource
.mockReturnValueOnce('prompt') // operation
.mockReturnValueOnce('Show me today\'s missions') // question
.mockReturnValueOnce(123) // user_id
.mockReturnValueOnce(true); // save_to_history
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockResponse = {
success: true,
response: {
role: 'assistant',
content: 'Here are today\'s missions...',
commands: []
}
};
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce(mockResponse);
mockHelpersReturnJsonArray.mockReturnValue([mockResponse]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/walter/prompt',
body: expect.objectContaining({
question: 'Show me today\'s missions',
save_to_history: true,
user_id: 123,
}),
}));
});
it('should send message from Walter', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('walter') // resource
.mockReturnValueOnce('say') // operation
.mockReturnValueOnce('Hello! I have an update for you.') // message
.mockReturnValueOnce(0) // user_id
.mockReturnValueOnce(true) // save_to_history
.mockReturnValueOnce({
command: [{
command: 'get_missions',
parameters: 'date_start,date_end'
}]
});
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockResponse = {
success: true,
message: {
role: 'assistant',
content: 'Hello! I have an update for you.',
commands: [{
command: 'get_missions',
parameters: ['date_start', 'date_end']
}]
}
};
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce(mockResponse);
mockHelpersReturnJsonArray.mockReturnValue([mockResponse]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/walter/say',
body: expect.objectContaining({
message: 'Hello! I have an update for you.',
save_to_history: true,
commands: [{
command: 'get_missions',
parameters: ['date_start', 'date_end']
}]
}),
}));
});
it('should send message from Walter with user_id', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('walter') // resource
.mockReturnValueOnce('say') // operation
.mockReturnValueOnce('Hello! I have an update for you.') // message
.mockReturnValueOnce(456) // user_id
.mockReturnValueOnce(true) // save_to_history
.mockReturnValueOnce({}); // commands
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockResponse = {
success: true,
message: {
role: 'assistant',
content: 'Hello! I have an update for you.',
commands: []
}
};
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce(mockResponse);
mockHelpersReturnJsonArray.mockReturnValue([mockResponse]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/walter/say',
body: expect.objectContaining({
message: 'Hello! I have an update for you.',
save_to_history: true,
user_id: 456,
}),
}));
});
it('should get Walter commands', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('walter') // resource
.mockReturnValueOnce('getCommands'); // operation
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockResponse = {
success: true,
commands: [
{
command: 'get_missions',
parameters: ['date_start', 'date_end'],
description: 'Retrieve missions for a given period'
}
],
count: 1
};
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce(mockResponse);
mockHelpersReturnJsonArray.mockReturnValue([mockResponse]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'GET',
uri: 'https://tests.everst.io/api/walter/commands',
}));
});
it('should handle message length validation', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('walter') // resource
.mockReturnValueOnce('prompt') // operation
.mockReturnValueOnce('x'.repeat(2001)); // question too long
mockContinueOnFail.mockReturnValue(false);
// Execute & Assert
await expect(everestNode.execute.call(mockExecuteFunctions)).rejects.toThrow('Question too long. Maximum 2000 characters allowed');
});
});
describe('Notification Operations', () => {
it('should send SMS notifications', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('notification') // resource
.mockReturnValueOnce('sendSms') // operation
.mockReturnValueOnce('0600000000,0611111111') // tels
.mockReturnValueOnce('Your mission {MISSION_REF} has been updated') // text
.mockReturnValueOnce('ABC123XXX'); // mission_ref
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockResponse = { success: true, sent_count: 2, total_count: 2, errors: [] };
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce(mockResponse);
mockHelpersReturnJsonArray.mockReturnValue([mockResponse]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/notifications/send-sms',
body: expect.objectContaining({
tels: ['0600000000', '0611111111'],
text: 'Your mission {MISSION_REF} has been updated',
mission_ref: 'ABC123XXX',
}),
}));
});
it('should send email notifications', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('notification') // resource
.mockReturnValueOnce('sendEmail') // operation
.mockReturnValueOnce('john@example.com,jane@example.com') // emails
.mockReturnValueOnce('Your mission {MISSION_REF} has been updated') // text
.mockReturnValueOnce('ABC123XXX'); // mission_ref
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockResponse = { success: true, sent_count: 2, total_count: 2, errors: [] };
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce(mockResponse);
mockHelpersReturnJsonArray.mockReturnValue([mockResponse]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/notifications/send-email',
body: expect.objectContaining({
emails: ['john@example.com', 'jane@example.com'],
text: 'Your mission {MISSION_REF} has been updated',
mission_ref: 'ABC123XXX',
}),
}));
});
it('should send push notification', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('notification') // resource
.mockReturnValueOnce('sendPushNotification') // operation
.mockReturnValueOnce(123) // agent_id
.mockReturnValueOnce('You have a new mission {MISSION_REF}') // text
.mockReturnValueOnce('ABC123XXX'); // mission_ref
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockResponse = { success: true, agent_id: 123, agent_name: 'John Doe' };
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce(mockResponse);
mockHelpersReturnJsonArray.mockReturnValue([mockResponse]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/notifications/send-push-notification',
body: expect.objectContaining({
agent_id: 123,
text: 'You have a new mission {MISSION_REF}',
mission_ref: 'ABC123XXX',
}),
}));
});
});
describe('Error Handling', () => {
it('should handle authentication errors', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('general')
.mockReturnValueOnce('getPlatformInfo');
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'invalid_client_id',
clientSecret: 'invalid_client_secret',
});
mockHelpersRequest.mockRejectedValue(new Error('Authentication failed'));
mockContinueOnFail.mockReturnValue(false);
// Execute & Assert
await expect(everestNode.execute.call(mockExecuteFunctions)).rejects.toThrow('Authentication failed');
});
it('should continue on fail when configured', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('mission')
.mockReturnValueOnce('get')
.mockReturnValueOnce(''); // empty ref to cause error
mockContinueOnFail.mockReturnValue(true);
mockHelpersReturnJsonArray.mockReturnValue([{ error: 'Required field \'ref\' is missing or empty' }]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(result[0]).toEqual([{ error: 'Required field \'ref\' is missing or empty' }]);
});
});
describe('Route Optimization', () => {
it('should optimize routes', async () => {
// Setup
mockGetInputData.mockReturnValue([{}]);
mockGetNodeParameter
.mockReturnValueOnce('route') // resource
.mockReturnValueOnce('optimize') // operation
.mockReturnValueOnce({
shipment: [{
pickup_id: 1,
pickup_description: 'Pickup 1',
pickup_lng: 2.3317,
pickup_lat: 48.8291,
pickup_setup: 60,
pickup_service: 300,
delivery_id: 2,
delivery_description: 'Delivery 1',
delivery_lng: 2.3928,
delivery_lat: 48.8522,
delivery_setup: 60,
delivery_service: 300,
amount: 1,
volume: 0.25,
weight: 100,
}]
})
.mockReturnValueOnce({
vehicle: [{
id: 1,
profile: 'car',
description: 'Vehicle 1',
start_lng: 2.3969,
start_lat: 48.8666,
capacity: 10,
weight: 250,
volume: 1.3,
}]
})
.mockReturnValue({}); // options
mockGetCredentials.mockResolvedValue({
domain: 'tests.everst.io',
clientId: 'test_client_id',
clientSecret: 'test_client_secret',
});
const mockSolution = { code: 0, cost: 10013, routes: [] };
mockHelpersRequest
.mockResolvedValueOnce({ token: 'test_token' })
.mockResolvedValueOnce({ solution: mockSolution });
mockHelpersReturnJsonArray.mockReturnValue([mockSolution]);
// Execute
const result = await everestNode.execute.call(mockExecuteFunctions);
// Assert
expect(result).toBeDefined();
expect(mockHelpersRequest).toHaveBeenCalledWith(expect.objectContaining({
method: 'POST',
uri: 'https://tests.everst.io/api/routes/solve',
body: expect.objectContaining({
shipments: expect.arrayContaining([
expect.objectContaining({
pickup: expect.objectContaining({
id: 1,
location: [2.3317, 48.8291],
}),
delivery: expect.objectContaining({
id: 2,
location: [2.3928, 48.8522],
}),
})
]),
vehicles: expect.arrayContaining([
expect.objectContaining({
id: 1,
profile: 'car',
start: [2.3969, 48.8666],
})
]),
}),
}));
});
});
});
//# sourceMappingURL=Everest.node.test.js.map