mirror of
https://github.com/DayuanJiang/next-ai-draw-io.git
synced 2026-10-07 18:27:47 +08:00
dayuan.jiang
69c7896002
- A redirect followed for a custom base URL (quota on) no longer carries
the user's key or cookies to another origin, as fetch itself does, and
a private address may redirect to another private one (already counted).
- The admin Test of an Ollama or Vertex AI entry without a URL goes where
chat sends that entry's key: the environment's own URL variable, for
Ollama else the local default. The Test of an Ollama Cloud key without
a URL went to the cloud while chat went to local Ollama.
- Chat saves: each save notes the chat on screen and the order of the
reads before reading its data. A save read before switching chats no
longer writes into the chat switched to, and a copy that waited for its
thumbnail no longer replaces a newer one.
- "Continue without saving" keeps its button when a later auto-save fails,
and goes away when a new message is sent.
- A screenshot check that was waiting for its image when the user pressed
Stop stays skipped after the next message.
- MCP History: draw.io's own copy of a diagram (after get_diagram) no
longer adds an entry without a picture; a change of background is still
its own version. The tab ignores an edit's answer that arrives after a
newer AI write loaded.
- Desktop: a deleted preset is not brought back by a failed switch, and a
request naming no preset does not stop a rollback. An origin keeping
an access code counts as having settings.
- .env: a quoted value ending in a backslash ("C:\dir\") is read as dotenv
reads it.
- The tool card no longer crashes on an id that does not turn into text;
an older Test's success timer no longer ends a newer Test's spinner.
- Tests that passed without their fix now check it.
105 lines
3.5 KiB
TypeScript
105 lines
3.5 KiB
TypeScript
// @vitest-environment node
|
|
import { beforeEach, describe, expect, it, vi } from "vitest"
|
|
|
|
vi.mock("electron", () => ({
|
|
app: {
|
|
isPackaged: true,
|
|
getName: () => "app",
|
|
getVersion: () => "1",
|
|
getLocale: () => "en",
|
|
},
|
|
BrowserWindow: { getFocusedWindow: () => null },
|
|
dialog: {},
|
|
Menu: { buildFromTemplate: () => ({}), setApplicationMenu: () => {} },
|
|
shell: {},
|
|
}))
|
|
|
|
// The saved current preset, and restarts that wait until the test ends them
|
|
const state = vi.hoisted(() => ({
|
|
current: "A" as string | null,
|
|
restarts: [] as Array<{ resolve: () => void; reject: (e: Error) => void }>,
|
|
}))
|
|
vi.mock("@/electron/main/config-manager", () => ({
|
|
applyPresetToEnv: (id: string) => {
|
|
if (id === "missing") return null
|
|
state.current = id
|
|
return { AI_PROVIDER: id }
|
|
},
|
|
getAllPresets: () => [],
|
|
getCurrentPresetId: () => state.current,
|
|
setCurrentPreset: (id: string | null) => {
|
|
state.current = id
|
|
return true
|
|
},
|
|
}))
|
|
vi.mock("@/electron/main/next-server", () => ({
|
|
restartNextServer: () =>
|
|
new Promise<void>((resolve, reject) =>
|
|
state.restarts.push({ resolve, reject }),
|
|
),
|
|
}))
|
|
vi.mock("@/electron/main/menu-i18n", () => ({
|
|
getMenuTranslations: () => new Proxy({}, { get: () => "x" }),
|
|
getPreferredLocale: () => "en",
|
|
}))
|
|
vi.mock("@/electron/main/settings-window", () => ({
|
|
showSettingsWindow: () => {},
|
|
}))
|
|
|
|
import { switchPreset } from "@/electron/main/app-menu"
|
|
|
|
beforeEach(() => {
|
|
state.current = "A"
|
|
state.restarts = []
|
|
})
|
|
|
|
describe("switchPreset", () => {
|
|
it("keeps a preset chosen while a failed switch was restarting", async () => {
|
|
const toB = switchPreset("B").catch(() => {})
|
|
const toC = switchPreset("C")
|
|
// B's restart fails after the user already picked C
|
|
state.restarts[0].reject(new Error("timed out"))
|
|
await new Promise((r) => setTimeout(r, 0))
|
|
for (const r of state.restarts.slice(1)) r.resolve()
|
|
await toB
|
|
await toC
|
|
expect(state.current).toBe("C")
|
|
})
|
|
|
|
it("keeps a newer choice of the same preset", async () => {
|
|
// A, then B, C, and B again while the first restart is pending
|
|
const first = switchPreset("B").catch(() => {})
|
|
const second = switchPreset("C").catch(() => {})
|
|
const third = switchPreset("B")
|
|
// The first restart fails: the current preset is B again, but it is
|
|
// the third switch's, which must not be undone
|
|
state.restarts[0].reject(new Error("timed out"))
|
|
await new Promise((r) => setTimeout(r, 0))
|
|
for (const r of state.restarts.slice(1)) r.resolve()
|
|
await first
|
|
await second
|
|
await third
|
|
expect(state.current).toBe("B")
|
|
})
|
|
|
|
it("does not bring back the old preset over a deletion", async () => {
|
|
const toB = switchPreset("B").catch(() => {})
|
|
// B is deleted while its restart is pending
|
|
state.current = null
|
|
state.restarts[0].reject(new Error("timed out"))
|
|
await toB
|
|
expect(state.current).toBeNull()
|
|
expect(state.restarts).toHaveLength(1)
|
|
})
|
|
|
|
it("still rolls back when a later request named no preset", async () => {
|
|
const toB = switchPreset("B").catch(() => {})
|
|
await expect(switchPreset("missing")).rejects.toThrow("not found")
|
|
state.restarts[0].reject(new Error("timed out"))
|
|
await new Promise((r) => setTimeout(r, 0))
|
|
state.restarts[1]?.resolve()
|
|
await toB
|
|
expect(state.current).toBe("A")
|
|
})
|
|
})
|