chore: import upstream snapshot with attribution

2026-07-13 13:32:57 +08:00
commit cd420f9332
4811 changed files with 884702 additions and 0 deletions
@@ -0,0 +1,168 @@
+import { describe, expect, it } from "vitest";
+import {
+  baseWorkerQueue,
+  resolveScheduledQueueSplitEnabled,
+  workerQueueForRun,
+  workerQueueForClass,
+  SCHEDULED_WORKER_QUEUE_SUFFIX,
+} from "~/runEngine/concerns/workerQueueSplit.server";
+import { FEATURE_FLAG } from "~/v3/featureFlags";
+
+const FLAG = FEATURE_FLAG.workerQueueScheduledSplitEnabled;
+
+describe("resolveScheduledQueueSplitEnabled", () => {
+  it("falls back to the global default when the org has no override", () => {
+    expect(resolveScheduledQueueSplitEnabled({ orgFeatureFlags: null, globalDefault: false })).toBe(
+      false
+    );
+    expect(
+      resolveScheduledQueueSplitEnabled({ orgFeatureFlags: undefined, globalDefault: true })
+    ).toBe(true);
+    expect(resolveScheduledQueueSplitEnabled({ orgFeatureFlags: {}, globalDefault: true })).toBe(
+      true
+    );
+  });
+
+  it("per-org true overrides a global default of false (beta opt-in)", () => {
+    expect(
+      resolveScheduledQueueSplitEnabled({
+        orgFeatureFlags: { [FLAG]: true },
+        globalDefault: false,
+      })
+    ).toBe(true);
+  });
+
+  it("per-org false overrides a global default of true (escape hatch)", () => {
+    expect(
+      resolveScheduledQueueSplitEnabled({
+        orgFeatureFlags: { [FLAG]: false },
+        globalDefault: true,
+      })
+    ).toBe(false);
+  });
+
+  it("ignores unrelated org flags", () => {
+    expect(
+      resolveScheduledQueueSplitEnabled({
+        orgFeatureFlags: { somethingElse: true },
+        globalDefault: false,
+      })
+    ).toBe(false);
+  });
+
+  it("coerces a present override to boolean (z.coerce.boolean semantics)", () => {
+    // The catalog type is z.coerce.boolean(), matching the mollifier flag, so any
+    // present value is coerced rather than rejected. The admin routes validate
+    // against the same catalog on write, so stored values are real JSON booleans;
+    // this just documents that a present override always wins over the default.
+    expect(
+      resolveScheduledQueueSplitEnabled({
+        orgFeatureFlags: { [FLAG]: 0 as unknown as boolean },
+        globalDefault: true,
+      })
+    ).toBe(false);
+  });
+});
+
+describe("workerQueueForRun", () => {
+  const region = "us-nyc-3";
+  const scheduled = `${region}${SCHEDULED_WORKER_QUEUE_SUFFIX}`;
+
+  it("suffixes scheduled-lineage runs when the split is enabled", () => {
+    expect(
+      workerQueueForRun({ workerQueue: region, rootTriggerSource: "schedule", splitEnabled: true })
+    ).toBe(scheduled);
+  });
+
+  it("leaves standard/agent runs on the base queue", () => {
+    for (const rootTriggerSource of ["api", "sdk", "dashboard", "cli", "mcp", undefined]) {
+      expect(
+        workerQueueForRun({ workerQueue: region, rootTriggerSource, splitEnabled: true })
+      ).toBe(region);
+    }
+  });
+
+  it("never suffixes when the split is disabled, even for scheduled runs", () => {
+    expect(
+      workerQueueForRun({ workerQueue: region, rootTriggerSource: "schedule", splitEnabled: false })
+    ).toBe(region);
+  });
+
+  it("is idempotent — does not double-suffix an already-scheduled queue", () => {
+    expect(
+      workerQueueForRun({
+        workerQueue: scheduled,
+        rootTriggerSource: "schedule",
+        splitEnabled: true,
+      })
+    ).toBe(scheduled);
+  });
+});
+
+describe("baseWorkerQueue", () => {
+  const region = "us-nyc-3";
+  const scheduled = `${region}${SCHEDULED_WORKER_QUEUE_SUFFIX}`;
+
+  it("strips the scheduled split suffix back to the base region", () => {
+    expect(baseWorkerQueue(scheduled)).toBe(region);
+  });
+
+  it("leaves a base region untouched (idempotent)", () => {
+    expect(baseWorkerQueue(region)).toBe(region);
+    expect(baseWorkerQueue(baseWorkerQueue(scheduled))).toBe(region);
+  });
+
+  it("strips any future `:<class>` suffix, not just `:scheduled`", () => {
+    expect(baseWorkerQueue("us-nyc-3:priority")).toBe(region);
+    expect(baseWorkerQueue("us-nyc-3:a:b")).toBe(region);
+  });
+
+  it("handles the project-scoped masterQueue shape (`<projectId>-<name>`)", () => {
+    expect(baseWorkerQueue("proj_abc123-main:scheduled")).toBe("proj_abc123-main");
+  });
+
+  it("returns an empty string unchanged", () => {
+    expect(baseWorkerQueue("")).toBe("");
+  });
+
+  it("passes a nullish worker queue straight through (synthetic run snapshots)", () => {
+    expect(baseWorkerQueue(null)).toBeNull();
+    expect(baseWorkerQueue(undefined)).toBeUndefined();
+  });
+
+  it("round-trips with workerQueueForRun: the split queue strips back to the region it came from", () => {
+    const enqueued = workerQueueForRun({
+      workerQueue: region,
+      rootTriggerSource: "schedule",
+      splitEnabled: true,
+    });
+    expect(baseWorkerQueue(enqueued)).toBe(region);
+  });
+});
+
+describe("workerQueueForClass", () => {
+  const region = "us-nyc-3";
+  const scheduled = `${region}${SCHEDULED_WORKER_QUEUE_SUFFIX}`;
+
+  it("returns the base queue for the default class or no class", () => {
+    expect(workerQueueForClass(region, "default")).toBe(region);
+    expect(workerQueueForClass(region, undefined)).toBe(region);
+  });
+
+  it("returns the suffixed queue for the scheduled class", () => {
+    expect(workerQueueForClass(region, "scheduled")).toBe(scheduled);
+  });
+
+  it("is idempotent — does not double-suffix", () => {
+    expect(workerQueueForClass(scheduled, "scheduled")).toBe(scheduled);
+  });
+
+  it("round-trips with workerQueueForRun: a scheduled run lands on the queue its class targets", () => {
+    const enqueued = workerQueueForRun({
+      workerQueue: region,
+      rootTriggerSource: "schedule",
+      splitEnabled: true,
+    });
+    expect(workerQueueForClass(region, "scheduled")).toBe(enqueued);
+  });
+});