mirror of
https://github.com/czlonkowski/n8n-mcp.git
synced 2026-02-06 05:23:08 +00:00
feat: implement comprehensive expression format validation system
- Add universal expression validator with 100% reliable detection - Implement confidence-based scoring for node-specific recommendations - Add resource locator format detection and validation - Fix pattern matching precision (exact/prefix instead of includes) - Add recursion depth protection (MAX_RECURSION_DEPTH = 100) - Validate resource locator modes (id, url, expression, name, list) - Separate universal rules from node-specific intelligence - Add comprehensive test coverage (94%+ statements) - Prevent common AI agent mistakes with expressions Addresses code review feedback with critical fixes and enhancements. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
czlonkowski
148
tests/unit/services/confidence-scorer.test.ts
Normal file
148
tests/unit/services/confidence-scorer.test.ts
Normal file
@@ -0,0 +1,148 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { ConfidenceScorer } from '../../../src/services/confidence-scorer';
|
||||
|
||||
describe('ConfidenceScorer', () => {
|
||||
describe('scoreResourceLocatorRecommendation', () => {
|
||||
it('should give high confidence for exact field matches', () => {
|
||||
const score = ConfidenceScorer.scoreResourceLocatorRecommendation(
|
||||
'owner',
|
||||
'n8n-nodes-base.github',
|
||||
'={{ $json.owner }}'
|
||||
);
|
||||
|
||||
expect(score.value).toBeGreaterThanOrEqual(0.5);
|
||||
expect(score.factors.find(f => f.name === 'exact-field-match')?.matched).toBe(true);
|
||||
});
|
||||
|
||||
it('should give medium confidence for field pattern matches', () => {
|
||||
const score = ConfidenceScorer.scoreResourceLocatorRecommendation(
|
||||
'customerId',
|
||||
'n8n-nodes-base.customApi',
|
||||
'={{ $json.id }}'
|
||||
);
|
||||
|
||||
expect(score.value).toBeGreaterThan(0);
|
||||
expect(score.value).toBeLessThan(0.8);
|
||||
expect(score.factors.find(f => f.name === 'field-pattern')?.matched).toBe(true);
|
||||
});
|
||||
|
||||
it('should give low confidence for unrelated fields', () => {
|
||||
const score = ConfidenceScorer.scoreResourceLocatorRecommendation(
|
||||
'message',
|
||||
'n8n-nodes-base.emailSend',
|
||||
'={{ $json.content }}'
|
||||
);
|
||||
|
||||
expect(score.value).toBeLessThan(0.3);
|
||||
});
|
||||
|
||||
it('should consider value patterns', () => {
|
||||
const score = ConfidenceScorer.scoreResourceLocatorRecommendation(
|
||||
'target',
|
||||
'n8n-nodes-base.httpRequest',
|
||||
'={{ $json.userId }}'
|
||||
);
|
||||
|
||||
const valueFactor = score.factors.find(f => f.name === 'value-pattern');
|
||||
expect(valueFactor?.matched).toBe(true);
|
||||
});
|
||||
|
||||
it('should consider node category', () => {
|
||||
const scoreGitHub = ConfidenceScorer.scoreResourceLocatorRecommendation(
|
||||
'field',
|
||||
'n8n-nodes-base.github',
|
||||
'={{ $json.value }}'
|
||||
);
|
||||
|
||||
const scoreEmail = ConfidenceScorer.scoreResourceLocatorRecommendation(
|
||||
'field',
|
||||
'n8n-nodes-base.emailSend',
|
||||
'={{ $json.value }}'
|
||||
);
|
||||
|
||||
expect(scoreGitHub.value).toBeGreaterThan(scoreEmail.value);
|
||||
});
|
||||
|
||||
it('should handle GitHub repository field with high confidence', () => {
|
||||
const score = ConfidenceScorer.scoreResourceLocatorRecommendation(
|
||||
'repository',
|
||||
'n8n-nodes-base.github',
|
||||
'={{ $vars.GITHUB_REPO }}'
|
||||
);
|
||||
|
||||
expect(score.value).toBeGreaterThanOrEqual(0.5);
|
||||
expect(ConfidenceScorer.getConfidenceLevel(score.value)).not.toBe('very-low');
|
||||
});
|
||||
|
||||
it('should handle Slack channel field with high confidence', () => {
|
||||
const score = ConfidenceScorer.scoreResourceLocatorRecommendation(
|
||||
'channel',
|
||||
'n8n-nodes-base.slack',
|
||||
'={{ $json.channelId }}'
|
||||
);
|
||||
|
||||
expect(score.value).toBeGreaterThanOrEqual(0.5);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getConfidenceLevel', () => {
|
||||
it('should return correct confidence levels', () => {
|
||||
expect(ConfidenceScorer.getConfidenceLevel(0.9)).toBe('high');
|
||||
expect(ConfidenceScorer.getConfidenceLevel(0.8)).toBe('high');
|
||||
expect(ConfidenceScorer.getConfidenceLevel(0.6)).toBe('medium');
|
||||
expect(ConfidenceScorer.getConfidenceLevel(0.5)).toBe('medium');
|
||||
expect(ConfidenceScorer.getConfidenceLevel(0.4)).toBe('low');
|
||||
expect(ConfidenceScorer.getConfidenceLevel(0.3)).toBe('low');
|
||||
expect(ConfidenceScorer.getConfidenceLevel(0.2)).toBe('very-low');
|
||||
expect(ConfidenceScorer.getConfidenceLevel(0)).toBe('very-low');
|
||||
});
|
||||
});
|
||||
|
||||
describe('shouldApplyRecommendation', () => {
|
||||
it('should apply based on threshold', () => {
|
||||
// Strict threshold (0.8)
|
||||
expect(ConfidenceScorer.shouldApplyRecommendation(0.9, 'strict')).toBe(true);
|
||||
expect(ConfidenceScorer.shouldApplyRecommendation(0.7, 'strict')).toBe(false);
|
||||
|
||||
// Normal threshold (0.5)
|
||||
expect(ConfidenceScorer.shouldApplyRecommendation(0.6, 'normal')).toBe(true);
|
||||
expect(ConfidenceScorer.shouldApplyRecommendation(0.4, 'normal')).toBe(false);
|
||||
|
||||
// Relaxed threshold (0.3)
|
||||
expect(ConfidenceScorer.shouldApplyRecommendation(0.4, 'relaxed')).toBe(true);
|
||||
expect(ConfidenceScorer.shouldApplyRecommendation(0.2, 'relaxed')).toBe(false);
|
||||
});
|
||||
|
||||
it('should use normal threshold by default', () => {
|
||||
expect(ConfidenceScorer.shouldApplyRecommendation(0.6)).toBe(true);
|
||||
expect(ConfidenceScorer.shouldApplyRecommendation(0.4)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('confidence factors', () => {
|
||||
it('should include all expected factors', () => {
|
||||
const score = ConfidenceScorer.scoreResourceLocatorRecommendation(
|
||||
'testField',
|
||||
'n8n-nodes-base.testNode',
|
||||
'={{ $json.test }}'
|
||||
);
|
||||
|
||||
expect(score.factors).toHaveLength(4);
|
||||
expect(score.factors.map(f => f.name)).toContain('exact-field-match');
|
||||
expect(score.factors.map(f => f.name)).toContain('field-pattern');
|
||||
expect(score.factors.map(f => f.name)).toContain('value-pattern');
|
||||
expect(score.factors.map(f => f.name)).toContain('node-category');
|
||||
});
|
||||
|
||||
it('should have reasonable weights', () => {
|
||||
const score = ConfidenceScorer.scoreResourceLocatorRecommendation(
|
||||
'testField',
|
||||
'n8n-nodes-base.testNode',
|
||||
'={{ $json.test }}'
|
||||
);
|
||||
|
||||
const totalWeight = score.factors.reduce((sum, f) => sum + f.weight, 0);
|
||||
expect(totalWeight).toBeCloseTo(1.0, 1);
|
||||
});
|
||||
});
|
||||
});
|
||||
364
tests/unit/services/expression-format-validator.test.ts
Normal file
364
tests/unit/services/expression-format-validator.test.ts
Normal file
@@ -0,0 +1,364 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { ExpressionFormatValidator } from '../../../src/services/expression-format-validator';
|
||||
|
||||
describe('ExpressionFormatValidator', () => {
|
||||
describe('validateAndFix', () => {
|
||||
const context = {
|
||||
nodeType: 'n8n-nodes-base.httpRequest',
|
||||
nodeName: 'HTTP Request',
|
||||
nodeId: 'test-id-1'
|
||||
};
|
||||
|
||||
describe('Simple string expressions', () => {
|
||||
it('should detect missing = prefix for expression', () => {
|
||||
const value = '{{ $env.API_KEY }}';
|
||||
const issue = ExpressionFormatValidator.validateAndFix(value, 'apiKey', context);
|
||||
|
||||
expect(issue).toBeTruthy();
|
||||
expect(issue?.issueType).toBe('missing-prefix');
|
||||
expect(issue?.correctedValue).toBe('={{ $env.API_KEY }}');
|
||||
expect(issue?.severity).toBe('error');
|
||||
});
|
||||
|
||||
it('should accept expression with = prefix', () => {
|
||||
const value = '={{ $env.API_KEY }}';
|
||||
const issue = ExpressionFormatValidator.validateAndFix(value, 'apiKey', context);
|
||||
|
||||
expect(issue).toBeNull();
|
||||
});
|
||||
|
||||
it('should detect mixed content without prefix', () => {
|
||||
const value = 'Bearer {{ $env.TOKEN }}';
|
||||
const issue = ExpressionFormatValidator.validateAndFix(value, 'authorization', context);
|
||||
|
||||
expect(issue).toBeTruthy();
|
||||
expect(issue?.issueType).toBe('missing-prefix');
|
||||
expect(issue?.correctedValue).toBe('=Bearer {{ $env.TOKEN }}');
|
||||
});
|
||||
|
||||
it('should accept mixed content with prefix', () => {
|
||||
const value = '=Bearer {{ $env.TOKEN }}';
|
||||
const issue = ExpressionFormatValidator.validateAndFix(value, 'authorization', context);
|
||||
|
||||
expect(issue).toBeNull();
|
||||
});
|
||||
|
||||
it('should ignore plain strings without expressions', () => {
|
||||
const value = 'https://api.example.com';
|
||||
const issue = ExpressionFormatValidator.validateAndFix(value, 'url', context);
|
||||
|
||||
expect(issue).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Resource Locator fields', () => {
|
||||
const githubContext = {
|
||||
nodeType: 'n8n-nodes-base.github',
|
||||
nodeName: 'GitHub',
|
||||
nodeId: 'github-1'
|
||||
};
|
||||
|
||||
it('should detect expression in owner field needing resource locator', () => {
|
||||
const value = '{{ $vars.GITHUB_OWNER }}';
|
||||
const issue = ExpressionFormatValidator.validateAndFix(value, 'owner', githubContext);
|
||||
|
||||
expect(issue).toBeTruthy();
|
||||
expect(issue?.issueType).toBe('needs-resource-locator');
|
||||
expect(issue?.correctedValue).toEqual({
|
||||
__rl: true,
|
||||
value: '={{ $vars.GITHUB_OWNER }}',
|
||||
mode: 'expression'
|
||||
});
|
||||
expect(issue?.severity).toBe('error');
|
||||
});
|
||||
|
||||
it('should accept resource locator with expression', () => {
|
||||
const value = {
|
||||
__rl: true,
|
||||
value: '={{ $vars.GITHUB_OWNER }}',
|
||||
mode: 'expression'
|
||||
};
|
||||
const issue = ExpressionFormatValidator.validateAndFix(value, 'owner', githubContext);
|
||||
|
||||
expect(issue).toBeNull();
|
||||
});
|
||||
|
||||
it('should detect missing prefix in resource locator value', () => {
|
||||
const value = {
|
||||
__rl: true,
|
||||
value: '{{ $vars.GITHUB_OWNER }}',
|
||||
mode: 'expression'
|
||||
};
|
||||
const issue = ExpressionFormatValidator.validateAndFix(value, 'owner', githubContext);
|
||||
|
||||
expect(issue).toBeTruthy();
|
||||
expect(issue?.issueType).toBe('missing-prefix');
|
||||
expect(issue?.correctedValue.value).toBe('={{ $vars.GITHUB_OWNER }}');
|
||||
});
|
||||
|
||||
it('should warn if expression has prefix but should use RL format', () => {
|
||||
const value = '={{ $vars.GITHUB_OWNER }}';
|
||||
const issue = ExpressionFormatValidator.validateAndFix(value, 'owner', githubContext);
|
||||
|
||||
expect(issue).toBeTruthy();
|
||||
expect(issue?.issueType).toBe('needs-resource-locator');
|
||||
expect(issue?.severity).toBe('warning');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Multiple expressions', () => {
|
||||
it('should detect multiple expressions without prefix', () => {
|
||||
const value = '{{ $json.first }} - {{ $json.last }}';
|
||||
const issue = ExpressionFormatValidator.validateAndFix(value, 'fullName', context);
|
||||
|
||||
expect(issue).toBeTruthy();
|
||||
expect(issue?.issueType).toBe('missing-prefix');
|
||||
expect(issue?.correctedValue).toBe('={{ $json.first }} - {{ $json.last }}');
|
||||
});
|
||||
|
||||
it('should accept multiple expressions with prefix', () => {
|
||||
const value = '={{ $json.first }} - {{ $json.last }}';
|
||||
const issue = ExpressionFormatValidator.validateAndFix(value, 'fullName', context);
|
||||
|
||||
expect(issue).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Edge cases', () => {
|
||||
it('should handle null values', () => {
|
||||
const issue = ExpressionFormatValidator.validateAndFix(null, 'field', context);
|
||||
expect(issue).toBeNull();
|
||||
});
|
||||
|
||||
it('should handle undefined values', () => {
|
||||
const issue = ExpressionFormatValidator.validateAndFix(undefined, 'field', context);
|
||||
expect(issue).toBeNull();
|
||||
});
|
||||
|
||||
it('should handle empty strings', () => {
|
||||
const issue = ExpressionFormatValidator.validateAndFix('', 'field', context);
|
||||
expect(issue).toBeNull();
|
||||
});
|
||||
|
||||
it('should handle numbers', () => {
|
||||
const issue = ExpressionFormatValidator.validateAndFix(42, 'field', context);
|
||||
expect(issue).toBeNull();
|
||||
});
|
||||
|
||||
it('should handle booleans', () => {
|
||||
const issue = ExpressionFormatValidator.validateAndFix(true, 'field', context);
|
||||
expect(issue).toBeNull();
|
||||
});
|
||||
|
||||
it('should handle arrays', () => {
|
||||
const issue = ExpressionFormatValidator.validateAndFix(['item1', 'item2'], 'field', context);
|
||||
expect(issue).toBeNull();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('validateNodeParameters', () => {
|
||||
const context = {
|
||||
nodeType: 'n8n-nodes-base.emailSend',
|
||||
nodeName: 'Send Email',
|
||||
nodeId: 'email-1'
|
||||
};
|
||||
|
||||
it('should validate all parameters recursively', () => {
|
||||
const parameters = {
|
||||
fromEmail: '{{ $env.SENDER_EMAIL }}',
|
||||
toEmail: 'user@example.com',
|
||||
subject: 'Test {{ $json.type }}',
|
||||
body: {
|
||||
html: '<p>Hello {{ $json.name }}</p>',
|
||||
text: 'Hello {{ $json.name }}'
|
||||
},
|
||||
options: {
|
||||
replyTo: '={{ $env.REPLY_EMAIL }}'
|
||||
}
|
||||
};
|
||||
|
||||
const issues = ExpressionFormatValidator.validateNodeParameters(parameters, context);
|
||||
|
||||
expect(issues).toHaveLength(4);
|
||||
expect(issues.map(i => i.fieldPath)).toContain('fromEmail');
|
||||
expect(issues.map(i => i.fieldPath)).toContain('subject');
|
||||
expect(issues.map(i => i.fieldPath)).toContain('body.html');
|
||||
expect(issues.map(i => i.fieldPath)).toContain('body.text');
|
||||
});
|
||||
|
||||
it('should handle arrays with expressions', () => {
|
||||
const parameters = {
|
||||
recipients: [
|
||||
'{{ $json.email1 }}',
|
||||
'static@example.com',
|
||||
'={{ $json.email2 }}'
|
||||
]
|
||||
};
|
||||
|
||||
const issues = ExpressionFormatValidator.validateNodeParameters(parameters, context);
|
||||
|
||||
expect(issues).toHaveLength(1);
|
||||
expect(issues[0].fieldPath).toBe('recipients[0]');
|
||||
expect(issues[0].correctedValue).toBe('={{ $json.email1 }}');
|
||||
});
|
||||
|
||||
it('should handle nested objects', () => {
|
||||
const parameters = {
|
||||
config: {
|
||||
database: {
|
||||
host: '{{ $env.DB_HOST }}',
|
||||
port: 5432,
|
||||
name: 'mydb'
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const issues = ExpressionFormatValidator.validateNodeParameters(parameters, context);
|
||||
|
||||
expect(issues).toHaveLength(1);
|
||||
expect(issues[0].fieldPath).toBe('config.database.host');
|
||||
});
|
||||
|
||||
it('should skip circular references', () => {
|
||||
const circular: any = { a: 1 };
|
||||
circular.self = circular;
|
||||
|
||||
const parameters = {
|
||||
normal: '{{ $json.value }}',
|
||||
circular
|
||||
};
|
||||
|
||||
const issues = ExpressionFormatValidator.validateNodeParameters(parameters, context);
|
||||
|
||||
// Should only find the issue in 'normal', not crash on circular
|
||||
expect(issues).toHaveLength(1);
|
||||
expect(issues[0].fieldPath).toBe('normal');
|
||||
});
|
||||
|
||||
it('should handle maximum recursion depth', () => {
|
||||
// Create a deeply nested object (105 levels deep, exceeding the limit of 100)
|
||||
let deepObject: any = { value: '{{ $json.data }}' };
|
||||
let current = deepObject;
|
||||
for (let i = 0; i < 105; i++) {
|
||||
current.nested = { value: `{{ $json.level${i} }}` };
|
||||
current = current.nested;
|
||||
}
|
||||
|
||||
const parameters = {
|
||||
deep: deepObject
|
||||
};
|
||||
|
||||
const issues = ExpressionFormatValidator.validateNodeParameters(parameters, context);
|
||||
|
||||
// Should find expression format issues up to the depth limit
|
||||
const depthWarning = issues.find(i => i.explanation.includes('Maximum recursion depth'));
|
||||
expect(depthWarning).toBeTruthy();
|
||||
expect(depthWarning?.severity).toBe('warning');
|
||||
|
||||
// Should still find some expression format errors before hitting the limit
|
||||
const formatErrors = issues.filter(i => i.issueType === 'missing-prefix');
|
||||
expect(formatErrors.length).toBeGreaterThan(0);
|
||||
expect(formatErrors.length).toBeLessThanOrEqual(100); // Should not exceed the depth limit
|
||||
});
|
||||
});
|
||||
|
||||
describe('formatErrorMessage', () => {
|
||||
const context = {
|
||||
nodeType: 'n8n-nodes-base.github',
|
||||
nodeName: 'Create Issue',
|
||||
nodeId: 'github-1'
|
||||
};
|
||||
|
||||
it('should format error message for missing prefix', () => {
|
||||
const issue = {
|
||||
fieldPath: 'title',
|
||||
currentValue: '{{ $json.title }}',
|
||||
correctedValue: '={{ $json.title }}',
|
||||
issueType: 'missing-prefix' as const,
|
||||
explanation: "Expression missing required '=' prefix.",
|
||||
severity: 'error' as const
|
||||
};
|
||||
|
||||
const message = ExpressionFormatValidator.formatErrorMessage(issue, context);
|
||||
|
||||
expect(message).toContain("Expression format error in node 'Create Issue'");
|
||||
expect(message).toContain('Field \'title\'');
|
||||
expect(message).toContain('Current (incorrect):');
|
||||
expect(message).toContain('"title": "{{ $json.title }}"');
|
||||
expect(message).toContain('Fixed (correct):');
|
||||
expect(message).toContain('"title": "={{ $json.title }}"');
|
||||
});
|
||||
|
||||
it('should format error message for resource locator', () => {
|
||||
const issue = {
|
||||
fieldPath: 'owner',
|
||||
currentValue: '{{ $vars.OWNER }}',
|
||||
correctedValue: {
|
||||
__rl: true,
|
||||
value: '={{ $vars.OWNER }}',
|
||||
mode: 'expression'
|
||||
},
|
||||
issueType: 'needs-resource-locator' as const,
|
||||
explanation: 'Field needs resource locator format.',
|
||||
severity: 'error' as const
|
||||
};
|
||||
|
||||
const message = ExpressionFormatValidator.formatErrorMessage(issue, context);
|
||||
|
||||
expect(message).toContain("Expression format error in node 'Create Issue'");
|
||||
expect(message).toContain('Current (incorrect):');
|
||||
expect(message).toContain('"owner": "{{ $vars.OWNER }}"');
|
||||
expect(message).toContain('Fixed (correct):');
|
||||
expect(message).toContain('"__rl": true');
|
||||
expect(message).toContain('"value": "={{ $vars.OWNER }}"');
|
||||
expect(message).toContain('"mode": "expression"');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Real-world examples', () => {
|
||||
it('should validate Email Send node example', () => {
|
||||
const context = {
|
||||
nodeType: 'n8n-nodes-base.emailSend',
|
||||
nodeName: 'Error Handler',
|
||||
nodeId: 'b9dd1cfd-ee66-4049-97e7-1af6d976a4e0'
|
||||
};
|
||||
|
||||
const parameters = {
|
||||
fromEmail: '{{ $env.ADMIN_EMAIL }}',
|
||||
toEmail: 'admin@company.com',
|
||||
subject: 'GitHub Issue Workflow Error - HIGH PRIORITY',
|
||||
options: {}
|
||||
};
|
||||
|
||||
const issues = ExpressionFormatValidator.validateNodeParameters(parameters, context);
|
||||
|
||||
expect(issues).toHaveLength(1);
|
||||
expect(issues[0].fieldPath).toBe('fromEmail');
|
||||
expect(issues[0].correctedValue).toBe('={{ $env.ADMIN_EMAIL }}');
|
||||
});
|
||||
|
||||
it('should validate GitHub node example', () => {
|
||||
const context = {
|
||||
nodeType: 'n8n-nodes-base.github',
|
||||
nodeName: 'Send Welcome Comment',
|
||||
nodeId: '3c742ca1-af8f-4d80-a47e-e68fb1ced491'
|
||||
};
|
||||
|
||||
const parameters = {
|
||||
operation: 'createComment',
|
||||
owner: '{{ $vars.GITHUB_OWNER }}',
|
||||
repository: '{{ $vars.GITHUB_REPO }}',
|
||||
issueNumber: null,
|
||||
body: '👋 Hi @{{ $(\'Extract Issue Data\').first().json.author }}!\n\nThank you for creating this issue.'
|
||||
};
|
||||
|
||||
const issues = ExpressionFormatValidator.validateNodeParameters(parameters, context);
|
||||
|
||||
expect(issues.length).toBeGreaterThan(0);
|
||||
expect(issues.some(i => i.fieldPath === 'owner')).toBe(true);
|
||||
expect(issues.some(i => i.fieldPath === 'repository')).toBe(true);
|
||||
expect(issues.some(i => i.fieldPath === 'body')).toBe(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
217
tests/unit/services/universal-expression-validator.test.ts
Normal file
217
tests/unit/services/universal-expression-validator.test.ts
Normal file
@@ -0,0 +1,217 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { UniversalExpressionValidator } from '../../../src/services/universal-expression-validator';
|
||||
|
||||
describe('UniversalExpressionValidator', () => {
|
||||
describe('validateExpressionPrefix', () => {
|
||||
it('should detect missing prefix in pure expression', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionPrefix('{{ $json.value }}');
|
||||
|
||||
expect(result.isValid).toBe(false);
|
||||
expect(result.hasExpression).toBe(true);
|
||||
expect(result.needsPrefix).toBe(true);
|
||||
expect(result.isMixedContent).toBe(false);
|
||||
expect(result.confidence).toBe(1.0);
|
||||
expect(result.suggestion).toBe('={{ $json.value }}');
|
||||
});
|
||||
|
||||
it('should detect missing prefix in mixed content', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionPrefix(
|
||||
'Hello {{ $json.name }}'
|
||||
);
|
||||
|
||||
expect(result.isValid).toBe(false);
|
||||
expect(result.hasExpression).toBe(true);
|
||||
expect(result.needsPrefix).toBe(true);
|
||||
expect(result.isMixedContent).toBe(true);
|
||||
expect(result.confidence).toBe(1.0);
|
||||
expect(result.suggestion).toBe('=Hello {{ $json.name }}');
|
||||
});
|
||||
|
||||
it('should accept properly prefixed expression', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionPrefix('={{ $json.value }}');
|
||||
|
||||
expect(result.isValid).toBe(true);
|
||||
expect(result.hasExpression).toBe(true);
|
||||
expect(result.needsPrefix).toBe(false);
|
||||
expect(result.confidence).toBe(1.0);
|
||||
});
|
||||
|
||||
it('should accept properly prefixed mixed content', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionPrefix(
|
||||
'=Hello {{ $json.name }}!'
|
||||
);
|
||||
|
||||
expect(result.isValid).toBe(true);
|
||||
expect(result.hasExpression).toBe(true);
|
||||
expect(result.isMixedContent).toBe(true);
|
||||
expect(result.confidence).toBe(1.0);
|
||||
});
|
||||
|
||||
it('should ignore non-string values', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionPrefix(123);
|
||||
|
||||
expect(result.isValid).toBe(true);
|
||||
expect(result.hasExpression).toBe(false);
|
||||
expect(result.confidence).toBe(1.0);
|
||||
});
|
||||
|
||||
it('should ignore strings without expressions', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionPrefix('plain text');
|
||||
|
||||
expect(result.isValid).toBe(true);
|
||||
expect(result.hasExpression).toBe(false);
|
||||
expect(result.confidence).toBe(1.0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('validateExpressionSyntax', () => {
|
||||
it('should detect unclosed brackets', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionSyntax('={{ $json.value }');
|
||||
|
||||
expect(result.isValid).toBe(false);
|
||||
expect(result.explanation).toContain('Unmatched expression brackets');
|
||||
});
|
||||
|
||||
it('should detect empty expressions', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionSyntax('={{ }}');
|
||||
|
||||
expect(result.isValid).toBe(false);
|
||||
expect(result.explanation).toContain('Empty expression');
|
||||
});
|
||||
|
||||
it('should accept valid syntax', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionSyntax('={{ $json.value }}');
|
||||
|
||||
expect(result.isValid).toBe(true);
|
||||
expect(result.hasExpression).toBe(true);
|
||||
});
|
||||
|
||||
it('should handle multiple expressions', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionSyntax(
|
||||
'={{ $json.first }} and {{ $json.second }}'
|
||||
);
|
||||
|
||||
expect(result.isValid).toBe(true);
|
||||
expect(result.hasExpression).toBe(true);
|
||||
expect(result.isMixedContent).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('validateCommonPatterns', () => {
|
||||
it('should detect template literal syntax', () => {
|
||||
const result = UniversalExpressionValidator.validateCommonPatterns('={{ ${json.value} }}');
|
||||
|
||||
expect(result.isValid).toBe(false);
|
||||
expect(result.explanation).toContain('Template literal syntax');
|
||||
});
|
||||
|
||||
it('should detect double prefix', () => {
|
||||
const result = UniversalExpressionValidator.validateCommonPatterns('={{ =$json.value }}');
|
||||
|
||||
expect(result.isValid).toBe(false);
|
||||
expect(result.explanation).toContain('Double prefix');
|
||||
});
|
||||
|
||||
it('should detect nested brackets', () => {
|
||||
const result = UniversalExpressionValidator.validateCommonPatterns(
|
||||
'={{ $json.items[{{ $json.index }}] }}'
|
||||
);
|
||||
|
||||
expect(result.isValid).toBe(false);
|
||||
expect(result.explanation).toContain('Nested brackets');
|
||||
});
|
||||
|
||||
it('should accept valid patterns', () => {
|
||||
const result = UniversalExpressionValidator.validateCommonPatterns(
|
||||
'={{ $json.items[$json.index] }}'
|
||||
);
|
||||
|
||||
expect(result.isValid).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('validate (comprehensive)', () => {
|
||||
it('should return all validation issues', () => {
|
||||
const results = UniversalExpressionValidator.validate('{{ ${json.value} }}');
|
||||
|
||||
expect(results.length).toBeGreaterThan(0);
|
||||
const issues = results.filter(r => !r.isValid);
|
||||
expect(issues.length).toBeGreaterThan(0);
|
||||
|
||||
// Should detect both missing prefix and template literal syntax
|
||||
const prefixIssue = issues.find(i => i.needsPrefix);
|
||||
const patternIssue = issues.find(i => i.explanation.includes('Template literal'));
|
||||
|
||||
expect(prefixIssue).toBeTruthy();
|
||||
expect(patternIssue).toBeTruthy();
|
||||
});
|
||||
|
||||
it('should return success for valid expression', () => {
|
||||
const results = UniversalExpressionValidator.validate('={{ $json.value }}');
|
||||
|
||||
expect(results).toHaveLength(1);
|
||||
expect(results[0].isValid).toBe(true);
|
||||
expect(results[0].confidence).toBe(1.0);
|
||||
});
|
||||
|
||||
it('should handle non-expression strings', () => {
|
||||
const results = UniversalExpressionValidator.validate('plain text');
|
||||
|
||||
expect(results).toHaveLength(1);
|
||||
expect(results[0].isValid).toBe(true);
|
||||
expect(results[0].hasExpression).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getCorrectedValue', () => {
|
||||
it('should add prefix to expression', () => {
|
||||
const corrected = UniversalExpressionValidator.getCorrectedValue('{{ $json.value }}');
|
||||
expect(corrected).toBe('={{ $json.value }}');
|
||||
});
|
||||
|
||||
it('should add prefix to mixed content', () => {
|
||||
const corrected = UniversalExpressionValidator.getCorrectedValue(
|
||||
'Hello {{ $json.name }}'
|
||||
);
|
||||
expect(corrected).toBe('=Hello {{ $json.name }}');
|
||||
});
|
||||
|
||||
it('should not modify already prefixed expressions', () => {
|
||||
const corrected = UniversalExpressionValidator.getCorrectedValue('={{ $json.value }}');
|
||||
expect(corrected).toBe('={{ $json.value }}');
|
||||
});
|
||||
|
||||
it('should not modify non-expressions', () => {
|
||||
const corrected = UniversalExpressionValidator.getCorrectedValue('plain text');
|
||||
expect(corrected).toBe('plain text');
|
||||
});
|
||||
});
|
||||
|
||||
describe('hasMixedContent', () => {
|
||||
it('should detect URLs with expressions', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionPrefix(
|
||||
'https://api.example.com/users/{{ $json.id }}'
|
||||
);
|
||||
expect(result.isMixedContent).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect text with expressions', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionPrefix(
|
||||
'Welcome {{ $json.name }} to our service'
|
||||
);
|
||||
expect(result.isMixedContent).toBe(true);
|
||||
});
|
||||
|
||||
it('should identify pure expressions', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionPrefix('{{ $json.value }}');
|
||||
expect(result.isMixedContent).toBe(false);
|
||||
});
|
||||
|
||||
it('should identify pure expressions with spaces', () => {
|
||||
const result = UniversalExpressionValidator.validateExpressionPrefix(
|
||||
' {{ $json.value }} '
|
||||
);
|
||||
expect(result.isMixedContent).toBe(false);
|
||||
});
|
||||
});
|
||||
});
|
||||
488
tests/unit/services/workflow-validator-expression-format.test.ts
Normal file
488
tests/unit/services/workflow-validator-expression-format.test.ts
Normal file
@@ -0,0 +1,488 @@
|
||||
import { describe, it, expect, beforeEach, vi } from 'vitest';
|
||||
import { WorkflowValidator } from '../../../src/services/workflow-validator';
|
||||
import { NodeRepository } from '../../../src/database/node-repository';
|
||||
import { EnhancedConfigValidator } from '../../../src/services/enhanced-config-validator';
|
||||
|
||||
// Mock the database
|
||||
vi.mock('../../../src/database/node-repository');
|
||||
|
||||
describe('WorkflowValidator - Expression Format Validation', () => {
|
||||
let validator: WorkflowValidator;
|
||||
let mockNodeRepository: any;
|
||||
|
||||
beforeEach(() => {
|
||||
// Create mock repository
|
||||
mockNodeRepository = {
|
||||
findNodeByType: vi.fn().mockImplementation((type: string) => {
|
||||
// Return mock nodes for common types
|
||||
if (type === 'n8n-nodes-base.emailSend') {
|
||||
return {
|
||||
node_type: 'n8n-nodes-base.emailSend',
|
||||
display_name: 'Email Send',
|
||||
properties: {},
|
||||
version: 2.1
|
||||
};
|
||||
}
|
||||
if (type === 'n8n-nodes-base.github') {
|
||||
return {
|
||||
node_type: 'n8n-nodes-base.github',
|
||||
display_name: 'GitHub',
|
||||
properties: {},
|
||||
version: 1.1
|
||||
};
|
||||
}
|
||||
if (type === 'n8n-nodes-base.webhook') {
|
||||
return {
|
||||
node_type: 'n8n-nodes-base.webhook',
|
||||
display_name: 'Webhook',
|
||||
properties: {},
|
||||
version: 1
|
||||
};
|
||||
}
|
||||
if (type === 'n8n-nodes-base.httpRequest') {
|
||||
return {
|
||||
node_type: 'n8n-nodes-base.httpRequest',
|
||||
display_name: 'HTTP Request',
|
||||
properties: {},
|
||||
version: 4
|
||||
};
|
||||
}
|
||||
return null;
|
||||
}),
|
||||
searchNodes: vi.fn().mockReturnValue([]),
|
||||
getAllNodes: vi.fn().mockReturnValue([]),
|
||||
close: vi.fn()
|
||||
};
|
||||
|
||||
validator = new WorkflowValidator(mockNodeRepository, EnhancedConfigValidator);
|
||||
});
|
||||
|
||||
describe('Expression Format Detection', () => {
|
||||
it('should detect missing = prefix in simple expressions', async () => {
|
||||
const workflow = {
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'Send Email',
|
||||
type: 'n8n-nodes-base.emailSend',
|
||||
position: [0, 0] as [number, number],
|
||||
parameters: {
|
||||
fromEmail: '{{ $env.SENDER_EMAIL }}',
|
||||
toEmail: 'user@example.com',
|
||||
subject: 'Test Email'
|
||||
},
|
||||
typeVersion: 2.1
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const result = await validator.validateWorkflow(workflow);
|
||||
|
||||
expect(result.valid).toBe(false);
|
||||
|
||||
// Find expression format errors
|
||||
const formatErrors = result.errors.filter(e => e.message.includes('Expression format error'));
|
||||
expect(formatErrors).toHaveLength(1);
|
||||
|
||||
const error = formatErrors[0];
|
||||
expect(error.message).toContain('Expression format error');
|
||||
expect(error.message).toContain('fromEmail');
|
||||
expect(error.message).toContain('{{ $env.SENDER_EMAIL }}');
|
||||
expect(error.message).toContain('={{ $env.SENDER_EMAIL }}');
|
||||
});
|
||||
|
||||
it('should detect missing resource locator format for GitHub fields', async () => {
|
||||
const workflow = {
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'GitHub',
|
||||
type: 'n8n-nodes-base.github',
|
||||
position: [0, 0] as [number, number],
|
||||
parameters: {
|
||||
operation: 'createComment',
|
||||
owner: '{{ $vars.GITHUB_OWNER }}',
|
||||
repository: '{{ $vars.GITHUB_REPO }}',
|
||||
issueNumber: 123,
|
||||
body: 'Test comment'
|
||||
},
|
||||
typeVersion: 1.1
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const result = await validator.validateWorkflow(workflow);
|
||||
|
||||
expect(result.valid).toBe(false);
|
||||
// Should have errors for both owner and repository
|
||||
const ownerError = result.errors.find(e => e.message.includes('owner'));
|
||||
const repoError = result.errors.find(e => e.message.includes('repository'));
|
||||
|
||||
expect(ownerError).toBeTruthy();
|
||||
expect(repoError).toBeTruthy();
|
||||
expect(ownerError?.message).toContain('resource locator format');
|
||||
expect(ownerError?.message).toContain('__rl');
|
||||
});
|
||||
|
||||
it('should detect mixed content without prefix', async () => {
|
||||
const workflow = {
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'HTTP Request',
|
||||
type: 'n8n-nodes-base.httpRequest',
|
||||
position: [0, 0] as [number, number],
|
||||
parameters: {
|
||||
url: 'https://api.example.com/{{ $json.endpoint }}',
|
||||
headers: {
|
||||
Authorization: 'Bearer {{ $env.API_TOKEN }}'
|
||||
}
|
||||
},
|
||||
typeVersion: 4
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const result = await validator.validateWorkflow(workflow);
|
||||
|
||||
expect(result.valid).toBe(false);
|
||||
const errors = result.errors.filter(e => e.message.includes('Expression format'));
|
||||
expect(errors.length).toBeGreaterThan(0);
|
||||
|
||||
// Check for URL error
|
||||
const urlError = errors.find(e => e.message.includes('url'));
|
||||
expect(urlError).toBeTruthy();
|
||||
expect(urlError?.message).toContain('=https://api.example.com/{{ $json.endpoint }}');
|
||||
});
|
||||
|
||||
it('should accept properly formatted expressions', async () => {
|
||||
const workflow = {
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'Send Email',
|
||||
type: 'n8n-nodes-base.emailSend',
|
||||
position: [0, 0] as [number, number],
|
||||
parameters: {
|
||||
fromEmail: '={{ $env.SENDER_EMAIL }}',
|
||||
toEmail: 'user@example.com',
|
||||
subject: '=Test {{ $json.type }}'
|
||||
},
|
||||
typeVersion: 2.1
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const result = await validator.validateWorkflow(workflow);
|
||||
|
||||
// Should have no expression format errors
|
||||
const formatErrors = result.errors.filter(e => e.message.includes('Expression format'));
|
||||
expect(formatErrors).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('should accept resource locator format', async () => {
|
||||
const workflow = {
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'GitHub',
|
||||
type: 'n8n-nodes-base.github',
|
||||
position: [0, 0] as [number, number],
|
||||
parameters: {
|
||||
operation: 'createComment',
|
||||
owner: {
|
||||
__rl: true,
|
||||
value: '={{ $vars.GITHUB_OWNER }}',
|
||||
mode: 'expression'
|
||||
},
|
||||
repository: {
|
||||
__rl: true,
|
||||
value: '={{ $vars.GITHUB_REPO }}',
|
||||
mode: 'expression'
|
||||
},
|
||||
issueNumber: 123,
|
||||
body: '=Test comment from {{ $json.author }}'
|
||||
},
|
||||
typeVersion: 1.1
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const result = await validator.validateWorkflow(workflow);
|
||||
|
||||
// Should have no expression format errors
|
||||
const formatErrors = result.errors.filter(e => e.message.includes('Expression format'));
|
||||
expect(formatErrors).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('should validate nested expressions in complex parameters', async () => {
|
||||
const workflow = {
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'HTTP Request',
|
||||
type: 'n8n-nodes-base.httpRequest',
|
||||
position: [0, 0] as [number, number],
|
||||
parameters: {
|
||||
method: 'POST',
|
||||
url: 'https://api.example.com',
|
||||
sendBody: true,
|
||||
bodyParameters: {
|
||||
parameters: [
|
||||
{
|
||||
name: 'userId',
|
||||
value: '{{ $json.id }}'
|
||||
},
|
||||
{
|
||||
name: 'timestamp',
|
||||
value: '={{ $now }}'
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
typeVersion: 4
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const result = await validator.validateWorkflow(workflow);
|
||||
|
||||
// Should detect the missing prefix in nested parameter
|
||||
const errors = result.errors.filter(e => e.message.includes('Expression format'));
|
||||
expect(errors.length).toBeGreaterThan(0);
|
||||
|
||||
const nestedError = errors.find(e => e.message.includes('bodyParameters'));
|
||||
expect(nestedError).toBeTruthy();
|
||||
});
|
||||
|
||||
it('should warn about RL format even with prefix', async () => {
|
||||
const workflow = {
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'GitHub',
|
||||
type: 'n8n-nodes-base.github',
|
||||
position: [0, 0] as [number, number],
|
||||
parameters: {
|
||||
operation: 'createComment',
|
||||
owner: '={{ $vars.GITHUB_OWNER }}',
|
||||
repository: '={{ $vars.GITHUB_REPO }}',
|
||||
issueNumber: 123,
|
||||
body: 'Test'
|
||||
},
|
||||
typeVersion: 1.1
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const result = await validator.validateWorkflow(workflow);
|
||||
|
||||
// Should have warnings about using RL format
|
||||
const warnings = result.warnings.filter(w => w.message.includes('resource locator format'));
|
||||
expect(warnings.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Real-world workflow examples', () => {
|
||||
it('should validate Email workflow with expression issues', async () => {
|
||||
const workflow = {
|
||||
name: 'Error Notification Workflow',
|
||||
nodes: [
|
||||
{
|
||||
id: 'webhook-1',
|
||||
name: 'Webhook',
|
||||
type: 'n8n-nodes-base.webhook',
|
||||
position: [250, 300] as [number, number],
|
||||
parameters: {
|
||||
path: 'error-handler',
|
||||
httpMethod: 'POST'
|
||||
},
|
||||
typeVersion: 1
|
||||
},
|
||||
{
|
||||
id: 'email-1',
|
||||
name: 'Error Handler',
|
||||
type: 'n8n-nodes-base.emailSend',
|
||||
position: [450, 300] as [number, number],
|
||||
parameters: {
|
||||
fromEmail: '{{ $env.ADMIN_EMAIL }}',
|
||||
toEmail: 'admin@company.com',
|
||||
subject: 'Error in {{ $json.workflow }}',
|
||||
message: 'An error occurred: {{ $json.error }}',
|
||||
options: {
|
||||
replyTo: '={{ $env.SUPPORT_EMAIL }}'
|
||||
}
|
||||
},
|
||||
typeVersion: 2.1
|
||||
}
|
||||
],
|
||||
connections: {
|
||||
'Webhook': {
|
||||
main: [[{ node: 'Error Handler', type: 'main', index: 0 }]]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const result = await validator.validateWorkflow(workflow);
|
||||
|
||||
// Should have multiple expression format errors
|
||||
const formatErrors = result.errors.filter(e => e.message.includes('Expression format'));
|
||||
expect(formatErrors.length).toBeGreaterThanOrEqual(3); // fromEmail, subject, message
|
||||
|
||||
// Check specific errors
|
||||
const fromEmailError = formatErrors.find(e => e.message.includes('fromEmail'));
|
||||
expect(fromEmailError).toBeTruthy();
|
||||
expect(fromEmailError?.message).toContain('={{ $env.ADMIN_EMAIL }}');
|
||||
});
|
||||
|
||||
it('should validate GitHub workflow with resource locator issues', async () => {
|
||||
const workflow = {
|
||||
name: 'GitHub Issue Handler',
|
||||
nodes: [
|
||||
{
|
||||
id: 'webhook-1',
|
||||
name: 'Issue Webhook',
|
||||
type: 'n8n-nodes-base.webhook',
|
||||
position: [250, 300] as [number, number],
|
||||
parameters: {
|
||||
path: 'github-issue',
|
||||
httpMethod: 'POST'
|
||||
},
|
||||
typeVersion: 1
|
||||
},
|
||||
{
|
||||
id: 'github-1',
|
||||
name: 'Create Comment',
|
||||
type: 'n8n-nodes-base.github',
|
||||
position: [450, 300] as [number, number],
|
||||
parameters: {
|
||||
operation: 'createComment',
|
||||
owner: '{{ $vars.GITHUB_OWNER }}',
|
||||
repository: '{{ $vars.GITHUB_REPO }}',
|
||||
issueNumber: '={{ $json.body.issue.number }}',
|
||||
body: 'Thanks for the issue @{{ $json.body.issue.user.login }}!'
|
||||
},
|
||||
typeVersion: 1.1
|
||||
}
|
||||
],
|
||||
connections: {
|
||||
'Issue Webhook': {
|
||||
main: [[{ node: 'Create Comment', type: 'main', index: 0 }]]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const result = await validator.validateWorkflow(workflow);
|
||||
|
||||
// Should have errors for owner, repository, and body
|
||||
const formatErrors = result.errors.filter(e => e.message.includes('Expression format'));
|
||||
expect(formatErrors.length).toBeGreaterThanOrEqual(3);
|
||||
|
||||
// Check for resource locator suggestions
|
||||
const ownerError = formatErrors.find(e => e.message.includes('owner'));
|
||||
expect(ownerError?.message).toContain('__rl');
|
||||
expect(ownerError?.message).toContain('resource locator format');
|
||||
});
|
||||
|
||||
it('should provide clear fix examples in error messages', async () => {
|
||||
const workflow = {
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'Process Data',
|
||||
type: 'n8n-nodes-base.httpRequest',
|
||||
position: [0, 0] as [number, number],
|
||||
parameters: {
|
||||
url: 'https://api.example.com/users/{{ $json.userId }}'
|
||||
},
|
||||
typeVersion: 4
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const result = await validator.validateWorkflow(workflow);
|
||||
|
||||
const error = result.errors.find(e => e.message.includes('Expression format'));
|
||||
expect(error).toBeTruthy();
|
||||
|
||||
// Error message should contain both incorrect and correct examples
|
||||
expect(error?.message).toContain('Current (incorrect):');
|
||||
expect(error?.message).toContain('"url": "https://api.example.com/users/{{ $json.userId }}"');
|
||||
expect(error?.message).toContain('Fixed (correct):');
|
||||
expect(error?.message).toContain('"url": "=https://api.example.com/users/{{ $json.userId }}"');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Integration with other validations', () => {
|
||||
it('should validate expression format alongside syntax', async () => {
|
||||
const workflow = {
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'Test Node',
|
||||
type: 'n8n-nodes-base.httpRequest',
|
||||
position: [0, 0] as [number, number],
|
||||
parameters: {
|
||||
url: '{{ $json.url', // Syntax error: unclosed expression
|
||||
headers: {
|
||||
'X-Token': '{{ $env.TOKEN }}' // Format error: missing prefix
|
||||
}
|
||||
},
|
||||
typeVersion: 4
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const result = await validator.validateWorkflow(workflow);
|
||||
|
||||
// Should have both syntax and format errors
|
||||
const syntaxErrors = result.errors.filter(e => e.message.includes('Unmatched expression brackets'));
|
||||
const formatErrors = result.errors.filter(e => e.message.includes('Expression format'));
|
||||
|
||||
expect(syntaxErrors.length).toBeGreaterThan(0);
|
||||
expect(formatErrors.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('should not interfere with node validation', async () => {
|
||||
// Test that expression format validation works alongside other validations
|
||||
const workflow = {
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'HTTP Request',
|
||||
type: 'n8n-nodes-base.httpRequest',
|
||||
position: [0, 0] as [number, number],
|
||||
parameters: {
|
||||
url: '{{ $json.endpoint }}', // Expression format error
|
||||
headers: {
|
||||
Authorization: '={{ $env.TOKEN }}' // Correct format
|
||||
}
|
||||
},
|
||||
typeVersion: 4
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const result = await validator.validateWorkflow(workflow);
|
||||
|
||||
// Should have expression format error for url field
|
||||
const formatErrors = result.errors.filter(e => e.message.includes('Expression format'));
|
||||
expect(formatErrors).toHaveLength(1);
|
||||
expect(formatErrors[0].message).toContain('url');
|
||||
|
||||
// The workflow should still have structure validation (no trigger warning, etc)
|
||||
// This proves that expression validation doesn't interfere with other checks
|
||||
expect(result.warnings.some(w => w.message.includes('trigger'))).toBe(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user