Add mockStepResult

Author: pombosilva

packages/workflows-shared/src/context.ts

@@ -274,7 +274,14 @@ export class Context extends RpcTarget {
 				await this.#state.storage.put(stepStateKey, stepState);
 				const priorityQueueHash = `${cacheKey}-${stepState.attemptedCount}`;
 
-				result = await Promise.race([doWrapperClosure(), timeoutPromise()]);
+				const replaceResult = await this.#state.storage.get(
+					`replace-result-${valueKey}`
+				);
+				if (replaceResult) {
+					result = replaceResult;
+				} else {
+					result = await Promise.race([doWrapperClosure(), timeoutPromise()]);
+				}
 
 				// if we reach here, means that the clouse ran successfully and we can remove the timeout from the PQ
 				// @ts-expect-error priorityQueue is initiated in init

packages/workflows-shared/src/modifier.ts

@@ -23,16 +23,45 @@ export class InstanceModifier extends RpcTarget {
 		this.#state = state;
 	}
 
+	async #getWaitForEventCacheKey(step: StepSelector): Promise<string> {
+		let count = 1;
+		if (step.index) {
+			count = step.index;
+		}
+		const name = `${step.name}-${count}`;
+		const hash = await computeHash(name);
+		const cacheKey = `${hash}-${count}`;
+		const waitForEventKey = `${cacheKey}-value`;
+
+		return waitForEventKey;
+	}
+
+	async #getStepCacheKey(step: StepSelector): Promise<string> {
+		const hash = await computeHash(step.name);
+		let count = 1;
+		if (step.index) {
+			count = step.index;
+		}
+		const cacheKey = `${hash}-${count}`;
+		const valueKey = `${cacheKey}-value`;
+
+		return valueKey;
+	}
+
 	async disableSleeps(): Promise<void> {
 		await this.#state.storage.put("disableSleeps", true);
 	}
 
+	async mockStepResult(step: StepSelector, stepResult: unknown): Promise<void> {
+		const valueKey = await this.#getStepCacheKey(step);
+		await this.#state.storage.put(`replace-result-${valueKey}`, stepResult);
+	}
+
 	async mockEvent(event: UserEvent): Promise<void> {
-		console.log("SENDING THE EVENT WITH TYPE", event.type);
 		// could maybe:
 		// WorkflowInstance.sendEvent()
 		// Engine.receiveEvent()
-		//const waitForEventKey = await this.#getWaitForEventCacheKey(step);
+		// flag with waitForEventKey
 
 		const myEvent: Event = {
 			timestamp: new Date(),
@@ -43,19 +72,6 @@ export class InstanceModifier extends RpcTarget {
 		await this.#engine.receiveEvent(myEvent);
 	}
 
-	async #getWaitForEventCacheKey(step: StepSelector): Promise<string> {
-		let count = 1;
-		if (step.index) {
-			count = step.index;
-		}
-		const name = `${step.name}-${count}`;
-		const hash = await computeHash(name);
-		const cacheKey = `${hash}-${count}`;
-		const waitForEventKey = `${cacheKey}-value`;
-
-		return waitForEventKey;
-	}
-
 	async forceEventTimeout(step: StepSelector): Promise<void> {
 		const waitForEventKey = await this.#getWaitForEventCacheKey(step);
 		await this.#state.storage.put(`forceEventTimeout-${waitForEventKey}`, true);