@kabmo-labs/kabmo 0.7.0 → 0.9.0

package/src/server/lib/updates/shell-release-desktop.test.ts

@@ -0,0 +1,166 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The DESKTOP half of the shell-release read: which artifact a per-architecture
+ * shell installs, and when the answer is only the release page.
+ *
+ * Split from `shell-release.test.ts` because that file is at the repo's 350-line
+ * ceiling, and the two questions are separable: the mobile pair resolves ONE
+ * artifact for every device, while the desktop trio's answer depends on the
+ * architecture the shell reported.
+ */
+
+import { beforeEach, describe, expect, test } from 'bun:test';
+
+import { fetchShellRelease, resetShellReleaseCache } from '@/server/lib/updates/shell-release';
+
+/** A fetch double that answers one body. */
+function stubFetch(body: unknown) {
+  const calls: string[] = [];
+  const impl = (async (input: string | URL | Request) => {
+    calls.push(String(input));
+    return {
+      ok: true,
+      json: async () => body,
+      text: async () => (typeof body === 'string' ? body : JSON.stringify(body)),
+    } as Response;
+  }) as unknown as typeof fetch;
+  return { impl, calls };
+}
+
+describe('fetchShellRelease — desktop architectures', () => {
+  // The cache is process-wide (see `resetShellReleaseCache`), so every case
+  // starts from a cold one or it reads the previous case's answer.
+  beforeEach(() => resetShellReleaseCache());
+
+  /**
+   * A desktop probe WITHOUT an architecture answers the RELEASE PAGE.
+   *
+   * Every desktop artifact is per-architecture, and a console served to another
+   * machine cannot know which one the window asking runs on. Naming one arch's
+   * file would hand half the readers a build that will not launch, so the link is
+   * the page that lists all of them and `direct` says it is not installable.
+   */
+  test('a desktop probe without an arch answers the release page', async () => {
+    const { impl } = stubFetch([
+      {
+        html_url: 'https://x/app',
+        assets: [
+          { name: 'Kabmo-0.2.0-mac-arm64.zip', browser_download_url: 'https://x/mac-arm.zip' },
+          { name: 'Kabmo-0.2.0-mac-x64.dmg', browser_download_url: 'https://x/mac-x64.dmg' },
+        ],
+      },
+    ]);
+
+    expect(await fetchShellRelease('macos', impl)).toEqual({
+      url: 'https://x/app',
+      latest: '0.2.0',
+      releaseUrl: 'https://x/app',
+      direct: false,
+    });
+  });
+
+  /**
+   * WITH an architecture it answers that machine's own installer.
+   *
+   * This is what makes the desktop self-update possible at all: the shell
+   * reports its arch over the bridge, and the console names ONE file instead of
+   * a page a human has to read.
+   */
+  test('a desktop probe with an arch answers that arch’s installer', async () => {
+    const { impl } = stubFetch([
+      {
+        html_url: 'https://x/app',
+        assets: [
+          { name: 'Kabmo-0.2.0-mac-x64.zip', browser_download_url: 'https://x/mac-x64.zip' },
+          { name: 'Kabmo-0.2.0-mac-arm64.zip', browser_download_url: 'https://x/mac-arm.zip' },
+        ],
+      },
+    ]);
+
+    expect(await fetchShellRelease('macos', impl, 'arm64')).toEqual({
+      url: 'https://x/mac-arm.zip',
+      latest: '0.2.0',
+      releaseUrl: 'https://x/app',
+      direct: true,
+    });
+  });
+
+  test('an arch the release does not publish keeps the page, never the sibling', async () => {
+    // A build that only shipped x64 must not be installed on an arm64 machine:
+    // the page is a correct answer, the other architecture's file is not.
+    const { impl } = stubFetch([
+      {
+        html_url: 'https://x/app',
+        assets: [
+          { name: 'Kabmo-0.2.0-mac-x64.zip', browser_download_url: 'https://x/mac-x64.zip' },
+        ],
+      },
+    ]);
+
+    expect(await fetchShellRelease('macos', impl, 'arm64')).toEqual({
+      url: 'https://x/app',
+      latest: '0.2.0',
+      releaseUrl: 'https://x/app',
+      direct: false,
+    });
+  });
+
+  test('the self-update file is the ONE file that shell can install', async () => {
+    // macOS installs from the `.zip` (ditto extracts it); the `.dmg` beside it is
+    // for a human. Windows installs from the Inno `.exe`; Linux from the
+    // AppImage, which is the only one of its four formats a shell can replace.
+    const mac = stubFetch([
+      {
+        html_url: 'https://x/app',
+        assets: [
+          { name: 'Kabmo-0.2.0-mac-arm64.dmg', browser_download_url: 'https://x/mac-arm.dmg' },
+          { name: 'Kabmo-0.2.0-mac-arm64.zip', browser_download_url: 'https://x/mac-arm.zip' },
+        ],
+      },
+    ]);
+    expect((await fetchShellRelease('macos', mac.impl, 'arm64'))?.url).toBe('https://x/mac-arm.zip');
+
+    const win = stubFetch([
+      {
+        html_url: 'https://x/app',
+        assets: [
+          { name: 'Kabmo-0.2.0-win-x64-setup.exe', browser_download_url: 'https://x/win-x64.exe' },
+        ],
+      },
+    ]);
+    expect((await fetchShellRelease('windows', win.impl, 'x64'))?.url).toBe('https://x/win-x64.exe');
+
+    const linux = stubFetch([
+      {
+        html_url: 'https://x/app',
+        assets: [
+          { name: 'Kabmo-0.2.0-linux-x86_64.tar.gz', browser_download_url: 'https://x/linux.tgz' },
+          { name: 'Kabmo-0.2.0-linux-x86_64.AppImage', browser_download_url: 'https://x/linux.AppImage' },
+        ],
+      },
+    ]);
+    expect((await fetchShellRelease('linux', linux.impl, 'x64'))?.url).toBe('https://x/linux.AppImage');
+  });
+
+  test('the arch is part of the cache key', async () => {
+    // One console is routinely shared by a whole team, and two machines on it
+    // differ only by architecture. A shared slot would answer the second one with
+    // the first one's installer.
+    const release = {
+      html_url: 'https://x/app',
+      assets: [
+        { name: 'Kabmo-0.3.0-mac-arm64.zip', browser_download_url: 'https://x/arm.zip' },
+        { name: 'Kabmo-0.3.0-mac-x64.zip', browser_download_url: 'https://x/x64.zip' },
+      ],
+    };
+    expect((await fetchShellRelease('macos', stubFetch([release]).impl, 'arm64'))?.url).toBe('https://x/arm.zip');
+
+    const { impl, calls } = stubFetch([release]);
+    expect((await fetchShellRelease('macos', impl, 'x64'))?.url).toBe('https://x/x64.zip');
+    expect(calls.length, 'a different arch is a different question').toBeGreaterThan(0);
+  });
+});

