wehub-resource-sync
268 lines
8.7 KiB
TypeScript
268 lines
8.7 KiB
TypeScript
import { heteroPostgresTest, heteroRunOpsPostgresTest } from "@internal/testcontainers";
|
|
import { PostgresRunStore, RoutingRunStore } from "@internal/run-store";
|
|
import type { PrismaClient } from "@trigger.dev/database";
|
|
import { describe, expect, vi } from "vitest";
|
|
import { buildRunStore } from "./runStore.server";
|
|
|
|
vi.setConfig({ testTimeout: 60_000 });
|
|
|
|
// 25-char internal id -> cuid -> LEGACY; v1 body (version "1" at index 25) -> NEW.
|
|
const CUID_25 = "c".repeat(25);
|
|
const NEW_ID_26 = "k".repeat(24) + "01";
|
|
|
|
async function seedEnvironment(prisma: PrismaClient, slugSuffix: string) {
|
|
const organization = await prisma.organization.create({
|
|
data: { title: `Org ${slugSuffix}`, slug: `org-${slugSuffix}` },
|
|
});
|
|
const project = await prisma.project.create({
|
|
data: {
|
|
name: `Project ${slugSuffix}`,
|
|
slug: `project-${slugSuffix}`,
|
|
externalRef: `proj_${slugSuffix}`,
|
|
organizationId: organization.id,
|
|
},
|
|
});
|
|
const environment = await prisma.runtimeEnvironment.create({
|
|
data: {
|
|
type: "DEVELOPMENT",
|
|
slug: "dev",
|
|
projectId: project.id,
|
|
organizationId: organization.id,
|
|
apiKey: `tr_dev_${slugSuffix}`,
|
|
pkApiKey: `pk_dev_${slugSuffix}`,
|
|
shortcode: `short_${slugSuffix}`,
|
|
},
|
|
});
|
|
return { organization, project, environment };
|
|
}
|
|
|
|
function createRunInput(params: {
|
|
runId: string;
|
|
friendlyId: string;
|
|
organizationId: string;
|
|
projectId: string;
|
|
runtimeEnvironmentId: string;
|
|
}) {
|
|
return {
|
|
data: {
|
|
id: params.runId,
|
|
engine: "V2" as const,
|
|
status: "PENDING" as const,
|
|
friendlyId: params.friendlyId,
|
|
runtimeEnvironmentId: params.runtimeEnvironmentId,
|
|
environmentType: "DEVELOPMENT" as const,
|
|
organizationId: params.organizationId,
|
|
projectId: params.projectId,
|
|
taskIdentifier: "my-task",
|
|
payload: '{"hello":"world"}',
|
|
payloadType: "application/json",
|
|
context: { foo: "bar" },
|
|
traceContext: { trace: "ctx" },
|
|
traceId: "trace_1",
|
|
spanId: "span_1",
|
|
runTags: ["alpha"],
|
|
queue: "task/my-task",
|
|
isTest: false,
|
|
taskEventStore: "taskEvent",
|
|
depth: 0,
|
|
createdAt: new Date("2024-01-01T00:00:00.000Z"),
|
|
},
|
|
snapshot: {
|
|
engine: "V2" as const,
|
|
executionStatus: "RUN_CREATED" as const,
|
|
description: "Run was created",
|
|
runStatus: "PENDING" as const,
|
|
environmentId: params.runtimeEnvironmentId,
|
|
environmentType: "DEVELOPMENT" as const,
|
|
projectId: params.projectId,
|
|
organizationId: params.organizationId,
|
|
},
|
|
};
|
|
}
|
|
|
|
describe("T24 — findRun resolves run-ops run on dedicated DB", () => {
|
|
heteroRunOpsPostgresTest(
|
|
"split ON: findRun({friendlyId, runtimeEnvironmentId}, {select}) finds a run-ops run on the new store",
|
|
async ({ prisma14, prisma17 }) => {
|
|
const ENV_ID = "env_t24_runops_probe";
|
|
const WORKER_ID = "worker_t24_lock";
|
|
await prisma17.taskRun.create({
|
|
data: {
|
|
id: NEW_ID_26,
|
|
engine: "V2",
|
|
status: "EXECUTING",
|
|
friendlyId: `run_${NEW_ID_26}`,
|
|
runtimeEnvironmentId: ENV_ID,
|
|
environmentType: "DEVELOPMENT",
|
|
organizationId: "org_t24",
|
|
projectId: "proj_t24",
|
|
taskIdentifier: "my-task",
|
|
payload: "{}",
|
|
payloadType: "application/json",
|
|
traceId: "trace_t24",
|
|
spanId: "span_t24",
|
|
queue: "task/my-task",
|
|
lockedToVersionId: WORKER_ID,
|
|
createdAt: new Date("2024-01-01T00:00:00.000Z"),
|
|
},
|
|
});
|
|
|
|
const store = buildRunStore({
|
|
splitEnabled: true,
|
|
newWriter: prisma17,
|
|
newReplica: prisma17,
|
|
legacyWriter: prisma14,
|
|
legacyReplica: prisma14,
|
|
singleWriter: prisma14,
|
|
singleReplica: prisma14,
|
|
});
|
|
|
|
const run = await store.findRun(
|
|
{ friendlyId: `run_${NEW_ID_26}`, runtimeEnvironmentId: ENV_ID },
|
|
{ select: { lockedToVersionId: true } }
|
|
);
|
|
|
|
expect(run).not.toBeNull();
|
|
expect(run?.lockedToVersionId).toBe(WORKER_ID);
|
|
expect(await prisma14.taskRun.findUnique({ where: { id: NEW_ID_26 } })).toBeNull();
|
|
}
|
|
);
|
|
});
|
|
|
|
describe("buildRunStore", () => {
|
|
heteroPostgresTest(
|
|
"split OFF returns a passthrough PostgresRunStore that writes only to the single DB",
|
|
async ({ prisma14, prisma17 }) => {
|
|
// Single-DB: every handle is prisma14. prisma17 must stay untouched.
|
|
const store = buildRunStore({
|
|
splitEnabled: false,
|
|
newWriter: prisma14,
|
|
newReplica: prisma14,
|
|
legacyWriter: prisma14,
|
|
legacyReplica: prisma14,
|
|
singleWriter: prisma14,
|
|
singleReplica: prisma14,
|
|
});
|
|
|
|
expect(store).toBeInstanceOf(PostgresRunStore);
|
|
|
|
const seed = await seedEnvironment(prisma14, "off");
|
|
// A run-ops id (would route to NEW under split) must still land on the single DB.
|
|
const runId = NEW_ID_26;
|
|
await store.createRun(
|
|
createRunInput({
|
|
runId,
|
|
friendlyId: "run_off",
|
|
organizationId: seed.organization.id,
|
|
projectId: seed.project.id,
|
|
runtimeEnvironmentId: seed.environment.id,
|
|
})
|
|
);
|
|
|
|
expect(await prisma14.taskRun.findUnique({ where: { id: runId } })).not.toBeNull();
|
|
expect(await prisma17.taskRun.findUnique({ where: { id: runId } })).toBeNull();
|
|
}
|
|
);
|
|
|
|
heteroPostgresTest(
|
|
"split ON routes a NEW-classified create to the new store and a LEGACY-classified create to the legacy store",
|
|
async ({ prisma14, prisma17 }) => {
|
|
// legacy = PG14, new = PG17.
|
|
const store = buildRunStore({
|
|
splitEnabled: true,
|
|
newWriter: prisma17,
|
|
newReplica: prisma17,
|
|
legacyWriter: prisma14,
|
|
legacyReplica: prisma14,
|
|
singleWriter: prisma14,
|
|
singleReplica: prisma14,
|
|
});
|
|
|
|
expect(store).toBeInstanceOf(RoutingRunStore);
|
|
|
|
const seedNew = await seedEnvironment(prisma17, "on_new");
|
|
const seedLegacy = await seedEnvironment(prisma14, "on_legacy");
|
|
|
|
// run-ops id -> NEW (PG17)
|
|
await store.createRun(
|
|
createRunInput({
|
|
runId: NEW_ID_26,
|
|
friendlyId: "run_new",
|
|
organizationId: seedNew.organization.id,
|
|
projectId: seedNew.project.id,
|
|
runtimeEnvironmentId: seedNew.environment.id,
|
|
})
|
|
);
|
|
expect(await prisma17.taskRun.findUnique({ where: { id: NEW_ID_26 } })).not.toBeNull();
|
|
expect(await prisma14.taskRun.findUnique({ where: { id: NEW_ID_26 } })).toBeNull();
|
|
|
|
// cuid -> LEGACY (PG14)
|
|
await store.createRun(
|
|
createRunInput({
|
|
runId: CUID_25,
|
|
friendlyId: "run_legacy",
|
|
organizationId: seedLegacy.organization.id,
|
|
projectId: seedLegacy.project.id,
|
|
runtimeEnvironmentId: seedLegacy.environment.id,
|
|
})
|
|
);
|
|
expect(await prisma14.taskRun.findUnique({ where: { id: CUID_25 } })).not.toBeNull();
|
|
expect(await prisma17.taskRun.findUnique({ where: { id: CUID_25 } })).toBeNull();
|
|
}
|
|
);
|
|
|
|
heteroPostgresTest(
|
|
"split ON keeps a write on a LEGACY-classified id on the legacy store",
|
|
async ({ prisma14, prisma17 }) => {
|
|
// Routing is pure id-shape, so a cuid write stays LEGACY.
|
|
const store = buildRunStore({
|
|
splitEnabled: true,
|
|
newWriter: prisma17,
|
|
newReplica: prisma17,
|
|
legacyWriter: prisma14,
|
|
legacyReplica: prisma14,
|
|
singleWriter: prisma14,
|
|
singleReplica: prisma14,
|
|
});
|
|
|
|
const seedLegacy = await seedEnvironment(prisma14, "no_marker_legacy");
|
|
// The run lives on LEGACY (PG14); seed it directly.
|
|
await prisma14.taskRun.create({
|
|
data: {
|
|
id: CUID_25,
|
|
engine: "V2",
|
|
status: "EXECUTING",
|
|
friendlyId: "run_no_marker",
|
|
runtimeEnvironmentId: seedLegacy.environment.id,
|
|
environmentType: "DEVELOPMENT",
|
|
organizationId: seedLegacy.organization.id,
|
|
projectId: seedLegacy.project.id,
|
|
taskIdentifier: "my-task",
|
|
payload: "{}",
|
|
payloadType: "application/json",
|
|
traceId: "t",
|
|
spanId: "s",
|
|
queue: "task/my-task",
|
|
createdAt: new Date("2024-01-01T00:00:00.000Z"),
|
|
},
|
|
});
|
|
|
|
const updated = await store.updateMetadata(
|
|
CUID_25,
|
|
{
|
|
metadata: '{"k":"v"}',
|
|
metadataType: "application/json",
|
|
metadataVersion: { increment: 1 },
|
|
updatedAt: new Date("2024-01-02T00:00:00.000Z"),
|
|
},
|
|
{}
|
|
);
|
|
expect(updated.count).toBe(1);
|
|
|
|
const onLegacy = await prisma14.taskRun.findUnique({ where: { id: CUID_25 } });
|
|
expect(onLegacy?.metadata).toBe('{"k":"v"}');
|
|
expect(await prisma17.taskRun.findUnique({ where: { id: CUID_25 } })).toBeNull();
|
|
}
|
|
);
|
|
});
|