✨ Add fc.scheduler arbitrary

src/check/arbitrary/AsyncSchedulerArbitrary.ts

@@ -0,0 +1,151 @@
+import { cloneMethod } from '../symbols';
+import { Random } from '../../random/generator/Random';
+import { Arbitrary } from './definition/Arbitrary';
+import { Shrinkable } from './definition/Shrinkable';
+import { stringify } from '../../utils/stringify';
+
+// asyncScheduler
+// taskScheduler
+// asyncOrchestrator
+
+// produce a scheduler
+// with schedule and schedulable method
+// plus waitAll and waitOne methods
+
+export interface Scheduler {
+  /** Wrap a new task using the Scheduler */
+  schedule: <T>(task: Promise<T>) => Promise<T>;
+
+  /** Automatically wrap function output using the Scheduler */
+  scheduleFunction: <TArgs extends any[], T>(
+    asyncFunction: (...args: TArgs) => Promise<T>
+  ) => (...args: TArgs) => Promise<T>;
+
+  /**
+   * Count of pending scheduled tasks
+   */
+  count(): number;
+
+  /**
+   * Wait one scheduled task to be executed
+   * @throws Whenever there is no task scheduled
+   */
+  waitOne: () => Promise<void>;
+
+  /**
+   * Wait all scheduled tasks,
+   * including the ones that might be greated by one of the resolved task
+   */
+  waitAll: () => Promise<void>;
+}
+
+type ScheduledTask = {
+  original: PromiseLike<unknown>;
+  scheduled: PromiseLike<unknown>;
+  trigger: () => void;
+  label: string;
+};
+
+export class SchedulerImplem implements Scheduler {
+  private lastTaskId: number;
+  private readonly sourceMrng: Random;
+  private readonly scheduledTasks: ScheduledTask[];
+  private readonly triggeredTasksLogs: string[];
+
+  constructor(private readonly mrng: Random) {
+    this.lastTaskId = 0;
+    // here we should received an already cloned mrng so that we can do whatever we want on it
+    this.sourceMrng = mrng.clone();
+    this.scheduledTasks = [];
+    this.triggeredTasksLogs = [];
+  }
+
+  private buildLog(taskId: number, meta: string, type: 'resolve' | 'reject' | 'pending', data: any[]) {
+    return `[task#${taskId}][${meta}][${type}] ${stringify(data)}`;
+  }
+
+  private log(taskId: number, meta: string, type: 'resolve' | 'reject' | 'pending', data: any[]) {
+    this.triggeredTasksLogs.push(this.buildLog(taskId, meta, type, data));
+  }
+
+  private scheduleInternal<T>(meta: string, task: PromiseLike<T>) {
+    let trigger: (() => void) | null = null;
+    const taskId = ++this.lastTaskId;
+    const scheduledPromise = new Promise<T>((resolve, reject) => {
+      trigger = () => {
+        task.then(
+          (...args) => {
+            this.log(taskId, meta, 'resolve', args);
+            return resolve(...args);
+          },
+          (...args) => {
+            this.log(taskId, meta, 'reject', args);
+            return reject(...args);
+          }
+        );
+      };
+    });
+    this.scheduledTasks.push({
+      original: task,
+      scheduled: scheduledPromise,
+      trigger: trigger!,
+      label: this.buildLog(taskId, meta, 'pending', [])
+    });
+    return scheduledPromise;
+  }
+
+  schedule<T>(task: Promise<T>) {
+    return this.scheduleInternal('promise', task);
+  }
+
+  scheduleFunction<TArgs extends any[], T>(
+    asyncFunction: (...args: TArgs) => Promise<T>
+  ): (...args: TArgs) => Promise<T> {
+    return (...args: TArgs) =>
+      this.scheduleInternal(
+        `function::${asyncFunction.name}(${args.map(stringify).join(',')})`,
+        asyncFunction(...args)
+      );
+  }
+
+  count() {
+    return this.scheduledTasks.length;
+  }
+
+  async waitOne() {
+    if (this.scheduledTasks.length === 0) {
+      throw new Error('No task scheduled');
+    }
+    const taskIndex = this.mrng.nextInt(0, this.scheduledTasks.length - 1);
+    const [scheduledTask] = this.scheduledTasks.splice(taskIndex, 1);
+    scheduledTask.trigger(); // release the promise
+    await scheduledTask.scheduled; // wait for its completion
+  }
+
+  async waitAll() {
+    while (this.scheduledTasks.length > 0) {
+      await this.waitOne();
+    }
+  }
+
+  toString() {
+    return this.triggeredTasksLogs
+      .concat(this.scheduledTasks.map(t => t.label))
+      .map(log => `-> ${log}`)
+      .join('\n');
+  }
+
+  [cloneMethod]() {
+    return new SchedulerImplem(this.sourceMrng);
+  }
+}
+
+class SchedulerArbitrary extends Arbitrary<Scheduler> {
+  generate(mrng: Random) {
+    return new Shrinkable(new SchedulerImplem(mrng.clone()));
+  }
+}
+
+export function scheduler(): Arbitrary<Scheduler> {
+  return new SchedulerArbitrary();
+}

src/fast-check-default.ts

@@ -87,6 +87,7 @@ import { ExecutionTree } from './check/runner/reporter/ExecutionTree';
 import { cloneMethod } from './check/symbols';
 import { Stream, stream } from './stream/Stream';
 import { stringify } from './utils/stringify';
