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 { describe, expect, it, beforeEach, vi } from 'vitest';
import { StrictMode } from 'react';
import { act, fireEvent, render, screen } from '@testing-library/react';
const mock = vi.hoisted(() => ({ getInstanceFeatures: vi.fn() }));
vi.mock('../services/api', () => mock);
import { INSTANCE_FEATURES_CHANGED } from '../constants/events.js';
import {
useInstanceFeatures,
publishInstanceFeatures,
invalidateInstanceFeatures,
__resetInstanceFeatureCache,
} from './useInstanceFeatures.js';
const JIRA_ON = [{ id: 'jira', label: 'JIRA', enabled: true }];
const JIRA_OFF = [{ id: 'jira', label: 'JIRA', enabled: false }];
function Probe({ label = 'a' }) {
const { features, error, isFeatureEnabled, reload } = useInstanceFeatures();
return <>
<output data-testid={label} data-features={JSON.stringify(features)} data-error={Boolean(error)}>
{isFeatureEnabled('jira') ? 'on' : 'off'}
</output>
<button onClick={reload}>Reload {label}</button>
</>;
}
const deferred = () => {
let resolve;
let reject;
const promise = new Promise((r, j) => { resolve = r; reject = j; });
return { promise, resolve, reject };
};
describe('useInstanceFeatures', () => {
beforeEach(() => {
vi.clearAllMocks();
__resetInstanceFeatureCache();
mock.getInstanceFeatures.mockResolvedValue({ features: JIRA_OFF });
});
it('shares one fetch across every consumer', async () => {
render(<><Probe label="a" /><Probe label="b" /></>);
await act(async () => {});
expect(mock.getInstanceFeatures).toHaveBeenCalledTimes(1);
expect(screen.getByTestId('a')).toHaveTextContent('off');
expect(screen.getByTestId('b')).toHaveTextContent('off');
});
it('applies a published list to every consumer without refetching', async () => {
render(<><Probe label="a" /><Probe label="b" /></>);
await act(async () => {});
act(() => publishInstanceFeatures(JIRA_ON, { featureId: 'jira', enabled: true }));
expect(screen.getByTestId('a')).toHaveTextContent('on');
expect(screen.getByTestId('b')).toHaveTextContent('on');
expect(mock.getInstanceFeatures).toHaveBeenCalledTimes(1);
});
it('shares a legacy invalidation without hiding navigation during the refresh', async () => {
mock.getInstanceFeatures.mockResolvedValueOnce({ features: JIRA_ON });
render(<><Probe label="a" /><Probe label="b" /></>);
await act(async () => {});
const fresh = deferred();
mock.getInstanceFeatures.mockReturnValueOnce(fresh.promise);
act(() => {
window.dispatchEvent(new CustomEvent(INSTANCE_FEATURES_CHANGED, { detail: { featureId: 'jira', enabled: false } }));
});
expect(mock.getInstanceFeatures).toHaveBeenCalledTimes(2);
for (const label of ['a', 'b']) expect(screen.getByTestId(label)).toHaveTextContent('on');
await act(async () => { fresh.resolve({ features: JIRA_OFF }); });
for (const label of ['a', 'b']) expect(screen.getByTestId(label)).toHaveTextContent('off');
});
// The race the generation counter exists for: a save lands while the initial
// fetch is still open, and that fetch read the PRE-save state.
it('does not let a stale in-flight response overwrite a newer answer', async () => {
const slow = deferred();
mock.getInstanceFeatures.mockReturnValueOnce(slow.promise);
render(<><Probe label="a" /><Probe label="b" /></>);
// The save publishes the fresh list while the first fetch is still open.
act(() => publishInstanceFeatures(JIRA_ON, { featureId: 'jira', enabled: true }));
expect(screen.getByTestId('a')).toHaveTextContent('on');
// The stale response now arrives carrying the pre-save answer.
await act(async () => {
slow.resolve({ features: JIRA_OFF });
await slow.promise;
});
expect(screen.getByTestId('a')).toHaveTextContent('on');
});
it.each(['before', 'after'])('ignores a superseded read settling %s its replacement', async (order) => {
const stale = deferred();
const fresh = deferred();
mock.getInstanceFeatures.mockReturnValueOnce(stale.promise).mockReturnValueOnce(fresh.promise);
render(<><Probe label="a" /><Probe label="b" /></>);
act(() => invalidateInstanceFeatures('jira'));
expect(mock.getInstanceFeatures).toHaveBeenCalledTimes(2);
const settleStale = () => act(async () => { stale.resolve({ features: JIRA_ON }); });
if (order === 'before') {
await settleStale();
for (const label of ['a', 'b']) {
expect(screen.getByTestId(label)).toHaveAttribute('data-features', 'null');
expect(screen.getByTestId(label)).toHaveTextContent('off');
}
}
await act(async () => { fresh.resolve({ features: JIRA_OFF }); });
if (order === 'after') await settleStale();
for (const label of ['a', 'b']) {
expect(screen.getByTestId(label)).toHaveAttribute('data-features', JSON.stringify(JIRA_OFF));
expect(screen.getByTestId(label)).toHaveTextContent('off');
}
});
it('shares refresh failures and recovers every consumer when one retries', async () => {
render(<><Probe label="a" /><Probe label="b" /></>);
await act(async () => {});
const failed = deferred();
mock.getInstanceFeatures.mockReturnValueOnce(failed.promise);
act(() => invalidateInstanceFeatures('jira'));
expect(mock.getInstanceFeatures).toHaveBeenCalledTimes(2);
await act(async () => { failed.reject(new Error('synthetic offline')); });
for (const label of ['a', 'b']) {
expect(screen.getByTestId(label)).toHaveTextContent('on');
expect(screen.getByTestId(label)).toHaveAttribute('data-features', 'null');
expect(screen.getByTestId(label)).toHaveAttribute('data-error', 'true');
}
const retry = deferred();
mock.getInstanceFeatures.mockReturnValueOnce(retry.promise);
act(() => { fireEvent.click(screen.getByText('Reload a')); });
expect(mock.getInstanceFeatures).toHaveBeenCalledTimes(3);
for (const label of ['a', 'b']) expect(screen.getByTestId(label)).toHaveTextContent('on');
await act(async () => { retry.resolve({ features: JIRA_OFF }); });
for (const label of ['a', 'b']) {
expect(screen.getByTestId(label)).toHaveTextContent('off');
expect(screen.getByTestId(label)).toHaveAttribute('data-error', 'false');
}
});
it('keeps one bridge through StrictMode, late subscriptions and remounts', async () => {
const view = render(<StrictMode><Probe /></StrictMode>);
await act(async () => {});
act(() => publishInstanceFeatures([]));
view.rerender(<StrictMode><Probe /><Probe label="b" /></StrictMode>);
expect(screen.getByTestId('b')).toHaveAttribute('data-features', '[]');
expect(screen.getByTestId('b')).toHaveTextContent('on');
expect(mock.getInstanceFeatures).toHaveBeenCalledTimes(1);
view.unmount();
render(<StrictMode><Probe /><Probe label="b" /></StrictMode>);
await act(async () => { invalidateInstanceFeatures('jira'); });
expect(mock.getInstanceFeatures).toHaveBeenCalledTimes(2);
expect(screen.getByTestId('a')).toHaveTextContent('off');
expect(screen.getByTestId('b')).toHaveTextContent('off');
});
it('fails open so a failed fetch never blanks navigation', async () => {
mock.getInstanceFeatures.mockRejectedValue(new Error('offline'));
render(<><Probe label="a" /><Probe label="b" /></>);
await act(async () => {});
expect(screen.getByTestId('a')).toHaveTextContent('on');
});
// Feature GROUPS (#40) — only the Settings > Features tab reads `groups`, but
// the shared hook has to carry it alongside `features` for that consumer.
describe('feature groups (#40)', () => {
function GroupsProbe() {
const { groups } = useInstanceFeatures();
return <output data-testid="groups">{groups === null ? 'loading' : JSON.stringify(groups)}</output>;
}
it('carries the groups list from the same fetch as features', async () => {
mock.getInstanceFeatures.mockResolvedValue({
features: JIRA_OFF,
groups: [{ id: 'comms', label: 'Comms', enabled: true }],
});
render(<GroupsProbe />);
await act(async () => {});
expect(screen.getByTestId('groups')).toHaveTextContent('"id":"comms"');
});
it('keeps the previously known groups when a publisher only announces a plain feature change', async () => {
mock.getInstanceFeatures.mockResolvedValue({
features: JIRA_OFF,
groups: [{ id: 'comms', label: 'Comms', enabled: true }],
});
render(<GroupsProbe />);
await act(async () => {});
// No `groups` in this publish — the plain shape every existing caller sends.
act(() => publishInstanceFeatures(JIRA_ON, { featureId: 'jira', enabled: true }));
expect(screen.getByTestId('groups')).toHaveTextContent('"id":"comms"');
});
it('applies a freshly published groups list without refetching', async () => {
mock.getInstanceFeatures.mockResolvedValue({
features: JIRA_OFF,
groups: [{ id: 'comms', label: 'Comms', enabled: true }],
});
render(<GroupsProbe />);
await act(async () => {});
act(() => publishInstanceFeatures(JIRA_ON, {
featureId: 'jira',
enabled: true,
groups: [{ id: 'comms', label: 'Comms', enabled: false }],
}));
expect(screen.getByTestId('groups')).toHaveTextContent('"enabled":false');
expect(mock.getInstanceFeatures).toHaveBeenCalledTimes(1);
});
});
});