test(e2e): add interactive onboard policy-preset step-ordering test (#6042)

src/lib/onboard/inference-selection-validation.test.ts

@@ -269,67 +269,66 @@ describe("inference selection validation", () => {
       expectedEndpointUrl: "https://anthropic.corp.example/v1",
       expectedProbeOptions: { calibrateTimeouts: true, skipResponsesProbe: true },
     },
-  ])("probes an exactly allowlisted private Anthropic endpoint on its $runtimeSurface surface (#7037)", async ({
-    intendedApi,
-    expectedEndpointUrl,
-    expectedProbeOptions,
-  }) => {
-    vi.stubEnv("NEMOCLAW_TRUSTED_PRIVATE_INFERENCE_HOSTS", "anthropic.corp.example");
-    vi.stubEnv("NEMOCLAW_REASONING", "false");
-    const probeEndpoint = vi.fn(() => ({
-      ok: true,
-      api: intendedApi,
-      label: "Compatible API",
-    }));
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const log = vi.spyOn(console, "log").mockImplementation(() => {});
-    const helpers = createInferenceSelectionValidationHelpers({
-      isNonInteractive: () => false,
-      agentProductName: () => "NemoClaw agent",
-      getCredential: () => "test-key",
-      probeAnthropicEndpoint: probeEndpoint,
-      probeOpenAiLikeEndpoint: probeEndpoint,
-      promptValidationRecovery: vi.fn(async () => "selection" as const),
-      resolveEndpointHost: async () => [{ address: "10.0.0.8", family: 4 }],
-    });
-
-    try {
-      const result = await helpers.validateCustomAnthropicSelection(
-        "Custom Anthropic endpoint",
-        "https://anthropic.corp.example",
-        "model-a",
-        "COMPATIBLE_ANTHROPIC_API_KEY",
-        null,
-        { intendedApi },
-      );
-
-      expect(result).toMatchObject({
+  ])(
+    "probes an exactly allowlisted private Anthropic endpoint on its $runtimeSurface surface (#7037)",
+    async ({ intendedApi, expectedEndpointUrl, expectedProbeOptions }) => {
+      vi.stubEnv("NEMOCLAW_TRUSTED_PRIVATE_INFERENCE_HOSTS", "anthropic.corp.example");
+      vi.stubEnv("NEMOCLAW_REASONING", "false");
+      const probeEndpoint = vi.fn(() => ({
         ok: true,
         api: intendedApi,
-        pinnedAddresses: ["10.0.0.8"],
-        trustedPrivateCapability: {
-          host: "anthropic.corp.example",
-          addresses: ["10.0.0.8"],
-        },
+        label: "Compatible API",
+      }));
+      const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const log = vi.spyOn(console, "log").mockImplementation(() => {});
+      const helpers = createInferenceSelectionValidationHelpers({
+        isNonInteractive: () => false,
+        agentProductName: () => "NemoClaw agent",
+        getCredential: () => "test-key",
+        probeAnthropicEndpoint: probeEndpoint,
+        probeOpenAiLikeEndpoint: probeEndpoint,
+        promptValidationRecovery: vi.fn(async () => "selection" as const),
+        resolveEndpointHost: async () => [{ address: "10.0.0.8", family: 4 }],
       });
-      expect(probeEndpoint).toHaveBeenCalledOnce();
-      expect(probeEndpoint).toHaveBeenCalledWith(
-        expectedEndpointUrl,
-        "model-a",
-        "test-key",
-        expect.objectContaining({
-          ...expectedProbeOptions,
+
+      try {
+        const result = await helpers.validateCustomAnthropicSelection(
+          "Custom Anthropic endpoint",
+          "https://anthropic.corp.example",
+          "model-a",
+          "COMPATIBLE_ANTHROPIC_API_KEY",
+          null,
+          { intendedApi },
+        );
+
+        expect(result).toMatchObject({
+          ok: true,
+          api: intendedApi,
           pinnedAddresses: ["10.0.0.8"],
-          trustedPrivateCapability: expect.objectContaining({ addresses: ["10.0.0.8"] }),
-        }),
-      );
-      expect(warn).toHaveBeenCalledWith(expect.stringContaining("operator-trusted private"));
-    } finally {
-      log.mockRestore();
-      warn.mockRestore();
-      vi.unstubAllEnvs();
-    }
-  });
+          trustedPrivateCapability: {
+            host: "anthropic.corp.example",
+            addresses: ["10.0.0.8"],
+          },
+        });
+        expect(probeEndpoint).toHaveBeenCalledOnce();
+        expect(probeEndpoint).toHaveBeenCalledWith(
+          expectedEndpointUrl,
+          "model-a",
+          "test-key",
+          expect.objectContaining({
+            ...expectedProbeOptions,
+            pinnedAddresses: ["10.0.0.8"],
+            trustedPrivateCapability: expect.objectContaining({ addresses: ["10.0.0.8"] }),
+          }),
+        );
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining("operator-trusted private"));
+      } finally {
+        log.mockRestore();
+        warn.mockRestore();
+        vi.unstubAllEnvs();
+      }
+    },
+  );
 
   it("honors an exactly allowlisted private endpoint during non-interactive validation (#6861)", async () => {
     vi.stubEnv("NEMOCLAW_TRUSTED_PRIVATE_INFERENCE_HOSTS", "llm.corp.example");
@@ -403,47 +402,46 @@ describe("inference selection validation", () => {
     }
   });
 
-  it.each([
-    "http://127.0.0.1:8000/v1",
-    "https://inference.local/v1",
-    "https://93.184.216.34/v1",
-  ])("carries the approved no-pin capability to probes for %s (#6293)", async (endpointUrl) => {
-    const probeOpenAiLikeEndpoint = vi.fn(() => ({ ok: true, api: "openai-completions" }));
-    const resolveEndpointHost = vi.fn(async () => [{ address: "10.0.0.8", family: 4 }]);
-    const log = vi.spyOn(console, "log").mockImplementation(() => {});
-    const helpers = createInferenceSelectionValidationHelpers({
-      isNonInteractive: () => false,
-      agentProductName: () => "OpenClaw",
-      getCredential: () => "test-key",
-      probeOpenAiLikeEndpoint,
-      promptValidationRecovery: vi.fn(async () => "selection" as const),
-      resolveEndpointHost,
-    });
+  it.each(["http://127.0.0.1:8000/v1", "https://inference.local/v1", "https://93.184.216.34/v1"])(
+    "carries the approved no-pin capability to probes for %s (#6293)",
+    async (endpointUrl) => {
+      const probeOpenAiLikeEndpoint = vi.fn(() => ({ ok: true, api: "openai-completions" }));
+      const resolveEndpointHost = vi.fn(async () => [{ address: "10.0.0.8", family: 4 }]);
+      const log = vi.spyOn(console, "log").mockImplementation(() => {});
+      const helpers = createInferenceSelectionValidationHelpers({
+        isNonInteractive: () => false,
+        agentProductName: () => "OpenClaw",
+        getCredential: () => "test-key",
+        probeOpenAiLikeEndpoint,
+        promptValidationRecovery: vi.fn(async () => "selection" as const),
+        resolveEndpointHost,
+      });
 
-    try {
-      await expect(
-        helpers.validateCustomOpenAiLikeSelection(
-          "Custom endpoint",
+      try {
+        await expect(
+          helpers.validateCustomOpenAiLikeSelection(
+            "Custom endpoint",
+            endpointUrl,
+            "model-a",
+            "COMPATIBLE_API_KEY",
+          ),
+        ).resolves.toEqual({
+          ok: true,
+          api: "openai-completions",
+          pinnedAddresses: [],
+        });
+        expect(probeOpenAiLikeEndpoint).toHaveBeenCalledWith(
           endpointUrl,
           "model-a",
-          "COMPATIBLE_API_KEY",
-        ),
-      ).resolves.toEqual({
-        ok: true,
-        api: "openai-completions",
-        pinnedAddresses: [],
-      });
-      expect(probeOpenAiLikeEndpoint).toHaveBeenCalledWith(
-        endpointUrl,
-        "model-a",
-        "test-key",
-        expect.objectContaining({ pinnedAddresses: [] }),
-      );
-      expect(resolveEndpointHost).not.toHaveBeenCalled();
-    } finally {
-      log.mockRestore();
-    }
-  });
+          "test-key",
+          expect.objectContaining({ pinnedAddresses: [] }),
+        );
+        expect(resolveEndpointHost).not.toHaveBeenCalled();
+      } finally {
+        log.mockRestore();
+      }
+    },
+  );
 
   it("exits non-interactively when a custom Anthropic endpoint resolves to link-local metadata, without probing (#6293)", async () => {
     const originalExitCode = process.exitCode;