import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { NodeRepository, CommunityNodeFields } from '@/database/node-repository';
import { DatabaseAdapter, PreparedStatement, RunResult } from '@/database/database-adapter';
import { ParsedNode } from '@/parsers/node-parser';
/**
* Integration tests for the community nodes feature.
*
* These tests verify the end-to-end flow of community node operations
* using a mock database adapter that simulates real database behavior.
*/
// Mock logger
vi.mock('@/utils/logger', () => ({
logger: {
info: vi.fn(),
warn: vi.fn(),
error: vi.fn(),
debug: vi.fn(),
},
}));
/**
* In-memory database adapter for integration testing
*/
class InMemoryDatabaseAdapter implements DatabaseAdapter {
private nodes: Map<string, any> = new Map();
private nodesByNpmPackage: Map<string, any> = new Map();
prepare = vi.fn((sql: string) => new InMemoryPreparedStatement(sql, this));
exec = vi.fn();
close = vi.fn();
pragma = vi.fn();
transaction = vi.fn((fn: () => any) => fn());
checkFTS5Support = vi.fn(() => true);
inTransaction = false;
// Data access methods for the prepared statement
saveNode(node: any): void {
this.nodes.set(node.node_type, node);
if (node.npm_package_name) {
this.nodesByNpmPackage.set(node.npm_package_name, node);
}
}
getNode(nodeType: string): any {
return this.nodes.get(nodeType);
}
getNodeByNpmPackage(npmPackageName: string): any {
return this.nodesByNpmPackage.get(npmPackageName);
}
hasNodeByNpmPackage(npmPackageName: string): boolean {
return this.nodesByNpmPackage.has(npmPackageName);
}
getAllNodes(): any[] {
return Array.from(this.nodes.values());
}
getCommunityNodes(verified?: boolean): any[] {
const nodes = this.getAllNodes().filter((n) => n.is_community === 1);
if (verified !== undefined) {
return nodes.filter((n) => (n.is_verified === 1) === verified);
}
return nodes;
}
deleteCommunityNodes(): number {
const communityNodes = this.getCommunityNodes();
for (const node of communityNodes) {
this.nodes.delete(node.node_type);
if (node.npm_package_name) {
this.nodesByNpmPackage.delete(node.npm_package_name);
}
}
return communityNodes.length;
}
clear(): void {
this.nodes.clear();
this.nodesByNpmPackage.clear();
}
}
class InMemoryPreparedStatement implements PreparedStatement {
run = vi.fn((...params: any[]): RunResult => {
if (this.sql.includes('INSERT OR REPLACE INTO nodes')) {
const node = this.paramsToNode(params);
this.adapter.saveNode(node);
return { changes: 1, lastInsertRowid: 1 };
}
if (this.sql.includes('DELETE FROM nodes WHERE is_community = 1')) {
const deleted = this.adapter.deleteCommunityNodes();
return { changes: deleted, lastInsertRowid: 0 };
}
return { changes: 0, lastInsertRowid: 0 };
});
get = vi.fn((...params: any[]) => {
if (this.sql.includes('SELECT * FROM nodes WHERE node_type = ?')) {
return this.adapter.getNode(params[0]);
}
if (this.sql.includes('SELECT * FROM nodes WHERE npm_package_name = ?')) {
return this.adapter.getNodeByNpmPackage(params[0]);
}
if (this.sql.includes('SELECT 1 FROM nodes WHERE npm_package_name = ?')) {
return this.adapter.hasNodeByNpmPackage(params[0]) ? { '1': 1 } : undefined;
}
if (this.sql.includes('SELECT COUNT(*) as count FROM nodes WHERE is_community = 1') &&
!this.sql.includes('is_verified')) {
return { count: this.adapter.getCommunityNodes().length };
}
if (this.sql.includes('SELECT COUNT(*) as count FROM nodes WHERE is_community = 1 AND is_verified = 1')) {
return { count: this.adapter.getCommunityNodes(true).length };
}
return undefined;
});
all = vi.fn((...params: any[]) => {
if (this.sql.includes('SELECT * FROM nodes WHERE is_community = 1')) {
let nodes = this.adapter.getCommunityNodes();
if (this.sql.includes('AND is_verified = ?')) {
const isVerified = params[0] === 1;
nodes = nodes.filter((n: any) => (n.is_verified === 1) === isVerified);
}
if (this.sql.includes('LIMIT ?')) {
const limit = params[params.length - 1];
nodes = nodes.slice(0, limit);
}
return nodes;
}
if (this.sql.includes('SELECT * FROM nodes ORDER BY display_name')) {
return this.adapter.getAllNodes();
}
return [];
});
iterate = vi.fn();
pluck = vi.fn(() => this);
expand = vi.fn(() => this);
raw = vi.fn(() => this);
columns = vi.fn(() => []);
bind = vi.fn(() => this);
constructor(private sql: string, private adapter: InMemoryDatabaseAdapter) {}
private paramsToNode(params: any[]): any {
return {
node_type: params[0],
package_name: params[1],
display_name: params[2],
description: params[3],
category: params[4],
development_style: params[5],
is_ai_tool: params[6],
is_trigger: params[7],
is_webhook: params[8],
is_versioned: params[9],
is_tool_variant: params[10],
tool_variant_of: params[11],
has_tool_variant: params[12],
version: params[13],
documentation: params[14],
properties_schema: params[15],
operations: params[16],
credentials_required: params[17],
outputs: params[18],
output_names: params[19],
is_community: params[20],
is_verified: params[21],
author_name: params[22],
author_github_url: params[23],
npm_package_name: params[24],
npm_version: params[25],
npm_downloads: params[26],
community_fetched_at: params[27],
};
}
}
describe('Community Nodes Integration', () => {
let adapter: InMemoryDatabaseAdapter;
let repository: NodeRepository;
// Sample nodes for testing
const verifiedCommunityNode: ParsedNode & CommunityNodeFields = {
nodeType: 'n8n-nodes-verified.testNode',
packageName: 'n8n-nodes-verified',
displayName: 'Verified Test Node',
description: 'A verified community node for testing',
category: 'Community',
style: 'declarative',
properties: [{ name: 'url', type: 'string', displayName: 'URL' }],
credentials: [],
operations: [{ name: 'execute', displayName: 'Execute' }],
isAITool: false,
isTrigger: false,
isWebhook: false,
isVersioned: false,
version: '1.0.0',
isCommunity: true,
isVerified: true,
authorName: 'Verified Author',
authorGithubUrl: 'https://github.com/verified',
npmPackageName: 'n8n-nodes-verified',
npmVersion: '1.0.0',
npmDownloads: 5000,
communityFetchedAt: new Date().toISOString(),
};
const unverifiedCommunityNode: ParsedNode & CommunityNodeFields = {
nodeType: 'n8n-nodes-unverified.testNode',
packageName: 'n8n-nodes-unverified',
displayName: 'Unverified Test Node',
description: 'An unverified community node for testing',
category: 'Community',
style: 'declarative',
properties: [],
credentials: [],
operations: [],
isAITool: false,
isTrigger: true,
isWebhook: false,
isVersioned: false,
version: '0.5.0',
isCommunity: true,
isVerified: false,
authorName: 'Community Author',
npmPackageName: 'n8n-nodes-unverified',
npmVersion: '0.5.0',
npmDownloads: 1000,
communityFetchedAt: new Date().toISOString(),
};
const coreNode: ParsedNode = {
nodeType: 'nodes-base.httpRequest',
packageName: 'n8n-nodes-base',
displayName: 'HTTP Request',
description: 'Makes HTTP requests',
category: 'Core',
style: 'declarative',
properties: [{ name: 'url', type: 'string', displayName: 'URL' }],
credentials: [],
operations: [],
isAITool: false,
isTrigger: false,
isWebhook: false,
isVersioned: true,
version: '4.0',
};
beforeEach(() => {
vi.clearAllMocks();
adapter = new InMemoryDatabaseAdapter();
repository = new NodeRepository(adapter);
});
afterEach(() => {
adapter.clear();
});
describe('Full sync workflow', () => {
it('should save and retrieve community nodes correctly', () => {
// Save nodes
repository.saveNode(verifiedCommunityNode);
repository.saveNode(unverifiedCommunityNode);
repository.saveNode(coreNode);
// Verify community nodes
const communityNodes = repository.getCommunityNodes();
expect(communityNodes).toHaveLength(2);
// Verify verified filter
const verifiedNodes = repository.getCommunityNodes({ verified: true });
expect(verifiedNodes).toHaveLength(1);
expect(verifiedNodes[0].displayName).toBe('Verified Test Node');
// Verify unverified filter
const unverifiedNodes = repository.getCommunityNodes({ verified: false });
expect(unverifiedNodes).toHaveLength(1);
expect(unverifiedNodes[0].displayName).toBe('Unverified Test Node');
});
it('should correctly track community stats', () => {
repository.saveNode(verifiedCommunityNode);
repository.saveNode(unverifiedCommunityNode);
repository.saveNode(coreNode);
const stats = repository.getCommunityStats();
expect(stats.total).toBe(2);
expect(stats.verified).toBe(1);
expect(stats.unverified).toBe(1);
});
it('should check npm package existence correctly', () => {
repository.saveNode(verifiedCommunityNode);
expect(repository.hasNodeByNpmPackage('n8n-nodes-verified')).toBe(true);
expect(repository.hasNodeByNpmPackage('n8n-nodes-nonexistent')).toBe(false);
});
it('should delete only community nodes', () => {
repository.saveNode(verifiedCommunityNode);
repository.saveNode(unverifiedCommunityNode);
repository.saveNode(coreNode);
const deleted = repository.deleteCommunityNodes();
expect(deleted).toBe(2);
expect(repository.getCommunityNodes()).toHaveLength(0);
// Core node should still exist
expect(adapter.getNode('nodes-base.httpRequest')).toBeDefined();
});
});
describe('Node update workflow', () => {
it('should update existing community node', () => {
repository.saveNode(verifiedCommunityNode);
// Update the node
const updatedNode = {
...verifiedCommunityNode,
displayName: 'Updated Verified Node',
npmVersion: '1.1.0',
npmDownloads: 6000,
};
repository.saveNode(updatedNode);
const retrieved = repository.getNodeByNpmPackage('n8n-nodes-verified');
expect(retrieved).toBeDefined();
// Note: The actual update verification depends on parseNodeRow implementation
});
it('should handle transition from unverified to verified', () => {
repository.saveNode(unverifiedCommunityNode);
const nowVerified = {
...unverifiedCommunityNode,
isVerified: true,
};
repository.saveNode(nowVerified);
const stats = repository.getCommunityStats();
expect(stats.verified).toBe(1);
expect(stats.unverified).toBe(0);
});
});
describe('Edge cases', () => {
it('should handle empty database', () => {
expect(repository.getCommunityNodes()).toHaveLength(0);
expect(repository.getCommunityStats()).toEqual({
total: 0,
verified: 0,
unverified: 0,
});
expect(repository.hasNodeByNpmPackage('any-package')).toBe(false);
expect(repository.deleteCommunityNodes()).toBe(0);
});
it('should handle node with minimal fields', () => {
const minimalNode: ParsedNode & CommunityNodeFields = {
nodeType: 'n8n-nodes-minimal.node',
packageName: 'n8n-nodes-minimal',
displayName: 'Minimal Node',
description: 'Minimal',
category: 'Community',
style: 'declarative',
properties: [],
credentials: [],
operations: [],
isAITool: false,
isTrigger: false,
isWebhook: false,
isVersioned: false,
version: '1.0.0',
isCommunity: true,
isVerified: false,
npmPackageName: 'n8n-nodes-minimal',
};
repository.saveNode(minimalNode);
expect(repository.hasNodeByNpmPackage('n8n-nodes-minimal')).toBe(true);
expect(repository.getCommunityStats().total).toBe(1);
});
it('should handle multiple nodes from same package', () => {
const node1 = { ...verifiedCommunityNode };
const node2 = {
...verifiedCommunityNode,
nodeType: 'n8n-nodes-verified.anotherNode',
displayName: 'Another Node',
};
repository.saveNode(node1);
repository.saveNode(node2);
// Both should exist
expect(adapter.getNode('n8n-nodes-verified.testNode')).toBeDefined();
expect(adapter.getNode('n8n-nodes-verified.anotherNode')).toBeDefined();
});
it('should handle limit correctly', () => {
// Save multiple nodes
for (let i = 0; i < 10; i++) {
const node = {
...verifiedCommunityNode,
nodeType: `n8n-nodes-test-${i}.node`,
npmPackageName: `n8n-nodes-test-${i}`,
};
repository.saveNode(node);
}
const limited = repository.getCommunityNodes({ limit: 5 });
expect(limited).toHaveLength(5);
});
});
describe('Concurrent operations', () => {
it('should handle rapid consecutive saves', () => {
const nodes = Array(50)
.fill(null)
.map((_, i) => ({
...verifiedCommunityNode,
nodeType: `n8n-nodes-rapid-${i}.node`,
npmPackageName: `n8n-nodes-rapid-${i}`,
}));
nodes.forEach((node) => repository.saveNode(node));
expect(repository.getCommunityStats().total).toBe(50);
});
it('should handle save followed by immediate delete', () => {
repository.saveNode(verifiedCommunityNode);
expect(repository.getCommunityStats().total).toBe(1);
repository.deleteCommunityNodes();
expect(repository.getCommunityStats().total).toBe(0);
repository.saveNode(verifiedCommunityNode);
expect(repository.getCommunityStats().total).toBe(1);
});
});
});
