Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { StrictMode } from 'react';
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { render, screen, waitFor, fireEvent, act, within } from '@testing-library/react';
import { MemoryRouter } from 'react-router';
// ── Mocks must be declared before any imports that use them ──────────────────
const mockUploadRequest = vi.fn();
vi.mock('../services/apiCore.js', async importOriginal => ({ ...await importOriginal(), request: (...args) => mockUploadRequest(...args) }));
const mockGetMoodBoard = vi.fn();
const mockUpdateMoodBoard = vi.fn();
const mockAddMoodBoardItem = vi.fn();
const mockUpdateMoodBoardItem = vi.fn();
const mockSyncMoodBoardPinterest = vi.fn();
const mockImportMoodBoardPinterest = vi.fn();
const mockImportMoodBoardXPost = vi.fn();
const mockLocalizeMoodBoardMedia = vi.fn();
const mockRenderMoodBoardItem = vi.fn();
const socketHandlers = new Map();
const mockNavigate = vi.fn();
vi.mock('../services/socket', () => ({
default: {
on: (evt, fn) => socketHandlers.set(evt, fn),
off: (evt) => socketHandlers.delete(evt),
},
}));
vi.mock('../services/api', () => ({
getMoodBoard: (...args) => mockGetMoodBoard(...args),
updateMoodBoard: (...args) => mockUpdateMoodBoard(...args),
addMoodBoardItem: (...args) => mockAddMoodBoardItem(...args),
updateMoodBoardItem: (...args) => mockUpdateMoodBoardItem(...args),
removeMoodBoardItem: vi.fn(),
linkMoodBoardPinterest: vi.fn(),
unlinkMoodBoardPinterest: vi.fn(),
syncMoodBoardPinterest: (...args) => mockSyncMoodBoardPinterest(...args),
importMoodBoardPinterest: (...args) => mockImportMoodBoardPinterest(...args),
importMoodBoardXPost: (...args) => mockImportMoodBoardXPost(...args),
localizeMoodBoardMedia: (...args) => mockLocalizeMoodBoardMedia(...args),
renderMoodBoardItem: (...args) => mockRenderMoodBoardItem(...args),
}));
const mockToastError = vi.fn();
const mockToastSuccess = vi.fn();
vi.mock('../components/ui/Toast', () => ({
default: Object.assign(vi.fn(), {
success: (...args) => mockToastSuccess(...args),
error: (...args) => mockToastError(...args),
warning: vi.fn(),
}),
}));
// Stub the prompt-from-media modal (#4188 Phase 3) — the analysis flow under
// test is the page's own wiring (open, persist via onResult, stored-analysis
// children), not the analyzer internals, which have their own suite.
let analysisDelay = null;
vi.mock('../components/imageGen/GalleryImagePicker', () => ({ default: ({ open, onSelect }) => open ? <button onClick={() => onSelect({ key: 'image:pic.png', previewUrl: '/data/images/pic.png' })}>Choose fixture</button> : null }));
vi.mock('../components/moodBoard/MoodBoardGeneratePanel', () => ({ default: () => <div data-testid="generate-more-panel" /> }));
vi.mock('../components/moodBoard/MoodBoardStylePanel', () => ({
default: () => <div data-testid="board-style-panel" />,
}));
vi.mock('../components/media/MediaLightbox', () => ({
default: ({ item, onClose }) => (
<div data-testid="lightbox" data-src={item.previewUrl}>
<button type="button" onClick={onClose}>close-lightbox</button>
</div>
),
}));
vi.mock('../components/media/PromptFromMedia', () => ({
PromptFromMediaModal: ({ open, item, onResult, children }) => (open && item ? (
<div data-testid="pfm-modal">
{children}
<button
type="button"
onClick={() => {
const deliver = () => onResult?.({
imagePrompt: 'a moody castle at dusk',
imageNegativePrompt: 'blurry',
rationale: 'gothic look',
providerId: 'openai',
model: 'gpt-4o',
});
if (analysisDelay) analysisDelay.then(deliver);
else deliver();
}}
>
mock-generate
</button>
</div>
) : null),
}));
// Control the board id `useParams` returns so we can simulate the user
// navigating from one board to another mid-fetch.
let currentId = 'a';
vi.mock('react-router', async (importOriginal) => {
const actual = await importOriginal();
return {
...actual,
useParams: () => ({ id: currentId }),
useNavigate: () => mockNavigate,
};
});
import MoodBoardDetail from './MoodBoardDetail.jsx';
// A promise plus its resolver, so a test can control exactly when (and in what
// order) each fetch settles.
const deferred = () => {
let resolve;
let reject;
const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
return { promise, resolve, reject };
};
// Flush pending microtasks + one macrotask so an awaited fetch continuation
// (including its `.catch()` link) has fully run before we assert.
const flush = async () => {
await new Promise((r) => setTimeout(r, 0));
await Promise.resolve();
};
const renderPage = (initialEntries = ['/mood-boards/a']) => render(
<MemoryRouter initialEntries={initialEntries}><MoodBoardDetail /></MemoryRouter>,
);
const boardNameValue = () => screen.getByLabelText('Name').value;
const openTool = (name) => fireEvent.click(screen.getByRole('tab', { name }));
beforeEach(() => {
vi.clearAllMocks();
localStorage.clear();
mockLocalizeMoodBoardMedia.mockResolvedValue({ board: null, localized: 0, failed: 0 });
currentId = 'a';
analysisDelay = null;
});
describe('MoodBoardDetail image preview', () => {
it('opens the standard lightbox when an image item is clicked and closes it', async () => {
mockGetMoodBoard.mockResolvedValueOnce({
id: 'a', name: 'Board A',
items: [{ id: 'i1', type: 'image', imageUrl: '/data/images/one.png', caption: 'one' }],
});
renderPage();
fireEvent.click(await screen.findByRole('button', { name: 'Preview image' }));
expect(screen.getByTestId('lightbox').dataset.src).toBe('/data/images/one.png');
fireEvent.click(screen.getByText('close-lightbox'));
expect(screen.queryByTestId('lightbox')).toBeNull();
});
it('opens lightbox automatically when initial URL has preview search param', async () => {
mockGetMoodBoard.mockResolvedValueOnce({
id: 'a', name: 'Board A',
items: [{ id: 'i1', type: 'image', imageUrl: '/data/images/one.png', caption: 'one' }],
});
renderPage(['/mood-boards/a?preview=i1']);
expect((await screen.findByTestId('lightbox')).dataset.src).toBe('/data/images/one.png');
});
it('opens lightbox automatically when initial URL has item search param', async () => {
mockGetMoodBoard.mockResolvedValueOnce({
id: 'a', name: 'Board A',
items: [{ id: 'i1', type: 'image', imageUrl: '/data/images/one.png', caption: 'one' }],
});
renderPage(['/mood-boards/a?item=i1']);
expect((await screen.findByTestId('lightbox')).dataset.src).toBe('/data/images/one.png');
});
});
describe('MoodBoardDetail stale-response guards', () => {
it('renders the loaded board', async () => {
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [] });
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
});
it('ignores an out-of-order (stale) response after the board id changes', async () => {
const first = deferred();
const second = deferred();
mockGetMoodBoard
.mockReturnValueOnce(first.promise) // board 'a'
.mockReturnValueOnce(second.promise); // board 'b'
const { rerender } = renderPage();
// The user navigates to board 'b' before board 'a' has resolved.
currentId = 'b';
rerender(<MemoryRouter><MoodBoardDetail /></MemoryRouter>);
// Newer request resolves first — its data should show.
second.resolve({ id: 'b', name: 'Board B', items: [] });
await waitFor(() => expect(boardNameValue()).toBe('Board B'));
// GalleryImagePicker mounts with the loaded board and resets its filter
// state in a mount effect. Settle it before the unwrapped stale response.
await act(async () => {});
// Older (stale) request resolves last — it must NOT overwrite current state.
first.resolve({ id: 'a', name: 'Board A', items: [] });
await flush();
expect(boardNameValue()).toBe('Board B');
});
it('still renders under StrictMode (mount guard re-arms on remount)', async () => {
// StrictMode double-invokes mount/effects in dev; the mount guard must be
// re-armed on the real mount or the board would be stuck on "Loading…".
mockGetMoodBoard.mockResolvedValue({ id: 'a', name: 'Board A', items: [] });
render(
<StrictMode><MemoryRouter><MoodBoardDetail /></MemoryRouter></StrictMode>,
);
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
});
it('drops updates from a response that resolves after unmount', async () => {
const pending = deferred();
mockGetMoodBoard.mockReturnValueOnce(pending.promise);
const { unmount } = renderPage();
unmount();
// A not-found response after unmount must not fire its error toast — the
// unmounted guard returns before any setState / toast.
pending.resolve(null);
await flush();
expect(mockToastError).not.toHaveBeenCalled();
});
it('keeps the new board drafts and pending save when the old save and pin finish', async () => {
const oldSave = deferred();
const newSave = deferred();
const oldPin = deferred();
mockGetMoodBoard
.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [] })
.mockResolvedValueOnce({ id: 'b', name: 'Board B', items: [] });
mockUpdateMoodBoard.mockReturnValueOnce(oldSave.promise).mockReturnValueOnce(newSave.promise);
mockAddMoodBoardItem.mockReturnValueOnce(oldPin.promise);
const { rerender } = renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
fireEvent.change(screen.getByLabelText('Name'), { target: { value: 'Edited A' } });
fireEvent.click(screen.getByRole('button', { name: 'Save', exact: true }));
fireEvent.click(screen.getByRole('tab', { name: 'Note' }));
fireEvent.change(screen.getByLabelText('Note'), { target: { value: 'A note' } });
fireEvent.click(screen.getByRole('button', { name: 'Pin to board' }));
currentId = 'b';
rerender(<MemoryRouter><MoodBoardDetail /></MemoryRouter>);
await waitFor(() => expect(boardNameValue()).toBe('Board B'));
expect(screen.getByLabelText('Image URL')).toHaveValue('');
expect(screen.getByRole('button', { name: 'Pin to board' })).not.toBeDisabled();
fireEvent.change(screen.getByLabelText('Image URL'), { target: { value: 'https://example.com/b.png' } });
fireEvent.change(screen.getByLabelText('Name'), { target: { value: 'Edited B' } });
fireEvent.click(screen.getByRole('button', { name: 'Save', exact: true }));
await act(async () => {
oldSave.resolve({ id: 'a', name: 'Edited A', items: [] });
oldPin.resolve({ id: 'a-note', type: 'text', text: 'A note' });
});
expect(boardNameValue()).toBe('Edited B');
expect(screen.getByLabelText('Image URL')).toHaveValue('https://example.com/b.png');
expect(screen.queryByText('A note')).not.toBeInTheDocument();
expect(screen.getByRole('button', { name: 'Save', exact: true })).toBeDisabled();
expect(mockToastSuccess).not.toHaveBeenCalled();
expect(mockToastError).not.toHaveBeenCalled();
await act(async () => { newSave.resolve({ id: 'b', name: 'Edited B', items: [] }); });
expect(mockUpdateMoodBoard).toHaveBeenLastCalledWith('b', { name: 'Edited B', description: '' }, { silent: true });
expect(mockToastSuccess).toHaveBeenCalledWith('Board saved');
});
it('clears the old board when the next GET fails and ignores a rejected old sync', async () => {
const nextLoad = deferred();
const oldSync = deferred();
mockGetMoodBoard
.mockResolvedValueOnce({
id: 'a', name: 'Board A', items: [],
pinterest: { boardUrl: 'https://www.pinterest.com/example/board/', feedUrl: 'https://example.com/feed.rss' },
})
.mockReturnValueOnce(nextLoad.promise);
mockSyncMoodBoardPinterest.mockReturnValueOnce(oldSync.promise);
const { rerender } = renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
openTool('Import');
fireEvent.click(screen.getByRole('button', { name: 'Sync now' }));
currentId = 'missing';
rerender(<MemoryRouter><MoodBoardDetail /></MemoryRouter>);
expect(screen.queryByLabelText('Name')).not.toBeInTheDocument();
await act(async () => { nextLoad.reject(new Error('Not found')); });
expect(screen.getByText('This mood board doesn’t exist.')).toBeInTheDocument();
expect(screen.queryByLabelText('Name')).not.toBeInTheDocument();
expect(mockToastError).toHaveBeenCalledExactlyOnceWith('Mood board not found');
await act(async () => { oldSync.reject(new Error('Sync failed')); });
expect(mockToastError).toHaveBeenCalledExactlyOnceWith('Mood board not found');
expect(mockToastSuccess).not.toHaveBeenCalled();
});
});
describe('MoodBoardDetail private Pinterest import', () => {
it('imports a single Pin through the signed-in PortOS browser action', async () => {
const boardUrl = 'https://www.pinterest.com/pin/9999999999999999999/';
const importedBoard = {
id: 'a',
name: 'Board A',
items: [{
id: 'mbi-1',
type: 'image',
imageUrl: '/data/images/pinterest-example.jpg',
caption: 'Example pin',
source: 'https://www.pinterest.com/pin/9999999999999999999/',
}],
};
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [] });
mockImportMoodBoardPinterest.mockResolvedValueOnce({ board: importedBoard, added: 1, found: 1, skipped: 0 });
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
openTool('Import');
fireEvent.change(screen.getByLabelText('Pin or board URL'), { target: { value: boardUrl } });
fireEvent.click(screen.getByRole('button', { name: 'Import pins' }));
await waitFor(() => expect(mockToastSuccess).toHaveBeenCalledWith('Added 1 of 1 Pinterest pin'));
expect(mockImportMoodBoardPinterest).toHaveBeenCalledWith('a', boardUrl, { silent: true });
expect(screen.getByAltText('Example pin')).toHaveAttribute('src', '/data/images/pinterest-example.jpg');
});
});
describe('MoodBoardDetail external media re-hosting', () => {
it('imports external pins into the gallery on load and swaps in the localized board', async () => {
mockGetMoodBoard.mockResolvedValueOnce({
id: 'a', name: 'Board A',
items: [{ id: 'mbi-1', type: 'image', imageUrl: 'https://example.com/a.jpg' }],
});
mockLocalizeMoodBoardMedia.mockResolvedValueOnce({
board: { id: 'a', name: 'Board A', items: [{ id: 'mbi-1', type: 'image', imageUrl: '/data/images/board-1.jpg' }] },
localized: 1,
failed: 0,
});
renderPage();
await waitFor(() => expect(mockToastSuccess).toHaveBeenCalledWith('Imported 1 external image into the gallery'));
expect(mockLocalizeMoodBoardMedia).toHaveBeenCalledWith('a', { silent: true });
expect(document.querySelector('img[src="/data/images/board-1.jpg"]')).not.toBeNull();
});
it('does not call the importer when every pin is already local', async () => {
mockGetMoodBoard.mockResolvedValueOnce({
id: 'a', name: 'Board A',
items: [{ id: 'mbi-1', type: 'image', imageUrl: '/data/images/x.jpg' }],
});
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
expect(mockLocalizeMoodBoardMedia).not.toHaveBeenCalled();
});
});
describe('MoodBoardDetail X post import', () => {
it('imports a post URL and merges the returned board', async () => {
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [] });
mockImportMoodBoardXPost.mockResolvedValueOnce({
board: { id: 'a', name: 'Board A', items: [{ id: 'mbi-1', type: 'image', imageUrl: '/data/images/x.jpg' }] },
added: 1,
});
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
openTool('Import');
fireEvent.change(screen.getByLabelText('Post URL'), { target: { value: 'https://x.com/user/status/1' } });
fireEvent.click(screen.getByRole('button', { name: 'Import' }));
await waitFor(() => expect(mockToastSuccess).toHaveBeenCalledWith('Added 1 item from the post'));
expect(mockImportMoodBoardXPost).toHaveBeenCalledWith('a', 'https://x.com/user/status/1', { silent: true });
expect(screen.getByLabelText('Post URL')).toHaveValue('');
});
it('toasts an error and keeps the typed URL on failure', async () => {
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [] });
mockImportMoodBoardXPost.mockRejectedValueOnce(new Error('boom'));
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
openTool('Import');
fireEvent.change(screen.getByLabelText('Post URL'), { target: { value: 'https://x.com/user/status/1' } });
fireEvent.click(screen.getByRole('button', { name: 'Import' }));
await waitFor(() => expect(mockToastError).toHaveBeenCalledWith('Could not import that post — check the URL or try again'));
expect(screen.getByLabelText('Post URL')).toHaveValue('https://x.com/user/status/1');
});
});
describe('MoodBoardDetail item-type tabs (#7244)', () => {
it('keeps one tab stop on the bar and switches the add form with arrow keys', async () => {
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [] });
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
const image = screen.getByRole('tab', { name: 'Image' });
const note = screen.getByRole('tab', { name: 'Note' });
expect(image).toHaveAttribute('tabindex', '0');
expect(note).toHaveAttribute('tabindex', '-1');
// ArrowRight moves the tab stop and swaps the add-item form together.
image.focus();
fireEvent.keyDown(image, { key: 'ArrowRight' });
expect(note).toHaveAttribute('aria-selected', 'true');
expect(note).toHaveAttribute('tabindex', '0');
expect(document.activeElement).toBe(note);
expect(screen.getByLabelText('Note')).toBeInTheDocument();
expect(screen.queryByLabelText('Image URL')).not.toBeInTheDocument();
});
});
describe('MoodBoardDetail video items (#4188)', () => {
it('renders a video item as a poster with a play affordance, then plays inline', async () => {
mockGetMoodBoard.mockResolvedValueOnce({
id: 'a',
name: 'Board A',
items: [{
id: 'mbi-1',
type: 'video',
mediaKey: 'video:upload-ab12cd34.mp4',
imageUrl: '/data/video-thumbnails/upload-ab12cd34.jpg',
caption: null,
source: null,
}],
});
const { container } = renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
const playButton = screen.getByRole('button', { name: 'Play video' });
expect(playButton.querySelector('img').getAttribute('src')).toBe('/data/video-thumbnails/upload-ab12cd34.jpg');
fireEvent.click(playButton);
await waitFor(() => {
const video = container.querySelector('video');
expect(video).not.toBeNull();
expect(video.getAttribute('src')).toBe('/data/videos/upload-ab12cd34.mp4');
});
});
it('falls back to the derived stem poster when the stored thumbnail 404s (synced download pin)', async () => {
// A downloaded video's sender-side thumbnail is `<id>.jpg`, but a peer
// regenerates `<filename-stem>.jpg` on pull — the stored URL 404s there.
mockGetMoodBoard.mockResolvedValueOnce({
id: 'a',
name: 'Board A',
items: [{
id: 'mbi-1',
type: 'video',
mediaKey: 'video:downloaded-abc123.mp4',
imageUrl: '/data/video-thumbnails/abc123.jpg',
caption: null,
source: null,
}],
});
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
const poster = screen.getByRole('button', { name: 'Play video' }).querySelector('img');
expect(poster.getAttribute('src')).toBe('/data/video-thumbnails/abc123.jpg');
fireEvent.error(poster);
expect(poster.getAttribute('src')).toBe('/data/video-thumbnails/downloaded-abc123.jpg');
});
});
describe('MoodBoardDetail item analysis (#4188 Phase 3)', () => {
const galleryImageItem = {
id: 'i1', type: 'image', mediaKey: 'image:ref.png', imageUrl: null, caption: null, source: null,
};
it('does not persist an analysis callback delivered after leaving its board', async () => {
const pendingAnalysis = deferred();
analysisDelay = pendingAnalysis.promise;
mockGetMoodBoard
.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [galleryImageItem] })
.mockResolvedValueOnce({ id: 'b', name: 'Board B', items: [] });
const { rerender } = renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
fireEvent.click(screen.getByRole('button', { name: 'Prompt from media' }));
fireEvent.click(screen.getByRole('button', { name: 'mock-generate' }));
currentId = 'b';
rerender(<MemoryRouter><MoodBoardDetail /></MemoryRouter>);
await waitFor(() => expect(boardNameValue()).toBe('Board B'));
expect(screen.queryByTestId('pfm-modal')).not.toBeInTheDocument();
await act(async () => { pendingAnalysis.resolve(); });
expect(mockUpdateMoodBoardItem).not.toHaveBeenCalled();
expect(mockToastSuccess).not.toHaveBeenCalled();
expect(mockToastError).not.toHaveBeenCalled();
});
it('offers the analyze action only on gallery-backed media items', async () => {
mockGetMoodBoard.mockResolvedValueOnce({
id: 'a',
name: 'Board A',
items: [
galleryImageItem,
{ id: 'i2', type: 'text', text: 'note', caption: null, source: null },
{ id: 'i3', type: 'image', mediaKey: null, imageUrl: 'https://x/y.png', caption: null, source: null },
],
});
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
// One analyzable item → exactly one analyze button; the text item and the
// external-URL pin get none.
expect(screen.getAllByRole('button', { name: 'Prompt from media' })).toHaveLength(1);
});
it('persists a run onto the item and flips the card to its analyzed state', async () => {
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [galleryImageItem] });
const analyzedItem = {
...galleryImageItem,
analysis: {
prompt: 'a moody castle at dusk',
negativePrompt: 'blurry',
rationale: 'gothic look',
providerId: 'openai',
model: 'gpt-4o',
analyzedAt: '2026-08-14T00:00:00.000Z',
},
};
mockUpdateMoodBoardItem.mockResolvedValueOnce(analyzedItem);
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
fireEvent.click(screen.getByRole('button', { name: 'Prompt from media' }));
expect(screen.getByTestId('pfm-modal')).toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: 'mock-generate' }));
await waitFor(() => {
expect(mockUpdateMoodBoardItem).toHaveBeenCalledWith('a', 'i1', {
analysis: {
prompt: 'a moody castle at dusk',
negativePrompt: 'blurry',
rationale: 'gothic look',
providerId: 'openai',
model: 'gpt-4o',
},
// The caption mirrors the analysis prompt when the item had none.
caption: 'a moody castle at dusk',
}, { silent: true });
});
// The persisted item flows back into board state: the card badge flips and
// the modal now shows the stored analysis.
await screen.findByRole('button', { name: 'View prompt from media' });
expect(screen.getByLabelText('Saved analysis prompt')).toHaveValue('a moody castle at dusk');
});
it('removes a stored analysis via the modal', async () => {
const analyzed = {
...galleryImageItem,
analysis: {
prompt: 'a moody castle at dusk', negativePrompt: null, rationale: null,
providerId: null, model: null, analyzedAt: '2026-08-14T00:00:00.000Z',
},
};
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [analyzed] });
mockUpdateMoodBoardItem.mockResolvedValueOnce({ ...galleryImageItem, analysis: null });
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
fireEvent.click(screen.getByRole('button', { name: 'View prompt from media' }));
fireEvent.click(screen.getByRole('button', { name: 'Remove' }));
await waitFor(() => {
expect(mockUpdateMoodBoardItem).toHaveBeenCalledWith('a', 'i1', { analysis: null }, { silent: true });
});
await screen.findByRole('button', { name: 'Prompt from media' });
});
it('displays the analyzed prompt indicator and value over the default caption', async () => {
const analyzedItem = {
id: 'i1',
type: 'image',
mediaKey: 'image:pic.png',
caption: 'default caption from pin',
analysis: {
prompt: 'detailed analyzed prompt',
},
};
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [analyzedItem] });
mockUpdateMoodBoardItem.mockResolvedValueOnce({
...analyzedItem,
analysis: { prompt: 'updated analyzed prompt' },
});
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
expect(screen.getByTestId('item-indicator-analyzed')).toBeInTheDocument();
expect(screen.getByText('Analyzed prompt')).toBeInTheDocument();
expect(screen.getByText('default caption from pin')).toBeInTheDocument();
const input = screen.getByLabelText('Analyzed prompt');
expect(input).toHaveValue('detailed analyzed prompt');
fireEvent.change(input, { target: { value: 'updated analyzed prompt' } });
fireEvent.blur(input);
await waitFor(() => {
expect(mockUpdateMoodBoardItem).toHaveBeenCalledWith('a', 'i1', {
analysis: {
prompt: 'updated analyzed prompt',
},
prompt: 'updated analyzed prompt',
}, { silent: true });
});
});
it('displays the prompt indicator and value for items with prompt but no analysis', async () => {
const itemWithPrompt = {
id: 'i2',
type: 'image',
mediaKey: 'image:pic2.png',
prompt: 'explicit prompt text',
caption: 'default caption',
};
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [itemWithPrompt] });
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
expect(screen.getByTestId('item-indicator-prompt')).toBeInTheDocument();
expect(screen.getByTestId('item-indicator-prompt')).toHaveTextContent('Prompt');
const input = screen.getByLabelText('Item prompt');
expect(input).toHaveValue('explicit prompt text');
expect(input).toHaveAttribute('maxlength', '16000');
});
it('displays only default caption with no indicator when item has not been analyzed or given a prompt', async () => {
const pinItem = {
id: 'i3',
type: 'image',
imageUrl: '/data/images/pin.jpg',
caption: 'simple pin description',
};
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [pinItem] });
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
expect(screen.queryByTestId('item-indicator-analyzed')).not.toBeInTheDocument();
expect(screen.queryByTestId('item-indicator-prompt')).not.toBeInTheDocument();
expect(screen.getByText('Caption')).toBeInTheDocument();
const input = screen.getByLabelText('Item caption');
expect(input).toHaveValue('simple pin description');
});
});
describe('MoodBoardDetail layout', () => {
it('shows pins first with every board tool one tap away in the side rail', async () => {
mockGetMoodBoard.mockResolvedValueOnce({
id: 'a',
name: 'Board A',
items: [{ id: 'mbi-1', type: 'image', imageUrl: '/data/images/pic.jpg', caption: 'Pic 1' }],
});
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
const itemsSection = screen.getByRole('region', { name: 'Mood board items' });
const tools = screen.getByRole('complementary', { name: 'Board tools' });
expect(itemsSection.parentElement).toBe(tools.parentElement);
expect(itemsSection.compareDocumentPosition(tools) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
expect(itemsSection.parentElement.className).toContain('@4xl/board:grid-cols-[minmax(0,1fr)_24rem]');
// Add is the default tool; the others stay mounted but hidden.
expect(tools).toContainElement(screen.getByRole('button', { name: 'Pin to board' }));
expect(screen.queryByRole('button', { name: 'Import pins' })).toBeNull();
openTool('Import');
expect(screen.getByRole('heading', { name: 'Import from Pinterest' })).toBeInTheDocument();
expect(screen.getByRole('heading', { name: 'Import from an X post' })).toBeInTheDocument();
expect(screen.queryByRole('button', { name: 'Pin to board' })).toBeNull();
expect(screen.getByTestId('generate-more-panel')).toBeInTheDocument();
});
it('edits the board prompt as a multi-line field in the tool panel', async () => {
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', description: 'Old prompt', items: [] });
mockUpdateMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', description: 'New prompt\nSecond line', items: [] });
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
const tools = screen.getByRole('complementary', { name: 'Board tools' });
const field = screen.getByLabelText('Board prompt');
expect(tools).toContainElement(field);
expect(field.tagName).toBe('TEXTAREA');
expect(Number(field.getAttribute('rows'))).toBeGreaterThan(1);
expect(screen.queryByRole('button', { name: 'Save prompt' })).toBeNull();
fireEvent.change(field, { target: { value: 'New prompt\nSecond line' } });
expect(screen.queryByRole('button', { name: 'Save', exact: true })).toBeNull();
fireEvent.click(screen.getByRole('button', { name: 'Save prompt' }));
await waitFor(() => expect(mockUpdateMoodBoard).toHaveBeenCalledWith('a', { name: 'Board A', description: 'New prompt\nSecond line' }, { silent: true }));
await waitFor(() => expect(screen.queryByRole('button', { name: 'Save prompt' })).toBeNull());
});
it('remembers the last tool used for the next board', async () => {
mockGetMoodBoard.mockResolvedValue({ id: 'a', name: 'Board A', items: [] });
const { unmount } = renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
openTool('Import');
unmount();
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
expect(screen.getByRole('tab', { name: 'Import' })).toHaveAttribute('aria-selected', 'true');
expect(screen.getByRole('button', { name: 'Import pins' })).toBeInTheDocument();
});
});
describe('MoodBoardDetail phone tool sheet', () => {
const desktopWidth = window.innerWidth;
beforeEach(() => { window.innerWidth = 390; });
afterEach(() => { window.innerWidth = desktopWidth; });
it('opens a tool as a sheet on its own history entry and closes it with one step back', async () => {
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [] });
renderPage();
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
expect(screen.queryByRole('dialog', { name: 'Board tools' })).toBeNull();
const row = screen.getByRole('navigation', { name: 'Board tools' });
fireEvent.click(within(row).getByRole('button', { name: 'Import' }));
const sheet = screen.getByRole('dialog', { name: 'Board tools' });
expect(sheet).toContainElement(screen.getByRole('heading', { name: 'Import from Pinterest' }));
// Switching tools inside the sheet keeps it open on the same entry.
fireEvent.click(screen.getByRole('tab', { name: 'Add' }));
expect(screen.getByRole('dialog', { name: 'Board tools' })).toContainElement(screen.getByRole('button', { name: 'Pin to board' }));
fireEvent.click(screen.getByRole('button', { name: 'Close board tools' }));
expect(mockNavigate).toHaveBeenCalledWith(-1);
});
it('does not pop the sheet open for a ?tool= link from the desktop rail', async () => {
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [] });
renderPage(['/mood-boards/a?tool=style']);
await waitFor(() => expect(boardNameValue()).toBe('Board A'));
expect(screen.queryByRole('dialog', { name: 'Board tools' })).toBeNull();
expect(screen.getByRole('navigation', { name: 'Board tools' })).toBeInTheDocument();
});
});
describe('MoodBoardDetail note render', () => {
it('renders a text note and swaps in the image when the render event lands', async () => {
const note = { id: 'n1', type: 'text', text: 'Palette: violet and cyan' };
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [note] });
mockRenderMoodBoardItem.mockResolvedValueOnce({
jobId: 'job-1', item: { ...note, render: { status: 'queued', jobId: 'job-1', error: null } },
});
renderPage();
fireEvent.click(await screen.findByRole('button', { name: 'Render' }));
expect(mockRenderMoodBoardItem).toHaveBeenCalledWith('a', 'n1', { silent: true });
expect(await screen.findByRole('button', { name: 'Rendering…' })).toBeDisabled();
expect(screen.getByTestId('item-rendering')).toBeInTheDocument();
mockGetMoodBoard.mockResolvedValueOnce({
id: 'a', name: 'Board A',
items: [{ id: 'n1', type: 'image', mediaKey: 'image:job-1.png', caption: note.text }],
});
await act(async () => { await socketHandlers.get('mood-board:item-render')({ boardId: 'a', itemId: 'n1', status: 'done' }); });
expect(await screen.findByRole('button', { name: 'Preview image' })).toBeInTheDocument();
expect(screen.queryByRole('button', { name: /^Render/ })).toBeNull();
});
it('shows why a render failed and offers it again', async () => {
mockGetMoodBoard.mockResolvedValueOnce({
id: 'a', name: 'Board A',
items: [{ id: 'n1', type: 'text', text: 'Motif', render: { status: 'failed', jobId: 'j', error: 'out of memory' } }],
});
renderPage();
expect(await screen.findByText('Render failed: out of memory')).toBeInTheDocument();
expect(screen.getByRole('button', { name: 'Render' })).toBeEnabled();
});
});
describe('MoodBoardDetail direct upload', () => {
const image = new File(['synthetic image'], 'reference.png', { type: 'image/png' });
const video = new File(['synthetic video'], 'motion.mp4', { type: 'video/mp4' });
const savedImage = { filename: 'upload-image.png', path: '/data/images/upload-image.png', metadata: { prompt: 'Paper boat' } };
const savedVideo = { id: 'upload-video', filename: 'upload-video.mp4', thumbnail: 'upload-video-thumb.jpg', prompt: 'Clouds' };
const pick = files => fireEvent.change(screen.getByLabelText('Upload'), { target: { files } });
it('uploads mixed files once, preserves embedded prompts, and retries a lost pin response without reuploading or duplicating the pin', async () => {
const upload = deferred();
const pins = new Map();
let loseResponse = true;
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [] });
mockUploadRequest.mockImplementation(async (path, options) => {
if (path === '/image-gen/upload') return upload.promise;
if (path === '/video-gen/upload') return savedVideo;
const payload = JSON.parse(options.body);
if (!pins.has(payload.mediaKey)) pins.set(payload.mediaKey, { ...payload, id: `pin-${pins.size}` });
if (loseResponse) { loseResponse = false; throw new Error('Response lost'); }
return pins.get(payload.mediaKey);
});
renderPage();
await screen.findByLabelText('Upload');
expect(screen.getByLabelText('Upload')).toHaveAttribute('multiple');
expect(screen.getByRole('button', { name: 'Pick from gallery' })).toBeInTheDocument();
pick([image, video]);
pick([image, video]);
expect(screen.getByLabelText('Upload')).toBeDisabled();
expect(mockUploadRequest).toHaveBeenCalledTimes(1);
expect(screen.getByRole('list', { name: 'Import queue' })).toHaveTextContent('queued');
await act(async () => upload.resolve(savedImage));
await screen.findByText(/mood board assignment failed: Response lost/);
await screen.findByText('1 of 2 imported');
expect(screen.queryByRole('list', { name: 'Import queue' })).toBeNull();
const retry = screen.getByRole('button', { name: 'Retry failed / cancelled' });
await act(async () => { fireEvent.click(retry); fireEvent.click(retry); });
await screen.findByText('2 of 2 imported');
expect(screen.queryByRole('region', { name: 'Imports needing attention' })).toBeNull();
expect(mockUploadRequest.mock.calls.filter(([path]) => path.endsWith('/upload'))).toHaveLength(2);
expect([...pins.values()]).toEqual([
expect.objectContaining({ type: 'image', mediaKey: 'image:upload-image.png', prompt: 'Paper boat' }),
expect.objectContaining({ type: 'video', mediaKey: 'video:upload-video.mp4', imageUrl: '/data/video-thumbnails/upload-video-thumb.jpg', prompt: 'Clouds' }),
]);
expect(screen.getAllByLabelText('Item prompt')).toHaveLength(2);
});
it('finishes the active upload on its original board and stops queued files after navigation', async () => {
const upload = deferred();
mockGetMoodBoard.mockImplementation(async id => ({ id, name: `Board ${id}`, items: [] }));
mockUploadRequest.mockImplementation(async (path, options) => {
if (path === '/image-gen/upload') return upload.promise;
return { id: 'pin-old', ...JSON.parse(options.body) };
});
const view = renderPage();
await screen.findByLabelText('Upload');
pick([image, video]);
currentId = 'b';
view.rerender(<MemoryRouter><MoodBoardDetail /></MemoryRouter>);
await waitFor(() => expect(boardNameValue()).toBe('Board b'));
await act(async () => upload.resolve(savedImage));
expect(mockUploadRequest.mock.calls.map(([path]) => path)).toEqual(['/image-gen/upload', '/mood-boards/a/items']);
expect(screen.queryByLabelText('Item prompt')).toBeNull();
expect(screen.queryByRole('list', { name: 'Import queue' })).toBeNull();
expect(mockToastError).not.toHaveBeenCalled();
});
});
it('keeps one visible item when the gallery returns an already pinned asset', async () => {
const item = { id: 'existing-pin', type: 'image', mediaKey: 'image:pic.png', imageUrl: '/data/images/pic.png', caption: 'Legacy gallery caption' };
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [item] });
mockAddMoodBoardItem.mockResolvedValue(item);
renderPage();
fireEvent.click(await screen.findByRole('button', { name: 'Pick from gallery' }));
await act(async () => { fireEvent.click(screen.getByRole('button', { name: 'Choose fixture' })); });
await act(async () => { fireEvent.click(screen.getByRole('button', { name: 'Choose fixture' })); });
expect(screen.getAllByRole('button', { name: 'Preview image' })).toHaveLength(1);
expect(screen.getByLabelText('Item prompt')).toHaveAttribute('maxlength', '2000');
});
it('accepts a >2048-char data:image URL without input truncation and surfaces server error messages when pinning fails', async () => {
const longDataUrl = `data:image/webp;base64,${'A'.repeat(4000)}`;
const validationError = new Error('Validation failed');
validationError.context = { details: [{ path: 'imageUrl', message: 'Image data URL exceeds the 12MB limit' }] };
mockGetMoodBoard.mockResolvedValueOnce({ id: 'a', name: 'Board A', items: [] });
mockAddMoodBoardItem
.mockRejectedValueOnce(validationError)
.mockRejectedValueOnce(new Error('Image data URL is truncated — re-paste the full URL or upload the image'))
.mockResolvedValueOnce({ id: 'mbi-data', type: 'image', imageUrl: '/data/images/board-1234.webp', caption: null });
renderPage();
const input = await screen.findByLabelText('Image URL');
expect(input).not.toHaveAttribute('maxlength');
fireEvent.change(input, { target: { value: longDataUrl } });
await act(async () => { fireEvent.click(screen.getByRole('button', { name: 'Pin to board' })); });
expect(mockAddMoodBoardItem).toHaveBeenCalledWith('a', { type: 'image', imageUrl: longDataUrl, caption: null, source: null }, { silent: true });
expect(mockToastError).toHaveBeenCalledWith('Image data URL exceeds the 12MB limit');
await act(async () => { fireEvent.click(screen.getByRole('button', { name: 'Pin to board' })); });
expect(mockToastError).toHaveBeenCalledWith('Image data URL is truncated — re-paste the full URL or upload the image');
await act(async () => { fireEvent.click(screen.getByRole('button', { name: 'Pin to board' })); });
expect(screen.getByRole('button', { name: 'Preview image' })).toBeInTheDocument();
expect(input).toHaveValue('');
});