Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
8.4 KB
Raw Blame
import { expect } from "vitest";
import { createDenClient } from "@omnirush/sdk";
import { denFetch } from "@omnirush/behaviors";
import { localMysqlIsRunning, localRedisIsRunning, server, test } from "@omnirush/testkit";

const remote = process.env.OMNIRUSH_EVAL_DAYTONA === "1" || Boolean(process.env.OMNIRUSH_EVAL_DEN_API_URL);
const available = remote || (await localMysqlIsRunning() && await localRedisIsRunning());

test.skipIf(!available)(
  `an integration authenticates and manages teams with the generated Den SDK${available ? "" : " — needs local MySQL and Redis"}`,
  { timeout: 300_000 },
  async ({ evidence, place }) => {
    console.log(`placement: ${place.kind} (PR lane resolved by testkit)`);
    await using den = await server({ place, web: false, org: { name: "SDK integration", members: {} } });
    // There is no hosted Den, so the SDK has no default origin and refuses to
    // build a client without one.
    expect(() => createDenClient({} as Parameters<typeof createDenClient>[0])).toThrow(/explicit baseUrl/);
    let transportUrl = "";
    const transportClient = createDenClient({
      baseUrl: "https://den.example.com",
      fetch: async (input, init) => {
        const request = new Request(input, init);
        transportUrl = request.url;
        // Route the configured origin to the isolated test server.
        return fetch(new Request(`${den.ref.apiUrl}${new URL(request.url).pathname}`, request));
      },
    });
    const transportHealth = await transportClient.getHealth();
    expect(transportUrl).toBe("https://den.example.com/health");
    expect(transportHealth.response.status).toBe(200);
    const anonymous = createDenClient({ baseUrl: den.ref.apiUrl });
    const health = await anonymous.getHealth();
    expect(health.response.status).toBe(200);
    const denied = await anonymous.getV1Me();
    expect(denied.response.status).toBe(401);
    expect(denied.data).toBeUndefined();
    evidence.recordAssertionEvidence("Public health and protected identity", "Health succeeds without credentials; identity returns 401 with no data.",
      health.response.status === 200 && denied.response.status === 401 && denied.data === undefined);
    evidence.recordAssertionEvidence("Explicit base URL and custom transport", "A client without a base URL is refused; the configured HTTPS health URL is passed to the custom fetch, which reaches the isolated Den successfully.",
      transportUrl === "https://den.example.com/health" && transportHealth.response.status === 200);

    const session = createDenClient({ baseUrl: den.ref.apiUrl, token: den.admin.token });
    const identity = await session.getV1Me({ throwOnError: true });
    expect(identity.data.user.email).toBe(den.admin.email);
    const organizations = await session.getV1MeOrgs({ throwOnError: true });
    const org = organizations.data.orgs.find((org) => org.name === "SDK integration");
    if (!org) throw new Error("The SDK did not return the integration organization.");
    const scoped = createDenClient({ baseUrl: den.ref.apiUrl, token: den.admin.token, orgId: org.id });
    // Organization creation is a hidden route, used only to prepare the second
    // membership. All context assertions below exercise the public SDK.
    const secondCreated = await denFetch(den.admin, "/v1/org", {
      method: "POST", headers: { authorization: `Bearer ${den.admin.token}` },
      body: JSON.stringify({ name: "SDK default organization" }),
    });
    expect(secondCreated.response.status).toBe(201);
    const memberships = await session.getV1MeOrgs({ throwOnError: true });
    const secondOrg = memberships.data.orgs.find((entry) => entry.name === "SDK default organization");
    if (!secondOrg) throw new Error("The SDK did not return the second organization.");
    expect(secondOrg.id).not.toBe(org.id);
    expect(memberships.data.activeOrgId).toBe(secondOrg.id);
    const selectedTeam = await scoped.postV1Teams({ name: "SDK context team" }, { throwOnError: true });
    try {
      expect(selectedTeam.data.team.organizationId).toBe(org.id);
      const defaultTeam = await session.postV1Teams({ name: "SDK context team" }, { throwOnError: true });
      try {
        expect(defaultTeam.data.team.organizationId).toBe(secondOrg.id);
        expect(defaultTeam.data.team.id).not.toBe(selectedTeam.data.team.id);
        const override = await scoped.getV1Org(undefined, {
          headers: { "x-omnirush-org-id": secondOrg.id }, throwOnError: true,
        });
        expect(override.data.organization.id).toBe(secondOrg.id);
        const unchanged = await scoped.getV1Org(undefined, { throwOnError: true });
        expect(unchanged.data.organization.id).toBe(org.id);
        evidence.recordAssertionEvidence("Session organization context and request overrides", "With a different default organization, the configured orgId places a team in the selected organization. An unscoped client creates a distinct team in the default organization; a per-request override selects that organization without changing the client default.",
          selectedTeam.data.team.organizationId === org.id && defaultTeam.data.team.organizationId === secondOrg.id
          && override.data.organization.id === secondOrg.id && unchanged.data.organization.id === org.id);
      } finally {
        await session.deleteV1TeamsByTeamId({ teamId: defaultTeam.data.team.id }, { throwOnError: true });
      }
    } finally {
      await scoped.deleteV1TeamsByTeamId({ teamId: selectedTeam.data.team.id }, { throwOnError: true });
    }
    const key = await scoped.postV1ApiKeys({ createOrganizationApiKeyRequest: { name: "SDK integration" } }, { throwOnError: true });
    const requestedUrls: string[] = [];
    const keyed = createDenClient({
      baseUrl: den.ref.apiUrl, apiKey: key.data.key, orgId: org.id,
      fetch: async (input, init) => {
        const request = new Request(input, init);
        requestedUrls.push(request.url);
        return fetch(request);
      },
    });
    const keyedIdentity = await keyed.getV1Me({ throwOnError: true });
    expect(keyedIdentity.data.user.id).toBe(identity.data.user.id);
    const invalid = createDenClient({ baseUrl: den.ref.apiUrl, apiKey: "invalid-sdk-key", orgId: org.id });
    await expect(invalid.getV1Me({ throwOnError: true })).rejects.toBeDefined();
    evidence.recordAssertionEvidence("Session and API-key authentication", "Both credentials resolve to the issuing user; an invalid key rejects.",
      keyedIdentity.data.user.id === identity.data.user.id);
    const runs = await keyed.getV1WorkflowRuns({ limit: 1 }, { throwOnError: true });
    expect(runs.response.status).toBe(200);
    expect(requestedUrls).toContain(`${den.ref.apiUrl}/v1/workflow-runs?limit=1`);
    evidence.recordAssertionEvidence("Typed query parameters", "The numeric limit becomes ?limit=1 and Den accepts the request.",
      runs.response.status === 200 && requestedUrls.includes(`${den.ref.apiUrl}/v1/workflow-runs?limit=1`));

    const created = await keyed.postV1Teams({ name: "SDK team" }, { throwOnError: true });
    expect(created.data.team.name).toBe("SDK team");
    expect(created.data.team.organizationId).toBe(org.id);
    const teamId = created.data.team.id;
    try {
      const updated = await keyed.patchV1TeamsByTeamId({ teamId, name: "SDK renamed" }, { throwOnError: true });
      expect(updated.data.team.name).toBe("SDK renamed");
      expect(updated.data.team.id).toBe(teamId);
      const overridden = await keyed.patchV1TeamsByTeamId({ teamId, name: "Must not apply" }, {
        headers: { "x-api-key": "invalid-sdk-key" },
      });
      expect(overridden.response.status).toBe(401);
      expect(overridden.data).toBeUndefined();
      evidence.recordAssertionEvidence("Typed body, path, and request overrides", "A team is created in the selected org and renamed by ID; an invalid per-request key rejects the mutation.",
        created.data.team.organizationId === org.id && updated.data.team.id === teamId
        && updated.data.team.name === "SDK renamed" && overridden.response.status === 401);
    } finally {
      const removed = await keyed.deleteV1TeamsByTeamId({ teamId }, { throwOnError: true });
      expect(removed.response.status).toBe(204);
    }
    const missing = await keyed.patchV1TeamsByTeamId({ teamId, name: "Deleted" });
    expect(missing.response.status).toBe(404);
    expect(missing.data).toBeUndefined();
    evidence.recordAssertionEvidence("Deletion and error responses", "The deleted team cannot be updated: HTTP 404 and no success data.",
      missing.response.status === 404 && missing.data === undefined);
  },
);