Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import { assert, describe, it } from "@effect/vitest";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Ref from "effect/Ref";
import * as TestClock from "effect/testing/TestClock";
import * as DesktopState from "../app/DesktopState.ts";
import * as DesktopUpdates from "./DesktopUpdates.ts";
import { flushCallbacks, makeHarness } from "./test-support/UpdatesHarness.ts";
describe("DesktopUpdates", () => {
it.effect("preserves a queued installer when the feed has no update", () => {
const harness = makeHarness();
return Effect.scoped(
Effect.gen(function* () {
const updates = yield* DesktopUpdates.DesktopUpdates;
yield* updates.configure;
harness.emit("update-available", {
version: "1.2.4",
releaseNotes: "## What's changed\n- fix: queued update",
});
yield* flushCallbacks;
harness.emit("update-downloaded", { version: "1.2.4" });
yield* flushCallbacks;
yield* updates.check("poll");
harness.emit("update-not-available");
yield* flushCallbacks;
const state = yield* updates.getState;
assert.equal(state.status, "downloaded");
assert.equal(state.availableVersion, "1.2.4");
assert.equal(state.downloadedVersion, "1.2.4");
assert.deepEqual(state.releaseNotes, [{ version: "1.2.4", items: ["fix: queued update"] }]);
assert.equal(state.downloadPercent, 100);
}),
).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
});
it.effect(
"rejects install while a refresh check is in progress and releases the reservation",
() =>
Effect.gen(function* () {
const checkStarted = yield* Deferred.make<void>();
const releaseCheck = yield* Deferred.make<void>();
const harness = makeHarness({
checkForUpdates: Deferred.succeed(checkStarted, undefined).pipe(
Effect.andThen(Deferred.await(releaseCheck)),
),
});
yield* Effect.scoped(
Effect.gen(function* () {
const updates = yield* DesktopUpdates.DesktopUpdates;
yield* updates.configure;
harness.emit("update-downloaded", { version: "1.2.4" });
yield* flushCallbacks;
const checkFiber = yield* updates.check("manual").pipe(Effect.forkScoped);
yield* Deferred.await(checkStarted);
const installResult = yield* updates.install;
assert.isFalse(installResult.accepted);
yield* Deferred.succeed(releaseCheck, undefined);
const checkResult = yield* Fiber.join(checkFiber);
assert.isTrue(checkResult.checked);
const followUpCheck = yield* updates.check("manual");
assert.isTrue(followUpCheck.checked);
assert.equal(harness.checkCount(), 2);
}),
).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
}),
);
it.effect("rejects refresh checks while install is in progress", () =>
Effect.gen(function* () {
const installStarted = yield* Deferred.make<void>();
const releaseInstall = yield* Deferred.make<void>();
const harness = makeHarness({
stopBackend: Deferred.succeed(installStarted, undefined).pipe(
Effect.andThen(Deferred.await(releaseInstall)),
),
});
yield* Effect.scoped(
Effect.gen(function* () {
const updates = yield* DesktopUpdates.DesktopUpdates;
yield* updates.configure;
harness.emit("update-downloaded", { version: "1.2.4" });
yield* flushCallbacks;
const installFiber = yield* updates.install.pipe(Effect.forkScoped);
yield* Deferred.await(installStarted);
const checkResult = yield* updates.check("manual");
assert.isFalse(checkResult.checked);
assert.equal(harness.checkCount(), 0);
yield* Deferred.succeed(releaseInstall, undefined);
const installResult = yield* Fiber.join(installFiber);
assert.isTrue(installResult.accepted);
}),
).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
}),
);
it.effect("preserves a queued installer after a background updater error", () => {
const harness = makeHarness();
return Effect.scoped(
Effect.gen(function* () {
const updates = yield* DesktopUpdates.DesktopUpdates;
yield* updates.configure;
harness.emit("update-downloaded", { version: "1.2.4" });
yield* flushCallbacks;
harness.emit("error", new Error("background updater failure"));
yield* flushCallbacks;
const state = yield* updates.getState;
assert.equal(state.status, "error");
assert.equal(state.downloadedVersion, "1.2.4");
assert.isNull(state.errorContext);
const result = yield* updates.install;
assert.isTrue(result.accepted);
}),
).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
});
it.effect("restarts stopped backends when update installation fails", () => {
let starts = 0;
const harness = makeHarness({
startBackend: Effect.sync(() => {
starts += 1;
}),
});
return Effect.scoped(
Effect.gen(function* () {
const desktopState = yield* DesktopState.DesktopState;
const updates = yield* DesktopUpdates.DesktopUpdates;
yield* updates.configure;
harness.emit("update-downloaded", { version: "1.2.4" });
yield* flushCallbacks;
const install = yield* updates.install;
assert.isTrue(install.accepted);
harness.emit("error", new Error("installer failed"));
yield* flushCallbacks;
assert.equal(starts, 1);
assert.isFalse(yield* Ref.get(desktopState.quitting));
const state = yield* updates.getState;
assert.equal(state.errorContext, "install");
}),
).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
});
it.effect("clears quitting state after an unexpected install setup failure", () => {
const harness = makeHarness({
stopBackend: Effect.die(new Error("backend stop failed")),
});
return Effect.scoped(
Effect.gen(function* () {
const desktopState = yield* DesktopState.DesktopState;
const updates = yield* DesktopUpdates.DesktopUpdates;
yield* updates.configure;
harness.emit("update-downloaded", { version: "1.2.4" });
yield* flushCallbacks;
const result = yield* updates.install;
assert.isTrue(result.accepted);
assert.isFalse(result.completed);
assert.isFalse(yield* Ref.get(desktopState.quitting));
const failedState = yield* updates.getState;
assert.equal(failedState.status, "downloaded");
assert.equal(failedState.errorContext, "install");
assert.equal(failedState.message, "Desktop update install action failed unexpectedly.");
}),
).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
});
});