vest 5.0.0-dev-781e21 → 5.0.2-dev-d315d9

package/src/core/SuiteWalker/__tests__/hasRemainingTests.test.ts

@@ -0,0 +1,130 @@
+import wait from 'wait';
+
+import { TestWalker } from 'TestWalker';
+import * as vest from 'vest';
+
+describe('TestWalker.hasRemainingTests', () => {
+  let hasRemaining: boolean | null = null;
+  let count = 0;
+
+  beforeEach(() => {
+    hasRemaining = null;
+    count = 0;
+  });
+  describe('When no field specified', () => {
+    describe('When no remaining tests', () => {
+      it('should return false', () => {
+        vest.create(() => {
+          hasRemaining = TestWalker.hasRemainingTests();
+        })();
+        expect(hasRemaining).toBe(false);
+      });
+    });
+
+    describe('When there are remaining tests', () => {
+      it('pending tests return true', () => {
+        vest.create(() => {
+          vest.test('f1', async () => {
+            await wait(100);
+          });
+          hasRemaining = TestWalker.hasRemainingTests();
+        })();
+
+        expect(hasRemaining).toBe(true);
+      });
+
+      it('lagging tests return true', () => {
+        const suite = vest.create(() => {
+          if (count) vest.skip('f1');
+          vest.test('f1', async () => {
+            await wait(100);
+          });
+          count++;
+          hasRemaining = TestWalker.hasRemainingTests();
+        });
+        suite();
+        suite();
+
+        expect(hasRemaining).toBe(true);
+      });
+
+      it('lagging and pending tests return true', () => {
+        const suite = vest.create(() => {
+          if (count) vest.skip('f1');
+          vest.test('f1', async () => {
+            await wait(100);
+          });
+          vest.test('f2', async () => {
+            await wait(100);
+          });
+          count++;
+          hasRemaining = TestWalker.hasRemainingTests();
+        });
+
+        suite();
+        suite();
+
+        expect(hasRemaining).toBe(true);
+      });
+    });
+  });
+
+  describe('When field specified', () => {
+    describe('When no remaining tests', () => {
+      it('Should return false', () => {
+        vest.create(() => {
+          hasRemaining = TestWalker.hasRemainingTests('f1');
+        })();
+        expect(hasRemaining).toBe(false);
+      });
+    });
+
+    describe('When remaining tests', () => {
+      it('pending tests return true', () => {
+        vest.create(() => {
+          vest.test('f1', async () => {
+            await wait(100);
+          });
+          hasRemaining = TestWalker.hasRemainingTests('f1');
+        })();
+        expect(hasRemaining).toBe(true);
+      });
+
+      it('lagging tests return true', () => {
+        const suite = vest.create(() => {
+          if (count) vest.skip('f1');
+          vest.test('f1', async () => {
+            await wait(100);
+          });
+          count++;
+          hasRemaining = TestWalker.hasRemainingTests('f1');
+        });
+        suite();
+        suite();
+
+        expect(hasRemaining).toBe(true);
+      });
+
+      it('lagging and pending tests return true', () => {
+        const suite = vest.create(() => {
+          if (count) vest.skip('f1');
+          vest.test('f1', async () => {
+            await wait(100);
+          });
+          vest.test('f2', async () => {
+            await wait(100);
+          });
+          count++;
+          hasRemaining =
+            TestWalker.hasRemainingTests('f1') &&
+            TestWalker.hasRemainingTests('f2');
+        });
+
+        suite();
+        suite();
+
+        expect(hasRemaining).toBe(true);
+      });
+    });
+  });
+});

package/src/core/VestBus/VestBus.ts

@@ -0,0 +1,78 @@
+import { bus } from 'vest-utils';
+
+import { IsolateTest } from 'IsolateTest';
+import {
+  useExpireSuiteResultCache,
+  useResetCallbacks,
+  useResetSuite,
+} from 'PersistedContext';
+import { TFieldName } from 'SuiteResultTypes';
+import { TestWalker } from 'TestWalker';
+import { runDoneCallbacks, runFieldCallbacks } from 'runCallbacks';
+
+export function initVestBus() {
+  const VestBus = bus.createBus();
+
+  // Report a the completion of a test. There may be other tests with the same
+  // name that are still running, or not yet started.
+  on(Events.TEST_COMPLETED, (testObject: IsolateTest) => {
+    if (testObject.isCanceled()) {
+      return;
+    }
+
+    testObject.pass();
+    runFieldCallbacks(testObject.fieldName);
+
+    if (!TestWalker.hasRemainingTests()) {
+      // When no more tests are running, emit the done event
+      VestBus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
+    }
+  });
+
+  on(Events.TEST_RUN_STARTED, () => {
+    /* Let's just invalidate the suite cache for now */
+  });
+
+  // Called when all the tests, including async, are done running
+  on(Events.ALL_RUNNING_TESTS_FINISHED, () => {
+    runDoneCallbacks();
+  });
+
+  on(Events.RESET_FIELD, (fieldName: TFieldName) => {
+    TestWalker.resetField(fieldName);
+  });
+
+  on(Events.SUITE_RUN_STARTED, () => {
+    useResetCallbacks();
+  });
+
+  on(Events.REMOVE_FIELD, (fieldName: TFieldName) => {
+    TestWalker.removeTestByFieldName(fieldName);
+  });
+
+  on(Events.RESET_SUITE, () => {
+    useResetSuite();
+  });
+
+  return VestBus;
+
+  function on(event: Events, cb: (...args: any[]) => void) {
+    VestBus.on(event, (...args: any[]) => {
+      // This is more concise, but it might be an overkill
+      // if we're adding events that don't need to invalidate the cache
+      useExpireSuiteResultCache();
+      cb(...args);
+    });
+  }
+}
+
+export enum Events {
+  TEST_RUN_STARTED = 'test_run_started',
+  TEST_COMPLETED = 'test_completed',
+  ALL_RUNNING_TESTS_FINISHED = 'all_running_tests_finished',
+  REMOVE_FIELD = 'remove_field',
+  RESET_FIELD = 'reset_field',
+  RESET_SUITE = 'reset_suite',
+  SUITE_CALLBACK_DONE_RUNNING = 'suite_callback_done_running', // TODO: IMPLEMENT
+  SUITE_RUN_STARTED = 'suite_run_started',
+}

