@hot-updater/server 1.0.0-rc.1 → 1.0.0-rc.16

package/src/handler-standalone.integration.spec.ts

@@ -1,15 +1,6 @@
 import { PGlite } from "@electric-sql/pglite";
 import type { Bundle } from "@hot-updater/core";
-import {
-  createReleaseCatalogScopeKey,
-  encodeChannelKey,
-  NIL_UUID,
-} from "@hot-updater/core";
-import {
-  bundleToRow,
-  commitReleaseCatalogMutation,
-  createDatabaseClient,
-} from "@hot-updater/plugin-core";
+import { NIL_UUID } from "@hot-updater/core";
 import { Kysely } from "kysely";
 import { PGliteDialect } from "kysely-pglite-dialect";
 import { HttpResponse, http } from "msw";
@@ -18,17 +9,18 @@ import { uuidv7 } from "uuidv7";
 import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
 
 import { standaloneRepository } from "../../../plugins/standalone/src";
-import { createInMemoryDatabasePlugin } from "../../test-utils/test/inMemoryDatabasePlugin";
 import { kyselyAdapter } from "./adapters/kysely";
 import { createMigrator } from "./db";
 import { createHotUpdater, type RuntimeHotUpdaterAPI } from "./index";
+import { insights } from "./plugins/insights";
 
 const db = new PGlite();
 const kysely = new Kysely<object>({ dialect: new PGliteDialect(db) });
 const clientMountPath = "/hot-updater";
 const api = createHotUpdater({
   database: kyselyAdapter({ db: kysely, provider: "postgresql" }),
-  clientAccess: { type: "public" },
+  plugins: [insights()],
+  clientAccess: "public",
 });
 const baseUrl = "http://localhost:3000";
 const server = setupServer();
