456 lines
15 KiB
TypeScript
456 lines
15 KiB
TypeScript
/**
|
|
* ImportDefinitionEngine Unit Tests
|
|
*
|
|
* Tests the REAL ImportDefinitionEngine class with mocked database.
|
|
* Following TDD best practices: mock external dependencies, test real implementation.
|
|
*/
|
|
|
|
import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
|
|
|
|
// Store for mock data
|
|
const mockDefinitions = new Map<string, any>();
|
|
|
|
// Create chainable mock for Drizzle ORM that is thenable (can be awaited)
|
|
function createSelectChain(getData: () => any[]) {
|
|
const chain: any = {
|
|
from: vi.fn().mockImplementation(() => chain),
|
|
where: vi.fn().mockImplementation(() => chain),
|
|
orderBy: vi.fn().mockImplementation(() => chain),
|
|
limit: vi.fn().mockImplementation(() => chain),
|
|
// Make the chain thenable so it can be awaited directly
|
|
then: (resolve: (value: any[]) => void, reject?: (reason: any) => void) => {
|
|
return Promise.resolve(getData()).then(resolve, reject);
|
|
},
|
|
};
|
|
return chain;
|
|
}
|
|
|
|
// Track what data Drizzle queries should return
|
|
let mockDrizzleSelectResults: any[][] = [];
|
|
|
|
const mockLocalDb = {
|
|
select: vi.fn(() => createSelectChain(() => mockDrizzleSelectResults.shift() || [])),
|
|
insert: vi.fn(() => ({
|
|
values: vi.fn((data: any) => {
|
|
if (data && data.id) {
|
|
mockDefinitions.set(data.id, {
|
|
id: data.id,
|
|
projectId: data.projectId,
|
|
name: data.name,
|
|
wxrFilePath: data.wxrFilePath,
|
|
uploadsFolderPath: data.uploadsFolderPath,
|
|
lastAnalysisResult: data.lastAnalysisResult,
|
|
createdAt: data.createdAt,
|
|
updatedAt: data.updatedAt,
|
|
});
|
|
}
|
|
return Promise.resolve();
|
|
}),
|
|
})),
|
|
update: vi.fn(() => ({
|
|
set: vi.fn(() => ({
|
|
where: vi.fn(() => Promise.resolve()),
|
|
})),
|
|
})),
|
|
delete: vi.fn(() => ({
|
|
where: vi.fn(() => Promise.resolve()),
|
|
})),
|
|
};
|
|
|
|
// Mock the database module
|
|
vi.mock('../../src/main/database', () => ({
|
|
getDatabase: vi.fn(() => ({
|
|
getLocal: vi.fn(() => mockLocalDb),
|
|
getLocalClient: vi.fn(() => null),
|
|
getRemote: vi.fn(() => null),
|
|
getDataPaths: vi.fn(() => ({
|
|
database: '/mock/userData/bds.db',
|
|
posts: '/mock/userData/posts',
|
|
media: '/mock/userData/media',
|
|
})),
|
|
initializeLocal: vi.fn(),
|
|
initializeRemote: vi.fn(),
|
|
close: vi.fn(),
|
|
})),
|
|
}));
|
|
|
|
// Mock electron app
|
|
vi.mock('electron', () => ({
|
|
app: {
|
|
getPath: vi.fn(() => '/mock/userData'),
|
|
},
|
|
}));
|
|
|
|
import { ImportDefinitionEngine } from '../../src/main/engine/ImportDefinitionEngine';
|
|
|
|
describe('ImportDefinitionEngine', () => {
|
|
let engine: ImportDefinitionEngine;
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
mockDefinitions.clear();
|
|
mockDrizzleSelectResults = [];
|
|
engine = new ImportDefinitionEngine();
|
|
engine.setProjectContext('test-project');
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
describe('constructor', () => {
|
|
it('should create a new instance', () => {
|
|
expect(engine).toBeDefined();
|
|
expect(engine).toBeInstanceOf(ImportDefinitionEngine);
|
|
});
|
|
});
|
|
|
|
describe('setProjectContext', () => {
|
|
it('should set and return the current project ID', () => {
|
|
engine.setProjectContext('project-abc');
|
|
expect(engine.getProjectContext()).toBe('project-abc');
|
|
});
|
|
});
|
|
|
|
describe('createDefinition', () => {
|
|
it('should create a definition with default name', async () => {
|
|
const def = await engine.createDefinition();
|
|
|
|
expect(def).toBeDefined();
|
|
expect(def.id).toMatch(/^import_/);
|
|
expect(def.name).toBe('Untitled Import');
|
|
expect(def.projectId).toBe('test-project');
|
|
expect(def.wxrFilePath).toBeNull();
|
|
expect(def.uploadsFolderPath).toBeNull();
|
|
expect(def.lastAnalysisResult).toBeNull();
|
|
expect(def.createdAt).toBeDefined();
|
|
expect(def.updatedAt).toBeDefined();
|
|
});
|
|
|
|
it('should create a definition with custom name', async () => {
|
|
const def = await engine.createDefinition('My WordPress Blog');
|
|
|
|
expect(def.name).toBe('My WordPress Blog');
|
|
});
|
|
|
|
it('should insert into the database', async () => {
|
|
await engine.createDefinition('Test Import');
|
|
|
|
expect(mockLocalDb.insert).toHaveBeenCalledTimes(1);
|
|
});
|
|
});
|
|
|
|
describe('getDefinition', () => {
|
|
it('should return a definition by ID', async () => {
|
|
const created = await engine.createDefinition('My Import');
|
|
// Set up mock to return the created definition
|
|
mockDrizzleSelectResults = [[{
|
|
id: created.id,
|
|
projectId: 'test-project',
|
|
name: 'My Import',
|
|
wxrFilePath: null,
|
|
uploadsFolderPath: null,
|
|
lastAnalysisResult: null,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
}]];
|
|
|
|
const def = await engine.getDefinition(created.id);
|
|
|
|
expect(def).toBeDefined();
|
|
expect(def!.id).toBe(created.id);
|
|
expect(def!.name).toBe('My Import');
|
|
});
|
|
|
|
it('should return null for non-existent ID', async () => {
|
|
mockDrizzleSelectResults = [[]];
|
|
const def = await engine.getDefinition('non-existent-id');
|
|
|
|
expect(def).toBeNull();
|
|
});
|
|
|
|
it('should not return definitions from other projects', async () => {
|
|
const created = await engine.createDefinition('My Import');
|
|
engine.setProjectContext('other-project');
|
|
mockDrizzleSelectResults = [[]]; // would be filtered by project
|
|
|
|
const def = await engine.getDefinition(created.id);
|
|
|
|
expect(def).toBeNull();
|
|
});
|
|
|
|
it('should parse lastAnalysisResult JSON', async () => {
|
|
const created = await engine.createDefinition('My Import');
|
|
// Set up mock to return the definition with analysis result
|
|
mockDrizzleSelectResults = [[{
|
|
id: created.id,
|
|
projectId: 'test-project',
|
|
name: 'My Import',
|
|
wxrFilePath: null,
|
|
uploadsFolderPath: null,
|
|
lastAnalysisResult: JSON.stringify({ posts: { total: 5 } }),
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
}]];
|
|
|
|
const def = await engine.getDefinition(created.id);
|
|
|
|
expect(def!.lastAnalysisResult).toEqual({ posts: { total: 5 } });
|
|
});
|
|
});
|
|
|
|
describe('getAllForProject', () => {
|
|
it('should return empty array when no definitions exist', async () => {
|
|
mockDrizzleSelectResults = [[]];
|
|
const defs = await engine.getAllForProject();
|
|
|
|
expect(defs).toEqual([]);
|
|
});
|
|
|
|
it('should return all definitions for the current project', async () => {
|
|
await engine.createDefinition('Import 1');
|
|
await engine.createDefinition('Import 2');
|
|
// Mock returning both definitions
|
|
mockDrizzleSelectResults = [[
|
|
{ id: 'id1', projectId: 'test-project', name: 'Import 1', wxrFilePath: null, uploadsFolderPath: null, lastAnalysisResult: null, createdAt: new Date(), updatedAt: new Date() },
|
|
{ id: 'id2', projectId: 'test-project', name: 'Import 2', wxrFilePath: null, uploadsFolderPath: null, lastAnalysisResult: null, createdAt: new Date(), updatedAt: new Date() },
|
|
]];
|
|
|
|
const defs = await engine.getAllForProject();
|
|
|
|
expect(defs).toHaveLength(2);
|
|
});
|
|
|
|
it('should not include definitions from other projects', async () => {
|
|
await engine.createDefinition('Import A');
|
|
engine.setProjectContext('other-project');
|
|
await engine.createDefinition('Import B');
|
|
engine.setProjectContext('test-project');
|
|
// Mock returning only the test-project definition
|
|
mockDrizzleSelectResults = [[
|
|
{ id: 'id1', projectId: 'test-project', name: 'Import A', wxrFilePath: null, uploadsFolderPath: null, lastAnalysisResult: null, createdAt: new Date(), updatedAt: new Date() },
|
|
]];
|
|
|
|
const defs = await engine.getAllForProject();
|
|
|
|
expect(defs).toHaveLength(1);
|
|
expect(defs[0].name).toBe('Import A');
|
|
});
|
|
|
|
it('should return definitions ordered by updatedAt DESC', async () => {
|
|
const olderDate = new Date('2024-01-01');
|
|
const newerDate = new Date('2024-02-01');
|
|
mockDrizzleSelectResults = [[
|
|
{ id: 'id2', projectId: 'test-project', name: 'Newer', wxrFilePath: null, uploadsFolderPath: null, lastAnalysisResult: null, createdAt: newerDate, updatedAt: newerDate },
|
|
{ id: 'id1', projectId: 'test-project', name: 'Older', wxrFilePath: null, uploadsFolderPath: null, lastAnalysisResult: null, createdAt: olderDate, updatedAt: olderDate },
|
|
]];
|
|
|
|
const defs = await engine.getAllForProject();
|
|
|
|
expect(defs[0].name).toBe('Newer');
|
|
expect(defs[1].name).toBe('Older');
|
|
});
|
|
});
|
|
|
|
describe('updateDefinition', () => {
|
|
it('should update the name', async () => {
|
|
const created = await engine.createDefinition('Old Name');
|
|
// First call for getDefinition check, second for returning updated data
|
|
mockDrizzleSelectResults = [
|
|
[{ // getDefinition call inside updateDefinition
|
|
id: created.id,
|
|
projectId: 'test-project',
|
|
name: 'Old Name',
|
|
wxrFilePath: null,
|
|
uploadsFolderPath: null,
|
|
lastAnalysisResult: null,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
}],
|
|
[{ // return after update
|
|
id: created.id,
|
|
projectId: 'test-project',
|
|
name: 'New Name',
|
|
wxrFilePath: null,
|
|
uploadsFolderPath: null,
|
|
lastAnalysisResult: null,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
}],
|
|
];
|
|
|
|
const updated = await engine.updateDefinition(created.id, { name: 'New Name' });
|
|
|
|
expect(updated).toBeDefined();
|
|
expect(updated!.name).toBe('New Name');
|
|
});
|
|
|
|
it('should update wxrFilePath', async () => {
|
|
const created = await engine.createDefinition('Test');
|
|
// First call for check, second for returning updated data
|
|
mockDrizzleSelectResults = [
|
|
[{ // getDefinition check
|
|
id: created.id,
|
|
projectId: 'test-project',
|
|
name: 'Test',
|
|
wxrFilePath: null,
|
|
uploadsFolderPath: null,
|
|
lastAnalysisResult: null,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
}],
|
|
[{ // return after update
|
|
id: created.id,
|
|
projectId: 'test-project',
|
|
name: 'Test',
|
|
wxrFilePath: '/path/to/export.xml',
|
|
uploadsFolderPath: null,
|
|
lastAnalysisResult: null,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
}],
|
|
];
|
|
|
|
const updated = await engine.updateDefinition(created.id, { wxrFilePath: '/path/to/export.xml' });
|
|
|
|
expect(updated!.wxrFilePath).toBe('/path/to/export.xml');
|
|
});
|
|
|
|
it('should update uploadsFolderPath', async () => {
|
|
const created = await engine.createDefinition('Test');
|
|
mockDrizzleSelectResults = [
|
|
[{ // getDefinition check
|
|
id: created.id,
|
|
projectId: 'test-project',
|
|
name: 'Test',
|
|
wxrFilePath: null,
|
|
uploadsFolderPath: null,
|
|
lastAnalysisResult: null,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
}],
|
|
[{ // return after update
|
|
id: created.id,
|
|
projectId: 'test-project',
|
|
name: 'Test',
|
|
wxrFilePath: null,
|
|
uploadsFolderPath: '/path/to/uploads',
|
|
lastAnalysisResult: null,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
}],
|
|
];
|
|
|
|
const updated = await engine.updateDefinition(created.id, { uploadsFolderPath: '/path/to/uploads' });
|
|
|
|
expect(updated!.uploadsFolderPath).toBe('/path/to/uploads');
|
|
});
|
|
|
|
it('should update lastAnalysisResult as JSON', async () => {
|
|
const created = await engine.createDefinition('Test');
|
|
const report = { posts: { total: 10, new: 5 } };
|
|
mockDrizzleSelectResults = [
|
|
[{ // getDefinition check
|
|
id: created.id,
|
|
projectId: 'test-project',
|
|
name: 'Test',
|
|
wxrFilePath: null,
|
|
uploadsFolderPath: null,
|
|
lastAnalysisResult: null,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
}],
|
|
[{ // return after update
|
|
id: created.id,
|
|
projectId: 'test-project',
|
|
name: 'Test',
|
|
wxrFilePath: null,
|
|
uploadsFolderPath: null,
|
|
lastAnalysisResult: JSON.stringify(report),
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
}],
|
|
];
|
|
|
|
const updated = await engine.updateDefinition(created.id, { lastAnalysisResult: JSON.stringify(report) });
|
|
|
|
expect(updated).toBeDefined();
|
|
});
|
|
|
|
it('should return null for non-existent definition', async () => {
|
|
mockDrizzleSelectResults = [[]];
|
|
const updated = await engine.updateDefinition('non-existent', { name: 'Test' });
|
|
|
|
expect(updated).toBeNull();
|
|
});
|
|
|
|
it('should not update definitions from other projects', async () => {
|
|
const created = await engine.createDefinition('Test');
|
|
engine.setProjectContext('other-project');
|
|
mockDrizzleSelectResults = [[]]; // Would be filtered by project
|
|
|
|
const updated = await engine.updateDefinition(created.id, { name: 'Hacked' });
|
|
|
|
expect(updated).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('deleteDefinition', () => {
|
|
it('should delete an existing definition', async () => {
|
|
const created = await engine.createDefinition('To Delete');
|
|
mockDrizzleSelectResults = [[{
|
|
id: created.id,
|
|
projectId: 'test-project',
|
|
name: 'To Delete',
|
|
wxrFilePath: null,
|
|
uploadsFolderPath: null,
|
|
lastAnalysisResult: null,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
}]];
|
|
|
|
const result = await engine.deleteDefinition(created.id);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it('should return false for non-existent definition', async () => {
|
|
mockDrizzleSelectResults = [[]];
|
|
const result = await engine.deleteDefinition('non-existent');
|
|
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('should not delete definitions from other projects', async () => {
|
|
const created = await engine.createDefinition('Test');
|
|
engine.setProjectContext('other-project');
|
|
mockDrizzleSelectResults = [[]]; // Would be filtered by project
|
|
|
|
const result = await engine.deleteDefinition(created.id);
|
|
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('should remove the definition from the database', async () => {
|
|
const created = await engine.createDefinition('Test');
|
|
// First call returns the definition for delete
|
|
mockDrizzleSelectResults = [[{
|
|
id: created.id,
|
|
projectId: 'test-project',
|
|
name: 'Test',
|
|
wxrFilePath: null,
|
|
uploadsFolderPath: null,
|
|
lastAnalysisResult: null,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
}]];
|
|
await engine.deleteDefinition(created.id);
|
|
|
|
// Second call returns empty for get
|
|
mockDrizzleSelectResults = [[]];
|
|
const def = await engine.getDefinition(created.id);
|
|
expect(def).toBeNull();
|
|
});
|
|
});
|
|
});
|