import { RegistryContext } from "@effect/atom-react";
import {
DEFAULT_SERVER_SETTINGS,
EnvironmentId,
ProviderInstanceId,
type ServerSettings,
type ServerSettingsPatch,
} from "@t3tools/contracts";
import {
AVAILABLE_CONNECTION_STATE,
type SupervisorConnectionState,
} from "@t3tools/client-runtime/connection";
import * as Cause from "effect/Cause";
import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
import { applyServerSettingsPatch } from "@t3tools/shared/serverSettings";
import type { ReactNode } from "react";
import { describe, expect, it, vi } from "vite-plus/test";
import { act, render, type Screen } from "../../test/render";
const state = vi.hoisted(() => ({
catalog: null as unknown as Atom.Writable<{
readonly isReady: boolean;
readonly entries: ReadonlyMap<string, unknown>;
}>,
settings: new Map<string, unknown>(),
connections: new Map<
EnvironmentId,
Atom.Writable<AsyncResult.AsyncResult<SupervisorConnectionState>>
>(),
persist: vi.fn(),
}));
vi.mock(import("~/connection/catalog"), async (original) => {
const actual = await original();
const { Atom } = await import("effect/reactivity");
state.catalog = Atom.keepAlive(
Atom.make<{ readonly isReady: boolean; readonly entries: ReadonlyMap<string, unknown> }>({
isReady: true,
entries: new Map(),
}),
);
return {
...actual,
environmentCatalog: {
...actual.environmentCatalog,
catalogValueAtom: state.catalog as never,
stateAtom: ((id: EnvironmentId) => state.connections.get(id)) as never,
},
};
});
vi.mock("~/localApi", () => ({
ensureLocalApi: () => ({
persistence: {
getClientSettings: async () => ({ favorites: [{ provider, model }] }),
},
}),
}));
vi.mock(import("~/state/server"), async (original) => {
const actual = await original();
return {
...actual,
serverEnvironment: {
...actual.serverEnvironment,
settingsValueAtom: ((id: EnvironmentId) => state.settings.get(id)) as never,
updateSettings: {
...actual.serverEnvironment.updateSettings,
run: (_registry: unknown, input: unknown) => state.persist(input),
} as never,
},
};
});
vi.mock(import("~/state/use-atom-command"), async (original) => ({
...(await original()),
useAtomCommand: (() => state.persist) as never,
}));
import { appAtomRegistry } from "~/rpc/atomRegistry";
import {
ensureClientSettingsHydrated,
startModelPreferencesMigration,
useToggleEnvironmentModelFavorite,
} from "./useSettings";
const primaryId = EnvironmentId.make("primary");
const remoteId = EnvironmentId.make("remote");
const provider = ProviderInstanceId.make("codex_work");
const model = "gpt-6.1-sol";
const initialSettings = {
...DEFAULT_SERVER_SETTINGS,
favorites: [],
providerModelPreferences: {},
} satisfies ServerSettings;
interface Write {
environmentId: EnvironmentId;
patch: ServerSettingsPatch;
finish: (success?: boolean) => void;
}
const settingsAtom = (id: EnvironmentId) =>
state.settings.get(id) as Atom.Writable<ServerSettings | null>;
function FavoriteEditor({
environmentId,
toggles,
onClicked,
}: {
environmentId: EnvironmentId;
toggles: Array<() => Promise<void>>;
onClicked: (pending: Promise<void>) => void;
}) {
const toggle = useToggleEnvironmentModelFavorite(environmentId);
const onClick = () => toggle(provider, model);
toggles.push(onClick);
return <button onClick={() => onClicked(onClick())}>Toggle favorite</button>;
}
async function setup() {
await using stack = new AsyncDisposableStack();
const registry = stack.adopt(AtomRegistry.make(), (registry) => registry.dispose());
state.settings.clear();
state.connections.clear();
const durable = new Map<EnvironmentId, ServerSettings>();
const toggles: Array<() => Promise<void>> = [];
const writes: Write[] = [];
let pendingClick: Promise<void> | undefined;
for (const id of [primaryId, remoteId]) {
state.settings.set(id, Atom.make<ServerSettings | null>(initialSettings));
durable.set(id, initialSettings);
}
state.persist.mockReset().mockImplementation(
({
environmentId,
input,
}: {
environmentId: EnvironmentId;
input: { patch: ServerSettingsPatch };
}) =>
new Promise((resolve) => {
writes.push({
environmentId,
patch: input.patch,
finish: (success = true) => {
if (!success) {
resolve(AsyncResult.failure(Cause.fail(new Error("save failed"))));
return;
}
const settings = applyServerSettingsPatch(durable.get(environmentId)!, input.patch);
durable.set(environmentId, settings);
resolve(AsyncResult.success(settings));
},
});
}),
);
const environment = stack.move();
let screen: Screen | undefined;
const show = async (ui: ReactNode) => {
const tree = <RegistryContext.Provider value={registry}>{ui}</RegistryContext.Provider>;
if (screen) await screen.rerender(tree);
else screen = environment.use(await render(tree));
};
return {
registry,
durable,
toggles,
writes,
show,
mount: (environmentId = primaryId) =>
show(
<FavoriteEditor
environmentId={environmentId}
toggles={toggles}
onClicked={(pending) => {
pendingClick = pending;
}}
/>,
),
click(): Promise<void> {
screen!.container.querySelector("button")!.click();
return pendingClick!;
},
[Symbol.asyncDispose]: () => environment.disposeAsync(),
};
}
describe("environment favorite toggles", () => {
it.each([false, true])(
"toggles twice before any server echo when initially favorited=%s",
async (initiallyFavorited) => {
await using fixture = await setup();
const { registry, durable, writes, mount, click } = fixture;
const favorites = initiallyFavorited ? [{ provider, model }] : [];
const settings = { ...initialSettings, favorites };
registry.set(settingsAtom(primaryId), settings);
durable.set(primaryId, settings);
await mount();
const first = click();
const second = click();
await act(async () => {});
expect(writes.map((write) => write.patch.setModelFavorites?.[0]?.favorite)).toEqual([
!initiallyFavorited,
initiallyFavorited,
]);
writes[0]!.finish();
await first;
writes[1]!.finish();
await second;
expect(durable.get(primaryId)!.favorites).toEqual(favorites);
},
);
it("preserves an acknowledged add when a later remove fails before its echo", async () => {
await using fixture = await setup();
const { durable, writes, mount, click } = fixture;
await mount();
const first = click();
await act(async () => {});
writes[0]!.finish();
await first;
const failed = click();
await act(async () => {});
writes[1]!.finish(false);
await failed;
const retry = click();
await act(async () => {});
writes[2]!.finish();
await retry;
expect(durable.get(primaryId)!.favorites).toEqual([]);
});
it("does not reuse another environment's pending intent for the same model", async () => {
await using fixture = await setup();
const { durable, writes, mount, click } = fixture;
await mount();
const primary = click();
await mount(remoteId);
const remote = click();
await act(async () => {});
writes[0]!.finish();
await primary;
writes[1]!.finish();
await remote;
expect(durable.get(primaryId)!.favorites).toEqual([{ provider, model }]);
expect(durable.get(remoteId)!.favorites).toEqual([{ provider, model }]);
});
it("reads the latest server state even when the click callback predates its echo", async () => {
await using fixture = await setup();
const { registry, durable, toggles, writes, mount } = fixture;
await mount();
const previousClick = toggles.at(-1)!;
const updated = { ...initialSettings, favorites: [{ provider, model }] };
durable.set(primaryId, updated);
await act(() => registry.set(settingsAtom(primaryId), updated));
const clicked = previousClick();
await act(async () => {});
writes[0]!.finish();
await clicked;
expect(durable.get(primaryId)!.favorites).toEqual([]);
});
});
describe("legacy model preferences migration", () => {
it.each(["succeeds", "fails"] as const)(
"waits for connection and retries only after reconnect when the first save %s",
async (outcome) => {
await using _fixture = await setup();
const environmentId = EnvironmentId.make(`migration-${outcome}`);
const otherId = EnvironmentId.make(`other-${outcome}`);
for (const id of [environmentId, otherId]) {
state.settings.set(
id,
Atom.keepAlive(Atom.make<ServerSettings | null>(DEFAULT_SERVER_SETTINGS)),
);
state.connections.set(
id,
Atom.keepAlive(
Atom.make<AsyncResult.AsyncResult<SupervisorConnectionState>>(
AsyncResult.success(AVAILABLE_CONNECTION_STATE),
),
),
);
}
let finishFirstSave = () => {};
const firstSave = new Promise((resolve) => {
finishFirstSave = () =>
resolve(
outcome === "succeeds"
? AsyncResult.success(DEFAULT_SERVER_SETTINGS)
: AsyncResult.failure(Cause.fail(new Error("save failed"))),
);
});
state.persist
.mockReturnValueOnce(firstSave)
.mockResolvedValue(AsyncResult.success(DEFAULT_SERVER_SETTINGS));
const connect = (id: EnvironmentId, generation: number) =>
appAtomRegistry.set(
state.connections.get(id)!,
AsyncResult.success({
...AVAILABLE_CONNECTION_STATE,
desired: true,
generation,
phase: "connected",
}),
);
const pushSettings = (id = environmentId) =>
appAtomRegistry.set(settingsAtom(id), { ...DEFAULT_SERVER_SETTINGS });
const migration = (id: EnvironmentId) => ({
environmentId: id,
input: { patch: { migrateModelPreferences: { favorites: [{ provider, model }] } } },
});
appAtomRegistry.set(state.catalog, {
isReady: true,
entries: new Map([
[environmentId, {}],
[otherId, {}],
]),
});
using _migration = { [Symbol.dispose]: startModelPreferencesMigration() };
await ensureClientSettingsHydrated();
pushSettings();
expect(state.persist).not.toHaveBeenCalled();
connect(environmentId, 1);
expect(state.persist).toHaveBeenCalledExactlyOnceWith(migration(environmentId));
pushSettings();
expect(state.persist).toHaveBeenCalledTimes(1);
finishFirstSave();
await firstSave;
pushSettings();
pushSettings();
expect(state.persist).toHaveBeenCalledTimes(1);
connect(otherId, 7);
expect(state.persist).toHaveBeenLastCalledWith(migration(otherId));
pushSettings(otherId);
expect(state.persist).toHaveBeenCalledTimes(2);
appAtomRegistry.set(
state.connections.get(environmentId)!,
AsyncResult.success({ ...AVAILABLE_CONNECTION_STATE, generation: 1 }),
);
pushSettings();
expect(state.persist).toHaveBeenCalledTimes(2);
connect(environmentId, 2);
pushSettings();
expect(state.persist.mock.calls).toEqual([
[migration(environmentId)],
[migration(otherId)],
[migration(environmentId)],
]);
},
);
});