@kabmo-labs/kabmo 0.1.0 → 0.3.0

package/src/server/lib/fs/git-actions-sync.test.ts

@@ -0,0 +1,144 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The `sync` ACTION, not just the pull under it.
+ *
+ * `pullBranch` is pinned by `git-publish.test.ts`; what is pinned here is the
+ * handler's own two rules, both invisible from the pull alone:
+ *
+ * - A pull that stops on a conflict SKIPS the push. `git push` refuses while
+ *   the merge is unresolved, so without the skip the route answered 400 over a
+ *   conflict the operation bar was about to offer to resolve — the reported
+ *   "Sync failed" on the exact state the panel has a surface for.
+ * - A tree already in an operation is refused BY NAME rather than by git's
+ *   "You have not concluded your merge" — the panel can only act on an
+ *   operation it knows about, and an error that names it is what points the
+ *   user at the bar.
+ *
+ * Driven against real repositories: the exit codes, the merge commit and the
+ * `MERGE_HEAD` file are the whole subject.
+ */
+
+import { afterAll, describe, expect, test } from 'bun:test';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { GIT_BRANCH_ACTIONS } from '@/server/lib/fs/git-actions-branch';
+import { removeDir } from '@/test-support/remove-dir';
+
+const tempDirs: string[] = [];
+
+function tempDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kabmo-gitsync-action-'));
+  tempDirs.push(dir);
+  return dir;
+}
+
+function git(cwd: string, ...args: string[]): string {
+  const result = Bun.spawnSync({ cmd: ['git', ...args], cwd });
+  if (result.exitCode !== 0) {
+    throw new Error(`git ${args.join(' ')} failed: ${result.stderr.toString()}`);
+  }
+  return result.stdout.toString();
+}
+
+function initRepo(cwd: string): void {
+  git(cwd, 'init', '-q', '-b', 'main');
+  git(cwd, 'config', 'user.email', 'test@example.invalid');
+  git(cwd, 'config', 'user.name', 'Test');
+}
+
+function commitFile(cwd: string, name: string, message: string, content?: string): void {
+  fs.writeFileSync(path.join(cwd, name), content ?? `${name}\n`);
+  git(cwd, 'add', '-A');
+  git(cwd, 'commit', '-q', '-m', message);
+}
+
+/** A bare origin plus a clone tracking it, each on its own temp path. */
+function makeClone(): { origin: string; clone: string } {
+  const origin = tempDir();
+  git(origin, 'init', '-q', '--bare', '-b', 'main');
+  const clone = tempDir();
+  git(tempDir(), 'clone', '-q', origin, clone);
+  initRepo(clone);
+  commitFile(clone, 'seed.txt', 'seed');
+  git(clone, 'push', '-q', '-u', 'origin', 'main');
+  return { origin, clone };
+}
+
+/** Commit `name` in a second clone of `origin` and push it. */
+function pushFromOtherClone(origin: string, name: string, message: string, content?: string): void {
+  const other = tempDir();
+  git(tempDir(), 'clone', '-q', origin, other);
+  initRepo(other);
+  commitFile(other, name, message, content);
+  git(other, 'push', '-q');
+}
+
+function counts(cwd: string): string {
+  return git(cwd, 'rev-list', '--count', '--left-right', 'HEAD...@{upstream}').trim();
+}
+
+/** One sync, through the same handler the route dispatches. */
+async function sync(cwd: string): Promise<void> {
+  const handler = GIT_BRANCH_ACTIONS.sync;
+  await handler({ formData: new FormData(), targetDir: cwd });
+}
+
+afterAll(() => {
+  for (const dir of tempDirs) removeDir(dir);
+});
+
+describe('the sync action', () => {
+  test('reconciles a diverged branch and publishes the result', async () => {
+    const { origin, clone } = makeClone();
+    pushFromOtherClone(origin, 'other.txt', 'other');
+    commitFile(clone, 'mine.txt', 'mine');
+    git(clone, 'fetch', '-q');
+    expect(counts(clone)).toBe('1\t1');
+
+    await sync(clone);
+
+    // Both sides landed and the remote has them: nothing ahead or behind.
+    expect(counts(clone)).toBe('0\t0');
+    expect(fs.existsSync(path.join(clone, 'other.txt'))).toBe(true);
+    expect(git(clone, 'log', '-1', '--pretty=%s')).toContain('Merge branch');
+  });
+
+  test('leaves a conflicted merge open and does not push over it', async () => {
+    const { origin, clone } = makeClone();
+    commitFile(clone, 'seed.txt', 'mine', 'mine\n');
+    pushFromOtherClone(origin, 'seed.txt', 'theirs', 'theirs\n');
+    git(clone, 'fetch', '-q');
+
+    // The pull exits 1 with MERGE_HEAD in place; the handler must treat that as
+    // the state to show, not as a failure.
+    await sync(clone);
+
+    expect(fs.existsSync(path.join(clone, '.git', 'MERGE_HEAD'))).toBe(true);
+    expect(git(clone, 'status', '--porcelain=v1')).toContain('UU seed.txt');
+  });
+
+  test('refuses by name while an operation is already in progress', async () => {
+    const { origin, clone } = makeClone();
+    commitFile(clone, 'seed.txt', 'mine', 'mine\n');
+    pushFromOtherClone(origin, 'seed.txt', 'theirs', 'theirs\n');
+    git(clone, 'fetch', '-q');
+    // Start the merge the way the panel does, then try to sync over it.
+    Bun.spawnSync({ cmd: ['git', 'merge', '--no-edit', '--', '@{upstream}'], cwd: clone });
+    expect(fs.existsSync(path.join(clone, '.git', 'MERGE_HEAD'))).toBe(true);
+
+    // `expect(...).rejects` is typed as returning void by Bun's matcher types,
+    // so awaiting it is a no-op — the explicit catch is what actually waits.
+    let refusal = '';
+    try {
+      await sync(clone);
+    } catch (error) {
+      refusal = error instanceof Error ? error.message : String(error);
+    }
+    expect(refusal).toMatch(/finish the merge first/i);
+  });
+});