package/src/core/context/PersistedContext.ts

@@ -0,0 +1,243 @@
+import { createCascade } from 'context';
+import {
+  invariant,
+  deferThrow,
+  isNullish,
+  CB,
+  seq,
+  cache,
+  assign,
+  BusType,
+  TinyState,
+  tinyState,
+  CacheApi,
+} from 'vest-utils';
+
+import { OptionalFields } from 'OptionalTypes';
+import { SuiteName, SuiteResult, TFieldName } from 'SuiteResultTypes';
+import { Events, initVestBus } from 'VestBus';
+import { Isolate } from 'isolate';
+
+const suiteResultCache = cache<SuiteResult<TFieldName>>();
+
+export const PersistedContext = createCascade<CTXType>(
+  (vestState, parentContext) => {
+    if (parentContext) {
+      return null;
+    }
+
+    invariant(vestState.historyRoot);
+
+    const [historyRootNode] = vestState.historyRoot();
+
+    const ctxRef = {} as CTXType;
+
+    assign(
+      ctxRef,
+      {
+        historyNode: historyRootNode,
+        optional: {},
+        runtimeNode: null,
+        runtimeRoot: null,
+      },
+      vestState
+    );
+
+    return ctxRef;
+  }
+);
+
+export function createVestState({
+  suiteName,
+}: {
+  suiteName?: SuiteName;
+}): StateType {
+  const stateRef: StateType = {
+    VestBus: initVestBus(),
+    doneCallbacks: tinyState.createTinyState<DoneCallbacks>(() => []),
+    fieldCallbacks: tinyState.createTinyState<FieldCallbacks>(() => ({})),
+    historyRoot: tinyState.createTinyState<Isolate | null>(null),
+    optional: {},
+    suiteId: seq(),
+    suiteName,
+    suiteResultCache,
+  };
+
+  return stateRef;
+}
+
+export function persist<T extends CB>(cb: T): T {
+  const prev = PersistedContext.useX();
+
+  return function persisted(...args: Parameters<T>): ReturnType<T> {
+    const ctxToUse = PersistedContext.use() ?? prev;
+    return PersistedContext.run(ctxToUse, () => cb(...args));
+  } as T;
+}
+
+export function useSuiteResultCache(action: () => SuiteResult<TFieldName>) {
+  const suiteResultCache = PersistedContext.useX().suiteResultCache;
+
+  return suiteResultCache([useSuiteId()], action);
+}
+
+export function useExpireSuiteResultCache() {
+  const suiteResultCache = PersistedContext.useX().suiteResultCache;
+  suiteResultCache.invalidate([useSuiteId()]);
+}
+
+export function useResetCallbacks() {
+  const [, , resetDoneCallbacks] = useDoneCallbacks();
+  const [, , resetFieldCallbacks] = useFieldCallbacks();
+
+  resetDoneCallbacks();
+  resetFieldCallbacks();
+}
+
+export function useResetSuite() {
+  useResetCallbacks();
+  const [, , resetHistoryRoot] = useHistoryRoot();
+
+  resetHistoryRoot();
+}
+
+type CTXType = StateType & {
+  historyNode: Isolate | null;
+  runtimeNode: Isolate | null;
+  runtimeRoot: Isolate | null;
+};
+
+type StateType = {
+  historyRoot: TinyState<Isolate | null>;
+  doneCallbacks: TinyState<DoneCallbacks>;
+  fieldCallbacks: TinyState<FieldCallbacks>;
+  suiteName: string | undefined;
+  suiteId: string;
+  optional: OptionalFields;
+  VestBus: BusType;
+  suiteResultCache: CacheApi<SuiteResult<TFieldName>>;
+};
+
+type FieldCallbacks = Record<string, DoneCallbacks>;
+type DoneCallbacks = Array<DoneCallback>;
+
+export function useVestBus() {
+  return PersistedContext.useX().VestBus;
+}
+
+/*
+  Returns an emitter, but it also has a shortcut for emitting an event immediately
+  by passing an event name.
+*/
+export function useEmit() {
+  return persist(useVestBus().emit);
+}
+
+export function prepareEmitter<T = void>(event: Events): (arg: T) => void {
+  const emit = useEmit();
+
+  return (arg: T) => emit(event, arg);
+}
+
+export type DoneCallback = (res: SuiteResult<TFieldName>) => void;
+
+export function useOptionalFields(): OptionalFields {
+  return PersistedContext.useX().optional;
+}
+
+export function useOptionalField(fieldName: TFieldName) {
+  return useOptionalFields()[fieldName] ?? {};
+}
+
+export function useDoneCallbacks() {
+  return PersistedContext.useX().doneCallbacks();
+}
+
+export function useFieldCallbacks() {
+  return PersistedContext.useX().fieldCallbacks();
+}
+
+export function useHistoryRoot() {
+  return PersistedContext.useX().historyRoot();
+}
+
+export function useHistoryNode() {
+  return PersistedContext.useX().historyNode;
+}
+
+export function useSuiteName() {
+  return PersistedContext.useX().suiteName;
+}
+
+export function useSuiteId() {
+  return PersistedContext.useX().suiteId;
+}
+
+export function useSetHistory(history: Isolate) {
+  const context = PersistedContext.useX();
+
+  const [, setHistoryRoot] = context.historyRoot();
+  setHistoryRoot(history);
+}
+
+export function useHistoryKey(key?: string | null): Isolate | null {
+  if (isNullish(key)) {
+    return null;
+  }
+
+  const historyNode = PersistedContext.useX().historyNode;
+
+  return historyNode?.keys[key] ?? null;
+}
+
+export function useIsolate() {
+  return PersistedContext.useX().runtimeNode ?? null;
+}
+
+export function useCurrentCursor() {
+  return useIsolate()?.cursor() ?? 0;
+}
+
+export function useRuntimeRoot() {
+  return PersistedContext.useX().runtimeRoot;
+}
+
+export function useSetNextIsolateChild(child: Isolate): void {
+  const currentIsolate = useIsolate();
+
+  invariant(currentIsolate, 'Not within an active isolate');
+
+  currentIsolate.addChild(child);
+}
+
+export function useSetIsolateKey(key: string | null, value: Isolate): void {
+  if (!key) {
+    return;
+  }
+
+  const currentIsolate = useIsolate();
+
+  invariant(currentIsolate, 'Not within an active isolate');
+
+  if (isNullish(currentIsolate.keys[key])) {
+    currentIsolate.keys[key] = value;
+
+    return;
+  }
+
+  deferThrow(
+    `Encountered the same test key "${key}" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted.`
+  );
+}
+
+export function useAvailableSuiteRoot(): Isolate | null {
+  const root = useRuntimeRoot();
+
+  if (root) {
+    return root;
+  }
+
+  const [historyRoot] = useHistoryRoot();
+
+  return historyRoot;
+}

