Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
8.9 KB
Raw Blame
import { afterEach, describe, expect, test } from "bun:test";
import { getGithubData } from "../lib/github";
import { automaticDownloadHref } from "../lib/automatic-download";
import type { DetectedPlatform } from "@omnirush/ui/react";

type GithubFixtureAsset = {
  name: string;
  browser_download_url: string;
};

type GithubFixtureRelease = {
  draft: boolean;
  prerelease: boolean;
  html_url: string;
  tag_name: string;
  assets: GithubFixtureAsset[];
};

type GithubFetchFixtures = {
  latestRelease: GithubFixtureRelease;
  releases: GithubFixtureRelease[];
};

const repoUrl = "https://api.github.com/repos/omnirush-ai/omnirush-gui";
const latestReleaseUrl = "https://api.github.com/repos/omnirush-ai/omnirush-gui/releases/latest";
const releasesUrl = "https://api.github.com/repos/omnirush-ai/omnirush-gui/releases?per_page=50";
const fallbackReleaseUrl = "https://github.com/omnirush-ai/omnirush-gui/releases";
const releaseTag = "v0.17.38";
const releasePageUrl = `${fallbackReleaseUrl}/tag/${releaseTag}`;
const downloadBaseUrl = `${fallbackReleaseUrl}/download/${releaseTag}`;
const originalFetch = globalThis.fetch;

const asset = (name: string): GithubFixtureAsset => ({
  name,
  browser_download_url: `${downloadBaseUrl}/${name}`
});

const installGithubFetch = ({ latestRelease, releases }: GithubFetchFixtures) => {
  const fixtures: Record<string, unknown> = {
    [repoUrl]: { stargazers_count: 12345 },
    [latestReleaseUrl]: latestRelease,
    [releasesUrl]: releases
  };

  const fetchStub = Object.assign(
    async (input: Parameters<typeof fetch>[0]) => {
      const url =
        typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
      const fixture = fixtures[url];

      if (fixture === undefined) {
        return new Response("Not found", { status: 404 });
      }

      return new Response(JSON.stringify(fixture), {
        status: 200,
        headers: { "content-type": "application/json" }
      });
    },
    { preconnect: originalFetch.preconnect }
  ) satisfies typeof fetch;

  globalThis.fetch = fetchStub;
};

const releaseWithAssets = (assets: GithubFixtureAsset[]): GithubFixtureRelease => ({
  draft: false,
  prerelease: false,
  html_url: releasePageUrl,
  tag_name: releaseTag,
  assets
});

const expectNoInstallerUrl = (url: string) => {
  expect(url.length).toBeGreaterThan(0);
  expect(url.toLowerCase()).not.toContain("installer");
};

afterEach(() => {
  globalThis.fetch = originalFetch;
});

