mirror of
https://github.com/google-gemini/gemini-cli.git
synced 2026-03-21 03:21:11 -07:00
353 lines
12 KiB
TypeScript
353 lines
12 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright 2025 Google LLC
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
// Patch: Unset NO_COLOR at the very top before any imports
|
|
if (process.env['NO_COLOR'] !== undefined) {
|
|
delete process.env['NO_COLOR'];
|
|
}
|
|
|
|
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
|
import { themeManager, DEFAULT_THEME } from './theme-manager.js';
|
|
import type { CustomTheme } from '@google/gemini-cli-core';
|
|
import * as fs from 'node:fs';
|
|
import * as os from 'node:os';
|
|
import type * as osActual from 'node:os';
|
|
import { debugLogger } from '@google/gemini-cli-core';
|
|
|
|
vi.mock('node:fs');
|
|
vi.mock('node:os', async (importOriginal) => {
|
|
const actualOs = await importOriginal<typeof osActual>();
|
|
return {
|
|
...actualOs,
|
|
homedir: vi.fn(),
|
|
platform: vi.fn(() => 'linux'),
|
|
};
|
|
});
|
|
|
|
vi.mock('@google/gemini-cli-core', async (importOriginal) => {
|
|
const actual =
|
|
await importOriginal<typeof import('@google/gemini-cli-core')>();
|
|
return {
|
|
...actual,
|
|
homedir: () => os.homedir(),
|
|
};
|
|
});
|
|
|
|
const validCustomTheme: CustomTheme = {
|
|
type: 'custom',
|
|
name: 'MyCustomTheme',
|
|
Background: '#000000',
|
|
Foreground: '#ffffff',
|
|
LightBlue: '#89BDCD',
|
|
AccentBlue: '#3B82F6',
|
|
AccentPurple: '#8B5CF6',
|
|
AccentCyan: '#06B6D4',
|
|
AccentGreen: '#3CA84B',
|
|
AccentYellow: 'yellow',
|
|
AccentRed: 'red',
|
|
DiffAdded: 'green',
|
|
DiffRemoved: 'red',
|
|
Comment: 'gray',
|
|
Gray: 'gray',
|
|
};
|
|
|
|
describe('ThemeManager', () => {
|
|
beforeEach(() => {
|
|
// Reset themeManager state
|
|
themeManager.loadCustomThemes({});
|
|
themeManager.setActiveTheme(DEFAULT_THEME.name);
|
|
themeManager.setTerminalBackground(undefined);
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it('should load valid custom themes', () => {
|
|
themeManager.loadCustomThemes({ MyCustomTheme: validCustomTheme });
|
|
expect(themeManager.getCustomThemeNames()).toContain('MyCustomTheme');
|
|
expect(themeManager.isCustomTheme('MyCustomTheme')).toBe(true);
|
|
});
|
|
|
|
it('should set and get the active theme', () => {
|
|
expect(themeManager.getActiveTheme().name).toBe(DEFAULT_THEME.name);
|
|
themeManager.setActiveTheme('Ayu');
|
|
expect(themeManager.getActiveTheme().name).toBe('Ayu');
|
|
});
|
|
|
|
it('should set and get a custom active theme', () => {
|
|
themeManager.loadCustomThemes({ MyCustomTheme: validCustomTheme });
|
|
themeManager.setActiveTheme('MyCustomTheme');
|
|
expect(themeManager.getActiveTheme().name).toBe('MyCustomTheme');
|
|
});
|
|
|
|
it('should return false when setting a non-existent theme', () => {
|
|
expect(themeManager.setActiveTheme('NonExistentTheme')).toBe(false);
|
|
expect(themeManager.getActiveTheme().name).toBe(DEFAULT_THEME.name);
|
|
});
|
|
|
|
it('should list available themes including custom themes', () => {
|
|
themeManager.loadCustomThemes({ MyCustomTheme: validCustomTheme });
|
|
const available = themeManager.getAvailableThemes();
|
|
expect(
|
|
available.some(
|
|
(t: { name: string; isCustom?: boolean }) =>
|
|
t.name === 'MyCustomTheme' && t.isCustom,
|
|
),
|
|
).toBe(true);
|
|
});
|
|
|
|
it('should get a theme by name', () => {
|
|
expect(themeManager.getTheme('Ayu')).toBeDefined();
|
|
themeManager.loadCustomThemes({ MyCustomTheme: validCustomTheme });
|
|
expect(themeManager.getTheme('MyCustomTheme')).toBeDefined();
|
|
});
|
|
|
|
it('should fall back to default theme if active theme is invalid', () => {
|
|
(themeManager as unknown as { activeTheme: unknown }).activeTheme = {
|
|
name: 'NonExistent',
|
|
type: 'custom',
|
|
};
|
|
expect(themeManager.getActiveTheme().name).toBe(DEFAULT_THEME.name);
|
|
});
|
|
|
|
it('should return NoColorTheme if NO_COLOR is set', () => {
|
|
const original = process.env['NO_COLOR'];
|
|
process.env['NO_COLOR'] = '1';
|
|
expect(themeManager.getActiveTheme().name).toBe('NoColor');
|
|
if (original === undefined) {
|
|
delete process.env['NO_COLOR'];
|
|
} else {
|
|
process.env['NO_COLOR'] = original;
|
|
}
|
|
});
|
|
|
|
describe('when loading a theme from a file', () => {
|
|
const mockThemePath = './my-theme.json';
|
|
const mockTheme: CustomTheme = {
|
|
...validCustomTheme,
|
|
name: 'My File Theme',
|
|
};
|
|
|
|
beforeEach(() => {
|
|
vi.mocked(os.homedir).mockReturnValue('/home/user');
|
|
vi.spyOn(fs, 'realpathSync').mockImplementation((p) => p as string);
|
|
});
|
|
|
|
it('should load a theme from a valid file path', () => {
|
|
vi.spyOn(fs, 'existsSync').mockReturnValue(true);
|
|
vi.spyOn(fs, 'readFileSync').mockReturnValue(JSON.stringify(mockTheme));
|
|
|
|
const result = themeManager.setActiveTheme('/home/user/my-theme.json');
|
|
|
|
expect(result).toBe(true);
|
|
const activeTheme = themeManager.getActiveTheme();
|
|
expect(activeTheme.name).toBe('My File Theme');
|
|
expect(fs.readFileSync).toHaveBeenCalledWith(
|
|
expect.stringContaining('my-theme.json'),
|
|
'utf-8',
|
|
);
|
|
});
|
|
|
|
it('should not load a theme if the file does not exist', () => {
|
|
vi.spyOn(fs, 'existsSync').mockReturnValue(false);
|
|
|
|
const result = themeManager.setActiveTheme(mockThemePath);
|
|
|
|
expect(result).toBe(false);
|
|
expect(themeManager.getActiveTheme().name).toBe(DEFAULT_THEME.name);
|
|
});
|
|
|
|
it('should not load a theme from a file with invalid JSON', () => {
|
|
vi.spyOn(fs, 'existsSync').mockReturnValue(true);
|
|
vi.spyOn(fs, 'readFileSync').mockReturnValue('invalid json');
|
|
|
|
const result = themeManager.setActiveTheme(mockThemePath);
|
|
|
|
expect(result).toBe(false);
|
|
expect(themeManager.getActiveTheme().name).toBe(DEFAULT_THEME.name);
|
|
});
|
|
|
|
it('should not load a theme from an untrusted file path and log a message', () => {
|
|
vi.spyOn(fs, 'existsSync').mockReturnValue(true);
|
|
vi.spyOn(fs, 'readFileSync').mockReturnValue(JSON.stringify(mockTheme));
|
|
const consoleWarnSpy = vi
|
|
.spyOn(debugLogger, 'warn')
|
|
.mockImplementation(() => {});
|
|
|
|
const result = themeManager.setActiveTheme('/untrusted/my-theme.json');
|
|
|
|
expect(result).toBe(false);
|
|
expect(themeManager.getActiveTheme().name).toBe(DEFAULT_THEME.name);
|
|
expect(consoleWarnSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining('is outside your home directory'),
|
|
);
|
|
|
|
consoleWarnSpy.mockRestore();
|
|
});
|
|
});
|
|
|
|
describe('extension themes', () => {
|
|
it('should register and unregister themes from extensions with namespacing', () => {
|
|
const extTheme: CustomTheme = {
|
|
...validCustomTheme,
|
|
name: 'ExtensionTheme',
|
|
};
|
|
const extensionName = 'test-extension';
|
|
const namespacedName = `ExtensionTheme (${extensionName})`;
|
|
|
|
themeManager.registerExtensionThemes(extensionName, [extTheme]);
|
|
expect(themeManager.getCustomThemeNames()).toContain(namespacedName);
|
|
expect(themeManager.isCustomTheme(namespacedName)).toBe(true);
|
|
|
|
themeManager.unregisterExtensionThemes(extensionName, [extTheme]);
|
|
expect(themeManager.getCustomThemeNames()).not.toContain(namespacedName);
|
|
expect(themeManager.isCustomTheme(namespacedName)).toBe(false);
|
|
});
|
|
|
|
it('should not allow extension themes to overwrite built-in themes even with prefixing', () => {
|
|
// availableThemes has 'Ayu'.
|
|
// We verify that it DOES prefix, so it won't collide even if extension name is similar.
|
|
themeManager.registerExtensionThemes('Ext', [
|
|
{ ...validCustomTheme, name: 'Theme' },
|
|
]);
|
|
expect(themeManager.getCustomThemeNames()).toContain('Theme (Ext)');
|
|
});
|
|
|
|
it('should allow extension themes and settings themes to coexist', () => {
|
|
const extTheme: CustomTheme = {
|
|
...validCustomTheme,
|
|
name: 'ExtensionTheme',
|
|
};
|
|
const settingsTheme: CustomTheme = {
|
|
...validCustomTheme,
|
|
name: 'SettingsTheme',
|
|
};
|
|
|
|
themeManager.registerExtensionThemes('Ext', [extTheme]);
|
|
themeManager.loadCustomThemes({ SettingsTheme: settingsTheme });
|
|
|
|
expect(themeManager.getCustomThemeNames()).toContain(
|
|
'ExtensionTheme (Ext)',
|
|
);
|
|
expect(themeManager.getCustomThemeNames()).toContain('SettingsTheme');
|
|
|
|
expect(themeManager.isCustomTheme('ExtensionTheme (Ext)')).toBe(true);
|
|
expect(themeManager.isCustomTheme('SettingsTheme')).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('terminalBackground override', () => {
|
|
it('should store and retrieve terminal background', () => {
|
|
themeManager.setTerminalBackground('#123456');
|
|
expect(themeManager.getTerminalBackground()).toBe('#123456');
|
|
themeManager.setTerminalBackground(undefined);
|
|
expect(themeManager.getTerminalBackground()).toBeUndefined();
|
|
});
|
|
|
|
it('should override background.primary in semantic colors when terminal background is set', () => {
|
|
const color = '#1a1a1a';
|
|
themeManager.setTerminalBackground(color);
|
|
const semanticColors = themeManager.getSemanticColors();
|
|
expect(semanticColors.background.primary).toBe(color);
|
|
});
|
|
|
|
it('should override Background in colors when terminal background is set', () => {
|
|
const color = '#1a1a1a';
|
|
themeManager.setTerminalBackground(color);
|
|
const colors = themeManager.getColors();
|
|
expect(colors.Background).toBe(color);
|
|
});
|
|
|
|
it('should re-calculate dependent semantic colors when terminal background is set', () => {
|
|
themeManager.setTerminalBackground('#000000');
|
|
const semanticColors = themeManager.getSemanticColors();
|
|
|
|
// border.default should be interpolated from background (#000000) and Gray
|
|
// ui.dark should be interpolated from Gray and background (#000000)
|
|
expect(semanticColors.border.default).toBeDefined();
|
|
expect(semanticColors.ui.dark).toBeDefined();
|
|
expect(semanticColors.border.default).not.toBe(
|
|
DEFAULT_THEME.semanticColors.border.default,
|
|
);
|
|
});
|
|
|
|
it('should return original semantic colors when terminal background is NOT set', () => {
|
|
themeManager.setTerminalBackground(undefined);
|
|
const semanticColors = themeManager.getSemanticColors();
|
|
expect(semanticColors).toEqual(DEFAULT_THEME.semanticColors);
|
|
});
|
|
|
|
it('should NOT override background when theme is incompatible (Light theme on Dark terminal)', () => {
|
|
themeManager.setActiveTheme('Default Light');
|
|
const darkTerminalBg = '#000000';
|
|
themeManager.setTerminalBackground(darkTerminalBg);
|
|
|
|
const semanticColors = themeManager.getSemanticColors();
|
|
expect(semanticColors.background.primary).toBe(
|
|
themeManager.getTheme('Default Light')!.colors.Background,
|
|
);
|
|
|
|
const colors = themeManager.getColors();
|
|
expect(colors.Background).toBe(
|
|
themeManager.getTheme('Default Light')!.colors.Background,
|
|
);
|
|
});
|
|
|
|
it('should NOT override background when theme is incompatible (Dark theme on Light terminal)', () => {
|
|
themeManager.setActiveTheme('Default');
|
|
const lightTerminalBg = '#FFFFFF';
|
|
themeManager.setTerminalBackground(lightTerminalBg);
|
|
|
|
const semanticColors = themeManager.getSemanticColors();
|
|
expect(semanticColors.background.primary).toBe(
|
|
themeManager.getTheme('Default')!.colors.Background,
|
|
);
|
|
|
|
const colors = themeManager.getColors();
|
|
expect(colors.Background).toBe(
|
|
themeManager.getTheme('Default')!.colors.Background,
|
|
);
|
|
});
|
|
|
|
it('should override background for custom theme when compatible', () => {
|
|
themeManager.loadCustomThemes({
|
|
MyDark: {
|
|
name: 'MyDark',
|
|
type: 'custom',
|
|
Background: '#000000',
|
|
Foreground: '#ffffff',
|
|
},
|
|
});
|
|
themeManager.setActiveTheme('MyDark');
|
|
|
|
const darkTerminalBg = '#1a1a1a';
|
|
themeManager.setTerminalBackground(darkTerminalBg);
|
|
|
|
const semanticColors = themeManager.getSemanticColors();
|
|
expect(semanticColors.background.primary).toBe(darkTerminalBg);
|
|
});
|
|
|
|
it('should NOT override background for custom theme when incompatible', () => {
|
|
themeManager.loadCustomThemes({
|
|
MyLight: {
|
|
name: 'MyLight',
|
|
type: 'custom',
|
|
Background: '#ffffff',
|
|
Foreground: '#000000',
|
|
},
|
|
});
|
|
themeManager.setActiveTheme('MyLight');
|
|
|
|
const darkTerminalBg = '#000000';
|
|
themeManager.setTerminalBackground(darkTerminalBg);
|
|
|
|
const semanticColors = themeManager.getSemanticColors();
|
|
expect(semanticColors.background.primary).toBe('#ffffff');
|
|
});
|
|
});
|
|
});
|