Files
streamline/control-server/test/product_profiles_pg.test.ts
T
2026-11-16 17:26:44 -08:00

89 lines
5.7 KiB
TypeScript

import "./setup_env";
import { test, expect } from "bun:test";
// Explicit, disposable local DB only. Unit runs never open a database.
const url = process.env.PRODUCT_PROFILES_TEST_DATABASE_URL;
test.skipIf(!url)("product profiles: real persistence, CAS, imports, claims and admin guard", async () => {
const parsed = new URL(url!);
if (!["127.0.0.1", "localhost"].includes(parsed.hostname) || parsed.pathname !== "/streamline_profiles_test" || process.env.TEST_DATABASE_URL !== url) {
throw new Error("Use an explicit local streamline_profiles_test database and the same TEST_DATABASE_URL");
}
const { db, settings, tasks, features, node_clusters } = await import("../src/db_client");
const { eq, inArray } = await import("drizzle-orm");
const { readProductProfiles, saveProductProfiles, ProductProfilesConflict } = await import("../src/product_profiles");
const { createBugFromText } = await import("../src/importer");
const { createFeature } = await import("../src/feature_importer");
const { getTask, getFeature, updateTask, updateFeature, claimAnyEvalForNode, claimAnyFixForNode } = await import("../src/db");
const { api } = await import("../src/routes");
const original = await readProductProfiles();
const ids: string[] = [];
const cluster = `profiles-test-${crypto.randomUUID()}`;
const realFetch = globalThis.fetch;
// No fixture operation is allowed to send a real request to SSO, Lark, Bits, etc.
globalThis.fetch = (async (input: any, init?: RequestInit) => {
if (String(input).includes("/invoke/getUserInfo")) {
const session = new Headers(init?.headers).get("x-tt-session-v2");
return Response.json({ data: { email: session?.startsWith("profile-admin") ? "jiaopengwen@bytedance.com" : "profile-reader@bytedance.com" } });
}
throw new Error(`Unexpected external request in local test: ${input}`);
}) as typeof fetch;
try {
const config = await saveProductProfiles(original.profiles.map((p) => ({ ...p, enabled: true })), original.revision);
const bug = await createBugFromText({ description: "Notes profile fixture", platform: "ios", creator: { productProfileId: "notes", clusters: [cluster] } });
const feature = await createFeature({ description: "Notes feature fixture", platform: "ios", productProfileId: "notes", clusters: [cluster] });
const legacy = await createBugFromText({ description: "Legacy fixture", platform: "ios", creator: { clusters: [cluster] } });
ids.push(bug.id, feature.id, legacy.id);
expect(bug.baseRef).toBe("notes/develop");
expect(bug.productProfile?.baseBranch).toBe("notes/develop");
expect(feature.productProfile?.revision).toBe(config.revision);
expect(feature.baseRef).toBe("notes/develop");
expect(legacy.productProfile).toBeNull();
const modified = config.profiles.map((p) => ({ ...p, name: `${p.name} updated`, enabled: false }));
const writes = await Promise.allSettled([saveProductProfiles(modified, config.revision), saveProductProfiles(modified, config.revision)]);
expect(writes.filter((r) => r.status === "fulfilled")).toHaveLength(1);
expect(writes.some((r) => r.status === "rejected" && r.reason instanceof ProductProfilesConflict)).toBe(true);
await updateTask(bug.id, { productProfile: null, remark: "updated" });
await updateFeature(feature.id, { productProfile: null, remark: "updated" });
expect((await getTask(bug.id))?.productProfile).toEqual(bug.productProfile);
expect((await getFeature(feature.id))?.productProfile).toEqual(feature.productProfile);
await expect(createFeature({ description: "disabled profile", platform: "ios", productProfileId: "notes" })).rejects.toThrow();
await db.insert(node_clusters).values({ nodeId: cluster, cluster });
const oldClaim = await claimAnyEvalForNode(cluster, "ios", [], []);
expect(oldClaim?.kind === "bug" && oldClaim.task.id).toBe(legacy.id);
expect(await claimAnyEvalForNode(cluster, "ios", [legacy.id], [])).toBeNull();
expect((await getTask(bug.id))?.executorNodeId).toBeNull();
const newClaim = await claimAnyEvalForNode(cluster, "ios", [legacy.id], [], [], 1);
expect(newClaim?.kind === "bug" && newClaim.task.id).toBe(bug.id);
await updateTask(bug.id, { status: "awaiting_fix" });
await updateFeature(feature.id, { status: "awaiting_implementation" });
expect(await claimAnyFixForNode(cluster, "ios", [], [])).toBeNull();
const newFix = await claimAnyFixForNode(cluster, "ios", [], [], [], 1);
expect(newFix?.kind === "bug" && newFix.task.id).toBe(bug.id);
const request = (session?: string, body?: unknown) => api.request("/admin/product-profiles", {
method: body ? "PUT" : "GET", headers: { ...(session ? { "x-tt-session-v2": `${session}-${cluster}` } : {}), "Content-Type": "application/json" },
...(body ? { body: JSON.stringify(body) } : {}),
});
expect((await request()).status).toBe(401);
expect((await request("profile-reader")).status).toBe(403);
expect((await request("profile-admin")).status).toBe(200);
expect((await request("profile-admin", config)).status).toBe(409);
expect((await request("profile-admin", { revision: 0, profiles: [{ id: "bad" }] })).status).toBe(400);
expect((await (await api.request("/product-profiles")).json()).profiles).toEqual([]);
} finally {
globalThis.fetch = realFetch;
if (ids.length) {
await db.delete(tasks).where(inArray(tasks.id, ids));
await db.delete(features).where(inArray(features.id, ids));
}
await db.delete(node_clusters).where(eq(node_clusters.nodeId, cluster));
if (original.revision === 0) await db.delete(settings).where(eq(settings.key, "product_profiles_v1"));
else {
const current = await readProductProfiles();
await saveProductProfiles(original.profiles, current.revision);
}
}
}, 30_000);