The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.
Rust agent-orchestrationai-agentsai-assistantdesktopllmlocal-firstmcppersonal-aiprivacyrustsecond-braintauri
import { fireEvent, screen, waitFor } from '@testing-library/react';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import {
clearVoiceProviderKey,
loadVoiceSettings,
saveVoiceSettings,
setVoiceProviderKey,
testVoiceProvider,
type VoiceSettings,
} from '../../../../services/api/voiceSettingsApi';
import { renderWithProviders } from '../../../../test/test-utils';
import {
openhumanVoiceSetProviders,
openhumanVoiceStatus,
type VoiceStatus,
} from '../../../../utils/tauriCommands';
import VoicePanel from '../VoicePanel';
vi.mock('../../../../utils/tauriCommands', () => ({
openhumanVoiceSetProviders: vi.fn(),
openhumanVoiceStatus: vi.fn(),
}));
vi.mock('../../../../services/api/voiceSettingsApi', async () => {
const actual = await vi.importActual<typeof import('../../../../services/api/voiceSettingsApi')>(
'../../../../services/api/voiceSettingsApi'
);
return {
...actual,
loadVoiceSettings: vi.fn(),
saveVoiceSettings: vi.fn(),
setVoiceProviderKey: vi.fn(),
clearVoiceProviderKey: vi.fn(),
testVoiceProvider: vi.fn(),
};
});
// Mascot voice preview path (issue #1762) goes through the existing
// `synthesizeSpeech` TTS RPC, which is heavy + makes real network calls
// in production. Mocked here so the Preview button click is observable
// without standing up a backend. Other ttsClient exports are
// passed-through so transitive importers (e.g. `useHumanMascot`) still
// resolve their cleanup paths.
vi.mock('../../../../features/human/voice/ttsClient', async () => {
const actual = await vi.importActual<typeof import('../../../../features/human/voice/ttsClient')>(
'../../../../features/human/voice/ttsClient'
);
return { ...actual, synthesizeSpeech: vi.fn() };
});
/** A registered ElevenLabs entry — the STT engine tests need a provider in the
* registry, because the routing dropdown only offers slugs it knows about. */
const ELEVENLABS_PROVIDER = {
id: '1',
slug: 'elevenlabs',
label: 'ElevenLabs',
endpoint: 'https://api.elevenlabs.io/v1',
auth_style: 'bearer',
capability: 'both' as const,
stt_api_style: 'elevenlabs',
tts_api_style: 'elevenlabs',
default_stt_model: 'scribe_v1',
default_tts_voice: 'JBFqnCBsd6RMkjVDRZzb',
has_api_key: true,
};
/** Build a minimal VoiceSettings with no external providers registered. */
const makeVoiceSettings = (overrides: Partial<VoiceSettings> = {}): VoiceSettings => ({
voiceProviders: [],
sttProvider: { kind: 'cloud' },
ttsProvider: { kind: 'cloud' },
...overrides,
});
type RuntimeHarness = { voiceStatus: VoiceStatus; voiceSettings: VoiceSettings };
describe('VoicePanel', () => {
let runtime: RuntimeHarness;
beforeEach(() => {
vi.clearAllMocks();
runtime = {
voiceStatus: {
stt_available: true,
tts_available: true,
stt_model_id: 'ggml-tiny-q5_1.bin',
tts_voice_id: 'en_US-lessac-medium',
piper_binary: null,
tts_voice_path: '/tmp/tts.onnx',
llm_cleanup_enabled: true,
stt_engine: 'cloud',
stt_error: null,
tts_provider: 'cloud',
},
voiceSettings: makeVoiceSettings(),
};
vi.mocked(openhumanVoiceStatus).mockImplementation(async () => ({ ...runtime.voiceStatus }));
vi.mocked(openhumanVoiceSetProviders).mockImplementation(async update => {
if (update.stt_provider) runtime.voiceStatus.stt_engine = update.stt_provider;
if (update.tts_provider) runtime.voiceStatus.tts_provider = update.tts_provider;
if (update.stt_model) runtime.voiceStatus.stt_model_id = update.stt_model;
if (update.tts_voice) runtime.voiceStatus.tts_voice_id = update.tts_voice;
return {
stt_provider: runtime.voiceStatus.stt_engine,
tts_provider: runtime.voiceStatus.tts_provider,
stt_model_id: runtime.voiceStatus.stt_model_id,
tts_voice_id: runtime.voiceStatus.tts_voice_id,
};
});
vi.mocked(loadVoiceSettings).mockImplementation(async () => ({ ...runtime.voiceSettings }));
vi.mocked(saveVoiceSettings).mockResolvedValue(undefined);
vi.mocked(setVoiceProviderKey).mockResolvedValue(undefined);
vi.mocked(clearVoiceProviderKey).mockResolvedValue(undefined);
vi.mocked(testVoiceProvider).mockResolvedValue({ ok: true, detail: 'OK' });
});
afterEach(() => {
vi.useRealTimers();
});
it('does not render ambient listening controls or send removed settings', async () => {
renderWithProviders(<VoicePanel />);
expect(screen.queryByTestId('voice-always-on-card')).not.toBeInTheDocument();
await waitFor(() => expect(openhumanVoiceStatus).toHaveBeenCalled());
const removedSettingParam = ['always', 'on', 'enabled'].join('_');
expect(openhumanVoiceSetProviders).not.toHaveBeenCalledWith(
expect.objectContaining({ [removedSettingParam]: expect.anything() })
);
});
// ─── Voice Routing Section ──────────────────────────────────────────────
it('renders the STT and TTS provider dropdowns defaulting to cloud', async () => {
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const sttSelect = (await screen.findByTestId('stt-provider-select')) as HTMLSelectElement;
const ttsSelect = (await screen.findByTestId('tts-provider-select')) as HTMLSelectElement;
await waitFor(() => expect(sttSelect.value).toBe('cloud'));
expect(ttsSelect.value).toBe('cloud');
});
it('renders the STT and TTS provider dropdowns seeded from loadVoiceSettings', async () => {
runtime.voiceSettings = makeVoiceSettings({
voiceProviders: [ELEVENLABS_PROVIDER],
sttProvider: { kind: 'external', providerSlug: 'elevenlabs', model: 'scribe_v1' },
ttsProvider: { kind: 'local', engine: 'piper', model: '' },
});
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const sttSelect = (await screen.findByTestId('stt-provider-select')) as HTMLSelectElement;
const ttsSelect = (await screen.findByTestId('tts-provider-select')) as HTMLSelectElement;
// Wait for the seeding effect from loadVoiceSettings.
await waitFor(() => expect(sttSelect.value).toBe('elevenlabs'));
expect(ttsSelect.value).toBe('piper');
// tts_voice_id is seeded to 'en_US-lessac-medium' which is a known preset,
// so the UI should render the preset select, not the free-text input.
expect(screen.getByTestId('tts-voice-select')).toBeInTheDocument();
expect(screen.queryByTestId('tts-voice-input')).not.toBeInTheDocument();
});
it('shows the effective hosted STT engine when cloud routing delegates to it', async () => {
runtime.voiceStatus.stt_engine = 'elevenlabs';
runtime.voiceSettings = makeVoiceSettings({
voiceProviders: [ELEVENLABS_PROVIDER],
sttProvider: { kind: 'cloud' },
});
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const sttSelect = (await screen.findByTestId('stt-provider-select')) as HTMLSelectElement;
await waitFor(() => expect(sttSelect.value).toBe('elevenlabs'));
});
it('selecting a new STT provider updates local state without immediately calling the RPC', async () => {
// Seed an external STT provider so the dropdown starts on a non-cloud value.
runtime.voiceSettings = makeVoiceSettings({
voiceProviders: [ELEVENLABS_PROVIDER],
sttProvider: { kind: 'external', providerSlug: 'elevenlabs', model: 'scribe_v1' },
ttsProvider: { kind: 'cloud' },
});
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const sttSelect = (await screen.findByTestId('stt-provider-select')) as HTMLSelectElement;
// Initial value should be elevenlabs (seeded from voiceSettings).
await waitFor(() => expect(sttSelect.value).toBe('elevenlabs'));
// Change back to cloud — just updates local state, no RPC yet.
fireEvent.change(sttSelect, { target: { value: 'cloud' } });
await waitFor(() => expect(sttSelect.value).toBe('cloud'));
// No RPC call yet — user must click Save.
expect(vi.mocked(openhumanVoiceSetProviders)).not.toHaveBeenCalled();
});
it('persists STT provider changes through openhumanVoiceSetProviders when Save is clicked', async () => {
runtime.voiceSettings = makeVoiceSettings({
voiceProviders: [ELEVENLABS_PROVIDER],
sttProvider: { kind: 'external', providerSlug: 'elevenlabs', model: 'scribe_v1' },
ttsProvider: { kind: 'cloud' },
});
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const sttSelect = (await screen.findByTestId('stt-provider-select')) as HTMLSelectElement;
await waitFor(() => expect(sttSelect.value).toBe('elevenlabs'));
// Switch back to cloud, then save.
fireEvent.change(sttSelect, { target: { value: 'cloud' } });
await waitFor(() => expect(sttSelect.value).toBe('cloud'));
const saveBtn = screen.getByTestId('save-voice-routing');
fireEvent.click(saveBtn);
await waitFor(() =>
expect(vi.mocked(openhumanVoiceSetProviders)).toHaveBeenCalledWith(
expect.objectContaining({ stt_provider: 'cloud' })
)
);
expect(await screen.findByText(/Voice providers saved/i)).toBeInTheDocument();
});
it('persists TTS provider changes through openhumanVoiceSetProviders when Save is clicked', async () => {
runtime.voiceSettings = makeVoiceSettings({
sttProvider: { kind: 'cloud' },
ttsProvider: { kind: 'local', engine: 'piper', model: '' },
});
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const ttsSelect = (await screen.findByTestId('tts-provider-select')) as HTMLSelectElement;
await waitFor(() => expect(ttsSelect.value).toBe('piper'));
// Switch to cloud, then save.
fireEvent.change(ttsSelect, { target: { value: 'cloud' } });
const saveBtn = screen.getByTestId('save-voice-routing');
fireEvent.click(saveBtn);
await waitFor(() =>
expect(vi.mocked(openhumanVoiceSetProviders)).toHaveBeenCalledWith(
expect.objectContaining({ tts_provider: 'cloud' })
)
);
});
it('Save button is disabled when no routing changes are pending', async () => {
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const saveBtn = await screen.findByTestId('save-voice-routing');
// No changes yet — button is disabled.
expect(saveBtn).toBeDisabled();
});
it('shows an error when persistProviders fails', async () => {
runtime.voiceSettings = makeVoiceSettings({
voiceProviders: [ELEVENLABS_PROVIDER],
sttProvider: { kind: 'external', providerSlug: 'elevenlabs', model: 'scribe_v1' },
ttsProvider: { kind: 'cloud' },
});
vi.mocked(openhumanVoiceSetProviders).mockRejectedValueOnce(new Error('RPC timeout'));
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
// Wait for the initial load to complete (elevenlabs seeded from voiceSettings).
const sttSelect = (await screen.findByTestId('stt-provider-select')) as HTMLSelectElement;
await waitFor(() => expect(sttSelect.value).toBe('elevenlabs'));
// Keep the saveRouting refresh pending so it does not clear the error set
// by the failed persistence attempt.
vi.mocked(openhumanVoiceStatus).mockImplementation(() => new Promise(() => {}));
// Change provider and click save to trigger the RPC error.
fireEvent.change(sttSelect, { target: { value: 'cloud' } });
const saveBtn = screen.getByTestId('save-voice-routing');
fireEvent.click(saveBtn);
await waitFor(() => expect(screen.getByText('RPC timeout')).toBeInTheDocument());
});
it('renders a preset select and calls persistProviders when a Piper voice preset is changed', async () => {
runtime.voiceSettings = makeVoiceSettings({
sttProvider: { kind: 'cloud' },
ttsProvider: { kind: 'local', engine: 'piper', model: '' },
});
runtime.voiceStatus.tts_voice_id = 'en_US-lessac-medium';
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const ttsSelect = (await screen.findByTestId('tts-provider-select')) as HTMLSelectElement;
await waitFor(() => expect(ttsSelect.value).toBe('piper'));
const voiceSelect = (await screen.findByTestId('tts-voice-select')) as HTMLSelectElement;
fireEvent.change(voiceSelect, { target: { value: 'en_US-ryan-medium' } });
await waitFor(() =>
expect(vi.mocked(openhumanVoiceSetProviders)).toHaveBeenCalledWith(
expect.objectContaining({ tts_voice: 'en_US-ryan-medium' })
)
);
});
// ─── Provider Chip Rendering ────────────────────────────────────────────
it('renders the managed cloud chip as always enabled and locked', async () => {
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
// The cloud chip aria-label uses the i18n key voice.providers.chip.cloudAria.
const cloudSwitch = screen.getByRole('switch', {
name: /OpenHuman managed provider is always enabled/i,
});
expect(cloudSwitch).toHaveAttribute('aria-checked', 'true');
expect(cloudSwitch).toBeDisabled();
});
it('renders the Piper chip as enabled and clickable (regression #2788)', async () => {
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
// The Piper chip must be reachable so users can route to their own
// local TTS engine without editing config.toml by hand. The chip is "off"
// until Piper is the active TTS routing target. There is no STT
// counterpart: every speech-to-text engine is hosted.
const piperChip = await screen.findByTestId('voice-provider-chip-piper');
expect(piperChip).not.toBeDisabled();
expect(piperChip).toHaveAttribute('aria-checked', 'false');
expect(screen.queryByTestId('voice-provider-chip-whisper')).not.toBeInTheDocument();
});
it('opens the setup modal when the Piper chip is clicked', async () => {
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
const piperChip = await screen.findByTestId('voice-provider-chip-piper');
fireEvent.click(piperChip);
expect(await screen.findByTestId('voice-provider-key-modal')).toBeInTheDocument();
});
it('renders the Piper chip as on when TTS routing is set to piper', async () => {
runtime.voiceSettings = makeVoiceSettings({
sttProvider: { kind: 'cloud' },
ttsProvider: { kind: 'local', engine: 'piper', model: '' },
});
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
const piperChip = await screen.findByTestId('voice-provider-chip-piper');
await waitFor(() => expect(piperChip).toHaveAttribute('aria-checked', 'true'));
});
it('renders the ElevenLabs chip as off when no provider is registered', async () => {
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
const elevenLabsChip = screen.getByTestId('voice-provider-chip-elevenlabs');
expect(elevenLabsChip).toHaveAttribute('aria-checked', 'false');
});
it('renders the ElevenLabs chip as on when the provider is registered', async () => {
runtime.voiceSettings = makeVoiceSettings({
voiceProviders: [
{
id: '1',
slug: 'elevenlabs',
label: 'ElevenLabs',
endpoint: 'https://api.elevenlabs.io/v1',
auth_style: 'bearer',
capability: 'both',
stt_api_style: 'elevenlabs',
tts_api_style: 'elevenlabs',
default_stt_model: 'scribe_v1',
default_tts_voice: 'JBFqnCBsd6RMkjVDRZzb',
has_api_key: true,
},
],
sttProvider: { kind: 'cloud' },
ttsProvider: { kind: 'cloud' },
});
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
const elevenLabsChip = await screen.findByTestId('voice-provider-chip-elevenlabs');
await waitFor(() => expect(elevenLabsChip).toHaveAttribute('aria-checked', 'true'));
});
it('opens the API key modal when an unregistered external provider chip is clicked', async () => {
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
const elevenLabsChip = screen.getByTestId('voice-provider-chip-elevenlabs');
fireEvent.click(elevenLabsChip);
expect(await screen.findByTestId('voice-provider-key-modal')).toBeInTheDocument();
});
// ─── loadVoiceSettings failure fallback ─────────────────────────────────
it('falls back to the voice_status stt_engine when loadVoiceSettings rejects', async () => {
// Older cores have no voice-provider registry RPC, so the panel seeds the
// routing dropdown from voice_status instead of rendering an empty picker.
runtime.voiceStatus.stt_engine = 'cloud';
vi.mocked(loadVoiceSettings).mockRejectedValueOnce(new Error('not found'));
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const sttSelect = (await screen.findByTestId('stt-provider-select')) as HTMLSelectElement;
await waitFor(() => expect(sttSelect.value).toBe('cloud'));
});
// ─── Error / notice display ─────────────────────────────────────────────
it('shows an error banner when voice status cannot be loaded', async () => {
vi.mocked(openhumanVoiceStatus).mockRejectedValueOnce(new Error('core offline'));
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await waitFor(() => expect(screen.getByText('core offline')).toBeInTheDocument());
});
// ─── STT / TTS Test buttons ────────────────────────────────────────────────
it('clicking Test STT calls testVoiceProvider and shows success result', async () => {
vi.mocked(testVoiceProvider).mockResolvedValueOnce({ ok: true, detail: 'STT OK' });
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const testSttBtn = await screen.findByTestId('test-stt-button');
fireEvent.click(testSttBtn);
await waitFor(() => expect(vi.mocked(testVoiceProvider)).toHaveBeenCalledWith('stt', 'cloud'));
expect(await screen.findByText('STT OK')).toBeInTheDocument();
});
it('clicking Test STT shows error result when testVoiceProvider rejects', async () => {
vi.mocked(testVoiceProvider).mockRejectedValueOnce(new Error('STT timeout'));
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const testSttBtn = await screen.findByTestId('test-stt-button');
fireEvent.click(testSttBtn);
await waitFor(() => expect(screen.getByText('STT timeout')).toBeInTheDocument());
});
it('clicking Test TTS calls testVoiceProvider and shows success result', async () => {
vi.mocked(testVoiceProvider).mockResolvedValueOnce({ ok: true, detail: 'TTS OK' });
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const testTtsBtn = await screen.findByTestId('test-tts-button');
fireEvent.click(testTtsBtn);
await waitFor(() => expect(vi.mocked(testVoiceProvider)).toHaveBeenCalledWith('tts', 'cloud'));
expect(await screen.findByText('TTS OK')).toBeInTheDocument();
});
it('clicking Test TTS shows error result when testVoiceProvider rejects', async () => {
vi.mocked(testVoiceProvider).mockRejectedValueOnce(new Error('TTS unreachable'));
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const testTtsBtn = await screen.findByTestId('test-tts-button');
fireEvent.click(testTtsBtn);
await waitFor(() => expect(screen.getByText('TTS unreachable')).toBeInTheDocument());
});
it('Test TTS with elevenlabs provider includes elevenlabs in provider string', async () => {
// Seed voiceSettings with elevenlabs as a registered external provider
runtime.voiceSettings = makeVoiceSettings({
sttProvider: { kind: 'cloud' },
ttsProvider: { kind: 'external', providerSlug: 'elevenlabs', model: '' },
voiceProviders: [
{
id: 'el-tts-test',
slug: 'elevenlabs',
label: 'ElevenLabs',
endpoint: 'https://api.elevenlabs.io/v1',
auth_style: 'bearer',
capability: 'both',
stt_api_style: 'elevenlabs',
tts_api_style: 'elevenlabs',
default_stt_model: 'scribe_v1',
default_tts_voice: 'JBFqnCBsd6RMkjVDRZzb',
has_api_key: true,
},
],
});
vi.mocked(testVoiceProvider).mockResolvedValueOnce({ ok: true, detail: 'EL OK' });
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const ttsSelect = (await screen.findByTestId('tts-provider-select')) as HTMLSelectElement;
await waitFor(() => expect(ttsSelect.value).toBe('elevenlabs'));
const testTtsBtn = await screen.findByTestId('test-tts-button');
fireEvent.click(testTtsBtn);
await waitFor(() =>
expect(vi.mocked(testVoiceProvider)).toHaveBeenCalledWith(
'tts',
expect.stringContaining('elevenlabs')
)
);
});
// ─── Test buttons gate on the user-supplied Piper resolving ────────────────
it('disables Test TTS while the user-supplied Piper binary or voice is missing', async () => {
runtime.voiceSettings = makeVoiceSettings({
ttsProvider: { kind: 'local', engine: 'piper', model: '' },
});
// `piperReady` keys off `voice_status.tts_available` alone — the app no
// longer installs Piper, so there is no installer state to consult.
runtime.voiceStatus.tts_available = false;
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const ttsSelect = (await screen.findByTestId('tts-provider-select')) as HTMLSelectElement;
await waitFor(() => expect(ttsSelect.value).toBe('piper'));
expect(await screen.findByTestId('test-tts-button')).toBeDisabled();
});
it('enables Test TTS once voice_status resolves the user-supplied Piper', async () => {
runtime.voiceSettings = makeVoiceSettings({
ttsProvider: { kind: 'local', engine: 'piper', model: '' },
});
runtime.voiceStatus.tts_available = true;
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const ttsSelect = (await screen.findByTestId('tts-provider-select')) as HTMLSelectElement;
await waitFor(() => expect(ttsSelect.value).toBe('piper'));
await waitFor(() => expect(screen.getByTestId('test-tts-button')).toBeEnabled());
});
// ─── TTS voice picker (Piper preset select) ─────────────────────────────────
it('shows the Piper voice preset select and selecting __custom__ is a no-op', async () => {
runtime.voiceSettings = makeVoiceSettings({
sttProvider: { kind: 'cloud' },
ttsProvider: { kind: 'local', engine: 'piper', model: '' },
});
runtime.voiceStatus.tts_voice_id = 'en_US-lessac-medium';
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const ttsVoiceSelect = (await screen.findByTestId('tts-voice-select')) as HTMLSelectElement;
const beforeCallCount = vi.mocked(openhumanVoiceSetProviders).mock.calls.length;
// Selecting __custom__ should not trigger persistProviders
fireEvent.change(ttsVoiceSelect, { target: { value: '__custom__' } });
// Give async effects time to fire
await new Promise(r => setTimeout(r, 50));
expect(vi.mocked(openhumanVoiceSetProviders).mock.calls.length).toBe(beforeCallCount);
});
// ─── Modal: Piper is user-supplied (no installer) ───────────────────────────
it('shows the self-install hint and no install button in the Piper modal', async () => {
runtime.voiceStatus.tts_available = false;
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
fireEvent.click(await screen.findByTestId('voice-provider-chip-piper'));
await screen.findByTestId('voice-provider-key-modal');
expect(screen.getByTestId('voice-piper-self-install-hint')).toHaveTextContent(/PIPER_BIN/);
expect(screen.getByTestId('voice-piper-status')).toHaveTextContent(/^Piper not found$/);
expect(screen.queryByRole('button', { name: /install locally/i })).not.toBeInTheDocument();
});
it('Check again re-reads voice_status and enables Piper once it resolves', async () => {
runtime.voiceStatus.tts_available = false;
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
fireEvent.click(await screen.findByTestId('voice-provider-chip-piper'));
await screen.findByTestId('voice-provider-key-modal');
expect(screen.getByRole('button', { name: /^Enable$/i })).toBeDisabled();
// The user installs Piper themselves, then asks the panel to look again.
runtime.voiceStatus.tts_available = true;
const callsBefore = vi.mocked(openhumanVoiceStatus).mock.calls.length;
fireEvent.click(screen.getByTestId('voice-piper-recheck'));
await waitFor(() =>
expect(vi.mocked(openhumanVoiceStatus).mock.calls.length).toBeGreaterThan(callsBefore)
);
await waitFor(() =>
expect(screen.getByTestId('voice-piper-status')).toHaveTextContent(/^Piper found$/)
);
expect(screen.getByRole('button', { name: /^Enable$/i })).not.toBeDisabled();
});
// ─── Modal: Enable button for local providers ──────────────────────────────
it('keeps Enable disabled in the Piper modal until Piper resolves', async () => {
runtime.voiceStatus.tts_available = false;
runtime.voiceStatus.tts_voice_path = null;
runtime.voiceStatus.piper_binary = null;
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
const piperChip = await screen.findByTestId('voice-provider-chip-piper');
fireEvent.click(piperChip);
await screen.findByTestId('voice-provider-key-modal');
const enableBtn = screen.getByRole('button', { name: /^Enable$/i });
expect(enableBtn).toBeDisabled();
fireEvent.click(enableBtn);
expect(screen.getByTestId('voice-provider-key-modal')).toBeInTheDocument();
expect(vi.mocked(openhumanVoiceSetProviders)).not.toHaveBeenCalled();
});
it('allows Enable in the Piper modal when voice_status reports local TTS ready', async () => {
runtime.voiceStatus.tts_available = true;
runtime.voiceStatus.tts_voice_path = '/legacy/voices/en_US-lessac-medium.onnx';
runtime.voiceStatus.piper_binary = '/usr/local/bin/piper';
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
const piperChip = await screen.findByTestId('voice-provider-chip-piper');
fireEvent.click(piperChip);
await screen.findByTestId('voice-provider-key-modal');
const enableBtn = screen.getByRole('button', { name: /^Enable$/i });
expect(enableBtn).not.toBeDisabled();
fireEvent.click(enableBtn);
await waitFor(() =>
expect(screen.queryByTestId('voice-provider-key-modal')).not.toBeInTheDocument()
);
});
it('clicking Enable inside the Piper modal calls persistProviders and closes modal', async () => {
runtime.voiceStatus.tts_available = true;
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
const piperChip = await screen.findByTestId('voice-provider-chip-piper');
fireEvent.click(piperChip);
await screen.findByTestId('voice-provider-key-modal');
const enableBtn = screen.getByRole('button', { name: /^Enable$/i });
expect(enableBtn).not.toBeDisabled();
fireEvent.click(enableBtn);
await waitFor(() =>
expect(screen.queryByTestId('voice-provider-key-modal')).not.toBeInTheDocument()
);
});
// ─── Modal: Cancel button ──────────────────────────────────────────────────
// ─── External provider (ElevenLabs) modal API-key flow ────────────────────
it('opening ElevenLabs modal, entering a key, and clicking Save & Enable calls handlers', async () => {
vi.mocked(setVoiceProviderKey).mockResolvedValue(undefined);
vi.mocked(saveVoiceSettings).mockResolvedValue(undefined);
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
const elevenLabsChip = screen.getByTestId('voice-provider-chip-elevenlabs');
fireEvent.click(elevenLabsChip);
await screen.findByTestId('voice-provider-key-modal');
// Enter an API key (placeholder is 'sk-…' from i18n)
const keyInput = screen.getByPlaceholderText(/sk/i);
fireEvent.change(keyInput, { target: { value: 'sk-test-key-el-1234567890' } });
const saveBtn = screen.getByRole('button', { name: /save.*enable/i });
fireEvent.click(saveBtn);
await waitFor(() => expect(vi.mocked(setVoiceProviderKey)).toHaveBeenCalled());
});
// ─── Modal: "Test Key" is a dry run (#5896) ───────────────────────────────
//
// The regression these guard: the Test handler used to call
// `handleEnableExternalProvider` before testing, which (a) wrote the key to
// the keychain and activated the provider before it was known to work, and
// (b) cleared `pendingKeySlug` — unmounting the modal, so the result alert
// it then set could never render.
it('clicking Test Key validates without saving or activating the provider', async () => {
vi.mocked(testVoiceProvider).mockResolvedValueOnce({ ok: true, detail: 'Key OK' });
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
fireEvent.click(screen.getByTestId('voice-provider-chip-elevenlabs'));
await screen.findByTestId('voice-provider-key-modal');
const keyInput = screen.getByPlaceholderText(/sk/i);
fireEvent.change(keyInput, { target: { value: 'sk-candidate-key-1234567890' } });
fireEvent.click(screen.getByRole('button', { name: /^Test Key$/i }));
await waitFor(() => expect(vi.mocked(testVoiceProvider)).toHaveBeenCalled());
// The candidate key travels to the core for validation only.
expect(vi.mocked(testVoiceProvider)).toHaveBeenCalledWith(
'stt',
'elevenlabs',
true,
'sk-candidate-key-1234567890'
);
// Nothing is persisted and nothing is activated by a test.
expect(vi.mocked(setVoiceProviderKey)).not.toHaveBeenCalled();
expect(vi.mocked(saveVoiceSettings)).not.toHaveBeenCalled();
});
it('keeps the modal mounted after Test Key so the result is visible', async () => {
vi.mocked(testVoiceProvider).mockResolvedValueOnce({
ok: true,
detail: 'Provider key is valid (12ms)',
});
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
fireEvent.click(screen.getByTestId('voice-provider-chip-elevenlabs'));
await screen.findByTestId('voice-provider-key-modal');
fireEvent.change(screen.getByPlaceholderText(/sk/i), {
target: { value: 'sk-candidate-key-1234567890' },
});
fireEvent.click(screen.getByRole('button', { name: /^Test Key$/i }));
// The alert is the whole point of the button — if the modal has unmounted
// by the time the result lands, this text never appears.
expect(await screen.findByText(/Provider key is valid/i)).toBeInTheDocument();
expect(screen.getByTestId('voice-provider-key-modal')).toBeInTheDocument();
});
it('surfaces a failed Test Key without saving the bad key', async () => {
vi.mocked(testVoiceProvider).mockResolvedValueOnce({
ok: false,
detail: 'Key test failed: API returned 401 Unauthorized',
});
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
fireEvent.click(screen.getByTestId('voice-provider-chip-elevenlabs'));
await screen.findByTestId('voice-provider-key-modal');
fireEvent.change(screen.getByPlaceholderText(/sk/i), {
target: { value: 'sk-wrong-key-1234567890' },
});
fireEvent.click(screen.getByRole('button', { name: /^Test Key$/i }));
expect(await screen.findByText(/401 Unauthorized/i)).toBeInTheDocument();
// The user is left free to correct the key: it was never written.
expect(vi.mocked(setVoiceProviderKey)).not.toHaveBeenCalled();
expect(screen.getByTestId('voice-provider-key-modal')).toBeInTheDocument();
});
it('renders a thrown Test Key error without saving the key', async () => {
// A rejected RPC (transport dead, core down) takes the `catch` branch,
// which is a different path from a resolved `{ ok: false }` verdict.
vi.mocked(testVoiceProvider).mockRejectedValueOnce(new Error('core unreachable'));
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
fireEvent.click(screen.getByTestId('voice-provider-chip-elevenlabs'));
await screen.findByTestId('voice-provider-key-modal');
fireEvent.change(screen.getByPlaceholderText(/sk/i), {
target: { value: 'sk-key-for-a-dead-core' },
});
fireEvent.click(screen.getByRole('button', { name: /^Test Key$/i }));
expect(await screen.findByText(/core unreachable/i)).toBeInTheDocument();
expect(screen.getByTestId('voice-provider-key-modal')).toBeInTheDocument();
expect(vi.mocked(setVoiceProviderKey)).not.toHaveBeenCalled();
});
it('discards an in-flight Test Key result when the key is edited', async () => {
// The key field stays editable during a test (it is disabled only while
// *saving*). Without the request-id guard, key A's verdict lands next to
// key B and reads as a validation of B.
let resolveTest: (r: { ok: boolean; detail: string }) => void = () => {};
vi.mocked(testVoiceProvider).mockReturnValueOnce(
// Annotated: `VoiceTestResult` is not exported, and a bare `new Promise`
// would infer `Promise<unknown>` and fail typecheck on the mock.
new Promise<{ ok: boolean; detail: string }>(resolve => {
resolveTest = resolve;
})
);
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
fireEvent.click(screen.getByTestId('voice-provider-chip-elevenlabs'));
await screen.findByTestId('voice-provider-key-modal');
const keyInput = screen.getByPlaceholderText(/sk/i);
fireEvent.change(keyInput, { target: { value: 'sk-key-AAAA-1234567890' } });
fireEvent.click(screen.getByRole('button', { name: /^Test Key$/i }));
// User edits to a different key before the verdict for the first arrives.
fireEvent.change(keyInput, { target: { value: 'sk-key-BBBB-0987654321' } });
resolveTest({ ok: true, detail: 'STALE VERDICT FOR KEY A' });
await waitFor(() => expect(screen.getByRole('button', { name: /^Test Key$/i })).toBeEnabled());
expect(screen.queryByText(/STALE VERDICT FOR KEY A/i)).not.toBeInTheDocument();
});
it('the ElevenLabs modal Cancel button closes without saving', async () => {
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
await screen.findByTestId('voice-providers-section');
const elevenLabsChip = screen.getByTestId('voice-provider-chip-elevenlabs');
fireEvent.click(elevenLabsChip);
await screen.findByTestId('voice-provider-key-modal');
const cancelBtn = screen.getByRole('button', { name: /^Cancel$/i });
fireEvent.click(cancelBtn);
await waitFor(() =>
expect(screen.queryByTestId('voice-provider-key-modal')).not.toBeInTheDocument()
);
expect(vi.mocked(setVoiceProviderKey)).not.toHaveBeenCalled();
});
// ─── Mascot voice link ─────────────────────────────────────────────────────
it('shows the mascot voice section link when TTS is not Piper', async () => {
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
// Default TTS = cloud, so the mascot voice link section should appear
await screen.findByTestId('mascot-voice-link');
});
it('hides the mascot voice link when TTS provider is piper', async () => {
runtime.voiceSettings = makeVoiceSettings({
sttProvider: { kind: 'cloud' },
ttsProvider: { kind: 'local', engine: 'piper', model: '' },
});
runtime.voiceStatus.tts_voice_id = 'en_US-lessac-medium';
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const ttsSelect = (await screen.findByTestId('tts-provider-select')) as HTMLSelectElement;
await waitFor(() => expect(ttsSelect.value).toBe('piper'));
expect(screen.queryByTestId('mascot-voice-link')).not.toBeInTheDocument();
});
// ─── ElevenLabs voice select in routing section ────────────────────────────
it('shows the ElevenLabs voice select when TTS provider is elevenlabs', async () => {
runtime.voiceSettings = makeVoiceSettings({
sttProvider: { kind: 'cloud' },
ttsProvider: { kind: 'cloud' },
voiceProviders: [
{
id: 'el-1',
slug: 'elevenlabs',
label: 'ElevenLabs',
endpoint: 'https://api.elevenlabs.io/v1',
auth_style: 'bearer',
capability: 'both',
stt_api_style: 'elevenlabs',
tts_api_style: 'elevenlabs',
default_stt_model: 'scribe_v1',
default_tts_voice: 'JBFqnCBsd6RMkjVDRZzb',
has_api_key: true,
},
],
});
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const ttsSelect = (await screen.findByTestId('tts-provider-select')) as HTMLSelectElement;
// Switch to elevenlabs
fireEvent.change(ttsSelect, { target: { value: 'elevenlabs' } });
await waitFor(() =>
expect(screen.queryByTestId('elevenlabs-voice-select')).toBeInTheDocument()
);
});
it('selecting __custom__ in ElevenLabs voice preset is a no-op (does not update state)', async () => {
runtime.voiceSettings = makeVoiceSettings({
sttProvider: { kind: 'cloud' },
ttsProvider: { kind: 'cloud' },
voiceProviders: [
{
id: 'el-2',
slug: 'elevenlabs',
label: 'ElevenLabs',
endpoint: 'https://api.elevenlabs.io/v1',
auth_style: 'bearer',
capability: 'both',
stt_api_style: 'elevenlabs',
tts_api_style: 'elevenlabs',
default_stt_model: 'scribe_v1',
default_tts_voice: 'JBFqnCBsd6RMkjVDRZzb',
has_api_key: true,
},
],
});
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const ttsSelect = (await screen.findByTestId('tts-provider-select')) as HTMLSelectElement;
fireEvent.change(ttsSelect, { target: { value: 'elevenlabs' } });
const elVoiceSelect = (await screen.findByTestId(
'elevenlabs-voice-select'
)) as HTMLSelectElement;
const valueBefore = elVoiceSelect.value;
fireEvent.change(elVoiceSelect, { target: { value: '__custom__' } });
// Value should not change to __custom__
await new Promise(r => setTimeout(r, 50));
expect(elVoiceSelect.value).toBe(valueBefore);
});
// ─── Save routing ─────────────────────────────────────────────────────────
it('save routing button shows success notice after persisting', async () => {
runtime.voiceSettings = makeVoiceSettings({
sttProvider: { kind: 'cloud' },
ttsProvider: { kind: 'local', engine: 'piper', model: '' },
});
runtime.voiceStatus.tts_voice_id = 'en_US-lessac-medium';
renderWithProviders(<VoicePanel />, { initialEntries: ['/settings/voice'] });
const ttsSelect = (await screen.findByTestId('tts-provider-select')) as HTMLSelectElement;
await waitFor(() => expect(ttsSelect.value).toBe('piper'));
// Switch to cloud and save
fireEvent.change(ttsSelect, { target: { value: 'cloud' } });
const saveBtn = await screen.findByTestId('save-voice-routing');
fireEvent.click(saveBtn);
await waitFor(() => expect(screen.queryByText(/Voice providers saved/i)).toBeInTheDocument());
});
});