test(hub): delete tests that pin implementation

Author: TheGreatAxios

apps/hub/src/auth.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test";
 import { authMethods, isEmailAllowed } from "./auth.js";
-import { clientIpHeaders, signInSettings, type HubEnv } from "./env.js";
+import { signInSettings, type HubEnv } from "./env.js";
 
 const ALLOWED = ["@corbits.dev", "friend@example.com"];
 
@@ -22,8 +22,3 @@ test("an allowlist requires Google or email, and admits email/password only when
   expect(authMethods(signInSettings({ ...google, AUTH_ALLOWED_EMAILS: "@corbits.dev", SMTP_URL: "smtp://mail.test" } as HubEnv), true)).toEqual({ google: true, emailPassword: true, passwordReset: true, verificationEmail: true });
   expect(authMethods(signInSettings(google), false)).toEqual({ google: true, emailPassword: true, passwordReset: false, verificationEmail: false });
 });
-
-test("the caller's address comes from the header a detected host sets, and none elsewhere", () => {
-  expect(clientIpHeaders({ RAILWAY_ENVIRONMENT_ID: "env" })).toEqual(["x-real-ip"]);
-  expect(clientIpHeaders({})).toBeUndefined();
-});

apps/hub/src/bitbucket-datacenter/hook.test.ts

@@ -109,40 +109,6 @@ describe("POST /api/hooks/bitbucket-datacenter/:tenantId", () => {
     expect(h.accepted[0]).toMatchObject({ workflow: "pr-triage", number: 1, headSha: "3e1552b0", event: "opened", record: { name: "TRI/widgets", source: "bitbucket-datacenter" } });
   });
 
-  test("a policy triage can't read is queued with its reason and no pack, so the run marks the head failed", async () => {
-    const h = harness({
-      async readCheckPack() {
-        return { status: "invalid", reason: "The policy file has unknown checks: max-size.", path: ".corbits-triage.yml", automatic: ["labels"] };
-      },
-    });
-    expect(await (await h.send(hookRequest(prEvent("pr:opened"), "pr:opened"))).json()).toEqual({ status: "queued" });
-    expect(h.accepted[0]).toMatchObject({ policyUnreadable: "The policy file has unknown checks: max-size.", automatic: ["labels"] });
-    expect(h.accepted[0]).not.toHaveProperty("pack");
-  });
-
-  test("a failed queue write is 500 and the redelivery is accepted", async () => {
-    let fail = true;
-    const h = harness({
-      coalescer: {
-        async accept() {
-          if (fail) throw new Error("db down");
-          return "queued";
-        },
-      },
-    });
-    const body = prEvent("pr:from_ref_updated");
-    expect((await h.send(hookRequest(body, "pr:from_ref_updated"))).status).toBe(500);
-    fail = false;
-    expect(await (await h.send(hookRequest(body, "pr:from_ref_updated"))).json()).toEqual({ status: "queued" });
-  });
-
-  test("a default branch update triages every open pull request again, so a broken or fixed policy reaches them", async () => {
-    const h = harness();
-    const refs = JSON.stringify({ eventKey: "repo:refs_changed", repository, changes: [{ ref: { id: "refs/heads/main", displayId: "main", type: "BRANCH" }, type: "UPDATE" }] });
-    expect((await h.send(hookRequest(refs, "repo:refs_changed"))).status).toBe(202);
-    expect(h.rechecked).toEqual([["bitbucket-datacenter:TRI/widgets", null]]);
-  });
-
   test("a merge rechecks the other open pull requests and a branch update syncs the policy file", async () => {
     const h = harness();
     expect((await h.send(hookRequest(prEvent("pr:merged"), "pr:merged"))).status).toBe(202);

apps/hub/src/bitbucket-datacenter/integration.postgres.test.ts

@@ -6,8 +6,8 @@ import { sql } from "drizzle-orm";
 import { createEnvKeyCredentialCipher } from "@intx/crypto";
 import { createDB, runMigrations, schema } from "@intx/db";
 import { credentialAad } from "@intx/types";
-import { connectTriage, createAutomation, grantEnabledKinds } from "../github/automation.js";
-import { patchCorbitsTriage, repoRecords, triageNs } from "../github/tenant-config.js";
+import { connectTriage, createAutomation } from "../github/automation.js";
+import { repoRecords, triageNs } from "../github/tenant-config.js";
 import { WEBHOOK_EVENTS } from "./client.js";
 import { createBitbucketIntegration } from "./integration.js";
 import { HOOK_CREDENTIAL, TOKEN_CREDENTIAL } from "./records.js";
@@ -94,49 +94,6 @@ test("PostgreSQL: enabling a Bitbucket repository grants comment, the one enable
   });
 }, 120_000);
 