@@ -46,10 +38,11 @@ const invokeHandler = async (
     ? hotUpdater.handlers.admin
     : hotUpdater.handlers.client;
   const response = await handler(new Request(url, request));
-  return new HttpResponse(await response.text(), {
-    status: response.status,
-    headers: response.headers,
-  });
+  // A 204 carries no body, and a Response refuses one.
+  return new HttpResponse(
+    response.status === 204 ? null : await response.text(),
+    { status: response.status, headers: response.headers },
+  );
 };
 
 beforeAll(async () => {
@@ -67,11 +60,13 @@ beforeAll(async () => {
 });
 
 afterEach(async () => {
-  await db.exec("DELETE FROM bundle_patches");
-  await db.exec("DELETE FROM release_catalogs");
-  await db.exec("DELETE FROM releases");
-  await db.exec("DELETE FROM bundles");
-  await db.exec("DELETE FROM channels");
+  // Every table but the settings rows, aggregates included.
+  const { rows } = await db.query<{ tablename: string }>(
+    "SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename <> 'private_hot_updater_settings'",
+  );
+  await db.exec(
+    `TRUNCATE ${rows.map(({ tablename }) => `"${tablename}"`).join(", ")} CASCADE`,
+  );
 });
 
 afterAll(async () => {
@@ -83,448 +78,245 @@ afterAll(async () => {
 const createTestBundle = (overrides?: Partial<Bundle>): Bundle => ({
   id: NIL_UUID,
   platform: "ios",
-  fileHash: "test-hash",
   gitCommitHash: null,
-  storageUri: "test://storage",
-  archiveByteSize: 3_000_000_001,
+  manifestStorageUri: "test://storage/manifest.json",
+  manifestFileHash: "test-manifest-hash",
+  assetBaseStorageUri: "test://assets",
   ...overrides,
 });
 
-const createStandaloneClient = (base = `${baseUrl}/hot-updater/admin`) =>
-  createDatabaseClient(standaloneRepository({ baseUrl: base }));
-
-const commitTestRelease = async (
-  bundle: Bundle,
-  channelName = "production",
-) => {
-  const repository = standaloneRepository({
-    baseUrl: `${baseUrl}/hot-updater/admin`,
-  });
-  const channel = await repository.models.channels.insert({
-    onConflict: "returnExisting",
-    row: { id: uuidv7(), name: channelName },
-  });
-  const scopeKey = createReleaseCatalogScopeKey({
-    channelKey: encodeChannelKey(channelName),
-    platform: bundle.platform,
-    strategy: "APP_VERSION",
-  });
-  const releaseId = uuidv7();
-  const committed = await commitReleaseCatalogMutation({
-    companionChanges: [
-      {
-        model: "bundles",
-        operation: "insert",
-        row: bundleToRow(bundle),
-      },
-    ],
-    database: repository,
-    mutation: {
-      operation: "insert",
-      row: {
-        bundle_id: bundle.id,
-        channel_id: channel.row.id,
-        created_at_ms: 1,
-        enabled: true,
-        fingerprint_hash: null,
-        id: releaseId,
-        kind: "BUNDLE",
-        message: null,
-        operation: "DEPLOY",
-        platform: bundle.platform,
-        revision: 1,
-        rollout_cohort_count: 1_000,
-        scope_key: scopeKey,
-        should_force_update: false,
-        source_release_id: null,
-        strategy: "APP_VERSION",
-        target_app_version: "*",
-        target_cohorts: [],
-        updated_at_ms: 1,
-      },
-    },
-    scope: {
-      channelId: channel.row.id,
-      channelName,
+describe("Standalone core API over admin API protocol 2", () => {
+  const core = () =>
+    standaloneRepository({ baseUrl: `${baseUrl}/hot-updater/admin` }).core;
+  const deployment = (bundle: Bundle, channel = "production") => ({
+    bundle,
+    release: {
+      channel,
+      enabled: true,
       fingerprintHash: null,
-      platform: bundle.platform,
-      scopeKey,
-      strategy: "APP_VERSION",
+      message: null,
+      shouldForceUpdate: false,
+      targetAppVersion: "1.0.0",
     },
   });
-  return { channel: channel.row, committed, releaseId, repository, scopeKey };
-};
 
-describe("Handler <-> Standalone Repository Integration", () => {
-  it("uses Standalone for bundle management and the server database for Insights", async () => {
-    const bundleId = uuidv7();
-    const installId = "standalone-install";
-    await createStandaloneClient().insertBundle(
-      createTestBundle({ id: bundleId }),
+  it("deploys, lists by key, and reads bundles, releases, catalogs, and channels", async () => {
+    const remote = core();
+    const bundles = [uuidv7(), uuidv7(), uuidv7()].map((id) =>
+      createTestBundle({ id }),
     );
-
-    const ingestion = await api.handlers.client(
-      new Request(`${baseUrl}/events`, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-        },
-        body: JSON.stringify({
-          appVersion: "1.0.0",
-          channel: "production",
-          cohort: "default",
-          fingerprintHash: null,
-          fromBundleId: NIL_UUID,
-          fromReleaseId: null,
-          installId,
+    const deployed = [];
+    for (const bundle of bundles) {
+      deployed.push(...(await remote.deploy([deployment(bundle)])));
+    }
+    const scopeKey = deployed[0]!.catalog.scope_key;
+    const channel = await remote.findChannelByName("production");
+
+    expect(deployed.map(({ catalog }) => catalog.generation)).toEqual([
+      1, 2, 3,
+    ]);
+    expect(channel).toMatchObject({ name: "production" });
+    await expect(remote.listChannels()).resolves.toEqual([channel]);
+    const first = await remote.listBundles({ limit: 2, order: "desc" });
+    const second = await remote.listBundles({
+      limit: 2,
+      order: "desc",
+      after: first.at(-1)!.bundle.id,
+    });
+    expect([...first, ...second].map(({ bundle }) => bundle.id)).toEqual(
+      bundles.map(({ id }) => id).reverse(),
+    );
+    await expect(remote.countBundles()).resolves.toBe(3);
+    await expect(remote.countBundles("android")).resolves.toBe(0);
+    await expect(remote.getBundle(bundles[0]!.id)).resolves.toMatchObject({
+      bundle: { id: bundles[0]!.id },
+      patches: [],
+      childCount: 0,
+    });
+    await expect(remote.getBundle(uuidv7())).resolves.toBeNull();
+    await expect(
+      remote.listReleases({
+        limit: 10,
+        order: "asc",
+        filter: { kind: "scope", scopeKey, enabled: true },
+      }),
+    ).resolves.toHaveLength(3);
+    await expect(
+      remote.listReleases({
+        limit: 10,
+        filter: {
+          kind: "channelPlatform",
+          channelId: channel!.id,
           platform: "ios",
-          sdkVersion: "2.0.0",
-          toBundleId: bundleId,
-          toReleaseId: null,
-          type: "UPDATE_APPLIED",
-          updateStrategy: "appVersion",
-        }),
+          enabled: false,
+        },
       }),
-    );
-    const overview = await api.handlers.admin(
-      new Request(`${baseUrl}/installations/overview`),
-    );
-
-    expect(ingestion.status).toBe(204);
-    expect(overview.status).toBe(200);
-    await expect(overview.json()).resolves.toEqual({
-      bundles: [{ bundleId, installations: 1 }],
-      trackedInstallations: 1,
+    ).resolves.toEqual([]);
+    await expect(remote.getReleaseCatalogRow(scopeKey)).resolves.toMatchObject({
+      generation: 3,
     });
+    await expect(remote.listReleaseCatalogs({ limit: 10 })).resolves.toEqual([
+      expect.objectContaining({ scope_key: scopeKey }),
+    ]);
   });
 
-  it("atomically commits and reads Release catalogs through standalone management routes", async () => {
-    const bundle = createTestBundle({ id: uuidv7() });
-    const { committed, releaseId, repository, scopeKey } =
-      await commitTestRelease(bundle);
+  it("changes, previews, promotes, and deletes releases, and rebuilds catalogs", async () => {
+    const remote = core();
+    const [deployed] = await remote.deploy([
+      deployment(createTestBundle({ id: uuidv7() })),
+    ]);
+    const releaseId = deployed!.release!.id;
+    const scopeKey = deployed!.catalog.scope_key;
 
     await expect(
-      repository.models.releases.findById(releaseId),
+      remote.preflightReleasePolicy({
+        releaseId,
+        patch: { rolloutCohortCount: 100 },
+      }),
     ).resolves.toMatchObject({
-      bundle_id: bundle.id,
-      revision: 1,
+      expectedReleaseRevision: 1,
+      release: { revision: 2 },
     });
     await expect(
-      repository.models.releaseCatalogs.findByScopeKey(scopeKey),
-    ).resolves.toMatchObject({ generation: committed.catalog.generation });
-    const response = await api.handlers.client(
-      new Request(
-        `${baseUrl}/release-catalogs/app-version/ios/${encodeChannelKey("production")}/1.0.0`,
-      ),
-    );
-    expect(response.status).toBe(200);
-    await expect(response.json()).resolves.toMatchObject({
-      releases: [{ bundleId: bundle.id, releaseId }],
-    });
-  });
-
-  it("keeps Standalone management routes separate from API key protection", async () => {
-    const protectedApi = createHotUpdater({
-      database: createInMemoryDatabasePlugin(),
-      clientAccess: { type: "api-key" },
-    });
-    server.use(
-      http.all(`${baseUrl}/protected-hot-updater/*`, async ({ request }) => {
-        return invokeHandler(protectedApi, request, "/protected-hot-updater");
+      remote.updateReleasePolicy({
+        releaseId,
+        expectedRevision: 1,
+        patch: { rolloutCohortCount: 100 },
       }),
-    );
-    const bundleId = uuidv7();
-    const client = createStandaloneClient(
-      `${baseUrl}/protected-hot-updater/admin`,
-    );
-
-    await client.insertBundle(createTestBundle({ id: bundleId }));
-    const updateCheck = await protectedApi.handlers.client(
-      new Request(
-        `${baseUrl}/release-catalogs/app-version/ios/${encodeChannelKey("production")}/1.0.0`,
-      ),
-    );
-
-    await expect(client.getBundleById(bundleId)).resolves.toMatchObject({
-      id: bundleId,
-    });
-    expect(updateCheck.status).toBe(401);
-  });
-
-  it("creates a bundle through handler POST /bundles", async () => {
-    const bundleId = uuidv7();
-    const response = await api.handlers.admin(
-      new Request(`${baseUrl}/bundles`, {
-        body: JSON.stringify(
-          createTestBundle({
-            id: bundleId,
-            fileHash: "integration-hash-1",
-          }),
-        ),
-        headers: { "Content-Type": "application/json" },
-        method: "POST",
+    ).resolves.toMatchObject({ release: { revision: 2 } });
+    await expect(
+      remote.updateReleasePolicy({
+        releaseId,
+        expectedRevision: 1,
+        patch: { enabled: false },
       }),
-    );
-
-    const retrieved = await api.handlers.admin(
-      new Request(`${baseUrl}/bundles/${bundleId}`),
-    );
-    expect(response.status).toBe(201);
-    expect(retrieved.status).toBe(200);
-    await expect(retrieved.json()).resolves.toMatchObject({
-      id: bundleId,
-      fileHash: "integration-hash-1",
-    });
-    await expect(api.getReleases({ bundleId, limit: 10 })).resolves.toEqual([]);
-  });
-
-  it("retrieves a bundle through handler GET /bundles/:id", async () => {
-    const bundleId = uuidv7();
-    await api.insertBundle(
-      createTestBundle({ id: bundleId, fileHash: "get-hash-1" }),
-    );
-
-    const retrieved = await createStandaloneClient().getBundleById(bundleId);
-
-    expect(retrieved).toMatchObject({ id: bundleId, fileHash: "get-hash-1" });
-  });
-
-  it("refuses to delete an artifact referenced by a Release", async () => {
-    const bundleId = uuidv7();
-    const bundle = createTestBundle({ id: bundleId });
-    await commitTestRelease(bundle);
-    const client = createStandaloneClient();
-
-    await expect(client.deleteBundleById(bundleId)).rejects.toThrow(
-      "still referenced",
-    );
-
-    await expect(api.getBundleById(bundleId)).resolves.toMatchObject({
-      id: bundleId,
+    ).rejects.toMatchObject({
+      name: "ReleaseManagementError",
+      code: "VERSION_CONFLICT",
     });
-  });
-
-  it("lists and filters artifacts through handler GET /bundles", async () => {
-    await api.insertBundle(createTestBundle({ id: uuidv7() }));
-    await api.insertBundle(createTestBundle({ id: uuidv7() }));
-    await api.insertBundle(createTestBundle({ id: uuidv7() }));
-    const client = createStandaloneClient();
-
-    const all = await client.getBundles({ limit: 50 });
-    const ios = await client.getBundles({
-      where: { platform: "ios" },
-      limit: 50,
-    });
-
-    expect(all.data).toHaveLength(3);
-    expect(all.pagination.total).toBe(3);
-    expect(ios.data).toHaveLength(3);
-  });
-
-  it("lists Channel rows through handler GET /channels", async () => {
-    await api.insertChannel({
-      onConflict: "returnExisting",
-      row: { id: uuidv7(), name: "production" },
+    const promoted = await remote.promoteRelease({
+      releaseId,
+      targetChannel: "beta",
+      action: "move",
     });
-    await api.insertChannel({
-      onConflict: "returnExisting",
-      row: { id: uuidv7(), name: "beta" },
+    expect(promoted.source!.release).toMatchObject({ enabled: false });
+    expect(promoted.target.release).toMatchObject({
+      operation: "PROMOTE",
+      source_release_id: releaseId,
     });
-
-    const channels = await createStandaloneClient().getChannels();
-
-    expect(channels.map(({ name }) => name)).toEqual(
-      expect.arrayContaining(["production", "beta"]),
-    );
-    expect(channels.every(({ id }) => id.length > 0)).toBe(true);
-    expect(new Set(channels.map(({ name }) => name)).size).toBe(
-      channels.length,
+    await expect(
+      remote.preflightReleaseCatalogRebuild(scopeKey),
+    ).resolves.toMatchObject({ changed: false });
+    await expect(remote.rebuildReleaseCatalog(scopeKey)).resolves.toMatchObject(
+      { changed: false },
     );
+    await expect(remote.deleteRelease({ releaseId })).resolves.toMatchObject({
+      release: null,
+    });
+    await expect(remote.getRelease(releaseId)).resolves.toBeNull();
   });
 
-  it("creates and deletes an empty Channel through the canonical routes", async () => {
-    const client = createStandaloneClient();
-    const id = uuidv7();
+  it("creates and deletes channels, replaces patches, and refuses to delete a bundle a release uses", async () => {
+    const remote = core();
+    const base = createTestBundle({ id: uuidv7() });
+    const target = createTestBundle({ id: uuidv7() });
+    await remote.deploy([deployment(base)]);
+    await remote.deploy([deployment(target)]);
+    const qa = await remote.ensureChannel("qa");
 
-    await expect(
-      client.insertChannel({
-        row: { id, name: "preview" },
-        onConflict: "returnExisting",
-      }),
-    ).resolves.toEqual({
-      row: { id, name: "preview" },
-      inserted: true,
-    });
-    await expect(client.deleteChannel({ id })).resolves.toEqual({
+    await expect(remote.ensureChannel("qa")).resolves.toEqual(qa);
+    await expect(remote.deleteChannel(qa.id)).resolves.toEqual({
       deleted: true,
     });
-    await expect(client.deleteChannel({ id })).resolves.toEqual({
-      deleted: false,
-      reason: "not_found",
-    });
-  });
-
-  it("refuses to delete a Channel referenced by a Release", async () => {
-    const client = createStandaloneClient();
-    const bundleId = uuidv7();
-    await commitTestRelease(createTestBundle({ id: bundleId }), "preview");
-    const channel = (await client.getChannels()).find(
-      ({ name }) => name === "preview",
-    );
-
-    expect(channel).toBeDefined();
-    if (!channel) throw new Error("preview Channel was not created");
-    await expect(client.deleteChannel({ id: channel.id })).resolves.toEqual({
+    const production = await remote.findChannelByName("production");
+    await expect(remote.deleteChannel(production!.id)).resolves.toEqual({
       deleted: false,
       reason: "not_empty",
     });
-    await expect(client.getBundleById(bundleId)).resolves.toMatchObject({
-      id: bundleId,
-    });
-  });
-
-  it("updates an artifact without changing its Release or catalog", async () => {
-    const bundle = createTestBundle({ id: uuidv7() });
-    const { releaseId, repository, scopeKey } = await commitTestRelease(bundle);
-    const releaseBefore = await repository.models.releases.findById(releaseId);
-    const catalogBefore =
-      await repository.models.releaseCatalogs.findByScopeKey(scopeKey);
-
-    await createStandaloneClient().updateBundleById(bundle.id, {
-      storageUri: "test://updated-artifact",
-    });
-
-    await expect(api.getBundleById(bundle.id)).resolves.toMatchObject({
-      storageUri: "test://updated-artifact",
+    await remote.updateBundle(target.id, {
+      patches: [
+        {
+          baseBundleId: base.id,
+          baseFileHash: "base-hash",
+          byteSize: 10,
+          patchFileHash: "patch-hash",
+          patchStorageUri: "test://patches/1.patch",
+        },
+      ],
     });
     await expect(
-      repository.models.releases.findById(releaseId),
-    ).resolves.toEqual(releaseBefore);
+      remote.listPatchesFromBase(base.id, { limit: 10 }),
+    ).resolves.toEqual([expect.objectContaining({ bundle_id: target.id })]);
     await expect(
-      repository.models.releaseCatalogs.findByScopeKey(scopeKey),
-    ).resolves.toEqual(catalogBefore);
-  });
-
-  it("creates, retrieves, updates, and deletes through existing routes", async () => {
-    const client = createStandaloneClient();
-    const bundleId = uuidv7();
-    await client.insertBundle(
-      createTestBundle({ id: bundleId, fileHash: "e2e-hash" }),
-    );
-
-    await expect(client.getBundleById(bundleId)).resolves.toMatchObject({
-      fileHash: "e2e-hash",
+      remote.countBundleChildren([base.id, target.id]),
+    ).resolves.toEqual({ [base.id]: 1, [target.id]: 0 });
+    await expect(remote.deleteBundles([base.id])).rejects.toMatchObject({
+      status: 409,
     });
-    await client.updateBundleById(bundleId, { storageUri: "test://updated" });
-    await expect(client.getBundleById(bundleId)).resolves.toMatchObject({
-      storageUri: "test://updated",
-    });
-    await client.deleteBundleById(bundleId);
-    await expect(client.getBundleById(bundleId)).resolves.toBeNull();
   });
 
-  it("creates multiple artifacts atomically through POST /bundles", async () => {
-    const ids = [uuidv7(), uuidv7(), uuidv7()];
-
-    const response = await api.handlers.admin(
-      new Request(`${baseUrl}/bundles`, {
-        body: JSON.stringify(ids.map((id) => createTestBundle({ id }))),
-        headers: { "Content-Type": "application/json" },
-        method: "POST",
-      }),
-    );
-
-    expect(response.status).toBe(201);
-    for (const id of ids) {
-      await expect(api.getBundleById(id)).resolves.toMatchObject({ id });
-    }
-  });
-
-  it("rolls back the entire create batch when one bundle cannot be inserted", async () => {
-    const existingId = uuidv7();
-    const newId = uuidv7();
-    await api.insertBundle(createTestBundle({ id: existingId }));
-
-    const response = await api.handlers.admin(
-      new Request(`${baseUrl}/bundles`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify([
-          createTestBundle({ id: newId }),
-          createTestBundle({ id: existingId }),
-        ]),
-      }),
-    );
-
-    expect(response.status).toBe(500);
-    await expect(api.getBundleById(newId)).resolves.toBeNull();
-  });
-
-  it("works when handlers are mounted under a custom client path", async () => {
-    const customApi = createHotUpdater({
-      database: kyselyAdapter({ db: kysely, provider: "postgresql" }),
-      clientAccess: { type: "public" },
-    });
+  it("fails fast on a server that predates protocol 2, and refuses release filters no index serves", async () => {
     server.use(
-      http.all(`${baseUrl}/api/v2/*`, async ({ request }) => {
-        return invokeHandler(customApi, request, "/api/v2");
-      }),
+      http.get(`${baseUrl}/old-server/version`, () =>
+        HttpResponse.json({ error: "Not found" }, { status: 404 }),
+      ),
     );
-    const bundleId = uuidv7();
-    const client = createStandaloneClient(`${baseUrl}/api/v2/admin`);
+    await expect(
+      standaloneRepository({
+        baseUrl: `${baseUrl}/old-server`,
+      }).core.listChannels(),
+    ).rejects.toThrow("speaks admin API protocol 1, and this CLI needs 2");
 
-    await client.insertBundle(
-      createTestBundle({ id: bundleId, fileHash: "custom-hash" }),
+    const response = await fetch(
+      `${baseUrl}/hot-updater/admin/releases?v=2&channelId=x`,
     );
-
-    await expect(client.getBundleById(bundleId)).resolves.toMatchObject({
-      fileHash: "custom-hash",
-    });
+    expect(response.status).toBe(400);
   });
+});
 
-  it("returns null when the bundle endpoint returns 404", async () => {
-    await expect(
-      createStandaloneClient().getBundleById(uuidv7()),
-    ).resolves.toBeNull();
+describe("Insights through a self-hosted server's admin API", () => {
+  const offPath = "/no-insights";
+  const withoutInsights = createHotUpdater({
+    database: kyselyAdapter({ db: kysely, provider: "postgresql" }),
+    plugins: [],
+    clientAccess: "public",
   });
 
-  it("updates a bundle without creating a duplicate row", async () => {
-    const memoryApi = createHotUpdater({
-      database: createInMemoryDatabasePlugin(),
-      clientAccess: { type: "public" },
-    });
+  beforeAll(() => {
     server.use(
-      http.all(`${baseUrl}/memory-hot-updater/*`, async ({ request }) => {
-        return invokeHandler(memoryApi, request, "/memory-hot-updater");
-      }),
-    );
-    const client = createStandaloneClient(
-      `${baseUrl}/memory-hot-updater/admin`,
-    );
-    const bundleId = uuidv7();
-    await client.insertBundle(
-      createTestBundle({
-        id: bundleId,
-        storageUri: "s3://test-bucket/original.zip",
-      }),
+      http.all(`${baseUrl}${offPath}/*`, ({ request }) =>
+        invokeHandler(withoutInsights, request, offPath),
+      ),
     );
+  });
 
-    await client.updateBundleById(bundleId, {
-      storageUri: "s3://test-bucket/updated.zip",
+  it("reads events with the repository's headers, and a server without insights() says it is off", async () => {
+    const on = standaloneRepository({
+      baseUrl: `${baseUrl}/hot-updater/admin`,
     });
+    const onResponse = await on.fetchAdmin("/events?limit=1");
+    expect(onResponse.status).toBe(200);
+    await expect(onResponse.json()).resolves.toMatchObject({ data: [] });
+
+    const off = standaloneRepository({ baseUrl: `${baseUrl}${offPath}/admin` });
+    const offResponse = await off.fetchAdmin("/events?limit=1");
+    expect(offResponse.status).toBe(204);
+    expect(offResponse.headers.get("x-hot-updater-insights")).toBe("disabled");
+  });
 
-    await expect(client.getBundleById(bundleId)).resolves.toMatchObject({
-      id: bundleId,
-      storageUri: "s3://test-bucket/updated.zip",
-    });
-    await expect(client.getBundles({ limit: 50 })).resolves.toMatchObject({
-      data: [
-        expect.objectContaining({
-          id: bundleId,
-          storageUri: "s3://test-bucket/updated.zip",
-        }),
-      ],
-      pagination: { total: 1 },
-    });
+  it("lists the plugins each server runs on its admin /version, as the console reads them", async () => {
+    const plugins = async (adminUrl: string) => {
+      const response = await standaloneRepository({
+        baseUrl: adminUrl,
+      }).fetchAdmin("/version");
+      return ((await response.json()) as { plugins: unknown }).plugins;
+    };
+
+    await expect(plugins(`${baseUrl}/hot-updater/admin`)).resolves.toEqual([
+      "insights",
+    ]);
+    await expect(plugins(`${baseUrl}${offPath}/admin`)).resolves.toEqual([]);
+    const client = await fetch(`${baseUrl}/hot-updater/version`);
+    expect(await client.json()).not.toHaveProperty("plugins");
   });
 });