chore: import upstream snapshot with attribution
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,389 @@
|
||||
// Read-through proof for the public single-run result poll (ApiRunResultPresenter). The presenter
|
||||
// routes its TaskRun(+attempts) lookup-by-friendlyId through readThroughRun: split mode resolves
|
||||
// from new first then the legacy READ REPLICA on a new-probe miss (never a primary),
|
||||
// past-retention → undefined → the route's normal 404; single-DB is one plain findFirst. NEVER mock
|
||||
// the DB — the cross-version proof uses a heterogeneous legacy+new Postgres fixture; only pure
|
||||
// boundaries (splitEnabled/isPastRetention) are injected.
|
||||
import { heteroPostgresTest } from "@internal/testcontainers";
|
||||
import type { PrismaClient } from "@trigger.dev/database";
|
||||
import { generateRunOpsId } from "@trigger.dev/core/v3/isomorphic";
|
||||
import { customAlphabet } from "nanoid";
|
||||
import { describe, expect, vi } from "vitest";
|
||||
import { ApiRunResultPresenter } from "~/presenters/v3/ApiRunResultPresenter.server";
|
||||
import type { PrismaReplicaClient } from "~/db.server";
|
||||
import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
|
||||
|
||||
// Neutralize the db.server singleton so importing the presenter (via BasePresenter) and
|
||||
// readThrough.server (which imports db.server defaults) does not try to connect to the env
|
||||
// database. Every read in this file goes through clients we inject explicitly.
|
||||
vi.mock("~/db.server", () => ({ prisma: {}, $replica: {} }));
|
||||
|
||||
vi.setConfig({ testTimeout: 60_000 });
|
||||
|
||||
const idGenerator = customAlphabet("123456789abcdefghijkmnopqrstuvwxyz", 21);
|
||||
|
||||
// Residency by friendlyId shape (after stripping `run_`): a valid 26-char v1 body (version "1" at
|
||||
// index 25, base32hex core) → NEW; a 25-char body → LEGACY (cuid analog). ownerEngine classifies on
|
||||
// the public friendly id, so newFriendlyId uses the real generator to produce a NEW-classified body.
|
||||
function newFriendlyId(): string {
|
||||
return "run_" + generateRunOpsId();
|
||||
}
|
||||
function legacyFriendlyId(): string {
|
||||
return "run_" + customAlphabet("abcdefghijklmnopqrstuvwxyz0123456789", 25)();
|
||||
}
|
||||
|
||||
function authEnv(environmentId: string): AuthenticatedEnvironment {
|
||||
// The presenter only reads env.id (the runtimeEnvironmentId filter) and the tracing attrs.
|
||||
return {
|
||||
id: environmentId,
|
||||
project: { id: "p", name: "p" },
|
||||
organization: { id: "o", title: "o" },
|
||||
orgMember: null,
|
||||
} as unknown as AuthenticatedEnvironment;
|
||||
}
|
||||
|
||||
type SeedContext = {
|
||||
environmentId: string;
|
||||
projectId: string;
|
||||
organizationId: string;
|
||||
backgroundWorkerId: string;
|
||||
backgroundWorkerTaskId: string;
|
||||
queueId: string;
|
||||
};
|
||||
|
||||
async function seedEnv(prisma: PrismaClient, slug: string) {
|
||||
const user = await prisma.user.create({
|
||||
data: { email: `${slug}@test.com`, name: "t", authenticationMethod: "MAGIC_LINK" },
|
||||
});
|
||||
const organization = await prisma.organization.create({
|
||||
data: {
|
||||
title: "Org",
|
||||
slug: `org-${slug}-${idGenerator()}`,
|
||||
members: { create: { userId: user.id, role: "ADMIN" } },
|
||||
},
|
||||
});
|
||||
const project = await prisma.project.create({
|
||||
data: {
|
||||
name: "Proj",
|
||||
slug: `proj-${slug}-${idGenerator()}`,
|
||||
organizationId: organization.id,
|
||||
externalRef: `ext-${slug}-${idGenerator()}`,
|
||||
},
|
||||
});
|
||||
const environment = await prisma.runtimeEnvironment.create({
|
||||
data: {
|
||||
slug: `env-${slug}`,
|
||||
type: "PRODUCTION",
|
||||
projectId: project.id,
|
||||
organizationId: organization.id,
|
||||
apiKey: `api-${slug}-${idGenerator()}`,
|
||||
pkApiKey: `pk-${slug}-${idGenerator()}`,
|
||||
shortcode: `sc-${slug}-${idGenerator()}`,
|
||||
},
|
||||
});
|
||||
return { organization, project, environment };
|
||||
}
|
||||
|
||||
async function seedWorker(prisma: PrismaClient, ctx: { environmentId: string; projectId: string }) {
|
||||
const queue = await prisma.taskQueue.create({
|
||||
data: {
|
||||
friendlyId: `queue_${idGenerator()}`,
|
||||
name: "task/test-task",
|
||||
projectId: ctx.projectId,
|
||||
runtimeEnvironmentId: ctx.environmentId,
|
||||
},
|
||||
});
|
||||
const worker = await prisma.backgroundWorker.create({
|
||||
data: {
|
||||
friendlyId: `worker_${idGenerator()}`,
|
||||
contentHash: "hash",
|
||||
projectId: ctx.projectId,
|
||||
runtimeEnvironmentId: ctx.environmentId,
|
||||
version: "20240101.1",
|
||||
metadata: {},
|
||||
},
|
||||
});
|
||||
const task = await prisma.backgroundWorkerTask.create({
|
||||
data: {
|
||||
friendlyId: `task_${idGenerator()}`,
|
||||
slug: "test-task",
|
||||
filePath: "src/test.ts",
|
||||
exportName: "testTask",
|
||||
workerId: worker.id,
|
||||
projectId: ctx.projectId,
|
||||
runtimeEnvironmentId: ctx.environmentId,
|
||||
},
|
||||
});
|
||||
return { queueId: queue.id, backgroundWorkerId: worker.id, backgroundWorkerTaskId: task.id };
|
||||
}
|
||||
|
||||
async function fullSeed(prisma: PrismaClient, slug: string): Promise<SeedContext> {
|
||||
const { organization, project, environment } = await seedEnv(prisma, slug);
|
||||
const worker = await seedWorker(prisma, {
|
||||
environmentId: environment.id,
|
||||
projectId: project.id,
|
||||
});
|
||||
return {
|
||||
environmentId: environment.id,
|
||||
projectId: project.id,
|
||||
organizationId: organization.id,
|
||||
...worker,
|
||||
};
|
||||
}
|
||||
|
||||
async function seedRunWithAttempt(
|
||||
prisma: PrismaClient,
|
||||
ctx: SeedContext,
|
||||
friendlyId: string,
|
||||
opts: {
|
||||
status: "COMPLETED_SUCCESSFULLY" | "COMPLETED_WITH_ERRORS" | "CANCELED" | "EXECUTING";
|
||||
attempt?: {
|
||||
status: "COMPLETED" | "FAILED";
|
||||
output?: string;
|
||||
outputType?: string;
|
||||
error?: unknown;
|
||||
};
|
||||
}
|
||||
) {
|
||||
const runInternalId = idGenerator();
|
||||
const run = await prisma.taskRun.create({
|
||||
data: {
|
||||
id: runInternalId,
|
||||
friendlyId,
|
||||
taskIdentifier: "test-task",
|
||||
payload: "{}",
|
||||
payloadType: "application/json",
|
||||
traceId: idGenerator(),
|
||||
spanId: idGenerator(),
|
||||
queue: "task/test-task",
|
||||
runtimeEnvironmentId: ctx.environmentId,
|
||||
projectId: ctx.projectId,
|
||||
status: opts.status,
|
||||
},
|
||||
});
|
||||
|
||||
if (opts.attempt) {
|
||||
await prisma.taskRunAttempt.create({
|
||||
data: {
|
||||
friendlyId: `attempt_${idGenerator()}`,
|
||||
taskRunId: run.id,
|
||||
backgroundWorkerId: ctx.backgroundWorkerId,
|
||||
backgroundWorkerTaskId: ctx.backgroundWorkerTaskId,
|
||||
runtimeEnvironmentId: ctx.environmentId,
|
||||
queueId: ctx.queueId,
|
||||
status: opts.attempt.status,
|
||||
output: opts.attempt.output,
|
||||
outputType: opts.attempt.outputType ?? "application/json",
|
||||
error: opts.attempt.error as any,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
return run;
|
||||
}
|
||||
|
||||
// A legacy-replica closure that explodes if ever touched — used to prove the primary/legacy store
|
||||
// is structurally unreachable when it must not be read.
|
||||
function throwingLegacy(): PrismaReplicaClient {
|
||||
return new Proxy(
|
||||
{},
|
||||
{
|
||||
get() {
|
||||
throw new Error("legacy replica must never be read in this case");
|
||||
},
|
||||
}
|
||||
) as unknown as PrismaReplicaClient;
|
||||
}
|
||||
|
||||
describe("ApiRunResultPresenter read-through (heterogeneous legacy + new Postgres)", () => {
|
||||
heteroPostgresTest(
|
||||
"split: a run living on the NEW DB resolves from new and never probes the legacy replica",
|
||||
async ({ prisma14, prisma17 }) => {
|
||||
const friendlyId = newFriendlyId();
|
||||
const ctx = await fullSeed(prisma17 as unknown as PrismaClient, "new-only");
|
||||
await seedRunWithAttempt(prisma17 as unknown as PrismaClient, ctx, friendlyId, {
|
||||
status: "COMPLETED_SUCCESSFULLY",
|
||||
attempt: { status: "COMPLETED", output: '"hello"', outputType: "application/json" },
|
||||
});
|
||||
|
||||
const presenter = new ApiRunResultPresenter(
|
||||
prisma17 as unknown as PrismaReplicaClient,
|
||||
prisma17 as unknown as PrismaReplicaClient,
|
||||
{
|
||||
splitEnabled: true,
|
||||
newClient: prisma17 as unknown as PrismaReplicaClient,
|
||||
legacyReplica: throwingLegacy(),
|
||||
}
|
||||
);
|
||||
|
||||
const result = await presenter.call(friendlyId, authEnv(ctx.environmentId));
|
||||
expect(result).toBeDefined();
|
||||
expect(result?.ok).toBe(true);
|
||||
if (result?.ok) {
|
||||
expect(result.id).toBe(friendlyId);
|
||||
expect(result.taskIdentifier).toBe("test-task");
|
||||
expect(result.output).toBe('"hello"');
|
||||
expect(result.outputType).toBe("application/json");
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
// Old legacy-only run resolves from the legacy read replica (cross-version). The only legacy
|
||||
// handle exposed is a read replica — no writer/primary field exists in this path.
|
||||
heteroPostgresTest(
|
||||
"split: an OLD legacy-only run resolves from the legacy read replica across the version boundary",
|
||||
async ({ prisma14, prisma17 }) => {
|
||||
const friendlyId = legacyFriendlyId();
|
||||
// Seed only on legacy. New gets just an env so the new-probe runs but misses.
|
||||
const legacyCtx = await fullSeed(prisma14 as unknown as PrismaClient, "legacy-only");
|
||||
await fullSeed(prisma17 as unknown as PrismaClient, "new-empty");
|
||||
await seedRunWithAttempt(prisma14 as unknown as PrismaClient, legacyCtx, friendlyId, {
|
||||
status: "COMPLETED_SUCCESSFULLY",
|
||||
attempt: { status: "COMPLETED", output: '"from-legacy"', outputType: "application/json" },
|
||||
});
|
||||
|
||||
const presenter = new ApiRunResultPresenter(
|
||||
prisma17 as unknown as PrismaReplicaClient,
|
||||
prisma14 as unknown as PrismaReplicaClient,
|
||||
{
|
||||
splitEnabled: true,
|
||||
newClient: prisma17 as unknown as PrismaReplicaClient,
|
||||
legacyReplica: prisma14 as unknown as PrismaReplicaClient,
|
||||
}
|
||||
);
|
||||
|
||||
const result = await presenter.call(friendlyId, authEnv(legacyCtx.environmentId));
|
||||
expect(result).toBeDefined();
|
||||
expect(result?.ok).toBe(true);
|
||||
if (result?.ok) {
|
||||
// friendlyId / taskIdentifier / output+outputType round-trip across the version boundary identically.
|
||||
expect(result.id).toBe(friendlyId);
|
||||
expect(result.taskIdentifier).toBe("test-task");
|
||||
expect(result.output).toBe('"from-legacy"');
|
||||
expect(result.outputType).toBe("application/json");
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
// Legacy-classified id present on neither store, isPastRetention=true → past-retention → undefined.
|
||||
heteroPostgresTest(
|
||||
"split: a past-retention id returns undefined (the route's normal 404 surface)",
|
||||
async ({ prisma14, prisma17 }) => {
|
||||
const friendlyId = legacyFriendlyId();
|
||||
const ctx = await fullSeed(prisma17 as unknown as PrismaClient, "past-ret-new");
|
||||
await fullSeed(prisma14 as unknown as PrismaClient, "past-ret-legacy");
|
||||
|
||||
const presenter = new ApiRunResultPresenter(
|
||||
prisma17 as unknown as PrismaReplicaClient,
|
||||
prisma14 as unknown as PrismaReplicaClient,
|
||||
{
|
||||
splitEnabled: true,
|
||||
newClient: prisma17 as unknown as PrismaReplicaClient,
|
||||
legacyReplica: prisma14 as unknown as PrismaReplicaClient,
|
||||
isPastRetention: () => true,
|
||||
}
|
||||
);
|
||||
|
||||
const result = await presenter.call(friendlyId, authEnv(ctx.environmentId));
|
||||
// Identical surface to a genuinely missing run: the route maps undefined → normal 404.
|
||||
expect(result).toBeUndefined();
|
||||
}
|
||||
);
|
||||
|
||||
heteroPostgresTest(
|
||||
"single-DB passthrough: resolves from the one client; the legacy replica is never touched",
|
||||
async ({ prisma14, prisma17 }) => {
|
||||
const friendlyId = newFriendlyId();
|
||||
const ctx = await fullSeed(prisma17 as unknown as PrismaClient, "passthrough");
|
||||
await seedRunWithAttempt(prisma17 as unknown as PrismaClient, ctx, friendlyId, {
|
||||
status: "COMPLETED_SUCCESSFULLY",
|
||||
attempt: { status: "COMPLETED", output: '"single"', outputType: "application/json" },
|
||||
});
|
||||
|
||||
// No read-through deps → passthrough (single plain findFirst).
|
||||
const presenter = new ApiRunResultPresenter(
|
||||
prisma17 as unknown as PrismaReplicaClient,
|
||||
prisma17 as unknown as PrismaReplicaClient
|
||||
);
|
||||
|
||||
const result = await presenter.call(friendlyId, authEnv(ctx.environmentId));
|
||||
expect(result?.ok).toBe(true);
|
||||
if (result?.ok) {
|
||||
expect(result.id).toBe(friendlyId);
|
||||
expect(result.output).toBe('"single"');
|
||||
}
|
||||
|
||||
// splitEnabled:false with a throwing legacy proves no second store is touched.
|
||||
const presenter2 = new ApiRunResultPresenter(
|
||||
prisma17 as unknown as PrismaReplicaClient,
|
||||
prisma17 as unknown as PrismaReplicaClient,
|
||||
{
|
||||
splitEnabled: false,
|
||||
newClient: prisma17 as unknown as PrismaReplicaClient,
|
||||
legacyReplica: throwingLegacy(),
|
||||
}
|
||||
);
|
||||
const result2 = await presenter2.call(friendlyId, authEnv(ctx.environmentId));
|
||||
expect(result2?.ok).toBe(true);
|
||||
}
|
||||
);
|
||||
|
||||
// executionResultForTaskRun mapping is identical across split and single-DB for every status.
|
||||
heteroPostgresTest(
|
||||
"status parity: success / failed / canceled map identically in split and single-DB",
|
||||
async ({ prisma14, prisma17 }) => {
|
||||
const ctx = await fullSeed(prisma17 as unknown as PrismaClient, "parity");
|
||||
|
||||
const successId = newFriendlyId();
|
||||
const failedId = newFriendlyId();
|
||||
const canceledId = newFriendlyId();
|
||||
|
||||
await seedRunWithAttempt(prisma17 as unknown as PrismaClient, ctx, successId, {
|
||||
status: "COMPLETED_SUCCESSFULLY",
|
||||
attempt: { status: "COMPLETED", output: '"ok"', outputType: "application/json" },
|
||||
});
|
||||
await seedRunWithAttempt(prisma17 as unknown as PrismaClient, ctx, failedId, {
|
||||
status: "COMPLETED_WITH_ERRORS",
|
||||
attempt: {
|
||||
status: "FAILED",
|
||||
error: { type: "BUILT_IN_ERROR", name: "Error", message: "boom", stackTrace: "boom" },
|
||||
},
|
||||
});
|
||||
await seedRunWithAttempt(prisma17 as unknown as PrismaClient, ctx, canceledId, {
|
||||
status: "CANCELED",
|
||||
});
|
||||
|
||||
const splitPresenter = new ApiRunResultPresenter(
|
||||
prisma17 as unknown as PrismaReplicaClient,
|
||||
prisma17 as unknown as PrismaReplicaClient,
|
||||
{
|
||||
splitEnabled: true,
|
||||
newClient: prisma17 as unknown as PrismaReplicaClient,
|
||||
legacyReplica: throwingLegacy(),
|
||||
}
|
||||
);
|
||||
const passthroughPresenter = new ApiRunResultPresenter(
|
||||
prisma17 as unknown as PrismaReplicaClient,
|
||||
prisma17 as unknown as PrismaReplicaClient
|
||||
);
|
||||
|
||||
for (const id of [successId, failedId, canceledId]) {
|
||||
const split = await splitPresenter.call(id, authEnv(ctx.environmentId));
|
||||
const single = await passthroughPresenter.call(id, authEnv(ctx.environmentId));
|
||||
expect(split).toEqual(single);
|
||||
}
|
||||
|
||||
const success = await splitPresenter.call(successId, authEnv(ctx.environmentId));
|
||||
expect(success?.ok).toBe(true);
|
||||
|
||||
const failed = await splitPresenter.call(failedId, authEnv(ctx.environmentId));
|
||||
expect(failed?.ok).toBe(false);
|
||||
|
||||
const canceled = await splitPresenter.call(canceledId, authEnv(ctx.environmentId));
|
||||
expect(canceled?.ok).toBe(false);
|
||||
if (canceled && !canceled.ok) {
|
||||
expect(canceled.error.type).toBe("INTERNAL_ERROR");
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
Reference in New Issue
Block a user