306 lines
8.9 KiB
TypeScript
306 lines
8.9 KiB
TypeScript
/**
|
|
* SyncEngine Unit Tests
|
|
*
|
|
* Tests the REAL SyncEngine class with mocked dependencies.
|
|
* Note: Cloud sync is currently not implemented, so SyncEngine
|
|
* always returns "not configured" status.
|
|
*/
|
|
|
|
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
|
import { SyncEngine, SyncConfig } from '../../src/main/engine/SyncEngine';
|
|
import { resetMockCounters } from '../utils/factories';
|
|
|
|
// Create mock data stores
|
|
const mockPosts = new Map<string, any>();
|
|
const mockMedia = new Map<string, any>();
|
|
const mockSyncLog = new Map<string, any>();
|
|
|
|
// Create chainable mock for Drizzle ORM
|
|
function createSelectChain(data: Map<string, any>) {
|
|
return {
|
|
from: vi.fn().mockReturnThis(),
|
|
where: vi.fn().mockReturnThis(),
|
|
orderBy: vi.fn().mockReturnThis(),
|
|
limit: vi.fn().mockReturnThis(),
|
|
offset: vi.fn().mockReturnThis(),
|
|
all: vi.fn().mockImplementation(() => Promise.resolve(Array.from(data.values()))),
|
|
get: vi.fn().mockImplementation(() => Promise.resolve(data.size > 0 ? Array.from(data.values())[0] : undefined)),
|
|
};
|
|
}
|
|
|
|
function createDrizzleMock(data: Map<string, any>) {
|
|
return {
|
|
select: vi.fn(() => createSelectChain(data)),
|
|
insert: vi.fn(() => ({
|
|
values: vi.fn((record: any) => {
|
|
if (record && record.id) {
|
|
data.set(record.id, record);
|
|
}
|
|
return Promise.resolve();
|
|
}),
|
|
onConflictDoUpdate: vi.fn(() => Promise.resolve()),
|
|
})),
|
|
update: vi.fn(() => ({
|
|
set: vi.fn(() => ({
|
|
where: vi.fn(() => Promise.resolve()),
|
|
})),
|
|
})),
|
|
delete: vi.fn(() => ({
|
|
where: vi.fn(() => Promise.resolve()),
|
|
})),
|
|
};
|
|
}
|
|
|
|
const mockLocalDb = createDrizzleMock(new Map());
|
|
const mockRemoteDb = createDrizzleMock(new Map());
|
|
|
|
// 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(async () => {}),
|
|
runRemoteMigrations: vi.fn(async () => {}),
|
|
close: vi.fn(),
|
|
})),
|
|
}));
|
|
|
|
// Mock uuid
|
|
vi.mock('uuid', () => ({
|
|
v4: vi.fn(() => 'mock-sync-uuid-' + Math.random().toString(36).substr(2, 9)),
|
|
}));
|
|
|
|
describe('SyncEngine', () => {
|
|
let syncEngine: SyncEngine;
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
vi.useFakeTimers();
|
|
mockPosts.clear();
|
|
mockMedia.clear();
|
|
mockSyncLog.clear();
|
|
resetMockCounters();
|
|
|
|
syncEngine = new SyncEngine();
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.useRealTimers();
|
|
syncEngine.stopAutoSync();
|
|
});
|
|
|
|
describe('Constructor and Initialization', () => {
|
|
it('should create a SyncEngine instance', () => {
|
|
expect(syncEngine).toBeInstanceOf(SyncEngine);
|
|
});
|
|
|
|
it('should extend EventEmitter', () => {
|
|
expect(typeof syncEngine.on).toBe('function');
|
|
expect(typeof syncEngine.emit).toBe('function');
|
|
});
|
|
|
|
it('should start with idle status', () => {
|
|
expect(syncEngine.getSyncStatus()).toBe('idle');
|
|
});
|
|
|
|
it('should not be configured (cloud sync is not implemented)', () => {
|
|
expect(syncEngine.isConfigured()).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('Configuration', () => {
|
|
it('should emit configured event when configure is called', async () => {
|
|
const handler = vi.fn();
|
|
syncEngine.on('configured', handler);
|
|
|
|
const config: SyncConfig = {
|
|
autoSync: false,
|
|
syncInterval: 30,
|
|
};
|
|
|
|
await syncEngine.configure(config);
|
|
|
|
expect(handler).toHaveBeenCalledWith(config);
|
|
});
|
|
|
|
it('should always return not configured (cloud sync not implemented)', async () => {
|
|
const config: SyncConfig = {
|
|
autoSync: false,
|
|
syncInterval: 30,
|
|
};
|
|
|
|
await syncEngine.configure(config);
|
|
|
|
// Cloud sync is not implemented, so always returns false
|
|
expect(syncEngine.isConfigured()).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('Sync Status', () => {
|
|
it('should return idle when not syncing', () => {
|
|
expect(syncEngine.getSyncStatus()).toBe('idle');
|
|
});
|
|
});
|
|
|
|
describe('Sync Operations', () => {
|
|
it('should return error when syncing (cloud sync not implemented)', async () => {
|
|
const result = await syncEngine.sync('bidirectional');
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.errors).toContain('Cloud sync not configured');
|
|
});
|
|
|
|
it('should return zero counts when sync is not available', async () => {
|
|
const result = await syncEngine.sync('push');
|
|
|
|
expect(result.pushed).toBe(0);
|
|
expect(result.pulled).toBe(0);
|
|
expect(result.conflicts).toBe(0);
|
|
});
|
|
|
|
it('should accept push direction', async () => {
|
|
const result = await syncEngine.sync('push');
|
|
expect(result).toBeDefined();
|
|
expect(result.success).toBe(false);
|
|
});
|
|
|
|
it('should accept pull direction', async () => {
|
|
const result = await syncEngine.sync('pull');
|
|
expect(result).toBeDefined();
|
|
expect(result.success).toBe(false);
|
|
});
|
|
|
|
it('should accept bidirectional direction', async () => {
|
|
const result = await syncEngine.sync('bidirectional');
|
|
expect(result).toBeDefined();
|
|
expect(result.success).toBe(false);
|
|
});
|
|
|
|
it('should default to bidirectional when no direction specified', async () => {
|
|
const result = await syncEngine.sync();
|
|
expect(result).toBeDefined();
|
|
expect(result.success).toBe(false);
|
|
});
|
|
|
|
it('should use fullSync as alias for sync', async () => {
|
|
const result = await syncEngine.fullSync('push');
|
|
expect(result).toBeDefined();
|
|
expect(result.success).toBe(false);
|
|
expect(result.errors).toContain('Cloud sync not configured');
|
|
});
|
|
});
|
|
|
|
describe('Event Emission', () => {
|
|
it('should be an EventEmitter', () => {
|
|
expect(syncEngine.on).toBeDefined();
|
|
expect(syncEngine.emit).toBeDefined();
|
|
expect(syncEngine.removeListener).toBeDefined();
|
|
});
|
|
|
|
it('should allow adding event listeners', () => {
|
|
const listener = vi.fn();
|
|
syncEngine.on('testEvent', listener);
|
|
syncEngine.emit('testEvent', { data: 'test' });
|
|
|
|
expect(listener).toHaveBeenCalledWith({ data: 'test' });
|
|
});
|
|
|
|
it('should allow removing event listeners', () => {
|
|
const listener = vi.fn();
|
|
syncEngine.on('testEvent', listener);
|
|
syncEngine.removeListener('testEvent', listener);
|
|
syncEngine.emit('testEvent', { data: 'test' });
|
|
|
|
expect(listener).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('SyncResult Structure', () => {
|
|
it('should return complete SyncResult structure', async () => {
|
|
const result = await syncEngine.sync();
|
|
|
|
expect(result).toHaveProperty('success');
|
|
expect(result).toHaveProperty('pushed');
|
|
expect(result).toHaveProperty('pulled');
|
|
expect(result).toHaveProperty('conflicts');
|
|
expect(result).toHaveProperty('errors');
|
|
});
|
|
|
|
it('should have errors as an array', async () => {
|
|
const result = await syncEngine.sync();
|
|
|
|
expect(Array.isArray(result.errors)).toBe(true);
|
|
});
|
|
|
|
it('should have numeric counts', async () => {
|
|
const result = await syncEngine.sync();
|
|
|
|
expect(typeof result.pushed).toBe('number');
|
|
expect(typeof result.pulled).toBe('number');
|
|
expect(typeof result.conflicts).toBe('number');
|
|
});
|
|
});
|
|
|
|
describe('Pending Changes Count', () => {
|
|
it('should return pending changes count structure', async () => {
|
|
const count = await syncEngine.getPendingChangesCount();
|
|
|
|
expect(count).toHaveProperty('posts');
|
|
expect(count).toHaveProperty('media');
|
|
});
|
|
|
|
it('should return zero counts when no pending changes', async () => {
|
|
const count = await syncEngine.getPendingChangesCount();
|
|
|
|
expect(count.posts).toBeGreaterThanOrEqual(0);
|
|
expect(count.media).toBeGreaterThanOrEqual(0);
|
|
});
|
|
});
|
|
|
|
describe('Sync Log', () => {
|
|
it('should return sync log array', async () => {
|
|
const logs = await syncEngine.getSyncLog();
|
|
|
|
expect(Array.isArray(logs)).toBe(true);
|
|
});
|
|
|
|
it('should accept limit parameter', async () => {
|
|
const logs = await syncEngine.getSyncLog(10);
|
|
|
|
expect(Array.isArray(logs)).toBe(true);
|
|
});
|
|
|
|
it('should use default limit of 50', async () => {
|
|
const logs = await syncEngine.getSyncLog();
|
|
|
|
expect(Array.isArray(logs)).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('Stop Auto Sync', () => {
|
|
it('should emit autoSyncStopped event', () => {
|
|
const handler = vi.fn();
|
|
syncEngine.on('autoSyncStopped', handler);
|
|
|
|
syncEngine.stopAutoSync();
|
|
|
|
expect(handler).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should be safe to call multiple times', () => {
|
|
expect(() => {
|
|
syncEngine.stopAutoSync();
|
|
syncEngine.stopAutoSync();
|
|
syncEngine.stopAutoSync();
|
|
}).not.toThrow();
|
|
});
|
|
});
|
|
});
|