mirror of
https://github.com/AutoMaker-Org/automaker.git
synced 2026-01-30 06:12:03 +00:00
d8cdb0bf7a
- Added safeguards to prevent overwriting non-empty arrays with empty arrays during global settings updates, specifically for the 'projects' field. - Implemented logging for updates to assist in diagnosing accidental wipes of critical settings. - Updated tests to verify that projects are preserved during logout transitions and that theme changes are ignored if a project wipe is attempted. - Enhanced the settings synchronization logic to ensure safe handling during authentication state changes.
811 lines
29 KiB
TypeScript
811 lines
29 KiB
TypeScript
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
|
|
import fs from 'fs/promises';
|
|
import path from 'path';
|
|
import os from 'os';
|
|
import { SettingsService } from '@/services/settings-service.js';
|
|
import {
|
|
DEFAULT_GLOBAL_SETTINGS,
|
|
DEFAULT_CREDENTIALS,
|
|
DEFAULT_PROJECT_SETTINGS,
|
|
SETTINGS_VERSION,
|
|
CREDENTIALS_VERSION,
|
|
PROJECT_SETTINGS_VERSION,
|
|
type GlobalSettings,
|
|
type Credentials,
|
|
type ProjectSettings,
|
|
} from '@/types/settings.js';
|
|
|
|
describe('settings-service.ts', () => {
|
|
let testDataDir: string;
|
|
let testProjectDir: string;
|
|
let settingsService: SettingsService;
|
|
|
|
beforeEach(async () => {
|
|
testDataDir = path.join(os.tmpdir(), `settings-test-${Date.now()}`);
|
|
testProjectDir = path.join(os.tmpdir(), `project-test-${Date.now()}`);
|
|
await fs.mkdir(testDataDir, { recursive: true });
|
|
await fs.mkdir(testProjectDir, { recursive: true });
|
|
settingsService = new SettingsService(testDataDir);
|
|
});
|
|
|
|
afterEach(async () => {
|
|
try {
|
|
await fs.rm(testDataDir, { recursive: true, force: true });
|
|
await fs.rm(testProjectDir, { recursive: true, force: true });
|
|
} catch {
|
|
// Ignore cleanup errors
|
|
}
|
|
});
|
|
|
|
describe('getGlobalSettings', () => {
|
|
it('should return default settings when file does not exist', async () => {
|
|
const settings = await settingsService.getGlobalSettings();
|
|
expect(settings).toEqual(DEFAULT_GLOBAL_SETTINGS);
|
|
});
|
|
|
|
it('should read and return existing settings', async () => {
|
|
const customSettings: GlobalSettings = {
|
|
...DEFAULT_GLOBAL_SETTINGS,
|
|
theme: 'light',
|
|
sidebarOpen: false,
|
|
maxConcurrency: 5,
|
|
};
|
|
const settingsPath = path.join(testDataDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(customSettings, null, 2));
|
|
|
|
const settings = await settingsService.getGlobalSettings();
|
|
expect(settings.theme).toBe('light');
|
|
expect(settings.sidebarOpen).toBe(false);
|
|
expect(settings.maxConcurrency).toBe(5);
|
|
});
|
|
|
|
it('should merge with defaults for missing properties', async () => {
|
|
const partialSettings = {
|
|
version: SETTINGS_VERSION,
|
|
theme: 'dark',
|
|
};
|
|
const settingsPath = path.join(testDataDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(partialSettings, null, 2));
|
|
|
|
const settings = await settingsService.getGlobalSettings();
|
|
expect(settings.theme).toBe('dark');
|
|
expect(settings.sidebarOpen).toBe(DEFAULT_GLOBAL_SETTINGS.sidebarOpen);
|
|
expect(settings.maxConcurrency).toBe(DEFAULT_GLOBAL_SETTINGS.maxConcurrency);
|
|
});
|
|
|
|
it('should merge keyboard shortcuts deeply', async () => {
|
|
const customSettings: GlobalSettings = {
|
|
...DEFAULT_GLOBAL_SETTINGS,
|
|
keyboardShortcuts: {
|
|
...DEFAULT_GLOBAL_SETTINGS.keyboardShortcuts,
|
|
board: 'B',
|
|
},
|
|
};
|
|
const settingsPath = path.join(testDataDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(customSettings, null, 2));
|
|
|
|
const settings = await settingsService.getGlobalSettings();
|
|
expect(settings.keyboardShortcuts.board).toBe('B');
|
|
expect(settings.keyboardShortcuts.agent).toBe(
|
|
DEFAULT_GLOBAL_SETTINGS.keyboardShortcuts.agent
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('updateGlobalSettings', () => {
|
|
it('should create settings file with updates', async () => {
|
|
const updates: Partial<GlobalSettings> = {
|
|
theme: 'light',
|
|
sidebarOpen: false,
|
|
};
|
|
|
|
const updated = await settingsService.updateGlobalSettings(updates);
|
|
|
|
expect(updated.theme).toBe('light');
|
|
expect(updated.sidebarOpen).toBe(false);
|
|
expect(updated.version).toBe(SETTINGS_VERSION);
|
|
|
|
const settingsPath = path.join(testDataDir, 'settings.json');
|
|
const fileContent = await fs.readFile(settingsPath, 'utf-8');
|
|
const saved = JSON.parse(fileContent);
|
|
expect(saved.theme).toBe('light');
|
|
expect(saved.sidebarOpen).toBe(false);
|
|
});
|
|
|
|
it('should merge updates with existing settings', async () => {
|
|
const initial: GlobalSettings = {
|
|
...DEFAULT_GLOBAL_SETTINGS,
|
|
theme: 'dark',
|
|
maxConcurrency: 3,
|
|
};
|
|
const settingsPath = path.join(testDataDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(initial, null, 2));
|
|
|
|
const updates: Partial<GlobalSettings> = {
|
|
theme: 'light',
|
|
};
|
|
|
|
const updated = await settingsService.updateGlobalSettings(updates);
|
|
|
|
expect(updated.theme).toBe('light');
|
|
expect(updated.maxConcurrency).toBe(3); // Preserved from initial
|
|
});
|
|
|
|
it('should deep merge keyboard shortcuts', async () => {
|
|
const updates: Partial<GlobalSettings> = {
|
|
keyboardShortcuts: {
|
|
board: 'B',
|
|
},
|
|
};
|
|
|
|
const updated = await settingsService.updateGlobalSettings(updates);
|
|
|
|
expect(updated.keyboardShortcuts.board).toBe('B');
|
|
expect(updated.keyboardShortcuts.agent).toBe(DEFAULT_GLOBAL_SETTINGS.keyboardShortcuts.agent);
|
|
});
|
|
|
|
it('should not overwrite non-empty projects with an empty array (data loss guard)', async () => {
|
|
const initial: GlobalSettings = {
|
|
...DEFAULT_GLOBAL_SETTINGS,
|
|
theme: 'solarized' as GlobalSettings['theme'],
|
|
projects: [
|
|
{
|
|
id: 'proj1',
|
|
name: 'Project 1',
|
|
path: '/tmp/project-1',
|
|
lastOpened: new Date().toISOString(),
|
|
},
|
|
] as any,
|
|
};
|
|
const settingsPath = path.join(testDataDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(initial, null, 2));
|
|
|
|
const updated = await settingsService.updateGlobalSettings({
|
|
projects: [],
|
|
theme: 'light',
|
|
} as any);
|
|
|
|
expect(updated.projects.length).toBe(1);
|
|
expect((updated.projects as any)[0]?.id).toBe('proj1');
|
|
// Theme should be preserved in the same request if it attempted to wipe projects
|
|
expect(updated.theme).toBe('solarized');
|
|
});
|
|
|
|
it('should create data directory if it does not exist', async () => {
|
|
const newDataDir = path.join(os.tmpdir(), `new-data-dir-${Date.now()}`);
|
|
const newService = new SettingsService(newDataDir);
|
|
|
|
await newService.updateGlobalSettings({ theme: 'light' });
|
|
|
|
const stats = await fs.stat(newDataDir);
|
|
expect(stats.isDirectory()).toBe(true);
|
|
|
|
await fs.rm(newDataDir, { recursive: true, force: true });
|
|
});
|
|
});
|
|
|
|
describe('hasGlobalSettings', () => {
|
|
it('should return false when settings file does not exist', async () => {
|
|
const exists = await settingsService.hasGlobalSettings();
|
|
expect(exists).toBe(false);
|
|
});
|
|
|
|
it('should return true when settings file exists', async () => {
|
|
await settingsService.updateGlobalSettings({ theme: 'light' });
|
|
const exists = await settingsService.hasGlobalSettings();
|
|
expect(exists).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('getCredentials', () => {
|
|
it('should return default credentials when file does not exist', async () => {
|
|
const credentials = await settingsService.getCredentials();
|
|
expect(credentials).toEqual(DEFAULT_CREDENTIALS);
|
|
});
|
|
|
|
it('should read and return existing credentials', async () => {
|
|
const customCredentials: Credentials = {
|
|
...DEFAULT_CREDENTIALS,
|
|
apiKeys: {
|
|
anthropic: 'sk-test-key',
|
|
},
|
|
};
|
|
const credentialsPath = path.join(testDataDir, 'credentials.json');
|
|
await fs.writeFile(credentialsPath, JSON.stringify(customCredentials, null, 2));
|
|
|
|
const credentials = await settingsService.getCredentials();
|
|
expect(credentials.apiKeys.anthropic).toBe('sk-test-key');
|
|
});
|
|
|
|
it('should merge with defaults for missing api keys', async () => {
|
|
const partialCredentials = {
|
|
version: CREDENTIALS_VERSION,
|
|
apiKeys: {
|
|
anthropic: 'sk-test',
|
|
},
|
|
};
|
|
const credentialsPath = path.join(testDataDir, 'credentials.json');
|
|
await fs.writeFile(credentialsPath, JSON.stringify(partialCredentials, null, 2));
|
|
|
|
const credentials = await settingsService.getCredentials();
|
|
expect(credentials.apiKeys.anthropic).toBe('sk-test');
|
|
});
|
|
});
|
|
|
|
describe('updateCredentials', () => {
|
|
it('should create credentials file with updates', async () => {
|
|
const updates: Partial<Credentials> = {
|
|
apiKeys: {
|
|
anthropic: 'sk-test-key',
|
|
},
|
|
};
|
|
|
|
const updated = await settingsService.updateCredentials(updates);
|
|
|
|
expect(updated.apiKeys.anthropic).toBe('sk-test-key');
|
|
expect(updated.version).toBe(CREDENTIALS_VERSION);
|
|
|
|
const credentialsPath = path.join(testDataDir, 'credentials.json');
|
|
const fileContent = await fs.readFile(credentialsPath, 'utf-8');
|
|
const saved = JSON.parse(fileContent);
|
|
expect(saved.apiKeys.anthropic).toBe('sk-test-key');
|
|
});
|
|
|
|
it('should merge updates with existing credentials', async () => {
|
|
const initial: Credentials = {
|
|
...DEFAULT_CREDENTIALS,
|
|
apiKeys: {
|
|
anthropic: 'sk-initial',
|
|
},
|
|
};
|
|
const credentialsPath = path.join(testDataDir, 'credentials.json');
|
|
await fs.writeFile(credentialsPath, JSON.stringify(initial, null, 2));
|
|
|
|
const updates: Partial<Credentials> = {
|
|
apiKeys: {
|
|
anthropic: 'sk-updated',
|
|
},
|
|
};
|
|
|
|
const updated = await settingsService.updateCredentials(updates);
|
|
|
|
expect(updated.apiKeys.anthropic).toBe('sk-updated');
|
|
});
|
|
|
|
it('should deep merge api keys', async () => {
|
|
const initial: Credentials = {
|
|
...DEFAULT_CREDENTIALS,
|
|
apiKeys: {
|
|
anthropic: 'sk-anthropic',
|
|
},
|
|
};
|
|
const credentialsPath = path.join(testDataDir, 'credentials.json');
|
|
await fs.writeFile(credentialsPath, JSON.stringify(initial, null, 2));
|
|
|
|
const updates: Partial<Credentials> = {
|
|
apiKeys: {
|
|
anthropic: 'sk-updated-anthropic',
|
|
},
|
|
};
|
|
|
|
const updated = await settingsService.updateCredentials(updates);
|
|
|
|
expect(updated.apiKeys.anthropic).toBe('sk-updated-anthropic');
|
|
});
|
|
});
|
|
|
|
describe('getMaskedCredentials', () => {
|
|
it('should return masked credentials for empty keys', async () => {
|
|
const masked = await settingsService.getMaskedCredentials();
|
|
expect(masked.anthropic.configured).toBe(false);
|
|
expect(masked.anthropic.masked).toBe('');
|
|
});
|
|
|
|
it('should mask keys correctly', async () => {
|
|
await settingsService.updateCredentials({
|
|
apiKeys: {
|
|
anthropic: 'sk-ant-api03-1234567890abcdef',
|
|
},
|
|
});
|
|
|
|
const masked = await settingsService.getMaskedCredentials();
|
|
expect(masked.anthropic.configured).toBe(true);
|
|
expect(masked.anthropic.masked).toBe('sk-a...cdef');
|
|
});
|
|
|
|
it('should handle short keys', async () => {
|
|
await settingsService.updateCredentials({
|
|
apiKeys: {
|
|
anthropic: 'short',
|
|
},
|
|
});
|
|
|
|
const masked = await settingsService.getMaskedCredentials();
|
|
expect(masked.anthropic.configured).toBe(true);
|
|
expect(masked.anthropic.masked).toBe('');
|
|
});
|
|
});
|
|
|
|
describe('hasCredentials', () => {
|
|
it('should return false when credentials file does not exist', async () => {
|
|
const exists = await settingsService.hasCredentials();
|
|
expect(exists).toBe(false);
|
|
});
|
|
|
|
it('should return true when credentials file exists', async () => {
|
|
await settingsService.updateCredentials({
|
|
apiKeys: { anthropic: 'test' },
|
|
});
|
|
const exists = await settingsService.hasCredentials();
|
|
expect(exists).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('getProjectSettings', () => {
|
|
it('should return default settings when file does not exist', async () => {
|
|
const settings = await settingsService.getProjectSettings(testProjectDir);
|
|
expect(settings).toEqual(DEFAULT_PROJECT_SETTINGS);
|
|
});
|
|
|
|
it('should read and return existing project settings', async () => {
|
|
const customSettings: ProjectSettings = {
|
|
...DEFAULT_PROJECT_SETTINGS,
|
|
theme: 'light',
|
|
useWorktrees: true,
|
|
};
|
|
const automakerDir = path.join(testProjectDir, '.automaker');
|
|
await fs.mkdir(automakerDir, { recursive: true });
|
|
const settingsPath = path.join(automakerDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(customSettings, null, 2));
|
|
|
|
const settings = await settingsService.getProjectSettings(testProjectDir);
|
|
expect(settings.theme).toBe('light');
|
|
expect(settings.useWorktrees).toBe(true);
|
|
});
|
|
|
|
it('should merge with defaults for missing properties', async () => {
|
|
const partialSettings = {
|
|
version: PROJECT_SETTINGS_VERSION,
|
|
theme: 'dark',
|
|
};
|
|
const automakerDir = path.join(testProjectDir, '.automaker');
|
|
await fs.mkdir(automakerDir, { recursive: true });
|
|
const settingsPath = path.join(automakerDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(partialSettings, null, 2));
|
|
|
|
const settings = await settingsService.getProjectSettings(testProjectDir);
|
|
expect(settings.theme).toBe('dark');
|
|
expect(settings.version).toBe(PROJECT_SETTINGS_VERSION);
|
|
});
|
|
});
|
|
|
|
describe('updateProjectSettings', () => {
|
|
it('should create project settings file with updates', async () => {
|
|
const updates: Partial<ProjectSettings> = {
|
|
theme: 'light',
|
|
useWorktrees: true,
|
|
};
|
|
|
|
const updated = await settingsService.updateProjectSettings(testProjectDir, updates);
|
|
|
|
expect(updated.theme).toBe('light');
|
|
expect(updated.useWorktrees).toBe(true);
|
|
expect(updated.version).toBe(PROJECT_SETTINGS_VERSION);
|
|
|
|
const automakerDir = path.join(testProjectDir, '.automaker');
|
|
const settingsPath = path.join(automakerDir, 'settings.json');
|
|
const fileContent = await fs.readFile(settingsPath, 'utf-8');
|
|
const saved = JSON.parse(fileContent);
|
|
expect(saved.theme).toBe('light');
|
|
expect(saved.useWorktrees).toBe(true);
|
|
});
|
|
|
|
it('should merge updates with existing project settings', async () => {
|
|
const initial: ProjectSettings = {
|
|
...DEFAULT_PROJECT_SETTINGS,
|
|
theme: 'dark',
|
|
useWorktrees: false,
|
|
};
|
|
const automakerDir = path.join(testProjectDir, '.automaker');
|
|
await fs.mkdir(automakerDir, { recursive: true });
|
|
const settingsPath = path.join(automakerDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(initial, null, 2));
|
|
|
|
const updates: Partial<ProjectSettings> = {
|
|
theme: 'light',
|
|
};
|
|
|
|
const updated = await settingsService.updateProjectSettings(testProjectDir, updates);
|
|
|
|
expect(updated.theme).toBe('light');
|
|
expect(updated.useWorktrees).toBe(false); // Preserved
|
|
});
|
|
|
|
it('should deep merge board background', async () => {
|
|
const initial: ProjectSettings = {
|
|
...DEFAULT_PROJECT_SETTINGS,
|
|
boardBackground: {
|
|
imagePath: '/path/to/image.jpg',
|
|
cardOpacity: 0.8,
|
|
columnOpacity: 0.9,
|
|
columnBorderEnabled: true,
|
|
cardGlassmorphism: false,
|
|
cardBorderEnabled: true,
|
|
cardBorderOpacity: 0.5,
|
|
hideScrollbar: false,
|
|
},
|
|
};
|
|
const automakerDir = path.join(testProjectDir, '.automaker');
|
|
await fs.mkdir(automakerDir, { recursive: true });
|
|
const settingsPath = path.join(automakerDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(initial, null, 2));
|
|
|
|
const updates: Partial<ProjectSettings> = {
|
|
boardBackground: {
|
|
cardOpacity: 0.9,
|
|
},
|
|
};
|
|
|
|
const updated = await settingsService.updateProjectSettings(testProjectDir, updates);
|
|
|
|
expect(updated.boardBackground?.imagePath).toBe('/path/to/image.jpg');
|
|
expect(updated.boardBackground?.cardOpacity).toBe(0.9);
|
|
expect(updated.boardBackground?.columnOpacity).toBe(0.9);
|
|
});
|
|
|
|
it('should create .automaker directory if it does not exist', async () => {
|
|
const newProjectDir = path.join(os.tmpdir(), `new-project-${Date.now()}`);
|
|
|
|
await settingsService.updateProjectSettings(newProjectDir, { theme: 'light' });
|
|
|
|
const automakerDir = path.join(newProjectDir, '.automaker');
|
|
const stats = await fs.stat(automakerDir);
|
|
expect(stats.isDirectory()).toBe(true);
|
|
|
|
await fs.rm(newProjectDir, { recursive: true, force: true });
|
|
});
|
|
});
|
|
|
|
describe('hasProjectSettings', () => {
|
|
it('should return false when project settings file does not exist', async () => {
|
|
const exists = await settingsService.hasProjectSettings(testProjectDir);
|
|
expect(exists).toBe(false);
|
|
});
|
|
|
|
it('should return true when project settings file exists', async () => {
|
|
await settingsService.updateProjectSettings(testProjectDir, { theme: 'light' });
|
|
const exists = await settingsService.hasProjectSettings(testProjectDir);
|
|
expect(exists).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('migrateFromLocalStorage', () => {
|
|
it('should migrate global settings from localStorage data', async () => {
|
|
const localStorageData = {
|
|
'automaker-storage': JSON.stringify({
|
|
state: {
|
|
theme: 'light',
|
|
sidebarOpen: false,
|
|
maxConcurrency: 5,
|
|
},
|
|
}),
|
|
};
|
|
|
|
const result = await settingsService.migrateFromLocalStorage(localStorageData);
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.migratedGlobalSettings).toBe(true);
|
|
expect(result.migratedCredentials).toBe(false);
|
|
expect(result.migratedProjectCount).toBe(0);
|
|
|
|
const settings = await settingsService.getGlobalSettings();
|
|
expect(settings.theme).toBe('light');
|
|
expect(settings.sidebarOpen).toBe(false);
|
|
expect(settings.maxConcurrency).toBe(5);
|
|
});
|
|
|
|
it('should migrate credentials from localStorage data', async () => {
|
|
const localStorageData = {
|
|
'automaker-storage': JSON.stringify({
|
|
state: {
|
|
apiKeys: {
|
|
anthropic: 'sk-test-key',
|
|
},
|
|
},
|
|
}),
|
|
};
|
|
|
|
const result = await settingsService.migrateFromLocalStorage(localStorageData);
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.migratedCredentials).toBe(true);
|
|
|
|
const credentials = await settingsService.getCredentials();
|
|
expect(credentials.apiKeys.anthropic).toBe('sk-test-key');
|
|
});
|
|
|
|
it('should migrate project settings from localStorage data', async () => {
|
|
const localStorageData = {
|
|
'automaker-storage': JSON.stringify({
|
|
state: {
|
|
projects: [
|
|
{
|
|
id: 'proj1',
|
|
name: 'Project 1',
|
|
path: testProjectDir,
|
|
theme: 'light',
|
|
},
|
|
],
|
|
boardBackgroundByProject: {
|
|
[testProjectDir]: {
|
|
imagePath: '/path/to/image.jpg',
|
|
cardOpacity: 0.8,
|
|
columnOpacity: 0.9,
|
|
columnBorderEnabled: true,
|
|
cardGlassmorphism: false,
|
|
cardBorderEnabled: true,
|
|
cardBorderOpacity: 0.5,
|
|
hideScrollbar: false,
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
};
|
|
|
|
const result = await settingsService.migrateFromLocalStorage(localStorageData);
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.migratedProjectCount).toBe(1);
|
|
|
|
const projectSettings = await settingsService.getProjectSettings(testProjectDir);
|
|
expect(projectSettings.theme).toBe('light');
|
|
expect(projectSettings.boardBackground?.imagePath).toBe('/path/to/image.jpg');
|
|
});
|
|
|
|
it('should handle direct localStorage values', async () => {
|
|
const localStorageData = {
|
|
'automaker:lastProjectDir': '/path/to/project',
|
|
'file-browser-recent-folders': JSON.stringify(['/path1', '/path2']),
|
|
'worktree-panel-collapsed': 'true',
|
|
};
|
|
|
|
const result = await settingsService.migrateFromLocalStorage(localStorageData);
|
|
|
|
expect(result.success).toBe(true);
|
|
const settings = await settingsService.getGlobalSettings();
|
|
expect(settings.lastProjectDir).toBe('/path/to/project');
|
|
expect(settings.recentFolders).toEqual(['/path1', '/path2']);
|
|
expect(settings.worktreePanelCollapsed).toBe(true);
|
|
});
|
|
|
|
it('should handle invalid JSON gracefully', async () => {
|
|
const localStorageData = {
|
|
'automaker-storage': 'invalid json',
|
|
'file-browser-recent-folders': 'invalid json',
|
|
};
|
|
|
|
const result = await settingsService.migrateFromLocalStorage(localStorageData);
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.errors.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
// Skip on Windows as chmod doesn't work the same way (CI runs on Linux)
|
|
it.skipIf(process.platform === 'win32')(
|
|
'should handle migration errors gracefully',
|
|
async () => {
|
|
// Create a read-only directory to cause write errors
|
|
const readOnlyDir = path.join(os.tmpdir(), `readonly-${Date.now()}`);
|
|
await fs.mkdir(readOnlyDir, { recursive: true });
|
|
await fs.chmod(readOnlyDir, 0o444);
|
|
|
|
const readOnlyService = new SettingsService(readOnlyDir);
|
|
const localStorageData = {
|
|
'automaker-storage': JSON.stringify({
|
|
state: { theme: 'light' },
|
|
}),
|
|
};
|
|
|
|
const result = await readOnlyService.migrateFromLocalStorage(localStorageData);
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.errors.length).toBeGreaterThan(0);
|
|
|
|
await fs.chmod(readOnlyDir, 0o755);
|
|
await fs.rm(readOnlyDir, { recursive: true, force: true });
|
|
}
|
|
);
|
|
});
|
|
|
|
describe('getDataDir', () => {
|
|
it('should return the data directory path', () => {
|
|
const dataDir = settingsService.getDataDir();
|
|
expect(dataDir).toBe(testDataDir);
|
|
});
|
|
});
|
|
|
|
describe('phase model migration (v2 -> v3)', () => {
|
|
it('should migrate string phase models to PhaseModelEntry format', async () => {
|
|
// Simulate v2 format with string phase models
|
|
const v2Settings = {
|
|
version: 2,
|
|
theme: 'dark',
|
|
phaseModels: {
|
|
enhancementModel: 'sonnet',
|
|
fileDescriptionModel: 'haiku',
|
|
imageDescriptionModel: 'haiku',
|
|
validationModel: 'sonnet',
|
|
specGenerationModel: 'opus',
|
|
featureGenerationModel: 'sonnet',
|
|
backlogPlanningModel: 'sonnet',
|
|
projectAnalysisModel: 'sonnet',
|
|
},
|
|
};
|
|
const settingsPath = path.join(testDataDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(v2Settings, null, 2));
|
|
|
|
const settings = await settingsService.getGlobalSettings();
|
|
|
|
// Verify all phase models are now PhaseModelEntry objects
|
|
expect(settings.phaseModels.enhancementModel).toEqual({ model: 'sonnet' });
|
|
expect(settings.phaseModels.fileDescriptionModel).toEqual({ model: 'haiku' });
|
|
expect(settings.phaseModels.specGenerationModel).toEqual({ model: 'opus' });
|
|
expect(settings.version).toBe(SETTINGS_VERSION);
|
|
});
|
|
|
|
it('should preserve PhaseModelEntry objects during migration', async () => {
|
|
// Simulate v3 format (already has PhaseModelEntry objects)
|
|
const v3Settings = {
|
|
version: 3,
|
|
theme: 'dark',
|
|
phaseModels: {
|
|
enhancementModel: { model: 'sonnet', thinkingLevel: 'high' },
|
|
fileDescriptionModel: { model: 'haiku' },
|
|
imageDescriptionModel: { model: 'haiku', thinkingLevel: 'low' },
|
|
validationModel: { model: 'sonnet' },
|
|
specGenerationModel: { model: 'opus', thinkingLevel: 'ultrathink' },
|
|
featureGenerationModel: { model: 'sonnet' },
|
|
backlogPlanningModel: { model: 'sonnet', thinkingLevel: 'medium' },
|
|
projectAnalysisModel: { model: 'sonnet' },
|
|
},
|
|
};
|
|
const settingsPath = path.join(testDataDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(v3Settings, null, 2));
|
|
|
|
const settings = await settingsService.getGlobalSettings();
|
|
|
|
// Verify PhaseModelEntry objects are preserved with thinkingLevel
|
|
expect(settings.phaseModels.enhancementModel).toEqual({
|
|
model: 'sonnet',
|
|
thinkingLevel: 'high',
|
|
});
|
|
expect(settings.phaseModels.specGenerationModel).toEqual({
|
|
model: 'opus',
|
|
thinkingLevel: 'ultrathink',
|
|
});
|
|
expect(settings.phaseModels.backlogPlanningModel).toEqual({
|
|
model: 'sonnet',
|
|
thinkingLevel: 'medium',
|
|
});
|
|
});
|
|
|
|
it('should handle mixed format (some string, some object)', async () => {
|
|
// Edge case: mixed format (shouldn't happen but handle gracefully)
|
|
const mixedSettings = {
|
|
version: 2,
|
|
theme: 'dark',
|
|
phaseModels: {
|
|
enhancementModel: 'sonnet', // string
|
|
fileDescriptionModel: { model: 'haiku', thinkingLevel: 'low' }, // object
|
|
imageDescriptionModel: 'haiku', // string
|
|
validationModel: { model: 'opus' }, // object without thinkingLevel
|
|
specGenerationModel: 'opus',
|
|
featureGenerationModel: 'sonnet',
|
|
backlogPlanningModel: 'sonnet',
|
|
projectAnalysisModel: 'sonnet',
|
|
},
|
|
};
|
|
const settingsPath = path.join(testDataDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(mixedSettings, null, 2));
|
|
|
|
const settings = await settingsService.getGlobalSettings();
|
|
|
|
// Strings should be converted to objects
|
|
expect(settings.phaseModels.enhancementModel).toEqual({ model: 'sonnet' });
|
|
expect(settings.phaseModels.imageDescriptionModel).toEqual({ model: 'haiku' });
|
|
// Objects should be preserved
|
|
expect(settings.phaseModels.fileDescriptionModel).toEqual({
|
|
model: 'haiku',
|
|
thinkingLevel: 'low',
|
|
});
|
|
expect(settings.phaseModels.validationModel).toEqual({ model: 'opus' });
|
|
});
|
|
|
|
it('should migrate legacy enhancementModel/validationModel fields', async () => {
|
|
// Simulate v1 format with legacy fields
|
|
const v1Settings = {
|
|
version: 1,
|
|
theme: 'dark',
|
|
enhancementModel: 'haiku',
|
|
validationModel: 'opus',
|
|
// No phaseModels object
|
|
};
|
|
const settingsPath = path.join(testDataDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(v1Settings, null, 2));
|
|
|
|
const settings = await settingsService.getGlobalSettings();
|
|
|
|
// Legacy fields should be migrated to phaseModels
|
|
expect(settings.phaseModels.enhancementModel).toEqual({ model: 'haiku' });
|
|
expect(settings.phaseModels.validationModel).toEqual({ model: 'opus' });
|
|
// Other fields should use defaults
|
|
expect(settings.phaseModels.specGenerationModel).toEqual({ model: 'opus' });
|
|
});
|
|
|
|
it('should use default phase models when none are configured', async () => {
|
|
// Simulate empty settings
|
|
const emptySettings = {
|
|
version: 1,
|
|
theme: 'dark',
|
|
};
|
|
const settingsPath = path.join(testDataDir, 'settings.json');
|
|
await fs.writeFile(settingsPath, JSON.stringify(emptySettings, null, 2));
|
|
|
|
const settings = await settingsService.getGlobalSettings();
|
|
|
|
// Should use DEFAULT_PHASE_MODELS
|
|
expect(settings.phaseModels.enhancementModel).toEqual({ model: 'sonnet' });
|
|
expect(settings.phaseModels.fileDescriptionModel).toEqual({ model: 'haiku' });
|
|
expect(settings.phaseModels.specGenerationModel).toEqual({ model: 'opus' });
|
|
});
|
|
|
|
it('should deep merge phaseModels on update', async () => {
|
|
// Create initial settings with some phase models
|
|
await settingsService.updateGlobalSettings({
|
|
phaseModels: {
|
|
enhancementModel: { model: 'sonnet', thinkingLevel: 'high' },
|
|
},
|
|
});
|
|
|
|
// Update with a different phase model
|
|
await settingsService.updateGlobalSettings({
|
|
phaseModels: {
|
|
specGenerationModel: { model: 'opus', thinkingLevel: 'ultrathink' },
|
|
},
|
|
});
|
|
|
|
const settings = await settingsService.getGlobalSettings();
|
|
|
|
// Both should be preserved
|
|
expect(settings.phaseModels.enhancementModel).toEqual({
|
|
model: 'sonnet',
|
|
thinkingLevel: 'high',
|
|
});
|
|
expect(settings.phaseModels.specGenerationModel).toEqual({
|
|
model: 'opus',
|
|
thinkingLevel: 'ultrathink',
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('atomicWriteJson', () => {
|
|
// Skip on Windows as chmod doesn't work the same way (CI runs on Linux)
|
|
it.skipIf(process.platform === 'win32')(
|
|
'should handle write errors and clean up temp file',
|
|
async () => {
|
|
// Create a read-only directory to cause write errors
|
|
const readOnlyDir = path.join(os.tmpdir(), `readonly-${Date.now()}`);
|
|
await fs.mkdir(readOnlyDir, { recursive: true });
|
|
await fs.chmod(readOnlyDir, 0o444);
|
|
|
|
const readOnlyService = new SettingsService(readOnlyDir);
|
|
|
|
await expect(readOnlyService.updateGlobalSettings({ theme: 'light' })).rejects.toThrow();
|
|
|
|
await fs.chmod(readOnlyDir, 0o755);
|
|
await fs.rm(readOnlyDir, { recursive: true, force: true });
|
|
}
|
|
);
|
|
});
|
|
});
|