@serenity-js/core 3.2.1 → 3.3.1

package/src/screenplay/time/models/Scheduler.ts

@@ -10,11 +10,7 @@ import { Timestamp } from './Timestamp';
  */
 export class Scheduler {
 
-    private remainingCallbacks: Map<DelayedCallback<unknown>, CallbackInfo<unknown>> = new Map();
-    private completedCallbacks: Map<DelayedCallback<unknown>, CallbackInfo<unknown>> = new Map();
-    private failedCallbacks:    Map<DelayedCallback<unknown>, CallbackInfo<unknown>> = new Map();
-
-    private timer: NodeJS.Timer;
+    private scheduledOperations: Array<ScheduledOperation<unknown>> = [];
 
     /**
      * @param clock
@@ -39,7 +35,7 @@ export class Scheduler {
             {
                 maxInvocations: 1,
                 delayBetweenInvocations: () => delay,
-                timeout: this.interactionTimeout,
+                timeout: this.interactionTimeout.plus(delay),
             },
         );
     }
@@ -81,154 +77,111 @@ export class Scheduler {
             errorHandler            = rethrowErrors,
         } = limits;
 
-        this.remainingCallbacks.set(callback, {
-            exitCondition: exitCondition,
-            currentInvocation: 0,
-            invocationsLeft: maxInvocations,
-            delayBetweenInvocations,
-            startedAt: this.clock.now(),
-            timeout,
-            errorHandler,
-            result: undefined,
-        });
-
-        return this.receiptFor<Result>(callback);
+        const operation = new ScheduledOperation(
+            this.clock,
+            callback,
+            {
+                exitCondition,
+                maxInvocations,
+                delayBetweenInvocations,
+                timeout,
+                errorHandler,
+            }
+        );
+
+        this.scheduledOperations.push(operation);
+        return operation.start()
     }
 
-    start(): void {
-        if (! this.timer) {
-            this.timer = setInterval(
-                () =>  this.invokeCallbacksScheduledUntil(this.clock.now()),
-                100
-            )
+    stop(): void {
+        for (const operation of this.scheduledOperations) {
+            operation.cancel();
         }
     }
+}
+
+class ScheduledOperation<Result> {
+    private currentInvocation   = 0;
+    private invocationsLeft     = 0;
+    private startedAt: Timestamp;
+    private lastResult: Result;
 
-    isRunning(): boolean {
-        return Boolean(this.timer);
+    private isCancelled = false;
+
+    constructor(
+        private readonly clock: Clock,
+        private readonly callback: DelayedCallback<Result>,
+        private readonly limits: RepeatUntilLimits<Result> = {},
+    ) {
     }
 
-    stop(): void {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = undefined;
-
-            for (const [callback, info] of this.remainingCallbacks) {
-                this.remainingCallbacks.delete(callback);
-                this.failedCallbacks.set(callback, {
-                    ...info,
-                    error: new OperationInterruptedError(`Scheduler stopped before executing callback ${ callback }`)
-                });
-            }
-        }
+    async start(): Promise<Result> {
+        this.currentInvocation  = 0;
+        this.invocationsLeft    = this.limits.maxInvocations;
+        this.startedAt          = this.clock.now();
+
+        return await this.poll();
     }
 
-    invokeCallbacksScheduledForNext(duration: Duration): void {
-        this.invokeCallbacksScheduledUntil(
-            this.clock.now().plus(duration)
-        );
+    private async poll(): Promise<Result> {
+        await this.clock.waitFor(this.limits.delayBetweenInvocations(this.currentInvocation));
+
+        if (this.isCancelled) {
+            throw new OperationInterruptedError('Scheduler stopped before executing callback');
+        }
+
+        const receipt = await this.invoke();
+
+        if (receipt.hasCompleted) {
+            return receipt.result;
+        }
+
+        this.currentInvocation++;
+        this.invocationsLeft--;
+
+        return await this.poll();
     }
 
-    private invokeCallbacksScheduledUntil(timestamp: Timestamp): void {
-        for (const [ callback, info ] of this.remainingCallbacks) {
-            const { startedAt, currentInvocation, delayBetweenInvocations } = info;
-            const expectedInvocationTime = startedAt.plus(delayBetweenInvocations(currentInvocation));
+    private async invoke(): Promise<{ result?: Result, error?: Error, hasCompleted: boolean }> {
+
+        const timeoutExpired = this.startedAt.plus(this.limits.timeout).isBefore(this.clock.now());
+        const isLastInvocation = this.invocationsLeft === 1;
+
+        if (this.invocationsLeft === 0) {
+            return {
+                result: this.lastResult,
+                hasCompleted: true,
+            };
+        }
 
-            if (expectedInvocationTime.isBeforeOrEqual(timestamp)) {
-                this.invoke(callback);
+        try {
+            if (timeoutExpired) {
+                throw new TimeoutExpiredError(`Timeout of ${ this.limits.timeout } has expired`);
+            }
+
+            this.lastResult = await this.callback({ currentTime: this.clock.now(), i: this.currentInvocation });
+
+            return {
+                result:       this.lastResult,
+                hasCompleted: this.limits.exitCondition(this.lastResult) || isLastInvocation,
             }
         }
-    }
+        catch(error) {
 
-    private invoke<Result>(callback: DelayedCallback<Result>): void {
-        const info = this.remainingCallbacks.get(callback);
-
-        this.remainingCallbacks.delete(callback);
-
-        Promise.resolve()
-            .then(async () => {
-                const timeoutExpired = info.startedAt.plus(info.timeout).isBefore(this.clock.now());
-                const isLastInvocation = info.invocationsLeft === 1;
-
-                if (info.invocationsLeft === 0) {
-                    return {
-                        hasCompleted: true,
-                    };
-                }
-
-                try {
-                    if (timeoutExpired) {
-                        throw new TimeoutExpiredError(`Timeout of ${ info.timeout } has expired`);
-                    }
-
-                    const result = await callback({ currentTime: this.clock.now(), i: info.currentInvocation });
-
-                    return {
-                        result,
-                        hasCompleted: info.exitCondition(result) || isLastInvocation,
-                    }
-                }
-                catch(error) {
-                    info.errorHandler(error, info.result);
-
-                    // if the errorHandler didn't throw, it's a recoverable error
-                    return {
-                        error,
-                        hasCompleted: isLastInvocation,
-                    }
-                }
-            })
-            .then(({ result, error, hasCompleted }) => {
-                if (hasCompleted) {
-                    this['completedCallbacks'].set(callback, {
-                        ...info,
-                        result: result ?? info.result,
-                        error,
-                    });
-                }
-                else {
-                    this['remainingCallbacks'].set(callback, {
-                        ...info,
-                        currentInvocation:  info.currentInvocation + 1,
-                        invocationsLeft:    info.invocationsLeft - 1,
-                        result: result ?? info.result,
-                        error,
-                    });
-                }
-            })
-            .catch(error => {
-                this.failedCallbacks.set(callback, { ...info, error });
-            });
-    }
+            this.limits.errorHandler(error, this.lastResult);
 
-    private receiptFor<Result>(callback: DelayedCallback<unknown>): Promise<Result> {
-        return new Promise((resolve, reject) => {
-
-            const timer = setInterval(() => {
-                if (this.failedCallbacks.has(callback)) {
-                    clearInterval(timer);
-                    return reject(this.failedCallbacks.get(callback).error);
-                }
-
-                if (this.completedCallbacks.has(callback)) {
-                    clearInterval(timer);
-                    return resolve(this.completedCallbacks.get(callback).result as Result);
-                }
-            }, 25);
-        })
+            // if the errorHandler didn't throw, it's a recoverable error
+            return {
+                result:       this.lastResult,
+                error,
+                hasCompleted: isLastInvocation,
+            }
+        }
     }
-}
 
-interface CallbackInfo<Result> {
-    exitCondition: (result: Result) => boolean,
-    currentInvocation: number;
-    invocationsLeft: number,
-    delayBetweenInvocations: (i: number) => Duration,
-    timeout: Duration
-    startedAt: Timestamp,
-    errorHandler: (error: Error, result: Result) => void,
-    result?: Result,
-    error?: Error,
+    cancel(): void {
+        this.isCancelled = true;
+    }
 }
 
 function noDelay() {

package/src/stage/Stage.ts

@@ -1,7 +1,16 @@
 import { ensure, isDefined } from 'tiny-types';
 
 import { ConfigurationError, ErrorFactory, ErrorOptions, LogicError, RaiseErrors, RuntimeError } from '../errors';
-import { AsyncOperationAttempted, AsyncOperationCompleted, AsyncOperationFailed, DomainEvent, SceneFinishes, SceneStarts, TestRunFinishes } from '../events';
+import {
+    AsyncOperationAttempted,
+    AsyncOperationCompleted,
+    AsyncOperationFailed,
+    DomainEvent,
+    EmitsDomainEvents,
+    SceneFinishes,
+    SceneStarts,
+    TestRunFinishes
+} from '../events';
 import { ActivityDetails, CorrelationId, Description, Name } from '../model';
 import { Actor, Clock, Duration, ScheduleWork, Timestamp } from '../screenplay';
 import { ListensToDomainEvents } from '../stage';
@@ -23,7 +32,7 @@ import { StageManager } from './StageManager';
  *
  * @group Stage
  */
-export class Stage {
+export class Stage implements EmitsDomainEvents {
 
     private static readonly unknownSceneId = new CorrelationId('unknown')
 
@@ -91,11 +100,10 @@ export class Stage {
         if (! this.instantiatedActorCalled(name)) {
             let actor;
             try {
-                const newActor = new Actor(name, this)
-                    .whoCan(
-                        new RaiseErrors(this),
-                        new ScheduleWork(this.clock, this.interactionTimeout),
-                    );
+                const newActor = new Actor(name, this, [
+                    new RaiseErrors(this),
+                    new ScheduleWork(this.clock, this.interactionTimeout)
+                ]);
 
                 actor = this.cast.prepare(newActor);