@mnci/az-durable 0.1.1 → 0.1.3

package/dist/testing.esm.js

@@ -1,225 +0,0 @@
-function _instanceof(left, right) {
-    "@swc/helpers - instanceof";
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    } else return left instanceof right;
-}
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-/**
- * Runs an orchestration against stubbed activities, with no Azure running.
- *
- * @remarks
- * Drives the generator synchronously, feeding each yielded task the stubbed
- * result for that activity's name. There is no host, no emulator and no
- * storage — a three-step workflow with a short-circuit branch is testable in
- * about fifteen lines.
- *
- * **How it intercepts.** The orchestration is driven with a fake
- * `OrchestrationContext`, which works only because every scheduling call in
- * this package goes through `context.df` rather than through the registered
- * callable. The alternative — reading the name off `task.action.functionName` —
- * is an undocumented SDK internal the package's non-goals forbid.
- *
- * **Limits, stated rather than discovered later.** Retry policies are not
- * simulated: a stub returning an `Error` throws once, it does not exhaust
- * attempts. `Task.any` resolves to the FIRST task in the list, since there is
- * no real concurrency to race. Timers complete immediately.
- *
- * @param orchestration - The orchestration to run.
- * @param input - The input, checked against its declared type.
- * @param stub - The activity fakes, clock and instance id.
- * @returns The result, the ordered calls, and the status transitions.
- * @throws Error when an activity is called with no stub registered for it.
- * @typeParam TInput - The orchestration's input type.
- * @typeParam TOutput - The orchestration's output type.
- */ function runWorkflow(orchestration, input, stub) {
-    var _stub_now, _stub_instanceId;
-    var calls = [];
-    var statuses = [];
-    var continuedAsNew;
-    var clock = (_stub_now = stub.now) !== null && _stub_now !== void 0 ? _stub_now : new Date(0);
-    var schedule = function schedule(name, scheduledInput) {
-        calls.push({
-            name: name,
-            input: scheduledInput
-        });
-        return {
-            isCompleted: false,
-            isFaulted: false,
-            __name: name,
-            __input: scheduledInput
-        };
-    };
-    var context = {
-        df: {
-            instanceId: (_stub_instanceId = stub.instanceId) !== null && _stub_instanceId !== void 0 ? _stub_instanceId : 'test-instance',
-            isReplaying: false,
-            currentUtcDateTime: clock,
-            callActivity: schedule,
-            callActivityWithRetry: function callActivityWithRetry(name, _retry, i) {
-                return schedule(name, i);
-            },
-            callSubOrchestrator: function callSubOrchestrator(name, i) {
-                return schedule(name, i);
-            },
-            callSubOrchestratorWithRetry: function callSubOrchestratorWithRetry(name, _retry, i) {
-                return schedule(name, i);
-            },
-            waitForExternalEvent: function waitForExternalEvent(name) {
-                return schedule(name, undefined);
-            },
-            // Timers complete immediately: there is no real time to wait for, and a
-            // harness that blocked on one would be useless. `cancel` is real,
-            // because an orchestration that correctly cancels its losing timer must
-            // not crash in a test for doing the right thing.
-            createTimer: function createTimer(fireAt) {
-                var timer = schedule('__timer', fireAt.toISOString());
-                timer.isCanceled = false;
-                timer.cancel = function() {
-                    timer.isCanceled = true;
-                };
-                return timer;
-            },
-            setCustomStatus: function setCustomStatus(value) {
-                statuses.push(String(value));
-            },
-            continueAsNew: function continueAsNew(next) {
-                continuedAsNew = next;
-            },
-            Task: {
-                all: function all(tasks) {
-                    return {
-                        isCompleted: false,
-                        isFaulted: false,
-                        __all: tasks
-                    };
-                },
-                // A marker, not a winner. `Task.any` resolves to the winning TASK, not
-                // to its value, so choosing here would hand the orchestration the
-                // wrong kind of thing — which is exactly the bug the reconstructed
-                // workflows found.
-                any: function any(tasks) {
-                    return {
-                        isCompleted: false,
-                        isFaulted: false,
-                        __any: tasks
-                    };
-                }
-            }
-        }
-    };
-    var generator = orchestration.handler(context, input);
-    var step = generator.next();
-    while(!step.done){
-        var resumed = resolve(step.value, stub);
-        // INTO the generator, not out of the driver. Throwing here instead is the
-        // bug the reconstructed workflows found: every compensation branch was
-        // unreachable, while the docstring promised the opposite.
-        step = isThrowRequest(resumed) ? generator.throw(resumed.__throw) : generator.next(resumed);
-    }
-    return continuedAsNew === undefined ? {
-        result: step.value,
-        calls: calls,
-        statuses: statuses
-    } : {
-        result: step.value,
-        calls: calls,
-        statuses: statuses,
-        continuedAsNew: continuedAsNew
-    };
-}
-/**
- * Produces the value the driver resumes a yielded task with.
- *
- * @remarks
- * Separated so the `Task.all` fan-out case — where one yielded task stands for
- * several — is handled in one place rather than inline in the drive loop.
- *
- * @param task - The task the orchestration yielded.
- * @param stub - The stubs to resolve against.
- * @returns The value to resume with, or a {@link ThrowRequest} for the driver to inject.
- * @throws Error naming an activity with no stub registered.
- * @typeParam None - this function has no generic type parameters.
- */ function resolve(task, stub) {
-    var fanOut = task.__all;
-    if (fanOut !== undefined) {
-        return fanOut.map(function(t) {
-            return resolve(t, stub);
-        });
-    }
-    var race = task.__any;
-    if (race !== undefined) {
-        return resolveRace(race, stub);
-    }
-    var name = task.__name, input = task.__input;
-    if (name === '__timer') {
-        return undefined;
-    }
-    var activity = stub.activities[name];
-    if (activity === undefined) {
-        // Naming the activity matters: the alternative is `undefined` flowing into
-        // the orchestration and failing somewhere unrelated.
-        throw new Error("No stub registered for '".concat(name, "'. Add it to stub.activities to run this workflow."));
-    }
-    var result = activity(input);
-    if (_instanceof(result, Error)) {
-        // A returned Error becomes a THROWN error inside the orchestration, which
-        // is what makes failure branches testable at all. Handed back as a request
-        // so the DRIVER injects it; see {@link ThrowRequest}.
-        return {
-            __throw: result
-        };
-    }
-    return result;
-}
-/**
- * Settles a `Task.any` race and returns the winning TASK.
- *
- * @remarks
- * The distinction that matters: the SDK's `Task.any` resolves to the winning
- * task object, not to its value, and callers read the value afterwards with
- * `resultOf`. An earlier harness returned the resolved value instead, which
- * made every orchestration using a race fail with "Task.any returned a task
- * that was not one of the inputs" — correct code, rejected by the fake.
- *
- * The winner's `result` is populated and `isCompleted` set, so `resultOf` and
- * an `isCompleted` check on the loser both behave as they do in production.
- *
- * @param candidates - The racing tasks.
- * @param stub - The stubs to resolve the winner against.
- * @returns The winning task, completed and carrying its result.
- * @throws Error when `raceWinner` names a task that is not racing.
- * @typeParam None - this function has no generic type parameters.
- */ function resolveRace(candidates, stub) {
-    var _ref;
-    var _stub_raceWinner;
-    var names = candidates.map(function(c) {
-        return c.__name;
-    });
-    var chosen = (_ref = (_stub_raceWinner = stub.raceWinner) === null || _stub_raceWinner === void 0 ? void 0 : _stub_raceWinner.call(stub, names)) !== null && _ref !== void 0 ? _ref : names[0];
-    var winner = candidates.find(function(c) {
-        return c.__name === chosen;
-    });
-    if (winner === undefined) {
-        throw new Error("raceWinner chose '".concat(String(chosen), "', which is not racing. Candidates: ").concat(names.join(', '), "."));
-    }
-    var mutable = winner;
-    mutable.result = winner.__name === '__timer' ? undefined : resolve(winner, stub);
-    mutable.isCompleted = true;
-    return winner;
-}
-/**
- * Whether a resolved value is a request to throw inside the orchestration.
- *
- * @param value - Whatever `resolve` produced.
- * @returns `true` when the driver should call `generator.throw`.
- * @throws Never - a type guard.
- * @typeParam None - this function has no generic type parameters.
- */ function isThrowRequest(value) {
-    return (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && value !== null && '__throw' in value;
-}
-
-export { runWorkflow };