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 { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { render, cleanup, screen, fireEvent, waitFor, act } from '@testing-library/react';
import socket from '../../services/socket';
vi.mock('../../services/socket', () => ({
default: { on: vi.fn(), off: vi.fn(), emit: vi.fn(), connected: true },
}));
// Fires every handler registered for `event` — stands in for both a real
// Socket.IO reconnect and the initial connect, since the component tells
// them apart via its own "have we connected before" ref, not the event data.
const fireSocketEvent = (event) => {
for (const [name, handler] of socket.on.mock.calls) if (name === event) handler({});
};
vi.mock('../../services/api', () => ({
getDatabaseStatus: vi.fn(),
getDatabaseMaintenanceStatus: vi.fn(),
cutoverDatabase: vi.fn(),
recoverDatabaseCutover: vi.fn(),
setupNativeDatabase: vi.fn(),
exportDatabase: vi.fn(),
fixDatabase: vi.fn(),
syncDatabase: vi.fn(),
startDatabase: vi.fn(),
stopDatabase: vi.fn(),
destroyDatabase: vi.fn(),
}));
vi.mock('../ui/Toast', () => ({
default: Object.assign(vi.fn(), {
success: vi.fn(),
error: vi.fn(),
loading: vi.fn(),
warning: vi.fn(),
dismiss: vi.fn(),
}),
}));
vi.mock('../../lib/safeStorage', () => ({
safeReadJsonSession: vi.fn(() => null),
safeWriteJsonSession: vi.fn(),
safeRemoveSession: vi.fn(),
}));
import {
getDatabaseStatus, getDatabaseMaintenanceStatus, cutoverDatabase, recoverDatabaseCutover,
destroyDatabase,
} from '../../services/api';
import toast from '../ui/Toast';
import { safeReadJsonSession } from '../../lib/safeStorage';
import { DatabaseTab } from './DatabaseTab';
const dbStatus = {
connected: true, mode: 'docker', memoryCount: 10, dbBytes: 1000, tableCount: 5,
docker: { containerRunning: true, installed: true, daemonRunning: true },
native: { configured: false, installed: false, running: false },
};
const idleMaintenance = { stage: 'idle', fenced: false };
beforeEach(() => {
vi.clearAllMocks();
socket.connected = true;
getDatabaseStatus.mockResolvedValue(dbStatus);
getDatabaseMaintenanceStatus.mockResolvedValue(idleMaintenance);
safeReadJsonSession.mockReturnValue(null);
});
afterEach(cleanup);
const renderTab = async () => {
render(<DatabaseTab />);
await waitFor(() => expect(getDatabaseStatus).toHaveBeenCalled());
await waitFor(() => expect(screen.getByText(/Migrate Docker/i)).toBeTruthy());
};
describe('DatabaseTab sync and replacement', () => {
it('disables replace action for stopped targets and shows start requirement message', async () => {
const stoppedDbStatus = {
...dbStatus,
docker: { containerRunning: false, installed: true, daemonRunning: true },
native: { configured: true, installed: true, running: true },
mode: 'native',
};
getDatabaseStatus.mockResolvedValue(stoppedDbStatus);
render(<DatabaseTab />);
await waitFor(() => expect(getDatabaseStatus).toHaveBeenCalled());
// Docker is stopped/not-active, so the replace button should be disabled with start message
expect(screen.getByText(/Start Docker before replacing/i)).toBeTruthy();
});
it('enables replace action for running targets', async () => {
const runningDbStatus = {
...dbStatus,
docker: { containerRunning: true, installed: true, daemonRunning: true },
native: { configured: true, installed: true, running: true },
mode: 'docker',
};
getDatabaseStatus.mockResolvedValue(runningDbStatus);
render(<DatabaseTab />);
await waitFor(() => expect(getDatabaseStatus).toHaveBeenCalled());
// Native is running and not active, so replace button should be enabled
expect(screen.getByRole('button', { name: /Replace data from Docker/i })).toBeTruthy();
});
it('shows replacement warning in confirmation dialog when target is running', async () => {
const nativeRunningStatus = {
...dbStatus,
docker: { containerRunning: true, installed: true, daemonRunning: true },
native: { configured: true, installed: true, running: true },
mode: 'docker',
};
getDatabaseStatus.mockResolvedValue(nativeRunningStatus);
render(<DatabaseTab />);
await waitFor(() => expect(getDatabaseStatus).toHaveBeenCalled());
fireEvent.click(await screen.findByRole('button', { name: /Replace data from Docker/i }));
expect(screen.getByText(/Replace Native data with Docker data\?/i)).toBeTruthy();
expect(screen.getByText(/This replaces matching tables and their records/i)).toBeTruthy();
expect(screen.getByText(/records are not merged/i)).toBeTruthy();
expect(screen.getByText(/Back up Native first/i)).toBeTruthy();
});
it('uses explicit action verb "Replace Native data" in confirmation button', async () => {
const nativeRunningStatus = {
...dbStatus,
docker: { containerRunning: true, installed: true, daemonRunning: true },
native: { configured: true, installed: true, running: true },
mode: 'docker',
};
getDatabaseStatus.mockResolvedValue(nativeRunningStatus);
render(<DatabaseTab />);
await waitFor(() => expect(getDatabaseStatus).toHaveBeenCalled());
fireEvent.click(await screen.findByRole('button', { name: /Replace data from Docker/i }));
expect(screen.getByRole('button', { name: /Replace Native data/i })).toBeTruthy();
});
it('uses explicit action verb "Delete Docker database" in destroy confirmation', async () => {
const destroyableStatus = {
...dbStatus,
docker: { containerRunning: false, installed: true, daemonRunning: true },
native: { configured: true, installed: true, running: true },
mode: 'native',
};
getDatabaseStatus.mockResolvedValue(destroyableStatus);
render(<DatabaseTab />);
await waitFor(() => expect(getDatabaseStatus).toHaveBeenCalled());
fireEvent.click(await screen.findByRole('button', { name: /Destroy$/i }));
expect(screen.getByRole('button', { name: /Delete Docker database/i })).toBeTruthy();
});
it('offers Native deletion only while configured Native is running and explains its scope', async () => {
const nativeRunningStatus = {
...dbStatus,
docker: { containerRunning: true, installed: true, daemonRunning: true },
native: { configured: true, installed: true, running: true },
mode: 'docker',
};
getDatabaseStatus.mockResolvedValue(nativeRunningStatus);
destroyDatabase.mockResolvedValue({ success: true });
render(<DatabaseTab />);
await waitFor(() => expect(getDatabaseStatus).toHaveBeenCalled());
fireEvent.click(await screen.findByRole('button', { name: 'Delete Native database…' }));
expect(screen.getByText('Delete the inactive Native database?')).toBeTruthy();
expect(screen.getByText(/permanently deletes its tables and records/i)).toBeTruthy();
expect(screen.getByText(/System PostgreSQL and other databases are kept/i)).toBeTruthy();
expect(screen.getByText(/active Docker database is unchanged/i)).toBeTruthy();
fireEvent.click(screen.getByRole('button', { name: /Cancel/i }));
expect(destroyDatabase).not.toHaveBeenCalled();
fireEvent.click(await screen.findByRole('button', { name: 'Delete Native database…' }));
fireEvent.click(screen.getByRole('button', { name: 'Delete Native database' }));
await waitFor(() => expect(destroyDatabase).toHaveBeenCalledWith('native'));
});
it('shows an error, never a success toast, for a legacy resolved success:false', async () => {
getDatabaseStatus.mockResolvedValue({
...dbStatus,
docker: { containerRunning: true, installed: true, daemonRunning: true },
native: { configured: true, installed: true, running: true },
mode: 'docker',
});
destroyDatabase.mockResolvedValue({ success: false, output: 'volume busy' });
render(<DatabaseTab />);
await waitFor(() => expect(getDatabaseStatus).toHaveBeenCalled());
const callsBefore = getDatabaseStatus.mock.calls.length;
fireEvent.click(await screen.findByRole('button', { name: 'Delete Native database…' }));
fireEvent.click(screen.getByRole('button', { name: 'Delete Native database' }));
await waitFor(() => expect(toast.error).toHaveBeenCalledWith('volume busy'));
expect(toast.success).not.toHaveBeenCalled();
await waitFor(() => expect(getDatabaseStatus.mock.calls.length).toBeGreaterThan(callsBefore));
});
it('does not offer Native deletion when it is active, stopped, or unconfigured', async () => {
const statuses = [
{ ...dbStatus, mode: 'native', native: { configured: true, installed: true, running: true } },
{ ...dbStatus, mode: 'docker', native: { configured: true, installed: true, running: false } },
{ ...dbStatus, mode: 'docker', native: { configured: false, installed: false, running: false } },
];
for (const status of statuses) {
getDatabaseStatus.mockResolvedValueOnce(status);
const { unmount } = render(<DatabaseTab />);
await waitFor(() => expect(getDatabaseStatus).toHaveBeenCalled());
expect(screen.queryByRole('button', { name: /Delete Native database/i })).toBeNull();
unmount();
}
});
it('cancel button does not make any request and closes dialog', async () => {
const nativeRunningStatus = {
...dbStatus,
docker: { containerRunning: true, installed: true, daemonRunning: true },
native: { configured: true, installed: true, running: true },
mode: 'docker',
};
getDatabaseStatus.mockResolvedValue(nativeRunningStatus);
const { syncDatabase: syncDatabaseMock } = await import('../../services/api');
render(<DatabaseTab />);
await waitFor(() => expect(getDatabaseStatus).toHaveBeenCalled());
fireEvent.click(await screen.findByRole('button', { name: /Replace data from Docker/i }));
fireEvent.click(screen.getByRole('button', { name: /Cancel/i }));
expect(syncDatabaseMock).not.toHaveBeenCalled();
// Confirmation dialog should be gone
expect(screen.queryByText(/This replaces matching tables/i)).toBeNull();
});
});
describe('DatabaseTab migration', () => {
it('offers a migrate action when idle and reads status without a stale-poll interval', async () => {
await renderTab();
expect(getDatabaseMaintenanceStatus).toHaveBeenCalledTimes(1);
expect(screen.getByRole('button', { name: /Migrate Docker/i })).toBeTruthy();
});
it('never toasts success from an accepted cutover — only a matching verified operation does', async () => {
cutoverDatabase.mockResolvedValue({ id: 'op-1', stage: 'accepted', source: 'docker', target: 'native', accepted: true });
await renderTab();
fireEvent.click(screen.getByRole('button', { name: /Migrate Docker/i }));
fireEvent.click(screen.getByRole('button', { name: /Migrate to Native/i }));
await waitFor(() => expect(cutoverDatabase).toHaveBeenCalledWith({ source: 'docker', target: 'native' }));
// Accepted only: a loading toast, never a success toast.
expect(toast.loading).toHaveBeenCalled();
expect(toast.success).not.toHaveBeenCalled();
// Disables competing backend actions while the cutover is in flight.
await waitFor(() => expect(screen.getAllByRole('button', { name: /^Backup$/i })[0]).toBeDisabled());
});
it('ignores a stale in-flight status read that resolves after a cutover was accepted', async () => {
cutoverDatabase.mockResolvedValue({ id: 'op-9', stage: 'accepted', source: 'docker', target: 'native', accepted: true });
await renderTab();
// A manual refresh is in flight (deliberately unresolved) when the user
// also accepts a cutover — the refresh was issued against the pre-cutover
// idle state and must not win the race against the acceptance snapshot.
let resolveStaleRead;
getDatabaseMaintenanceStatus.mockImplementationOnce(() => new Promise((resolve) => { resolveStaleRead = resolve; }));
fireEvent.click(screen.getByTitle('Refresh status'));
await waitFor(() => expect(getDatabaseMaintenanceStatus).toHaveBeenCalledTimes(2));
fireEvent.click(screen.getByRole('button', { name: /Migrate Docker/i }));
fireEvent.click(screen.getByRole('button', { name: /Migrate to Native/i }));
await waitFor(() => expect(cutoverDatabase).toHaveBeenCalled());
// The stale read (issued before acceptance) resolves late with idle data.
// It must NOT clobber the just-established fence.
await act(async () => { resolveStaleRead(idleMaintenance); });
await waitFor(() => expect(screen.getAllByRole('button', { name: /^Backup$/i })[0]).toBeDisabled());
expect(toast.dismiss).not.toHaveBeenCalledWith('portos-database-cutover');
});
it('reconciles the durable journal on every socket connect, not on a timer', async () => {
await renderTab();
expect(getDatabaseMaintenanceStatus).toHaveBeenCalledTimes(1);
// Reconciling on every connect (not just a later reconnect) matters when a
// page reloads while the server is still down: the mount-time HTTP read
// fails, and the socket's first successful connect is the only signal
// that it's safe to re-read the journal.
await act(async () => { fireSocketEvent('connect'); });
await waitFor(() => expect(getDatabaseMaintenanceStatus).toHaveBeenCalledTimes(2));
await act(async () => { fireSocketEvent('disconnect'); });
await act(async () => { fireSocketEvent('connect'); });
await waitFor(() => expect(getDatabaseMaintenanceStatus).toHaveBeenCalledTimes(3));
});
it('keeps the last known fenced state (fails closed) when a status re-read errors mid-cutover', async () => {
getDatabaseMaintenanceStatus.mockResolvedValueOnce({
id: 'op-5', stage: 'exporting', coordinator: 'awaiting-exit', source: 'docker', target: 'native', fenced: true,
});
render(<DatabaseTab />);
await waitFor(() => expect(screen.getByText(/Draining writers|Exporting source database/i)).toBeTruthy());
getDatabaseMaintenanceStatus.mockRejectedValueOnce(new Error('server unreachable'));
await act(async () => { fireSocketEvent('disconnect'); });
await act(async () => { fireSocketEvent('connect'); });
// Still shows the fenced state — never silently drops to idle/unknown,
// which would re-enable competing backend actions mid-cutover.
expect(screen.getByText(/Exporting source database/i)).toBeTruthy();
});
it('shows an actionable recovery control for an interrupted cutover, and resumes the same operation id', async () => {
getDatabaseMaintenanceStatus.mockResolvedValue({
id: 'op-2', stage: 'importing', coordinator: 'exited', source: 'docker', target: 'native', fenced: true,
});
recoverDatabaseCutover.mockResolvedValue({ id: 'op-2', stage: 'importing', recovery: 'launched' });
render(<DatabaseTab />);
await waitFor(() => expect(screen.getByRole('button', { name: /Resume cutover/i })).toBeTruthy());
fireEvent.click(screen.getByRole('button', { name: /Resume cutover/i }));
await waitFor(() => expect(recoverDatabaseCutover).toHaveBeenCalledWith('op-2'));
expect(toast.success).not.toHaveBeenCalled();
});
it('reports success only once the journal reports a verified match for this tab\'s own operation', async () => {
safeReadJsonSession.mockReturnValue({ id: 'op-3', source: 'docker', target: 'native', acceptedAt: Date.now() });
getDatabaseMaintenanceStatus.mockResolvedValue({
stage: 'idle', fenced: false, lastCutover: { id: 'op-3', source: 'docker', target: 'native', sourceRetained: true },
});
await renderTab();
await waitFor(() => expect(toast.success).toHaveBeenCalledWith(
expect.stringContaining('native'), expect.objectContaining({ id: 'portos-database-cutover' })
));
});
it('does not claim success for a foreign or superseded operation id', async () => {
safeReadJsonSession.mockReturnValue({ id: 'op-4', source: 'docker', target: 'native', acceptedAt: Date.now() });
getDatabaseMaintenanceStatus.mockResolvedValue({ stage: 'idle', fenced: false });
await renderTab();
expect(toast.success).not.toHaveBeenCalled();
});
it('fails closed on competing actions when this tab has an unresolved operation but the status read errors', async () => {
safeReadJsonSession.mockReturnValue({ id: 'op-6', source: 'docker', target: 'native', acceptedAt: Date.now() });
getDatabaseMaintenanceStatus.mockRejectedValue(new Error('server unreachable'));
render(<DatabaseTab />);
await waitFor(() => expect(getDatabaseStatus).toHaveBeenCalled());
// Never learned this operation's outcome — must not read as idle.
await waitFor(() => expect(screen.getAllByRole('button', { name: /^Backup$/i })[0]).toBeDisabled());
});
it('does not attribute a later, different verified operation to this tab\'s earlier success', async () => {
safeReadJsonSession.mockReturnValue({ id: 'op-7', source: 'docker', target: 'native', acceptedAt: Date.now() });
getDatabaseMaintenanceStatus.mockResolvedValueOnce({
stage: 'idle', fenced: false, lastCutover: { id: 'op-7', source: 'docker', target: 'native', sourceRetained: true },
});
await renderTab();
await waitFor(() => expect(screen.getByText(/Verified — now running on native/i)).toBeTruthy());
// A different (e.g. CLI-run) operation later becomes the recorded
// lastCutover. This tab never claimed op-8, so it must not keep — or
// re-show — a verified banner for it.
getDatabaseMaintenanceStatus.mockResolvedValue({
stage: 'idle', fenced: false, lastCutover: { id: 'op-8', source: 'native', target: 'docker', sourceRetained: true },
});
fireEvent.click(screen.getByTitle('Refresh status'));
await waitFor(() => expect(getDatabaseMaintenanceStatus).toHaveBeenCalledTimes(2));
expect(screen.queryByText(/Verified — now running on/i)).toBeNull();
});
});