wehub-resource-sync
120 lines
4.5 KiB
TypeScript
120 lines
4.5 KiB
TypeScript
// Dedicated run-ops proof for the run-detail realtime stream loader after dropping its cross-DB
|
|
// control-plane include. The TaskRun scalar row lives on the dedicated run-ops client (PG17, subset
|
|
// schema, no control-plane tables); env lives on PG14. The DB is never mocked; the .count() proof
|
|
// shows the run does not exist on the control-plane side.
|
|
import { heteroRunOpsPostgresTest } from "@internal/testcontainers";
|
|
import type { RunOpsPrismaClient } from "@internal/run-ops-database";
|
|
import type { PrismaClient } from "@trigger.dev/database";
|
|
import { describe, expect } from "vitest";
|
|
import { ControlPlaneCache } from "~/v3/runOpsMigration/controlPlaneCache.server";
|
|
import { ControlPlaneResolver } from "~/v3/runOpsMigration/controlPlaneResolver.server";
|
|
import { resolveStreamBasin } from "~/services/realtime/v1StreamsGlobal.server";
|
|
|
|
vi.setConfig({ testTimeout: 60_000, hookTimeout: 60_000 });
|
|
|
|
let n = 0;
|
|
async function seedControlPlane(prisma: PrismaClient) {
|
|
const s = n++;
|
|
const organization = await prisma.organization.create({
|
|
data: { title: `Org ${s}`, slug: `org-${s}`, streamBasinName: `basin-${s}` },
|
|
});
|
|
const project = await prisma.project.create({
|
|
data: {
|
|
name: `P ${s}`,
|
|
slug: `p-${s}`,
|
|
externalRef: `proj_${s}`,
|
|
organizationId: organization.id,
|
|
},
|
|
});
|
|
const environment = await prisma.runtimeEnvironment.create({
|
|
data: {
|
|
type: "PRODUCTION",
|
|
slug: `prod-${s}`,
|
|
projectId: project.id,
|
|
organizationId: organization.id,
|
|
apiKey: `tr_${s}`,
|
|
pkApiKey: `pk_${s}`,
|
|
shortcode: `sc_${s}`,
|
|
},
|
|
});
|
|
return { organization, project, environment };
|
|
}
|
|
|
|
// The run lives on the dedicated run-ops client; control-plane FKs are synthetic
|
|
// scalar ids pointing at PG14 rows (the dedicated DB has no control-plane tables).
|
|
async function seedRunOpsRun(
|
|
prisma: RunOpsPrismaClient,
|
|
ctx: { organizationId: string; projectId: string; environmentId: string }
|
|
) {
|
|
const s = n++;
|
|
return prisma.taskRun.create({
|
|
data: {
|
|
friendlyId: `run_2abc${s}defghijklmnopqrst`,
|
|
taskIdentifier: "my-task",
|
|
status: "PENDING",
|
|
payload: "{}",
|
|
payloadType: "application/json",
|
|
traceId: `trace_${s}`,
|
|
spanId: `span_${s}`,
|
|
queue: "task/my-task",
|
|
runtimeEnvironmentId: ctx.environmentId,
|
|
projectId: ctx.projectId,
|
|
organizationId: ctx.organizationId,
|
|
environmentType: "PRODUCTION",
|
|
engine: "V2",
|
|
realtimeStreamsVersion: "v1",
|
|
streamBasinName: null,
|
|
},
|
|
});
|
|
}
|
|
|
|
describe("run-detail stream loader cross-DB read-through (dedicated run-ops client)", () => {
|
|
heteroRunOpsPostgresTest(
|
|
"run-ops scalars resolve from the dedicated run-ops DB; env (slug/org/basin) resolves from control-plane with no cross-join",
|
|
async ({ prisma14, prisma17 }) => {
|
|
const cp = await seedControlPlane(prisma14 as unknown as PrismaClient);
|
|
const run = await seedRunOpsRun(prisma17, {
|
|
organizationId: cp.organization.id,
|
|
projectId: cp.project.id,
|
|
environmentId: cp.environment.id,
|
|
});
|
|
|
|
const found = await prisma17.taskRun.findFirst({
|
|
where: { friendlyId: run.friendlyId, projectId: cp.project.id },
|
|
select: {
|
|
id: true,
|
|
friendlyId: true,
|
|
realtimeStreamsVersion: true,
|
|
streamBasinName: true,
|
|
runtimeEnvironmentId: true,
|
|
projectId: true,
|
|
},
|
|
});
|
|
expect(found).not.toBeNull();
|
|
expect(found!.friendlyId).toBe(run.friendlyId);
|
|
expect(found!.runtimeEnvironmentId).toBe(cp.environment.id);
|
|
|
|
const resolver = new ControlPlaneResolver({
|
|
controlPlanePrimary: prisma14 as unknown as PrismaClient,
|
|
controlPlaneReplica: prisma14 as unknown as PrismaClient,
|
|
cache: new ControlPlaneCache(),
|
|
splitEnabled: () => false,
|
|
});
|
|
const environment = await resolver.resolveAuthenticatedEnv(found!.runtimeEnvironmentId);
|
|
expect(environment).not.toBeNull();
|
|
expect(environment!.slug).toBe(cp.environment.slug);
|
|
expect(environment!.organization.id).toBe(cp.organization.id);
|
|
expect(environment!.organization.streamBasinName).toBe(cp.organization.streamBasinName);
|
|
|
|
const basin = resolveStreamBasin({
|
|
run: { streamBasinName: found!.streamBasinName },
|
|
organization: { streamBasinName: environment!.organization.streamBasinName },
|
|
});
|
|
expect(basin).toBe(cp.organization.streamBasinName);
|
|
|
|
// Inversion proof: no run on PG14 (control-plane).
|
|
expect(await (prisma14 as unknown as PrismaClient).taskRun.count()).toBe(0);
|
|
}
|
|
);
|
|
});
|