describe("getGithubData", () => {
  test("never substitutes another architecture when a public installer is missing", async () => {
    const release = releaseWithAssets([
      asset("omnirush-mac-arm64-0.17.38.dmg"),
      asset("omnirush-win-arm64-0.17.38.exe")
    ]);
    installGithubFetch({ latestRelease: release, releases: [release] });
    const data = await getGithubData();
    expect(data.installers.macos.intel).toBe(releasePageUrl);
    expect(data.installers.windows.x64).toBe(releasePageUrl);
    expect(automaticDownloadHref(data.installers, { os: "macos", arch: "x64", osVersion: null, source: "ua-ch" }, "Macintosh", 0)).toBeNull();

    const universal = asset("omnirush-mac-universal-0.17.38.dmg");
    const universalRelease = releaseWithAssets([universal]);
    installGithubFetch({ latestRelease: universalRelease, releases: [universalRelease] });
    const universalData = await getGithubData();
    expect(universalData.installers.macos.appleSilicon).toBe(universal.browser_download_url);
    expect(universalData.installers.macos.intel).toBe(universal.browser_download_url);
  });

  test("one-click selection uses the detected architecture, with safe manual fallbacks", async () => {
    const release = releaseWithAssets([
      asset("omnirush-mac-arm64-0.17.38.dmg"),
      asset("omnirush-mac-x64-0.17.38.dmg"),
      asset("omnirush-win-arm64-0.17.38.exe"),
      asset("omnirush-win-x64-0.17.38.exe"),
      asset("omnirush-linux-x86_64-0.17.38.AppImage"),
      asset("omnirush-linux-arm64-0.17.38.tar.gz")
    ]);
    installGithubFetch({ latestRelease: release, releases: [release] });
    const { installers } = await getGithubData();
    const devices: { os: DetectedPlatform["os"]; ua: string; hrefs: string[] }[] = [
      { os: "macos", ua: "Macintosh", hrefs: [installers.macos.appleSilicon, installers.macos.intel] },
      { os: "windows", ua: "Windows NT 10.0; Win64; x64", hrefs: [installers.windows.arm64, installers.windows.x64] },
      { os: "linux", ua: "X11; Linux x86_64", hrefs: [installers.linux.tarArm64, installers.linux.appImageX64] }
    ];
    const architectures: DetectedPlatform["arch"][] = ["arm64", "x64"];
    for (const device of devices) {
      for (const [index, arch] of architectures.entries()) {
        const detected: DetectedPlatform = { os: device.os, arch, osVersion: null, source: "ua-ch" };
        expect(automaticDownloadHref(installers, detected, device.ua, 0)).toBe(device.hrefs[index]);
        expect(automaticDownloadHref(installers, { ...detected, arch: null }, device.ua, 0)).toBeNull();
      }
    }
    const mac: DetectedPlatform = { os: "macos", arch: "arm64", osVersion: null, source: "webgl" };
    for (const ua of ["", "Unknown", "iPhone", "iPad", "Linux; Android", "X11; CrOS x86_64"]) {
      expect(automaticDownloadHref(installers, mac, ua, 0)).toBeNull();
    }
    expect(automaticDownloadHref(installers, mac, "Macintosh", 5)).toBeNull();
    expect(automaticDownloadHref(installers, mac, "Windows NT 10.0", 0)).toBeNull();
    expect(automaticDownloadHref(installers, null, "Macintosh", 0)).toBeNull();
  });

  test("selects only public desktop assets when installer assets are listed first", async () => {
    const macArm64 = asset("omnirush-mac-arm64-0.17.38.dmg");
    const macX64 = asset("omnirush-mac-x64-0.17.38.dmg");
    const winArm64 = asset("omnirush-win-arm64-0.17.38.exe");
    const winX64 = asset("omnirush-win-x64-0.17.38.exe");
    const linuxX64 = asset("omnirush-linux-x86_64-0.17.38.AppImage");
    const release = releaseWithAssets([
      asset("OmniRush.ai-Installer-mac-arm64.dmg"),
      asset("OmniRush.ai-Installer-mac-x64.dmg"),
      asset("OmniRush.ai-Installer-win-x64.exe"),
      asset("omnirush-cloud-mac-arm64-0.17.38.dmg"),
      asset("omnirush-cloud-mac-x64-0.17.38.dmg"),
      asset("omnirush-cloud-win-x64-0.17.38.exe"),
      asset("omnirush-cloud-linux-x86_64-0.17.38.AppImage"),
      asset("omnirush-enterprise-mac-arm64-0.17.38.dmg"),
      asset("omnirush-enterprise-mac-x64-0.17.38.dmg"),
      asset("omnirush-enterprise-win-x64-0.17.38.exe"),
      asset("omnirush-enterprise-linux-x86_64-0.17.38.AppImage"),
      macArm64,
      macX64,
      winArm64,
      winX64,
      linuxX64
    ]);

    installGithubFetch({ latestRelease: release, releases: [release] });

    const data = await getGithubData();

    expectNoInstallerUrl(data.downloads.macos);
    expectNoInstallerUrl(data.downloads.windows);
    expectNoInstallerUrl(data.downloads.linux);
    expect(data.installers.macos.appleSilicon).toBe(macArm64.browser_download_url);
    expect(data.installers.macos.intel).toBe(macX64.browser_download_url);
    expect(data.installers.windows.x64).toBe(winX64.browser_download_url);
    expect(data.installers.windows.arm64).toBe(winArm64.browser_download_url);
    expect(data.releaseTag).toBe(releaseTag);
  });

  test("falls back to release pages when a release contains only installer assets", async () => {
    const release = releaseWithAssets([
      asset("OmniRush.ai-Installer-mac-arm64.dmg"),
      asset("OmniRush.ai-Installer-mac-x64.dmg"),
      asset("OmniRush.ai-Installer-win-x64.exe")
    ]);

    installGithubFetch({ latestRelease: release, releases: [release] });

    const data = await getGithubData();
    const returnedUrls = [
      data.downloads.macos,
      data.downloads.windows,
      data.downloads.linux,
      data.installers.macos.appleSilicon,
      data.installers.macos.intel,
      data.installers.windows.x64,
      data.installers.windows.arm64,
      data.installers.linux.appImageX64,
      data.installers.linux.appImageArm64,
      data.installers.linux.tarX64,
      data.installers.linux.tarArm64
    ];

    for (const url of returnedUrls) {
      expectNoInstallerUrl(url);
    }

    expect(data.downloads).toEqual({
      macos: fallbackReleaseUrl,
      windows: fallbackReleaseUrl,
      linux: fallbackReleaseUrl
    });
    expect(data.installers.macos.appleSilicon).toBe(releasePageUrl);
    expect(data.installers.macos.intel).toBe(releasePageUrl);
    expect(data.installers.windows.x64).toBe(releasePageUrl);
    expect(data.installers.windows.arm64).toBe(releasePageUrl);
    expect(data.installers.linux.appImageX64).toBe(releasePageUrl);
    expect(data.installers.linux.appImageArm64).toBe(releasePageUrl);
    expect(data.installers.linux.tarX64).toBe(releasePageUrl);
    expect(data.installers.linux.tarArm64).toBe(releasePageUrl);
    expect(data.releaseUrl).toBe(releasePageUrl);
    expect(data.releaseTag).toBe(releaseTag);
  });
});