package/src/server/lib/fs/git-publish.test.ts

@@ -13,6 +13,10 @@
  * refusal, not a failure — and treating it as an error aborted Sync before it
  * ever reached the push. Driven against real repositories, because the exit
  * codes and the `-u` upstream write are what the module exists for.
+ *
+ * The pull suite also pins the DIVERGED case, where `--ff-only` exits 128 and
+ * Sync silently did nothing (one local commit, one on origin) — see the merge
+ * test and `pullBranch`'s own comment.
  */
 
 import { afterAll, describe, expect, test } from 'bun:test';
@@ -66,6 +70,32 @@ function upstreamOf(cwd: string): string {
   return git(cwd, 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}').trim();
 }
 
+/** "<ahead>\t<behind>" against the upstream — `1\t1` is a diverged branch. */
+function counts(cwd: string): string {
+  return git(cwd, 'rev-list', '--count', '--left-right', 'HEAD...@{upstream}').trim();
+}
+
+/**
+ * A second clone of `origin` that commits `name` and pushes it, so the branch
+ * under test is behind by one — the other half of a divergence.
+ *
+ * `content` overrides what the file holds, which is what makes the two sides
+ * CONFLICT instead of one of them being an unrelated new path.
+ */
+function pushFromOtherClone(origin: string, name: string, message: string, content?: string): void {
+  const other = tempDir();
+  git(tempDir(), 'clone', '-q', origin, other);
+  initRepo(other);
+  if (content === undefined) {
+    commitFile(other, name, message);
+  } else {
+    fs.writeFileSync(path.join(other, name), content);
+    git(other, 'add', '-A');
+    git(other, 'commit', '-q', '-m', message);
+  }
+  git(other, 'push', '-q');
+}
+
 afterAll(() => {
   for (const dir of tempDirs) removeDir(dir);
 });
@@ -144,4 +174,70 @@ describe('pullBranch', () => {
 
     expect(fs.existsSync(path.join(clone, 'remote.txt'))).toBe(true);
   });