package/src/server/lib/updates/shell-release.test.ts

@@ -5,75 +5,16 @@
 
 import { beforeEach, describe, expect, test } from 'bun:test';
 
-import { fetchShellRelease, resetShellReleaseCache, versionFromAssetName } from '@/server/lib/updates/shell-release';
+import { fetchShellRelease, resetShellReleaseCache } from '@/server/lib/updates/shell-release';
 
 /**
- * The asset name is the only place a shell artifact's version exists: the
- * release TAG names the SERVER version, and the two move independently. A parser
- * that read the tag would compare a server version against a shell version.
+ * A fetch double that answers one body, and counts its calls.
  *
- * Both shells are pinned here, because they share the parser and differ only by
- * prefix/extension — the shape that silently accepts the other shell's asset.
+ * `text()` is provided as well as `json()`: the public-pages fallback reads Atom
+ * and HTML, and a stub that only answered `json()` would throw inside it and make
+ * a broken parse look like a clean "no release" — the exact confusion these
+ * tests exist to prevent.
  */
-describe('versionFromAssetName', () => {
-  test('reads the version the release workflows write', () => {
-    expect(versionFromAssetName('android', 'Kabmo-0.5.0-android.apk')).toBe('0.5.0');
-    expect(versionFromAssetName('ios', 'Kabmo-0.1.0-ios.ipa')).toBe('0.1.0');
-  });
-
-  /**
-   * The old spelling is still READ, and that is not sentiment.
-   *
-   * These names are the only record of a published shell, and every release
-   * already on GitHub carries `kabmo-android-v<v>.apk`. A parser that only knew
-   * the new scheme would answer "no update" for an installed shell the moment
-   * this shipped — silently, because a name that does not match reads exactly
-   * like a release with no artifact.
-   */
-  test('still reads the legacy spelling every published release carries', () => {
-    expect(versionFromAssetName('android', 'kabmo-android-v0.5.0.apk')).toBe('0.5.0');
-    expect(versionFromAssetName('ios', 'kabmo-ios-v0.1.0.ipa')).toBe('0.1.0');
-  });
-
-  test('ignores anything that is not that shell’s artifact', () => {
-    expect(versionFromAssetName('android', 'Kabmo-1.2.3-android.apk.zip')).toBeNull();
-    expect(versionFromAssetName('android', 'source.tar.gz')).toBeNull();
-    expect(versionFromAssetName('android', 'Kabmo-latest-android.apk')).toBeNull();
-    expect(versionFromAssetName('android', 'Kabmo--android.apk')).toBeNull();
-    expect(versionFromAssetName('android', '')).toBeNull();
-  });
-
-  /**
-   * The desktop assets share the `Kabmo-` prefix, so the EXTENSION is what keeps
-   * them out. A probe that matched on the prefix alone would offer a Mac `.dmg`
-   * to an Android phone.
-   */
-  test('does not read a desktop asset as a mobile one', () => {
-    for (const name of [
-      'Kabmo-0.1.2-mac-arm64.zip',
-      'Kabmo-0.1.2-mac-arm64.dmg',
-      'Kabmo-0.1.0-win-x64-setup.exe',
-      'Kabmo-0.1.0-linux-x86_64.tar.gz',
-      'Kabmo-0.1.0-linux-amd64.deb',
-      'Kabmo-0.1.0-linux-x86_64.AppImage',
-    ]) {
-      expect(versionFromAssetName('android', name), name).toBeNull();
-      expect(versionFromAssetName('ios', name), name).toBeNull();
-    }
-  });
-
-  test('does not accept one shell’s asset for the other', () => {
-    // The two probes read the SAME release list, so a parser that ignored the
-    // kind would let an iOS probe answer with the APK (and offer an `.apk` to an
-    // iPhone).
-    expect(versionFromAssetName('ios', 'Kabmo-0.5.0-android.apk')).toBeNull();
-    expect(versionFromAssetName('android', 'Kabmo-0.1.0-ios.ipa')).toBeNull();
-    expect(versionFromAssetName('ios', 'kabmo-android-v1.2.3.apk')).toBeNull();
-    expect(versionFromAssetName('android', 'kabmo-ios-v1.2.3.ipa')).toBeNull();
-  });
-});
-
-/** A fetch double that answers one body, and counts its calls. */
 function stubFetch(body: unknown, ok = true) {
   const calls: string[] = [];
   const impl = (async (input: string | URL | Request) => {
@@ -81,11 +22,45 @@ function stubFetch(body: unknown, ok = true) {
     return {
       ok,
       json: async () => body,
+      text: async () => (typeof body === 'string' ? body : JSON.stringify(body)),
     } as Response;
   }) as unknown as typeof fetch;
   return { impl, calls };
 }
 
+/**
+ * A double that routes by URL, for the two-path probe.
+ *
+ * `api` answers the REST read (or fails, which is what a spent quota does) and
+ * `pages` answers the Atom feed and each release's asset fragment. Returning
+ * `null` for a route means "this request fails", which is how the fallback is
+ * entered at all.
+ */
+function routedFetch(routes: {
+  api?: unknown;
+  atom?: string;
+  assets?: Record<string, string>;
+}) {
+  const calls: string[] = [];
+  const impl = (async (input: string | URL | Request) => {
+    const url = String(input);
+    calls.push(url);
+
+    if (url.includes('/repos/')) {
+      if (routes.api === undefined) return { ok: false, json: async () => ({}), text: async () => '' } as Response;
+      return { ok: true, json: async () => routes.api, text: async () => JSON.stringify(routes.api) } as Response;
+    }
+    if (url.endsWith('/releases.atom')) {
+      const body = routes.atom ?? '';
+      return { ok: Boolean(routes.atom), json: async () => ({}), text: async () => body } as Response;
+    }
+    const tag = url.slice(url.lastIndexOf('/') + 1);
+    const body = routes.assets?.[decodeURIComponent(tag)];
+    return { ok: body !== undefined, json: async () => ({}), text: async () => body ?? '' } as Response;
+  }) as unknown as typeof fetch;
+  return { impl, calls };
+}
+
 describe('fetchShellRelease', () => {
   // The cache is process-wide (see `resetShellReleaseCache`), so every case
   // starts from a cold one or it reads the previous case's answer.
@@ -109,6 +84,7 @@ describe('fetchShellRelease', () => {
       url: 'https://x/Kabmo-1.2.3-android.apk',
       latest: '1.2.3',
       releaseUrl: 'https://github.com/kabmo-labs/kabmo/releases/tag/v9.9.9',
+      direct: true,
     });
   });
 
@@ -127,6 +103,7 @@ describe('fetchShellRelease', () => {
       url: 'https://x/i.ipa',
       latest: '0.4.0',
       releaseUrl: 'https://x/app',
+      direct: true,
     });
   });
 
