@stigmer/server 3.38.0 → 3.38.1

package/src/domain/workflowexecution/__tests__/store-faults.test.ts

@@ -45,7 +45,12 @@ import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/
 
 import { createLogger } from "../../../boot/logger.js";
 import { callerIdentityKey } from "../../../pipeline/interceptors/auth.js";
-import { testCallerIdentity } from "../../../pipeline/__tests__/support.js";
+import {
+  errorOf,
+  failingStore,
+  testCallerIdentity,
+  untouchable,
+} from "../../../pipeline/__tests__/support.js";
 import { RequestContext } from "../../../pipeline/request-context.js";
 import { newPermissiveSingleTeamAuthorizer } from "../../../pipeline/steps/authorize.js";
 import { ResourceNotFoundError } from "../../../store/interface.js";
@@ -80,35 +85,10 @@ const WORKFLOW_ID = "wfl_storefault";
 const EXECUTION_FAULT_COPY = "failed to load workflow execution";
 const WORKFLOW_FAULT_COPY = "failed to load workflow";
 
-/** A dependency the call must never reach once its load has failed. */
-function untouchable<T extends object>(name: string): T {
-  return new Proxy({} as T, {
-    get(_target, prop) {
-      throw new Error(`${name}.${String(prop)} reached after a failed load`);
-    },
-  });
-}
-
-/** A store whose every read fails with the given error. */
-function failingStore(error: Error): Store {
-  return {
-    getResource: () => Promise.reject(error),
-  } as unknown as Store;
-}
-
 const MISSING = (): Error =>
   new ResourceNotFoundError(`workflow_execution/${EXECUTION_ID}`);
 const LOCKED = (): Error => new Error("SQLITE_BUSY: database is locked");
 
-async function errorOf(call: () => Promise<unknown>): Promise<ConnectError> {
-  const error = await call().then(
-    () => undefined,
-    (e: unknown) => e,
-  );
-  expect(error, "the call must fail").toBeInstanceOf(ConnectError);
-  return error as ConnectError;
-}
-
 function handlerContext(): HandlerContext {
   const values = createContextValues();
   values.set(callerIdentityKey, testCallerIdentity());

package/src/pipeline/__tests__/blind-not-found.test.ts

@@ -44,11 +44,6 @@ const PENDING: ReadonlyMap<string, number> = new Map([
   ["domain/artifact/controller.ts", 1],
   ["domain/environment/controller.ts", 1],
   ["domain/environment/steps.ts", 1],
-  ["domain/mcpserver/complete-oauth-connect.ts", 1],
-  ["domain/mcpserver/connect.ts", 1],
-  ["domain/mcpserver/controller.ts", 1],
-  ["domain/mcpserver/initiate-oauth-connect.ts", 1],
-  ["domain/mcpserver/start-connect.ts", 2],
   ["domain/plugin/controller.ts", 1],
   ["domain/skill/controller.ts", 1],
   ["domain/workflow/controller.ts", 1],

package/src/pipeline/__tests__/support.ts

@@ -1,16 +1,31 @@
 /**
- * Shared test identity for RequestContext construction (O2, ruling Q3):
- * the identity parameter is required, so every test constructs one
- * explicitly — never a hidden default that could mask a missed threading
- * site in production code. Overrides let adversarial tests pin specific
- * caller classes.
+ * Shared test fixtures for the pipeline and the domains.
+ *
+ * The caller identity for RequestContext construction: the identity
+ * parameter is required, so every test constructs one explicitly — never a
+ * hidden default that could mask a missed threading site in production
+ * code. Overrides let adversarial tests pin specific caller classes.
+ *
+ * The run-gate authorizer, which isolates the AuthorizeRunTarget splice from
+ * every other authorization site on a chain.
+ *
+ * The store-fault helpers the per-domain `store-faults` tests share: a store
+ * whose reads fail with a chosen error, a dependency that must never be
+ * reached once a load has failed, and the ConnectError a failing call
+ * rejects with. Together they pin the error contract's store-fault rule
+ * (`src/pipeline/errors.ts`): a typed not-found answers NotFound, any other
+ * store failure a sanitized Internal.
  */
+import { ConnectError } from "@connectrpc/connect";
+import { expect } from "vitest";
+
 import type {
   Authorizer,
   AuthzCheck,
   AuthzDecision,
 } from "../../extensions/authorizer.js";
 import type { CallerIdentity } from "../../extensions/identity.js";
+import type { Store } from "../../store/interface.js";
 import { isRunGateCheck } from "../steps/authorize-run-target.js";
 
 export function testCallerIdentity(
@@ -52,3 +67,31 @@ export function runGateOnlyAuthorizer(decide: () => AuthzDecision): {
     },
   };
 }
+
+/** A dependency the call must never reach once its load has failed. */
+export function untouchable<T extends object>(name: string): T {
+  return new Proxy({} as T, {
+    get(_target, prop) {
+      throw new Error(`${name}.${String(prop)} reached after a failed load`);
+    },
+  });
+}
+
+/** A store whose every read fails with the given error. */
+export function failingStore(error: Error): Store {
+  return {
+    getResource: () => Promise.reject(error),
+  } as unknown as Store;
+}
+
+/** The ConnectError `call` rejects with; fails the test if it resolves. */
+export async function errorOf(
+  call: () => Promise<unknown>,
+): Promise<ConnectError> {
+  const error = await call().then(
+    () => undefined,
+    (e: unknown) => e,
+  );
+  expect(error, "the call must fail").toBeInstanceOf(ConnectError);
+  return error as ConnectError;
+}