package/src/core/context/SuiteContext.ts

@@ -0,0 +1,74 @@
+import { createCascade } from 'context';
+import { assign, TinyState, tinyState, cache, CacheApi } from 'vest-utils';
+
+import { IsolateTest } from 'IsolateTest';
+import { Modes } from 'mode';
+
+export const SuiteContext = createCascade<CTXType>((ctxRef, parentContext) => {
+  if (parentContext) {
+    return null;
+  }
+
+  return assign(
+    {
+      exclusion: {
+        tests: {},
+        groups: {},
+      },
+      inclusion: {},
+      mode: tinyState.createTinyState<Modes>(Modes.ALL),
+      testMemoCache,
+    },
+    ctxRef
+  );
+});
+
+type CTXType = {
+  exclusion: TExclusion;
+  inclusion: Record<string, boolean | (() => boolean)>;
+  currentTest?: IsolateTest;
+  groupName?: string;
+  skipped?: boolean;
+  omitted?: boolean;
+  mode: TinyState<Modes>;
+  testMemoCache: CacheApi<IsolateTest>;
+};
+
+export type TExclusion = {
+  tests: Record<string, boolean>;
+  groups: Record<string, boolean>;
+};
+
+export function useCurrentTest(msg?: string) {
+  return SuiteContext.useX(msg).currentTest;
+}
+
+export function useGroupName() {
+  return SuiteContext.useX().groupName;
+}
+
+export function useExclusion(hookError?: string) {
+  return SuiteContext.useX(hookError).exclusion;
+}
+
+export function useInclusion() {
+  return SuiteContext.useX().inclusion;
+}
+
+export function useMode() {
+  return SuiteContext.useX().mode();
+}
+
+export function useSkipped() {
+  return SuiteContext.useX().skipped ?? false;
+}
+
+export function useOmitted() {
+  return SuiteContext.useX().omitted ?? false;
+}
+
+const testMemoCache = cache<IsolateTest>(10);
+
+export function useTestMemoCache() {
+  return SuiteContext.useX().testMemoCache;
+}