@@ -155,6 +132,7 @@ describe('fetchShellRelease', () => {
       url: 'https://x/new.apk',
       latest: '0.6.0',
       releaseUrl: 'https://x/r',
+      direct: true,
     });
   });
 
@@ -208,6 +186,7 @@ describe('fetchShellRelease', () => {
       url: 'https://x/a.apk',
       latest: '0.3.0',
       releaseUrl: 'https://x/app',
+      direct: true,
     });
   });
 
@@ -237,19 +216,28 @@ describe('fetchShellRelease', () => {
       { html_url: 'https://x', assets: [{ name: 'notes.md' }] },
       { html_url: 'https://y', assets: [] },
     ]);
-    expect(await fetchShellRelease('android', impl)).toEqual({ url: null, latest: null, releaseUrl: null });
+    expect(await fetchShellRelease('android', impl)).toEqual({
+      url: null,
+      latest: null,
+      releaseUrl: null,
+      direct: false,
+    });
   });
 
   test('answers null when the probe fails', async () => {
-    // An offline box or a rate-limited GitHub must not take the sidebar down,
-    // and a failure must not be read as "no newer version" either — it is
-    // simply no offer.
-    const { impl } = stubFetch({}, false);
+    // An offline box must not take the sidebar down, and a failure must not be
+    // read as "no newer version" either — it is simply no offer. BOTH paths are
+    // down here: the API refuses and the feed is unreachable, which is the only
+    // shape that means "cannot ask" rather than "nothing published".
+    const { impl } = routedFetch({});
     expect(await fetchShellRelease('android', impl)).toBeNull();
   });
 
   test('answers null when the body is malformed', async () => {
-    const { impl } = stubFetch({ assets: 'nope' });
+    // The API answers 200 with something that is not a release list, and the
+    // feed is unreachable — the API's answer is a failed probe, not an empty
+    // repository.
+    const { impl } = routedFetch({ api: { assets: 'nope' } });
     expect(await fetchShellRelease('android', impl)).toBeNull();
   });
 });