+
+  /**
+   * The reported Sync failure: one local commit and one on origin.
+   *
+   * `--ff-only` exits 128 here ("Not possible to fast-forward, aborting."), so
+   * Sync threw before the push and the badge stayed at ↑1 ↓1 with git's advice
+   * text on screen. The fix is the merge pull, and the assertion is the state
+   * after a REAL push: nothing left ahead or behind.
+   */
+  test('merges a diverged branch instead of refusing, and the push then lands', async () => {
+    const { origin, clone } = makeClone();
+    pushFromOtherClone(origin, 'other.txt', 'other');
+    commitFile(clone, 'mine.txt', 'mine');
+    git(clone, 'fetch', '-q');
+    expect(counts(clone)).toBe('1\t1');
+
+    await pullBranch(clone);
+    await pushBranch(clone);
+
+    expect(counts(clone)).toBe('0\t0');
+    // The merge commit carries the remote branch's name, which is what a pull
+    // writes — not a rebase, whose history would hold two linear commits.
+    expect(git(clone, 'log', '-1', '--pretty=%s')).toContain('Merge branch');
+    expect(fs.existsSync(path.join(clone, 'other.txt'))).toBe(true);
+  });
+
+  /**
+   * A pull that stops on a conflict exits 1 with `MERGE_HEAD` in place — the
+   * state the operation bar exists to show, not a failed sync. Throwing there
+   * reported the conflict as an error and never reached the panel's own
+   * "resolve the conflicts" surface.
+   */
+  test('accepts a pull that stops on a conflict, leaving the merge open', async () => {
+    const { origin, clone } = makeClone();
+    // `seed.txt` exists on both sides already, so the two edits CONFLICT —
+    // a file only one side has would merge cleanly (`AA` only when both
+    // created it, which is a different shape than a content conflict).
+    fs.writeFileSync(path.join(clone, 'seed.txt'), 'mine\n');
+    git(clone, 'commit', '-q', '-am', 'mine');
+    pushFromOtherClone(origin, 'seed.txt', 'theirs', 'theirs\n');
+    git(clone, 'fetch', '-q');
+
+    await pullBranch(clone);
+
+    expect(fs.existsSync(path.join(clone, '.git', 'MERGE_HEAD'))).toBe(true);
+    expect(git(clone, 'status', '--porcelain=v1')).toContain('UU seed.txt');
+  });
+
+  /**
+   * The pull is pinned to merge semantics whatever the repository's own
+   * `pull.ff`/`pull.rebase` say — a Sync button must not mean two things.
+   */
+  test('does not inherit pull.ff=only, which reproduces the refusal', async () => {
+    const { origin, clone } = makeClone();
+    pushFromOtherClone(origin, 'other.txt', 'other');
+    commitFile(clone, 'mine.txt', 'mine');
+    git(clone, 'fetch', '-q');
+    git(clone, 'config', 'pull.ff', 'only');
+
+    await pullBranch(clone);
+
+    // Ahead by the local commit plus the merge commit, and no longer behind:
+    // the pull brought origin in rather than refusing it.
+    expect(counts(clone)).toBe('2\t0');
+    expect(git(clone, 'log', '-1', '--pretty=%s')).toContain('Merge branch');
+  });
 });

package/src/server/lib/fs/git-publish.ts

@@ -13,7 +13,7 @@
  *    branch" when the branch was never published, so Sync failed outright on
  *    exactly the branch whose commits it was supposed to send. `push -u <remote>
  *    HEAD` sets the upstream while it publishes.
- *  - `git pull --ff-only` exits 1 with "There is no tracking information for the
+ *  - `git pull` exits 1 with "There is no tracking information for the
  *    current branch" for the same branch — a refusal, not a failure of the
  *    user's intent: there is nothing to pull yet. Treating it as an error
  *    aborted Sync before it reached the push.
@@ -23,6 +23,7 @@
  */
 
 import { runGit, type GitRunResult } from '@/server/lib/fs/git-run';