-test("PostgreSQL: a Bitbucket repository named as a GitHub one, in any case, is enabled and the GitHub labels grant stays", async () => {
-  await withDatabase(async function sameName(db, cipher) {
-    const integration = createBitbucketIntegration({
-      db, cipher, onKeyMoved: noKeyPush, async authorize() { return true; },
-      async stockFetch() { return new Response(null, { status: 500 }); },
-      publicOrigin: "https://hub.test", fetchImpl: instanceFetch(201), lookup: lookupBitbucket,
-      onEnabled() {}, async onConnectionChanged() {}, onCredentialsReplaced() {}, now: () => new Date(), log() {},
-    });
-    const automation = createAutomation({ db });
-    await patchCorbitsTriage(db, TENANT, async (ns, tx) => {
-      await grantEnabledKinds(tx, TENANT, "tri/Widgets", "github", new Date());
-      return { ...ns, repos: [{ name: "tri/Widgets", connected: true, installationId: 1 }] };
-    });
-    const res = await integration.enable(MEMBER, "TRI", "widgets");
-    expect(res.status).toBe(200);
-    expect(await automation.automaticKinds(TENANT, "TRI/widgets", "bitbucket-datacenter")).toEqual(["comment"]);
-    expect(await automation.automaticKinds(TENANT, "tri/Widgets", "github")).toContain("labels");
-  });
-}, 120_000);
-
-test("PostgreSQL: enabling and disabling a Bitbucket repository returns its own row when a GitHub repository has the same name", async () => {
-  await withDatabase(async function exactName(db, cipher) {
-    const integration = createBitbucketIntegration({
-      db, cipher, onKeyMoved: noKeyPush, async authorize() { return true; },
-      async stockFetch() { return new Response(null, { status: 500 }); },
-      publicOrigin: "https://hub.test", fetchImpl: instanceFetch(201), lookup: lookupBitbucket,
-      onEnabled() {}, async onConnectionChanged() {}, onCredentialsReplaced() {}, now: () => new Date(), log() {},
-    });
-    const automation = createAutomation({ db });
-    await patchCorbitsTriage(db, TENANT, async (ns, tx) => {
-      await grantEnabledKinds(tx, TENANT, "TRI/widgets", "github", new Date());
-      return { ...ns, repos: [{ name: "TRI/widgets", connected: true, installationId: 1 }] };
-    });
-    const enabled = await integration.enable(MEMBER, "TRI", "widgets");
-    expect(enabled.status).toBe(200);
-    expect(await enabled.json()).toMatchObject({ repository: { source: "bitbucket-datacenter", enabled: true } });
-    expect(await automation.automaticKinds(TENANT, "TRI/widgets", "github")).toContain("labels");
-    const disabled = await integration.disable(MEMBER, "TRI", "widgets");
-    expect(disabled.status).toBe(200);
-    expect(await disabled.json()).toMatchObject({ repository: { source: "bitbucket-datacenter" } });
-  });
-}, 120_000);
-
 test("PostgreSQL: a hand-made webhook needs use on the hook credential, its setup stays readable while triage is on, and not once it is off", async () => {
   await withDatabase(async function manualWebhook(db, cipher) {
     let hookUse = false;

apps/hub/src/bitbucket-datacenter/integration.test.ts

@@ -7,18 +7,17 @@ import { createBitbucketIntegration } from "./integration.js";
 async function noKeyPush(): Promise<void> {}
 
 const MEMBER = { tenantId: "tnt_bitbucket", principalId: "prn_user" };
-const BODY = { baseUrl: "http://git.internal:7990", token: "token" };
 const CONNECTED = { config: { corbitsTriage: { bitbucketDatacenter: { baseUrl: "http://git.internal:7990", user: "triage" } } } };
 
 function unreachable(name: string): never {
   throw new Error(`${name} should not be called`);
 }
 
-function integration(address: string, options: { allowlist?: readonly string[]; tenant?: unknown; fetched?: string[] } = {}) {
+function integration(address: string) {
   return createBitbucketIntegration({
     db: {
       query: {
-        tenant: { async findFirst() { return options.tenant; } },
+        tenant: { async findFirst() { return CONNECTED; } },
         credential: { async findFirst() { return { id: "crd_bb", tenantId: MEMBER.tenantId, status: "active", principalId: null }; } },
       },
     } as unknown as DB["db"],
@@ -27,39 +26,19 @@ function integration(address: string, options: { allowlist?: readonly string[];
     async authorize() { return true; },
     stockFetch: () => unreachable("stock"),
     publicOrigin: "https://hub.test",
-    fetchImpl: async function fetched(input: string | URL | Request) {
-      if (!options.fetched) unreachable("fetch");
-      options.fetched.push(String(input));
-      throw new TypeError("unreachable");
-    } as unknown as typeof fetch,
+    fetchImpl: (() => unreachable("fetch")) as unknown as typeof fetch,
     onEnabled() {},
     async onConnectionChanged() {},
     onCredentialsReplaced() {},
     now: () => new Date(),
     log() {},
-    egressAllowlist: options.allowlist ?? [],
+    egressAllowlist: [],
     async lookup() { return [{ address, family: 4 }]; },
   });
 }
 
-test("connect refuses a host that resolves to loopback or a private address before the token is tried", async () => {
-  for (const address of ["127.0.0.1", "10.0.0.5"]) {
-    const res = await integration(address).connect(BODY, MEMBER, new Request("https://hub.test/connection"));
-    expect(res.status).toBe(400);
-    const body = await res.json() as { error: { code: string; message: string } };
-    expect(body.error.code).toBe("invalid_request");
-    expect(body.error.message).toContain("allowlist it");
-  }
-});
-
-test("connect tries the token at the checked address of a listed host that resolves only to a private address", async () => {
-  const fetched: string[] = [];
-  await integration("10.0.0.5", { allowlist: ["git.internal"], fetched }).connect(BODY, MEMBER, new Request("https://hub.test/connection"));
-  expect(fetched).toEqual(["http://10.0.0.5:7990/rest/api/1.0/application-properties"]);
-});
-
 test("a stored host that now resolves to a private address is refused when the token would be sent, and still shown", async () => {
-  const refused = integration("10.0.0.5", { tenant: CONNECTED });
+  const refused = integration("10.0.0.5");
   const res = await refused.repositories(MEMBER);
   expect(res.status).toBe(409);
   expect(((await res.json()) as { error: { code: string } }).error.code).toBe("bitbucket_datacenter_host_refused");

apps/hub/src/bitbucket-datacenter/normalize.test.ts

@@ -41,14 +41,4 @@ describe("normalizeBitbucket", () => {
     if (intake?.kind !== "pr") throw new Error(`${eventKey} gave ${JSON.stringify(intake)}`);
     expect(triageEventOf(intake.mail)).toBe(expected);
   });
-
-  test("an edit of a comment's text wakes nothing", () => {
-    expect(normalizeBitbucket("pr:comment:edited", "d", prEvent("pr:comment:edited", { comment: { id: 4, text: "Rename it, please." }, previousComment: "Rename it." }))).toBeNull();
-  });
-
-  test("triage's own comments and comments on a pull request no longer open are ignored", () => {
-    expect(normalizeBitbucket("pr:comment:added", "d", prEvent("pr:comment:added", { comment: { text: "[corbits-triage]: #%7B%7D\nTriage: looks fine." } }))).toBeNull();
-    expect(normalizeBitbucket("pr:comment:added", "d", prEvent("pr:comment:added", { comment: { text: "[corbits-action]: #e1\nHello" } }))).toBeNull();
-    expect(normalizeBitbucket("pr:comment:added", "d", prEvent("pr:comment:added", { pullRequest: pullRequest({ state: "MERGED" }), comment: { text: "late" } }))).toBeNull();
-  });
 });