fix: give unique name to min-successful-with-passing-threshold test

Changed config.name from 'Parallel minSuccessful' to 'Parallel minSuccessful with Passing Threshold'
to avoid Lambda function mapping conflict with the existing parallel-min-successful test.

Author: ParidelPooya

packages/aws-durable-execution-sdk-js-examples/src/examples/parallel/min-successful-with-passing-threshold/min-successful-with-passing-threshold.test.ts

@@ -0,0 +1,42 @@
+import { handler } from "./min-successful-with-passing-threshold";
+import { createTests } from "../../../utils/test-helper";
+import { OperationStatus } from "@aws/durable-execution-sdk-js-testing";
+
+createTests({
+  localRunnerConfig: {
+    skipTime: false,
+    checkpointDelay: 100,
+  },
+  handler,
+  tests: (runner) => {
+    it("should complete early when minSuccessful is reached", async () => {
+      const execution = await runner.run();
+      const result = execution.getResult() as any;
+
+      // Assert overall results
+      expect(result.successCount).toBe(2);
+      expect(result.completionReason).toBe("MIN_SUCCESSFUL_REACHED");
+      expect(result.totalCount).toBe(5);
+
+      // Get the parallel operation to verify individual branch results
+      // Get individual branch operations
+      const branch1 = runner.getOperation("branch-1");
+      const branch2 = runner.getOperation("branch-2");
+      const branch3 = runner.getOperation("branch-3");
+      const branch4 = runner.getOperation("branch-4");
+      const branch5 = runner.getOperation("branch-5");
+
+      // First two branches should succeed (branch-1 and branch-2 complete fastest)
+      expect(branch1?.getStatus()).toBe(OperationStatus.SUCCEEDED);
+      expect(branch2?.getStatus()).toBe(OperationStatus.SUCCEEDED);
+      expect(branch3?.getStatus()).toBe(OperationStatus.SUCCEEDED);
+      expect(branch4?.getStatus()).toBe(OperationStatus.SUCCEEDED);
+
+      // Remaining branches should be in STARTED state (not completed)
+      expect(branch5?.getStatus()).toBe(OperationStatus.STARTED);
+
+      // Verify the results array matches
+      expect(result.results).toEqual(["Branch 1 result", "Branch 2 result"]);
+    });
+  },
+});

packages/aws-durable-execution-sdk-js-examples/src/examples/parallel/min-successful-with-passing-threshold/min-successful-with-passing-threshold.ts

@@ -0,0 +1,89 @@
+import {
+  DurableContext,
+  withDurableExecution,
+} from "@aws/durable-execution-sdk-js";
+import { ExampleConfig } from "../../../types";
+import { log } from "../../../utils/logger";
+
+export const config: ExampleConfig = {
+  name: "Parallel minSuccessful with Passing Threshold",
+  description:
+    "Parallel execution with minSuccessful completion config and passing threshold",
+};
+
+export const handler = withDurableExecution(
+  async (event: any, context: DurableContext) => {
+    log("Starting parallel execution with minSuccessful: 2");
+
+    // First brach finishes first
+    // Branch 2 to 4 finish in the same time
+    // Branc 5 will finish later
+    const results = await context.parallel(
+      "min-successful-branches",
+      [
+        {
+          name: "branch-1",
+          func: async (ctx) => {
+            return await ctx.step("branch-1", async () => {
+              await new Promise((resolve) => setTimeout(resolve, 10));
+              return "Branch 1 result";
+            });
+          },
+        },
+        {
+          name: "branch-2",
+          func: async (ctx) => {
+            return await ctx.step("branch-2", async () => {
+              await new Promise((resolve) => setTimeout(resolve, 50));
+              return "Branch 2 result";
+            });
+          },
+        },
+        {
+          name: "branch-3",
+          func: async (ctx) => {
+            return await ctx.step("branch-3", async () => {
+              await new Promise((resolve) => setTimeout(resolve, 50));
+              return "Branch 3 result";
+            });
+          },
+        },
+        {
+          name: "branch-4",
+          func: async (ctx) => {
+            return await ctx.step("branch-4", async () => {
+              await new Promise((resolve) => setTimeout(resolve, 50));
+              return "Branch 4 result";
+            });
+          },
+        },
+        {
+          name: "branch-5",
+          func: async (ctx) => {
+            return await ctx.step("branch-4", async () => {
+              await new Promise((resolve) => setTimeout(resolve, 2000));
+              return "Branch 4 result";
+            });
+          },
+        },
+      ],
+      {
+        completionConfig: {
+          minSuccessful: 2,
+        },
+      },
+    );
+
+    await context.wait({ seconds: 1 });
+
+    log(`Completed with ${results.successCount} successes`);
+    log(`Completion reason: ${results.completionReason}`);
+
+    return {
+      successCount: results.successCount,
+      totalCount: results.totalCount,
+      completionReason: results.completionReason,
+      results: results.getResults(),
+    };
+  },
+);