+import { scheduler, Scheduler } from './check/arbitrary/AsyncSchedulerArbitrary';
 
 // boolean
 // floating point types
@@ -189,6 +190,9 @@ export {
   asyncModelRun,
   modelRun,
   commands,
+  // scheduler
+  scheduler,
+  Scheduler,
   // extend the framework
   Arbitrary,
   Shrinkable,

test/e2e/AsyncScheduler.spec.ts

@@ -0,0 +1,123 @@
+import * as fc from '../../src/fast-check';
+
+const seed = Date.now();
+describe(`AsyncScheduler (seed: ${seed})`, () => {
+  it('should detect trivial race conditions', async () => {
+    // The code below relies on the fact/expectation that fetchA takes less time that fetchB
+    // The aim of this test is to show that the code is wrong as soon as this assumption breaks
+    type CompoProps = { fetchHeroName: () => Promise<string>; fetchHeroes: () => Promise<{ name: string }[]> };
+    type CompoState = { heroName: string | undefined; heroes: { name: string }[] | undefined };
+    class Compo {
+      private props: CompoProps;
+      private state: CompoState;
+      constructor(props: CompoProps) {
+        this.props = props;
+        this.state = { heroName: undefined, heroes: undefined };
+      }
+      componentDidMount() {
+        this.props.fetchHeroName().then(heroName => (this.state = { ...this.state, heroName }));
+        this.props.fetchHeroes().then(heroes => (this.state = { ...this.state, heroes }));
+      }
+      render() {
+        const { heroName, heroes } = this.state;
+        if (!heroes) return null;
+        return `got: ${heroes.find(h => h.name === heroName!.toLowerCase())}`;
+      }
+    }
+    const out = await fc.check(
+      fc.asyncProperty(fc.scheduler(), async s => {
+        const fetchHeroName = s.scheduleFunction(function fetchHeroName() {
+          return Promise.resolve('James Bond');
+        });
+        const fetchHeroes = s.scheduleFunction(function fetchHeroesById() {
+          return Promise.resolve([{ name: 'James Bond' }]);
+        });
+        const c = new Compo({ fetchHeroName, fetchHeroes });
+        c.componentDidMount();
+        c.render();
+        while (s.count() !== 0) {
+          await s.waitOne();
+          c.render();
+        }
+      }),
+      { seed }
+    );
+    expect(out.failed).toBe(true);
+    expect(out.counterexample![0].toString()).toMatchInlineSnapshot(`
+      "-> [task#2][function::fetchHeroesById()][resolve] [[{\\"name\\":\\"James Bond\\"}]]
+      -> [task#1][function::fetchHeroName()][pending] []"
+    `);
+    expect(out.error).toContain(`Cannot read property 'toLowerCase' of undefined`);
+  });
+
+  it('should detect race conditions leading to infinite loops', async () => {
+    // Following case is an example of code trying to scan all the dependencies of a given package
+    // In order to build a nice graph
+    type PackageDefinition = {
+      dependencies: { [packageName: string]: string };
+    };
+    type AllPackagesDefinition = { [packageName: string]: PackageDefinition };
+    const allPackages: AllPackagesDefinition = {
+      toto: {
+        dependencies: {
+          titi: '^1.0.0',
+          tata: '^2.0.0',
+          tutu: '^3.0.0'
+        }
+      },
+      titi: {
+        dependencies: {
+          noop: '^1.0.0',
+          tutu: '^3.0.0'
+        }
+      },
+      tata: {
+        dependencies: {
+          noop: '^1.0.0'
+        }
+      },
+      noop: {
+        dependencies: {}
+      },
+      tutu: {
+        dependencies: {
+          titi: '^1.0.0'
+        }
+      }
+    };
+    const buildGraph = async (
+      initialPackageName: string,
+      fetch: (packageName: string) => Promise<PackageDefinition>
+    ) => {
+      const cache: AllPackagesDefinition = {};
+      // // Uncomment to remove the bug
+      //const cachePending = new Set<string>();
+      const feedCache = async (packageName: string) => {
+        // // Uncomment to remove the bug
+        // if (cachePending.has(packageName)) return;
+        // cachePending.add(packageName);
+        if (cache[packageName]) return;
+
+        const packageDef = await fetch(packageName); // cache miss
+        await Promise.all(Object.keys(packageDef.dependencies).map(dependencyName => feedCache(dependencyName)));
+      };
+      await feedCache(initialPackageName);
+      return cache; // we just return the cache instead of the garph for simplicity
+    };
+    const out = await fc.check(
+      fc.asyncProperty(fc.constantFrom(...Object.keys(allPackages)), fc.scheduler(), async (initialPackageName, s) => {
+        const originalFetch = (packageName: string) => Promise.resolve(allPackages[packageName]);
+        const fetch = s.scheduleFunction(originalFetch);
+        const handle = buildGraph(initialPackageName, fetch);
+        // Or: await s.waitAll();
+        while (s.count() !== 0) {
+          expect(s.count()).toBeLessThanOrEqual(Object.keys(allPackages).length);
+          await s.waitOne();
+        }
+        await handle; // nothing should block now
+      }),
+      { seed }
+    );
+    expect(out.failed).toBe(true);
+  });
+});