+import { readGitState } from '@/server/lib/fs/git-state';
 
 /** Runs a git command and throws with its stderr when it exits non-zero. */
 async function expectOk(args: string[], cwd: string, timeout?: number): Promise<GitRunResult> {
@@ -62,12 +63,43 @@ export async function pushBranch(cwd: string): Promise<void> {
 }
 
 /**
- * Pull with fast-forward only, standing down on a branch with no upstream.
+ * Pull the branch's upstream, standing down on a branch with no upstream.
  *
  * Nothing to pull is not an error, and aborting here is what stopped Sync from
  * ever publishing a fresh branch.
+ *
+ * **`--ff-only` was wrong, and it is the reported "Sync does nothing when I
+ * have one local commit and one on origin".** On a DIVERGED branch git refuses
+ * it outright — measured: `fatal: Not possible to fast-forward, aborting.`
+ * (exit 128) — so Sync threw before it reached the push, the badge stayed at
+ * `↑1 ↓1`, and the panel reported git's advice text as an error. The two
+ * branches cannot be reconciled by moving a pointer; they need a merge commit,
+ * which is what `git pull` does by default. `--ff --no-rebase` states that
+ * explicitly instead of inheriting the user's `pull.rebase`/`pull.ff`: both
+ * were measured to change the answer (`pull.ff=only` reproduces the refusal,
+ * `pull.rebase=true` rewrites local commits), and a Sync button must not mean
+ * two different things per repository. A fast-forward still happens where one
+ * is possible — verified against a behind-only branch.
+ *
+ * **A merge that stops on a conflict is SUCCESS, not a failure.** Measured:
+ * the command exits 1 with `MERGE_HEAD` in place and `UU` rows in the status —
+ * the state the panel's operation bar exists to show. Throwing there reported
+ * the conflict as a failed sync and hid the bar's own instructions, so the
+ * caller checks for a started merge exactly as `expectStarted` does for a
+ * merge the user asked for.
  */
 export async function pullBranch(cwd: string): Promise<void> {
   if (!(await readUpstream(cwd))) return;
-  await expectOk(['pull', '--ff-only'], cwd, 120000);
+  const result = await runGit(['pull', '--ff', '--no-rebase', '--no-edit'], {
+    cwd,
+    timeout: 120_000,
+    maxBuffer: 1024 * 1024,
+  });
+  if (result.error) throw result.error;
+  if (result.exitCode === 0) return;
+  const state = await readGitState(cwd);
+  if (state.operation === 'merge') return;
+  throw new Error(
+    result.stderr.trim() || result.stdout.trim() || `git exited with code ${result.exitCode}`,
+  );
 }

package/src/server/lib/fs/listing.test.ts

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * What the Files panel lists.
+ *
+ * The panel used to drop a hardcoded set of names (`node_modules`, `.git`,
+ * `dist`, `build`) at every depth, which hid `packages/android/dist` — the
+ * built APKs — from the user with no way to reach it. There is now no name
+ * filter at all: every entry is listed, and the `ignored` flag (one
+ * `git check-ignore` per listing) is what marks the untracked ones for dimming.
+ *
+ * Driven against a real temp directory, because the listing stats every entry
+ * and asks git about it.
+ */
+
+import { afterEach, describe, expect, test } from 'bun:test';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { listDirectoryEntries } from '@/server/lib/fs/listing';
+
+const roots: string[] = [];
+
+afterEach(() => {
+  while (roots.length > 0) fs.rmSync(roots.pop() as string, { recursive: true, force: true });
+});
+
+function makeRoot(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kabmo-listing-'));
+  roots.push(dir);
+  return dir;
+}
+
+function mkdirs(root: string, names: string[]): void {
+  for (const name of names) fs.mkdirSync(path.join(root, name), { recursive: true });
+}
+
+describe('listDirectoryEntries', () => {
+  test('lists every entry, node_modules and .git included', async () => {
+    const root = makeRoot();
+    mkdirs(root, ['src', 'dist', 'build', 'node_modules/preact', '.git/objects']);
+
+    const names = (await listDirectoryEntries(root, root)).map((entry) => entry.name);
+
+    expect(names).toContain('dist');
+    expect(names).toContain('build');
+    expect(names).toContain('src');
+    // No name table: the panel must be able to reach anything on disk.
+    expect(names).toContain('node_modules');
+    expect(names).toContain('.git');
+  });
+
+  test('a nested dist is listed where it lives, not filtered by name', async () => {
+    const root = makeRoot();
+    mkdirs(root, ['packages/android/dist', 'packages/core']);
+
+    const packages = await listDirectoryEntries(path.join(root, 'packages'), root);
+    expect(packages.map((entry) => entry.name)).toEqual(['android', 'core']);
+
+    const android = await listDirectoryEntries(path.join(root, 'packages/android'), root);
+    expect(android.map((entry) => entry.name)).toEqual(['dist']);
+    // Paths stay relative to the LISTED root, which is what the tree keys on,
+    // and they are POSIX-spelled whatever the platform: `path.relative` answers
+    // `packages\android\dist` on Windows, which keyed every row differently from
+    // the same row on POSIX and — because `git check-ignore` rejects a
+    // backslash — left the whole listing un-dimmed there. This assertion is the
+    // guard; it is what failed on the Windows CI leg.
+    expect(android[0]!.path).toBe('packages/android/dist');
+  });
+
+  test('folders sort before files, and dot-entries are listed', async () => {
+    const root = makeRoot();
+    fs.mkdirSync(path.join(root, 'zebra'));
+    fs.writeFileSync(path.join(root, 'alpha.txt'), '');
+    fs.writeFileSync(path.join(root, '.env'), 'K=1\n');
+
+    const entries = await listDirectoryEntries(root, root);
+    const names = entries.map((entry) => entry.name);
+
+    expect(entries[0]!.type).toBe('folder');
+    expect(names).toEqual(['zebra', '.env', 'alpha.txt']);
+  });
+});

package/src/server/lib/fs/listing.ts

@@ -17,9 +17,6 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { collectIgnoredPaths } from '@/server/lib/fs/git-ignore';
 
-/** Directory names never listed: build output and VCS metadata. */
-const NOISE_DIRS: Record<string, true> = { node_modules: true, '.git': true, dist: true, build: true };
-
 export interface DirectoryEntry {
   id: string;
   name: string;
@@ -30,13 +27,30 @@ export interface DirectoryEntry {
   ignored: boolean;
 }
 
-/** Read one directory, folders first then files, each marked ignored or not. */
+/**
+ * Read one directory, folders first then files, each marked ignored or not.
+ *
+ * EVERY entry is listed — `node_modules`, `.git`, `dist`, `build` and dot-files
+ * included. There is no name table: filtering by name cannot tell a dependency
+ * tree from a folder of release artifacts (`packages/android/dist` holds the
+ * built APKs), and it hid directories the user could not reach any other way.
+ * The panel's own signal for "this is untracked noise" is the `ignored` flag,
+ * which dims the row via `git check-ignore` instead of deleting it — and a tree
+ * that is expensive to expand costs nothing until someone expands it, because
+ * children are lazy.
+ */
 export async function listDirectoryEntries(dirPath: string, rootPath: string): Promise<DirectoryEntry[]> {
   const listed = (await fs.promises.readdir(dirPath))
-    .filter((child) => !NOISE_DIRS[child])
     .map((child) => {
       const full = path.join(dirPath, child);
-      return { child, full, rel: path.relative(rootPath, full) };
+      // POSIX spelling, because `rel` is not only a display value: it is the
+      // tree's id/key, the `fs:` topic's path, and the path handed to
+      // `git check-ignore` — which rejects a backslash outright, so on Windows
+      // every row came back un-dimmed and keyed `packages\android\dist`. The
+      // rest of the server states the same convention (`lib/fs/root.ts`,
+      // `lib/fs/transfer.ts`).
+      const rel = path.relative(rootPath, full).split(path.sep).join('/');
+      return { child, full, rel };
     });
 
   const ignored = await collectIgnoredPaths(rootPath, listed.map((entry) => entry.rel));

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

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { beforeEach, describe, expect, test } from 'bun:test';
+
+import {
+  fetchAndroidRelease,
+  resetAndroidReleaseCache,
+  versionFromAssetName,
+} from '@/server/lib/updates/android-release';
+
+/**
+ * The asset name is the only place the APK'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 an APK version.
+ */
+describe('versionFromAssetName', () => {
+  test('reads the version the release workflow writes', () => {
+    expect(versionFromAssetName('kabmo-android-v1.2.3.apk')).toBe('1.2.3');
+  });
+
+  test('accepts a hand-uploaded name without the v', () => {
+    expect(versionFromAssetName('kabmo-android-1.2.3.apk')).toBe('1.2.3');
+  });
+
+  test('ignores anything that is not the APK', () => {
+    expect(versionFromAssetName('kabmo-android-v1.2.3.apk.zip')).toBeNull();
+    expect(versionFromAssetName('source.tar.gz')).toBeNull();
+    expect(versionFromAssetName('kabmo-android-latest.apk')).toBeNull();
+    expect(versionFromAssetName('')).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) => {
+    calls.push(String(input));
+    return {
+      ok,
+      json: async () => body,
+    } as Response;
+  }) as unknown as typeof fetch;
+  return { impl, calls };
+}
+
+describe('fetchAndroidRelease', () => {
+  // The cache is process-wide (see `resetAndroidReleaseCache`), so every case
+  // starts from a cold one or it reads the previous case's answer.
+  beforeEach(() => resetAndroidReleaseCache());
+
+  test('picks the APK asset and its version', async () => {
+    const { impl } = stubFetch([
+      {
+        html_url: 'https://github.com/kabmo-labs/kabmo/releases/tag/v9.9.9',
+        assets: [
+          { name: 'source.tar.gz', browser_download_url: 'https://x/src.tgz' },
+          {
+            name: 'kabmo-android-v1.2.3.apk',
+            browser_download_url: 'https://x/kabmo-android-v1.2.3.apk',
+          },
+        ],
+      },
+    ]);
+
+    const release = await fetchAndroidRelease(impl);
+    expect(release).toEqual({
+      url: 'https://x/kabmo-android-v1.2.3.apk',
+      latest: '1.2.3',
+      releaseUrl: 'https://github.com/kabmo-labs/kabmo/releases/tag/v9.9.9',
+    });
+  });
+
+  test('skips a newer release that carries no APK', async () => {
+    // This is the shape that broke the button: `release.yml` releases the npm
+    // packages FIRST, so `kabmo-sdk/v0.0.2` is newer than the app release that
+    // holds the APK. Asking `/releases/latest` answered the package release and
+    // the button vanished while the APK sat one entry below.
+    const { impl } = stubFetch([
+      { html_url: 'https://x/kabmo-sdk', assets: [{ name: 'source.tar.gz' }] },
+      { html_url: 'https://x/kabmo-ui', assets: [] },
+      {
+        html_url: 'https://x/app',
+        assets: [{ name: 'kabmo-android-v0.3.0.apk', browser_download_url: 'https://x/a.apk' }],
+      },
+    ]);
+
+    expect(await fetchAndroidRelease(impl)).toEqual({
+      url: 'https://x/a.apk',
+      latest: '0.3.0',
+      releaseUrl: 'https://x/app',
+    });
+  });
+
+  test('skips drafts and prereleases', async () => {
+    const { impl } = stubFetch([
+      {
+        draft: true,
+        html_url: 'https://x/draft',
+        assets: [{ name: 'kabmo-android-v9.9.9.apk', browser_download_url: 'https://x/draft.apk' }],
+      },
+      {
+        prerelease: true,
+        html_url: 'https://x/pre',
+        assets: [{ name: 'kabmo-android-v8.0.0.apk', browser_download_url: 'https://x/pre.apk' }],
+      },
+      {
+        html_url: 'https://x/app',
+        assets: [{ name: 'kabmo-android-v0.3.0.apk', browser_download_url: 'https://x/a.apk' }],
+      },
+    ]);
+
+    expect((await fetchAndroidRelease(impl))?.latest).toBe('0.3.0');
+  });
+
+  test('answers null for a list with no APK anywhere', async () => {
+    const { impl } = stubFetch([
+      { html_url: 'https://x', assets: [{ name: 'notes.md' }] },
+      { html_url: 'https://y', assets: [] },
+    ]);
+    expect(await fetchAndroidRelease(impl)).toEqual({ url: null, latest: null, releaseUrl: null });
+  });
+
+  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);
+    expect(await fetchAndroidRelease(impl)).toBeNull();
+  });
+
+  test('answers null when the body is malformed', async () => {
+    const { impl } = stubFetch({ assets: 'nope' });
+    expect(await fetchAndroidRelease(impl)).toBeNull();
+  });
+});