mirror of
https://github.com/Abdulazizzn/n8n-enterprise-unlocked.git
synced 2025-12-16 17:46:45 +00:00
927 lines
26 KiB
TypeScript
927 lines
26 KiB
TypeScript
import type { BaseLanguageModel } from '@langchain/core/language_models/base';
|
|
import { OutputParserException } from '@langchain/core/output_parsers';
|
|
import { mock, type MockProxy } from 'jest-mock-extended';
|
|
import { normalizeItems } from 'n8n-core';
|
|
import {
|
|
jsonParse,
|
|
NodeConnectionTypes,
|
|
NodeOperationError,
|
|
type INode,
|
|
type ISupplyDataFunctions,
|
|
type IWorkflowDataProxyData,
|
|
} from 'n8n-workflow';
|
|
|
|
import {
|
|
N8nStructuredOutputParser,
|
|
type N8nOutputFixingParser,
|
|
} from '@utils/output_parsers/N8nOutputParser';
|
|
|
|
import { OutputParserStructured } from '../OutputParserStructured.node';
|
|
import { NAIVE_FIX_PROMPT } from '../prompt';
|
|
|
|
describe('OutputParserStructured', () => {
|
|
let outputParser: OutputParserStructured;
|
|
const thisArg = mock<ISupplyDataFunctions>({
|
|
helpers: { normalizeItems },
|
|
});
|
|
const workflowDataProxy = mock<IWorkflowDataProxyData>({ $input: mock() });
|
|
|
|
beforeEach(() => {
|
|
outputParser = new OutputParserStructured();
|
|
thisArg.getWorkflowDataProxy.mockReturnValue(workflowDataProxy);
|
|
thisArg.addInputData.mockReturnValue({ index: 0 });
|
|
thisArg.addOutputData.mockReturnValue();
|
|
});
|
|
|
|
describe('supplyData', () => {
|
|
describe('Version 1.1 and below', () => {
|
|
beforeEach(() => {
|
|
thisArg.getNode.mockReturnValue(mock<INode>({ typeVersion: 1.1 }));
|
|
});
|
|
|
|
it('should parse a complex nested schema', async () => {
|
|
const schema = `{
|
|
"type": "object",
|
|
"properties": {
|
|
"user": {
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" },
|
|
"details": {
|
|
"type": "object",
|
|
"properties": {
|
|
"age": { "type": "number" },
|
|
"hobbies": { "type": "array", "items": { "type": "string" } }
|
|
}
|
|
}
|
|
}
|
|
},
|
|
"timestamp": { "type": "string", "format": "date-time" }
|
|
},
|
|
"required": ["user", "timestamp"]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('jsonSchema', 0).mockReturnValueOnce(schema);
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
const outputObject = {
|
|
output: {
|
|
user: {
|
|
name: 'Alice',
|
|
details: {
|
|
age: 30,
|
|
hobbies: ['reading', 'hiking'],
|
|
},
|
|
},
|
|
timestamp: '2023-04-01T12:00:00Z',
|
|
},
|
|
};
|
|
const parsersOutput = await response.parse(`Here's the complex output:
|
|
\`\`\`json
|
|
${JSON.stringify(outputObject)}
|
|
\`\`\`
|
|
`);
|
|
|
|
expect(parsersOutput).toEqual(outputObject);
|
|
});
|
|
|
|
it('should handle optional fields correctly', async () => {
|
|
const schema = `{
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" },
|
|
"age": { "type": "number" },
|
|
"email": { "type": "string", "format": "email" }
|
|
},
|
|
"required": ["name"]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('jsonSchema', 0).mockReturnValueOnce(schema);
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
const outputObject = {
|
|
output: {
|
|
name: 'Bob',
|
|
email: 'bob@example.com',
|
|
},
|
|
};
|
|
const parsersOutput = await response.parse(`Here's the output with optional fields:
|
|
\`\`\`json
|
|
${JSON.stringify(outputObject)}
|
|
\`\`\`
|
|
`);
|
|
|
|
expect(parsersOutput).toEqual(outputObject);
|
|
});
|
|
|
|
it('should handle arrays of objects', async () => {
|
|
const schema = `{
|
|
"type": "object",
|
|
"properties": {
|
|
"users": {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": { "type": "number" },
|
|
"name": { "type": "string" }
|
|
},
|
|
"required": ["id", "name"]
|
|
}
|
|
}
|
|
},
|
|
"required": ["users"]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('jsonSchema', 0).mockReturnValueOnce(schema);
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
const outputObject = {
|
|
output: {
|
|
users: [
|
|
{ id: 1, name: 'Alice' },
|
|
{ id: 2, name: 'Bob' },
|
|
],
|
|
},
|
|
};
|
|
const parsersOutput = await response.parse(`Here's the array output:
|
|
\`\`\`json
|
|
${JSON.stringify(outputObject)}
|
|
\`\`\`
|
|
`);
|
|
|
|
expect(parsersOutput).toEqual(outputObject);
|
|
});
|
|
|
|
it('should handle empty objects', async () => {
|
|
const schema = `{
|
|
"type": "object",
|
|
"properties": {
|
|
"data": {
|
|
"type": "object"
|
|
}
|
|
},
|
|
"required": ["data"]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('jsonSchema', 0).mockReturnValueOnce(schema);
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
const outputObject = {
|
|
output: {
|
|
data: {},
|
|
},
|
|
};
|
|
const parsersOutput = await response.parse(`Here's the empty object output:
|
|
\`\`\`json
|
|
${JSON.stringify(outputObject)}
|
|
\`\`\`
|
|
`);
|
|
|
|
expect(parsersOutput).toEqual(outputObject);
|
|
});
|
|
|
|
it('should throw error for null values in non-nullable fields', async () => {
|
|
const schema = `{
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" },
|
|
"age": { "type": "number" }
|
|
},
|
|
"required": ["name", "age"]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('jsonSchema', 0).mockReturnValueOnce(schema);
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
const outputObject = {
|
|
output: {
|
|
name: 'Charlie',
|
|
age: null,
|
|
},
|
|
};
|
|
|
|
await expect(
|
|
response.parse(
|
|
`Here's the output with null value:
|
|
\`\`\`json
|
|
${JSON.stringify(outputObject)}
|
|
\`\`\`
|
|
`,
|
|
undefined,
|
|
(e) => e,
|
|
),
|
|
).rejects.toThrow('Expected number, received null');
|
|
});
|
|
});
|
|
|
|
describe('Version 1.2 and above', () => {
|
|
beforeEach(() => {
|
|
thisArg.getNode.mockReturnValue(mock<INode>({ typeVersion: 1.2 }));
|
|
});
|
|
|
|
it('should parse output using schema generated from complex JSON example', async () => {
|
|
const jsonExample = `{
|
|
"user": {
|
|
"name": "Alice",
|
|
"details": {
|
|
"age": 30,
|
|
"address": {
|
|
"street": "123 Main St",
|
|
"city": "Anytown",
|
|
"zipCode": "12345"
|
|
}
|
|
}
|
|
},
|
|
"orders": [
|
|
{
|
|
"id": "ORD-001",
|
|
"items": ["item1", "item2"],
|
|
"total": 50.99
|
|
},
|
|
{
|
|
"id": "ORD-002",
|
|
"items": ["item3"],
|
|
"total": 25.50
|
|
}
|
|
],
|
|
"isActive": true
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('schemaType', 0).mockReturnValueOnce('fromJson');
|
|
thisArg.getNodeParameter
|
|
.calledWith('jsonSchemaExample', 0)
|
|
.mockReturnValueOnce(jsonExample);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
|
|
const outputObject = {
|
|
output: jsonParse(jsonExample),
|
|
};
|
|
|
|
const parsersOutput = await response.parse(`Here's the complex output:
|
|
\`\`\`json
|
|
${JSON.stringify(outputObject)}
|
|
\`\`\`
|
|
`);
|
|
|
|
expect(parsersOutput).toEqual(outputObject);
|
|
});
|
|
|
|
it('should validate enum values', async () => {
|
|
const inputSchema = `{
|
|
"type": "object",
|
|
"properties": {
|
|
"color": {
|
|
"type": "string",
|
|
"enum": ["red", "green", "blue"]
|
|
}
|
|
},
|
|
"required": ["color"]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('schemaType', 0).mockReturnValueOnce('manual');
|
|
thisArg.getNodeParameter.calledWith('inputSchema', 0).mockReturnValueOnce(inputSchema);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
|
|
const validOutput = {
|
|
output: {
|
|
color: 'green',
|
|
},
|
|
};
|
|
|
|
const invalidOutput = {
|
|
output: {
|
|
color: 'yellow',
|
|
},
|
|
};
|
|
|
|
await expect(
|
|
response.parse(`Valid output:
|
|
\`\`\`json
|
|
${JSON.stringify(validOutput)}
|
|
\`\`\`
|
|
`),
|
|
).resolves.toEqual(validOutput);
|
|
|
|
await expect(
|
|
response.parse(
|
|
`Invalid output:
|
|
\`\`\`json
|
|
${JSON.stringify(invalidOutput)}
|
|
\`\`\`
|
|
`,
|
|
undefined,
|
|
(e) => e,
|
|
),
|
|
).rejects.toThrow();
|
|
});
|
|
|
|
it('should handle recursive structures', async () => {
|
|
const inputSchema = `{
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" },
|
|
"children": {
|
|
"type": "array",
|
|
"items": { "$ref": "#" }
|
|
}
|
|
},
|
|
"required": ["name"]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('schemaType', 0).mockReturnValueOnce('manual');
|
|
thisArg.getNodeParameter.calledWith('inputSchema', 0).mockReturnValueOnce(inputSchema);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
|
|
const outputObject = {
|
|
output: {
|
|
name: 'Root',
|
|
children: [
|
|
{
|
|
name: 'Child1',
|
|
children: [{ name: 'Grandchild1' }, { name: 'Grandchild2' }],
|
|
},
|
|
{
|
|
name: 'Child2',
|
|
},
|
|
],
|
|
},
|
|
};
|
|
|
|
const parsersOutput = await response.parse(`Here's the recursive structure output:
|
|
\`\`\`json
|
|
${JSON.stringify(outputObject)}
|
|
\`\`\`
|
|
`);
|
|
|
|
expect(parsersOutput).toEqual(outputObject);
|
|
});
|
|
|
|
it('should handle missing required properties', async () => {
|
|
const schema = `{
|
|
"type": "object",
|
|
"properties": {
|
|
"name": {
|
|
"type": "string"
|
|
},
|
|
"age": {
|
|
"type": "number"
|
|
}
|
|
},
|
|
"required": ["name", "age"]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('schemaType', 0).mockReturnValueOnce('manual');
|
|
thisArg.getNodeParameter.calledWith('inputSchema', 0).mockReturnValueOnce(schema);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
const outputObject = { output: { name: 'Mac' } };
|
|
|
|
await expect(
|
|
response.parse(
|
|
`Here's the output!
|
|
\`\`\`json
|
|
${JSON.stringify(outputObject)}
|
|
\`\`\`
|
|
`,
|
|
undefined,
|
|
(e) => e,
|
|
),
|
|
).rejects.toThrow('Required');
|
|
});
|
|
|
|
it('should throw on wrong type', async () => {
|
|
const schema = `{
|
|
"type": "object",
|
|
"properties": {
|
|
"name": {
|
|
"type": "string"
|
|
},
|
|
"age": {
|
|
"type": "number"
|
|
}
|
|
},
|
|
"required": ["name", "age"]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('inputSchema', 0).mockReturnValueOnce(schema);
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
const outputObject = { output: { name: 'Mac', age: '27' } };
|
|
|
|
await expect(
|
|
response.parse(
|
|
`Here's the output!
|
|
\`\`\`json
|
|
${JSON.stringify(outputObject)}
|
|
\`\`\`
|
|
`,
|
|
undefined,
|
|
(e) => e,
|
|
),
|
|
).rejects.toThrow('Expected number, received string');
|
|
});
|
|
|
|
it('should parse array output', async () => {
|
|
const schema = `{
|
|
"type": "object",
|
|
"properties": {
|
|
"myArr": {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"name": {
|
|
"type": "string"
|
|
},
|
|
"age": {
|
|
"type": "number"
|
|
}
|
|
},
|
|
"required": ["name", "age"]
|
|
}
|
|
}
|
|
},
|
|
"required": ["myArr"]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('inputSchema', 0).mockReturnValueOnce(schema);
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
const outputObject = {
|
|
output: {
|
|
myArr: [
|
|
{ name: 'Mac', age: 27 },
|
|
{ name: 'Alice', age: 25 },
|
|
],
|
|
},
|
|
};
|
|
const parsersOutput = await response.parse(`Here's the output!
|
|
\`\`\`json
|
|
${JSON.stringify(outputObject)}
|
|
\`\`\`
|
|
`);
|
|
|
|
expect(parsersOutput).toEqual(outputObject);
|
|
});
|
|
});
|
|
|
|
describe('Version 1.3', () => {
|
|
beforeEach(() => {
|
|
thisArg.getNode.mockReturnValue(mock<INode>({ typeVersion: 1.3 }));
|
|
});
|
|
|
|
describe('schema from JSON example', () => {
|
|
it('should make all fields required when generating schema from JSON example', async () => {
|
|
const jsonExample = `{
|
|
"user": {
|
|
"name": "Alice",
|
|
"email": "alice@example.com",
|
|
"profile": {
|
|
"age": 30,
|
|
"city": "New York"
|
|
}
|
|
},
|
|
"tags": ["work", "important"]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('schemaType', 0).mockReturnValueOnce('fromJson');
|
|
thisArg.getNodeParameter
|
|
.calledWith('jsonSchemaExample', 0)
|
|
.mockReturnValueOnce(jsonExample);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
|
|
const outputObject = {
|
|
output: {
|
|
user: {
|
|
name: 'Bob',
|
|
email: 'bob@example.com',
|
|
profile: {
|
|
age: 25,
|
|
city: 'San Francisco',
|
|
},
|
|
},
|
|
tags: ['personal'],
|
|
},
|
|
};
|
|
|
|
const parsersOutput = await response.parse(`Here's the user data:
|
|
\`\`\`json
|
|
${JSON.stringify(outputObject)}
|
|
\`\`\`
|
|
`);
|
|
|
|
expect(parsersOutput).toEqual(outputObject);
|
|
});
|
|
|
|
it('should reject output missing required fields from JSON example', async () => {
|
|
const jsonExample = `{
|
|
"name": "Alice",
|
|
"age": 30,
|
|
"email": "alice@example.com"
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('schemaType', 0).mockReturnValueOnce('fromJson');
|
|
thisArg.getNodeParameter
|
|
.calledWith('jsonSchemaExample', 0)
|
|
.mockReturnValueOnce(jsonExample);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
|
|
const incompleteOutput = {
|
|
output: {
|
|
name: 'Bob',
|
|
age: 25,
|
|
// Missing email field
|
|
},
|
|
};
|
|
|
|
await expect(
|
|
response.parse(
|
|
`Here's the incomplete output:
|
|
\`\`\`json
|
|
${JSON.stringify(incompleteOutput)}
|
|
\`\`\`
|
|
`,
|
|
undefined,
|
|
(e) => e,
|
|
),
|
|
).rejects.toThrow('Required');
|
|
});
|
|
|
|
it('should require all fields in array items from JSON example', async () => {
|
|
const jsonExample = `{
|
|
"users": [
|
|
{
|
|
"id": 1,
|
|
"name": "Alice",
|
|
"metadata": {
|
|
"department": "Engineering",
|
|
"role": "Developer"
|
|
}
|
|
}
|
|
]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('schemaType', 0).mockReturnValueOnce('fromJson');
|
|
thisArg.getNodeParameter
|
|
.calledWith('jsonSchemaExample', 0)
|
|
.mockReturnValueOnce(jsonExample);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
|
|
const incompleteArrayOutput = {
|
|
output: {
|
|
users: [
|
|
{
|
|
id: 2,
|
|
name: 'Bob',
|
|
metadata: {
|
|
department: 'Marketing',
|
|
// Missing role field
|
|
},
|
|
},
|
|
],
|
|
},
|
|
};
|
|
|
|
await expect(
|
|
response.parse(
|
|
`Here's the incomplete array output:
|
|
\`\`\`json
|
|
${JSON.stringify(incompleteArrayOutput)}
|
|
\`\`\`
|
|
`,
|
|
undefined,
|
|
(e) => e,
|
|
),
|
|
).rejects.toThrow('Required');
|
|
});
|
|
});
|
|
|
|
describe('manual schema mode', () => {
|
|
it('should work with manually defined schema in version 1.3', async () => {
|
|
const inputSchema = `{
|
|
"type": "object",
|
|
"properties": {
|
|
"result": {
|
|
"type": "object",
|
|
"properties": {
|
|
"status": { "type": "string" },
|
|
"data": {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": { "type": "number" },
|
|
"value": { "type": "string" }
|
|
},
|
|
"required": ["id", "value"]
|
|
}
|
|
}
|
|
},
|
|
"required": ["status", "data"]
|
|
}
|
|
},
|
|
"required": ["result"]
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('schemaType', 0).mockReturnValueOnce('manual');
|
|
thisArg.getNodeParameter.calledWith('inputSchema', 0).mockReturnValueOnce(inputSchema);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
|
|
const outputObject = {
|
|
output: {
|
|
result: {
|
|
status: 'success',
|
|
data: [
|
|
{ id: 1, value: 'first' },
|
|
{ id: 2, value: 'second' },
|
|
],
|
|
},
|
|
},
|
|
};
|
|
|
|
const parsersOutput = await response.parse(`Here's the result:
|
|
\`\`\`json
|
|
${JSON.stringify(outputObject)}
|
|
\`\`\`
|
|
`);
|
|
|
|
expect(parsersOutput).toEqual(outputObject);
|
|
});
|
|
});
|
|
|
|
describe('complex nested structures', () => {
|
|
it('should handle deeply nested objects with required fields', async () => {
|
|
const jsonExample = `{
|
|
"company": {
|
|
"name": "TechCorp",
|
|
"departments": [
|
|
{
|
|
"name": "Engineering",
|
|
"teams": [
|
|
{
|
|
"name": "Backend",
|
|
"members": [
|
|
{
|
|
"id": 1,
|
|
"name": "Alice",
|
|
"skills": ["Python", "Docker"]
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
}`;
|
|
thisArg.getNodeParameter.calledWith('schemaType', 0).mockReturnValueOnce('fromJson');
|
|
thisArg.getNodeParameter
|
|
.calledWith('jsonSchemaExample', 0)
|
|
.mockReturnValueOnce(jsonExample);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nStructuredOutputParser;
|
|
};
|
|
|
|
const complexOutput = {
|
|
output: {
|
|
company: {
|
|
name: 'StartupCorp',
|
|
departments: [
|
|
{
|
|
name: 'Product',
|
|
teams: [
|
|
{
|
|
name: 'Frontend',
|
|
members: [
|
|
{
|
|
id: 2,
|
|
name: 'Bob',
|
|
skills: ['React', 'TypeScript'],
|
|
},
|
|
{
|
|
id: 3,
|
|
name: 'Carol',
|
|
skills: ['Vue', 'CSS'],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
},
|
|
};
|
|
|
|
const parsersOutput = await response.parse(`Here's the complex company data:
|
|
\`\`\`json
|
|
${JSON.stringify(complexOutput)}
|
|
\`\`\`
|
|
`);
|
|
|
|
expect(parsersOutput).toEqual(complexOutput);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Auto-Fix', () => {
|
|
const model: BaseLanguageModel = jest.fn() as unknown as BaseLanguageModel;
|
|
|
|
beforeEach(() => {
|
|
thisArg.getNodeParameter.calledWith('schemaType', 0).mockReturnValueOnce('fromJson');
|
|
thisArg.getNodeParameter.calledWith('jsonSchemaExample', 0).mockReturnValueOnce(`{
|
|
"user": {
|
|
"name": "Alice"
|
|
}
|
|
}`);
|
|
thisArg.getNode.mockReturnValue(mock<INode>({ typeVersion: 1.2 }));
|
|
thisArg.getInputConnectionData
|
|
.calledWith(NodeConnectionTypes.AiLanguageModel, 0)
|
|
.mockResolvedValueOnce(model);
|
|
});
|
|
|
|
afterEach(() => {
|
|
jest.clearAllMocks();
|
|
});
|
|
|
|
describe('Configuration', () => {
|
|
it('should use default prompt when none specified', async () => {
|
|
thisArg.getNodeParameter.calledWith('autoFix', 0, false).mockReturnValueOnce(true);
|
|
thisArg.getNodeParameter
|
|
.calledWith('prompt', 0, NAIVE_FIX_PROMPT)
|
|
.mockReturnValueOnce(NAIVE_FIX_PROMPT);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nOutputFixingParser;
|
|
};
|
|
|
|
expect(response).toBeDefined();
|
|
});
|
|
|
|
it('should use custom prompt if one is provided', async () => {
|
|
thisArg.getNodeParameter.calledWith('autoFix', 0, false).mockReturnValueOnce(true);
|
|
thisArg.getNodeParameter
|
|
.calledWith('prompt', 0, NAIVE_FIX_PROMPT)
|
|
.mockReturnValueOnce(
|
|
'Some prompt with "{error}", "{instructions}", and "{completion}" placeholders',
|
|
);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nOutputFixingParser;
|
|
};
|
|
|
|
expect(response).toBeDefined();
|
|
});
|
|
|
|
it('should throw error when prompt template does not contain {error} placeholder', async () => {
|
|
thisArg.getNodeParameter.calledWith('autoFix', 0, false).mockReturnValueOnce(true);
|
|
thisArg.getNodeParameter
|
|
.calledWith('prompt', 0, NAIVE_FIX_PROMPT)
|
|
.mockReturnValueOnce('Invalid prompt without error placeholder');
|
|
|
|
await expect(outputParser.supplyData.call(thisArg, 0)).rejects.toThrow(
|
|
new NodeOperationError(
|
|
thisArg.getNode(),
|
|
'Auto-fixing parser prompt has to contain {error} placeholder',
|
|
),
|
|
);
|
|
});
|
|
|
|
it('should throw error when prompt template is empty', async () => {
|
|
thisArg.getNodeParameter.calledWith('autoFix', 0, false).mockReturnValueOnce(true);
|
|
thisArg.getNodeParameter.calledWith('prompt', 0, NAIVE_FIX_PROMPT).mockReturnValueOnce('');
|
|
|
|
await expect(outputParser.supplyData.call(thisArg, 0)).rejects.toThrow(
|
|
new NodeOperationError(
|
|
thisArg.getNode(),
|
|
'Auto-fixing parser prompt has to contain {error} placeholder',
|
|
),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('Parsing', () => {
|
|
let mockStructuredOutputParser: MockProxy<N8nStructuredOutputParser>;
|
|
|
|
beforeEach(() => {
|
|
mockStructuredOutputParser = mock<N8nStructuredOutputParser>();
|
|
|
|
jest
|
|
.spyOn(N8nStructuredOutputParser, 'fromZodJsonSchema')
|
|
.mockResolvedValue(mockStructuredOutputParser);
|
|
|
|
thisArg.getNodeParameter.calledWith('autoFix', 0, false).mockReturnValueOnce(true);
|
|
thisArg.getNodeParameter
|
|
.calledWith('prompt', 0, NAIVE_FIX_PROMPT)
|
|
.mockReturnValueOnce(NAIVE_FIX_PROMPT);
|
|
});
|
|
|
|
afterEach(() => {
|
|
jest.clearAllMocks();
|
|
});
|
|
|
|
function getMockedRetryChain(output: string) {
|
|
return jest.fn().mockReturnValue({
|
|
invoke: jest.fn().mockResolvedValue({
|
|
content: output,
|
|
}),
|
|
});
|
|
}
|
|
|
|
it('should successfully parse valid output without needing to fix it', async () => {
|
|
const validOutput = { name: 'Alice', age: 25 };
|
|
|
|
mockStructuredOutputParser.parse.mockResolvedValueOnce(validOutput);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nOutputFixingParser;
|
|
};
|
|
|
|
const result = await response.parse('{"name": "Alice", "age": 25}');
|
|
|
|
expect(result).toEqual(validOutput);
|
|
expect(mockStructuredOutputParser.parse.mock.calls).toHaveLength(1);
|
|
});
|
|
|
|
it('should not retry on non-OutputParserException errors', async () => {
|
|
const error = new Error('Some other error');
|
|
mockStructuredOutputParser.parse.mockRejectedValueOnce(error);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nOutputFixingParser;
|
|
};
|
|
|
|
await expect(response.parse('Invalid JSON string')).rejects.toThrow(error);
|
|
expect(mockStructuredOutputParser.parse.mock.calls).toHaveLength(1);
|
|
});
|
|
|
|
it('should retry on OutputParserException and succeed', async () => {
|
|
const validOutput = { name: 'Bob', age: 28 };
|
|
|
|
mockStructuredOutputParser.parse
|
|
.mockRejectedValueOnce(new OutputParserException('Invalid JSON'))
|
|
.mockResolvedValueOnce(validOutput);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nOutputFixingParser;
|
|
};
|
|
|
|
response.getRetryChain = getMockedRetryChain(JSON.stringify(validOutput));
|
|
|
|
const result = await response.parse('Invalid JSON string');
|
|
|
|
expect(result).toEqual(validOutput);
|
|
expect(mockStructuredOutputParser.parse.mock.calls).toHaveLength(2);
|
|
});
|
|
|
|
it('should handle failed retry attempt', async () => {
|
|
mockStructuredOutputParser.parse
|
|
.mockRejectedValueOnce(new OutputParserException('Invalid JSON'))
|
|
.mockRejectedValueOnce(new Error('Still invalid JSON'));
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nOutputFixingParser;
|
|
};
|
|
|
|
response.getRetryChain = getMockedRetryChain('Still not valid JSON');
|
|
|
|
await expect(response.parse('Invalid JSON string')).rejects.toThrow('Still invalid JSON');
|
|
expect(mockStructuredOutputParser.parse.mock.calls).toHaveLength(2);
|
|
});
|
|
|
|
it('should throw non-OutputParserException errors immediately without retry', async () => {
|
|
const customError = new Error('Database connection error');
|
|
const retryChainSpy = jest.fn();
|
|
|
|
mockStructuredOutputParser.parse.mockRejectedValueOnce(customError);
|
|
|
|
const { response } = (await outputParser.supplyData.call(thisArg, 0)) as {
|
|
response: N8nOutputFixingParser;
|
|
};
|
|
|
|
response.getRetryChain = retryChainSpy;
|
|
|
|
await expect(response.parse('Some input')).rejects.toThrow('Database connection error');
|
|
expect(mockStructuredOutputParser.parse.mock.calls).toHaveLength(1);
|
|
expect(retryChainSpy).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|
|
});
|