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

package/src/__tests__/integration.stateful-async.test.ts

@@ -0,0 +1,137 @@
+import wait from 'wait';
+
+import { dummyTest } from '../../testUtils/testDummy';
+import { TestPromise } from '../../testUtils/testPromise';
+
+import * as vest from 'vest';
+
+type SuiteParams = { skip?: string; skipGroup?: string };
+
+const suite = () =>
+  vest.create(({ skip, skipGroup }: SuiteParams = {}) => {
+    vest.skip(skip);
+    vest.skip.group(skipGroup);
+
+    vest.group('group', () => {
+      dummyTest.failingAsync('field_1', { message: 'field_1_group_message' });
+      dummyTest.failingAsync('field_4', { message: 'field_4_group_message' });
+    });
+
+    dummyTest.failing('field_1', 'field_message_1');
+
+    dummyTest.failingAsync('field_2', {
+      time: 50,
+      message: 'rejection_message_1',
+    });
+
+    dummyTest.passing('field_2', 'field_message_2');
+
+    dummyTest.passingAsync('field_3', { message: 'field_message_3' });
+    dummyTest.failingAsync('field_3', { message: 'field_message_3' });
+  });
+
+let validate: vest.Suite<({ skip, skipGroup }: SuiteParams) => void, string>;
+let callback_1 = jest.fn(),
+  callback_2 = jest.fn(),
+  callback_3 = jest.fn(),
+  callback_4 = jest.fn(),
+  control = jest.fn();
+
+describe('Stateful async tests', () => {
+  beforeEach(() => {
+    callback_1 = jest.fn();
+    callback_2 = jest.fn();
+    callback_3 = jest.fn();
+    callback_4 = jest.fn();
+    control = jest.fn();
+    validate = suite();
+  });
+
+  it('Should only run callbacks for last suite run', () =>
+    TestPromise(done => {
+      validate({}).done(callback_1).done('field_3', callback_2);
+      expect(callback_1).not.toHaveBeenCalled();
+      expect(callback_2).not.toHaveBeenCalled();
+      validate({}).done(callback_3).done('field_3', callback_4);
+      expect(callback_3).not.toHaveBeenCalled();
+      expect(callback_4).not.toHaveBeenCalled();
+      setTimeout(() => {
+        expect(callback_1).not.toHaveBeenCalled();
+        expect(callback_2).not.toHaveBeenCalled();
+        expect(callback_3).not.toHaveBeenCalled();
+        expect(callback_4).toHaveBeenCalled();
+        control();
+      });
+      setTimeout(() => {
+        expect(callback_1).not.toHaveBeenCalled();
+        expect(callback_2).not.toHaveBeenCalled();
+        expect(callback_3).toHaveBeenCalledTimes(1);
+        expect(control).toHaveBeenCalled();
+        done();
+      }, 50);
+    }));
+
+  it('Merges skipped validations from previous suite', () =>
+    TestPromise(done => {
+      const res = validate({ skipGroup: 'group', skip: 'field_3' });
+      expect(res.testCount).toBe(3);
+      expect(res.errorCount).toBe(1);
+      expect(res.warnCount).toBe(0);
+      expect(res.hasErrors('field_1')).toBe(true);
+      expect(res.tests.field_1.errorCount).toBe(1);
+      expect(res.hasErrors('field_2')).toBe(false);
+      expect(res.hasErrors('field_3')).toBe(false);
+      expect(res.hasErrors('field_4')).toBe(false);
+      expect(res).toMatchSnapshot();
+      setTimeout(() => {
+        const res = validate.get();
+
+        expect(res.testCount).toBe(3);
+        expect(res.errorCount).toBe(2);
+        expect(res.warnCount).toBe(0);
+        expect(res.tests.field_1.errorCount).toBe(1);
+        expect(res.hasErrors('field_2')).toBe(true);
+        expect(res.hasErrors('field_3')).toBe(false);
+        expect(res.hasErrors('field_4')).toBe(false);
+        expect(res).toMatchSnapshot();
+
+        validate({ skip: 'field_2' }).done(res => {
+          expect(res.testCount).toBe(7);
+          expect(res.errorCount).toBe(5);
+          expect(res.warnCount).toBe(0);
+          expect(res.tests.field_1.errorCount).toBe(2);
+          expect(res.hasErrors('field_2')).toBe(true);
+          expect(res.hasErrors('field_3')).toBe(true);
+          expect(res.hasErrors('field_4')).toBe(true);
+          expect(res).toMatchSnapshot();
+          done();
+        });
+      }, 50);
+    }));
+
+  it('Should discard of re-tested async tests', async () => {
+    const tests: Array<vest.IsolateTest> = [];
+    const control = jest.fn();
+    const suite = vest.create(() => {
+      tests.push(
+        vest.test('field_1', tests.length.toString(), async () => {
+          await wait(100);
+          throw new Error();
+        })
+      );
+    });
+    suite().done(() => {
+      control(0);
+    });
+    await wait(5);
+    suite().done(() => {
+      control(1);
+    });
+    await wait(100);
+    expect(control).toHaveBeenCalledTimes(1);
+    expect(control).toHaveBeenCalledWith(1);
+
+    expect(tests[0].isCanceled()).toBe(true);
+    expect(tests[1].isFailing()).toBe(true);
+  });
+});

package/src/__tests__/integration.stateful-tests.test.ts

@@ -0,0 +1,155 @@
+import { enforce } from 'n4s';
+
+import * as vest from 'vest';
+
+describe('Stateful behavior', () => {
+  let result;
+  const validate = genSuite();
+
+  test('Should merge skipped fields with previous values', () => {
+    result = validate({ only: 'field_1' });
+    expect(result.tests.field_1.errorCount).toBe(1);
+    expect(result.errorCount).toBe(1);
+    expect(Object.keys(result.tests)).toHaveLength(5); // including 4 skipped tests
+    expect(result.tests).toHaveProperty('field_1');
+    expect(result).toMatchSnapshot();
+
+    result = validate({ only: 'field_5' });
+    expect(result.errorCount).toBe(3);
+    expect(result.tests.field_1.errorCount).toBe(1);
+    expect(result.tests.field_5.errorCount).toBe(2);
+    expect(Object.keys(result.tests)).toHaveLength(5); // including 4 skipped tests
+    expect(result.tests).toHaveProperty('field_1');
+    expect(result.tests).toHaveProperty('field_5');
+    expect(result).toMatchSnapshot();
+
+    result = validate();
+    expect(result.errorCount).toBe(4);
+    expect(result.tests.field_1.errorCount).toBe(1);
+    expect(result.tests.field_2.errorCount).toBe(1);
+    expect(result.tests.field_4.warnCount).toBe(1);
+    expect(result.tests.field_5.errorCount).toBe(2);
+    expect(Object.keys(result.tests)).toHaveLength(5);
+    expect(result).toMatchSnapshot();
+  });
+});
+
+describe('more complex', () => {
+  const data: Record<string, string> = {};
+
+  it('Should run correctly', () => {
+    expect(suite.get().hasErrors()).toBe(false);
+    expect(suite.get()).toMatchSnapshot();
+
+    data.username = 'user_1';
+    suite(data, 'username');
+
+    expect(suite.get().hasErrors()).toBe(false);
+    expect(suite.get()).toMatchSnapshot();
+
+    suite(data, 'password');
+    expect(suite.get().hasErrors()).toBe(true);
+    expect(suite.get().tests.password).toMatchInlineSnapshot(`
+      {
+        "errorCount": 1,
+        "errors": [
+          "password is required",
+        ],
+        "testCount": 1,
+        "valid": false,
+        "warnCount": 0,
+        "warnings": [],
+      }
+    `);
+    expect(suite.get()).toMatchSnapshot();
+
+    suite(data, 'confirm');
+    expect(suite.get().tests.confirm).toMatchInlineSnapshot(`
+      {
+        "errorCount": 0,
+        "errors": [],
+        "testCount": 0,
+        "valid": false,
+        "warnCount": 0,
+        "warnings": [],
+      }
+    `);
+    expect(suite.get()).toMatchSnapshot();
+    expect(suite.get().hasErrors('password')).toBe(true);
+    expect(suite.get().hasErrors('confirm')).toBe(false);
+
+    data.password = '123456';
+    suite(data, 'password');
+    expect(suite.get().tests.confirm).toMatchInlineSnapshot(`
+      {
+        "errorCount": 0,
+        "errors": [],
+        "testCount": 0,
+        "valid": false,
+        "warnCount": 0,
+        "warnings": [],
+      }
+    `);
+    data.confirm = '123456';
+    suite(data, 'confirm');
+    expect(suite.get().hasErrors('password')).toBe(false);
+    expect(suite.get().hasErrors('confirm')).toBe(false);
+    expect(suite.get().tests.confirm).toMatchInlineSnapshot(`
+      {
+        "errorCount": 0,
+        "errors": [],
+        "testCount": 1,
+        "valid": true,
+        "warnCount": 0,
+        "warnings": [],
+      }
+    `);
+  });
+
+  const suite = vest.create(
+    (data: Record<string, unknown> = {}, only: string) => {
+      vest.only(only);
+
+      vest.test('username', 'username is required', () => {
+        enforce(data.username).isNotEmpty();
+      });
+
+      vest.test('username', 'username must be at least 3 characters', () => {
+        enforce(data.username).longerThanOrEquals(3);
+      });
+
+      vest.test('password', 'password is required', () => {
+        enforce(data.password).isNotEmpty();
+      });
+
+      vest.skipWhen(
+        draft => draft.hasErrors('password'),
+        () => {
+          vest.test('confirm', 'passwords do not match', () => {
+            enforce(data.confirm).equals(data.password);
+          });
+        }
+      );
+    }
+  );
+});
+
+function genSuite() {
+  return vest.create(({ only }: { only?: string | string[] } = {}) => {
+    vest.only(only);
+    vest.test('field_1', 'field_statement_1', () => false);
+    vest.test('field_2', 'field_statement_2', () => {
+      enforce(2).equals(3);
+    });
+    vest.test('field_3', 'field_statement_3', jest.fn());
+    vest.test('field_4', 'field_statement_4', () => {
+      vest.warn();
+      throw new Error();
+    });
+    vest.test('field_4', 'field_statement_4', () => {
+      vest.warn();
+    });
+    vest.test('field_5', 'field_statement_5', () => false);
+    vest.test('field_5', 'field_statement_6', () => false);
+  });
+}

package/src/__tests__/isolate.test.ts

@@ -0,0 +1,288 @@
+import { CB } from 'vest-utils';
+import { TDeferThrow } from 'vest-utils/src/deferThrow';
+
+import { TVestMock } from '../../testUtils/TVestMock';
+import mockThrowError from '../../testUtils/mockThrowError';
+import { TDummyTest } from '../../testUtils/testDummy';
+
+import { IsolateTypes } from 'IsolateTypes';
+
+describe('isolate', () => {
+  let vest: TVestMock;
+  let firstRun = true;
+  // eslint-disable-next-line no-unused-expressions
+  require('IsolateTest').IsolateTest;
+  let Isolate = require('isolate').Isolate;
+  let dummyTest: TDummyTest;
+  let deferThrow: TDeferThrow;
+
+  beforeEach(() => {
+    firstRun = true;
+    const mock = mockThrowError();
+    deferThrow = mock.deferThrow;
+    // eslint-disable-next-line no-unused-expressions
+    require('IsolateTest').IsolateTest;
+    Isolate = require('isolate').Isolate;
+    vest = mock.vest;
+    dummyTest = require('../../testUtils/testDummy').dummyTest;
+  });
+
+  afterEach(() => {
+    jest.resetModules();
+    jest.resetAllMocks();
+  });
+
+  describe('Base behavior', () => {
+    it("Should throw an error if the callback isn't a function", () => {
+      expect(() => Isolate.create({}, 'not a function')).toThrow();
+    });
+
+    it('Should retain test results between runs', () => {
+      const f1 = jest.fn(() => false);
+      const f2 = jest.fn(() => false);
+      const suite = genSuite(() => {
+        vest.skipWhen(!firstRun, () => {
+          Isolate.create({ type: IsolateTypes.DEFAULT }, () => {
+            vest.test('f1', f1);
+            vest.test('f2', f2);
+          });
+        });
+      });
+
+      suite();
+      expect(suite.get().hasErrors('f1')).toBe(true);
+      expect(suite.get().hasErrors('f2')).toBe(true);
+      expect(f1).toHaveBeenCalledTimes(1);
+      expect(f2).toHaveBeenCalledTimes(1);
+      suite();
+      expect(suite.get().hasErrors('f1')).toBe(true);
+      expect(suite.get().hasErrors('f2')).toBe(true);
+      expect(f1).toHaveBeenCalledTimes(1);
+      expect(f2).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('When order changes within the isolate', () => {
+    it('Should contain test order changes within the isolate', () => {
+      const suite = genSuite(() => {
+        dummyTest.failing('f1');
+
+        Isolate.create({ type: IsolateTypes.EACH }, () => {
+          dummyTest.failing('f2');
+          if (!firstRun) {
+            dummyTest.failing('f3');
+            dummyTest.failing('f4');
+          }
+        });
+
+        vest.skipWhen(!firstRun, () => {
+          dummyTest.failing('f5');
+        });
+      });
+
+      suite();
+      expect(suite.get().hasErrors('f1')).toBe(true);
+      expect(suite.get().hasErrors('f2')).toBe(true);
+      expect(suite.get().hasErrors('f3')).toBe(false);
+      expect(suite.get().hasErrors('f4')).toBe(false);
+      expect(suite.get().hasErrors('f5')).toBe(true);
+      expect(suite.get().tests.f1).toBeDefined();
+      expect(suite.get().tests.f2).toBeDefined();
+      expect(suite.get().tests.f3).toBeUndefined();
+      expect(suite.get().tests.f4).toBeUndefined();
+      expect(suite.get().tests.f5).toBeDefined();
+
+      suite();
+      expect(suite.get().hasErrors('f1')).toBe(true);
+      expect(suite.get().hasErrors('f2')).toBe(true);
+      expect(suite.get().hasErrors('f3')).toBe(true);
+      expect(suite.get().hasErrors('f4')).toBe(true);
+
+      // without "isolate" this assertion would fail
+      // because the test would have been overwritten
+      expect(suite.get().hasErrors('f5')).toBe(true);
+
+      expect(suite.get().tests.f1).toBeDefined();
+      expect(suite.get().tests.f2).toBeDefined();
+      expect(suite.get().tests.f3).toBeDefined();
+      expect(suite.get().tests.f4).toBeDefined();
+      expect(suite.get().tests.f5).toBeDefined();
+    });
+
+    it('Should only retain the state of the unmoved state before the order index', () => {
+      const suite = genSuite(() => {
+        Isolate.create({ type: IsolateTypes.EACH }, () => {
+          vest.skipWhen(!firstRun, () => {
+            dummyTest.failing('f1');
+          });
+          if (!firstRun) {
+            dummyTest.failing('f2');
+          }
+          vest.skipWhen(!firstRun, () => {
+            dummyTest.failing('f3');
+          });
+        });
+
+        suite();
+        expect(suite.get().hasErrors('f1')).toBe(true);
+        expect(suite.get().hasErrors('f2')).toBe(false);
+        expect(suite.get().hasErrors('f3')).toBe(true);
+        expect(suite.get().tests.f1).toBeDefined();
+        expect(suite.get().tests.f2).toBeUndefined();
+        expect(suite.get().tests.f3).toBeDefined();
+
+        suite();
+        expect(suite.get().hasErrors('f1')).toBe(true);
+        expect(suite.get().hasErrors('f2')).toBe(true);
+        expect(suite.get().hasErrors('f3')).toBe(false);
+        expect(suite.get().tests.f1).toBeDefined();
+        expect(suite.get().tests.f2).toBeDefined();
+        expect(suite.get().tests.f3).toBeDefined();
+      });
+    });
+  });
+
+  describe('When test order changes before the isolate opens', () => {
+    it('Should clean up follow up tests. Reregister', () => {
+      const suite = genSuite(() => {
+        dummyTest.failing('f1');
+        if (!firstRun) {
+          dummyTest.failing('f6');
+        }
+
+        // this way we can tell if the state is kept or discarded.
+        // if the state is kept, they should be invalid. Otherwise
+        // they should be untested.
+        vest.skipWhen(!firstRun, () => {
+          Isolate.create({ type: IsolateTypes.EACH }, () => {
+            dummyTest.failing('f2');
+            dummyTest.failing('f3');
+            dummyTest.failing('f4');
+          });
+
+          dummyTest.failing('f5');
+        });
+      });
+
+      suite();
+      expect(suite.get().hasErrors('f1')).toBe(true);
+      expect(suite.get().hasErrors('f2')).toBe(true);
+      expect(suite.get().hasErrors('f3')).toBe(true);
+      expect(suite.get().hasErrors('f4')).toBe(true);
+      expect(suite.get().hasErrors('f5')).toBe(true);
+      expect(suite.get().hasErrors('f6')).toBe(false);
+      expect(suite.get().tests.f1).toBeDefined();
+      expect(suite.get().tests.f2).toBeDefined();
+      expect(suite.get().tests.f3).toBeDefined();
+      expect(suite.get().tests.f4).toBeDefined();
+      expect(suite.get().tests.f5).toBeDefined();
+      expect(suite.get().tests.f6).toBeUndefined();
+
+      suite();
+      expect(suite.get().hasErrors('f1')).toBe(true);
+      expect(suite.get().hasErrors('f2')).toBe(false);
+      expect(suite.get().hasErrors('f3')).toBe(false);
+      expect(suite.get().hasErrors('f4')).toBe(false);
+      expect(suite.get().hasErrors('f5')).toBe(false);
+      expect(suite.get().hasErrors('f6')).toBe(true);
+      expect(suite.get().tests.f1).toBeDefined();
+      expect(suite.get().tests.f2).toBeDefined();
+      expect(suite.get().tests.f3).toBeDefined();
+      expect(suite.get().tests.f4).toBeDefined();
+      expect(suite.get().tests.f5).toBeDefined();
+      expect(suite.get().tests.f6).toBeDefined();
+    });
+  });
+
+  describe('When an incorrect isolate is encountered', () => {
+    it('Should replace isolate completely', () => {
+      const suite = genSuite(() => {
+        if (firstRun) {
+          Isolate.create({ type: IsolateTypes.EACH }, () => {
+            dummyTest.failing('f1');
+          });
+        } else {
+          Isolate.create({ type: IsolateTypes.EACH }, () => {
+            dummyTest.failing('f2');
+          });
+        }
+      });
+
+      suite();
+      expect(suite.get().hasErrors('f1')).toBe(true);
+      expect(suite.get().hasErrors('f2')).toBe(false);
+      expect(suite.get().tests.f1).toBeDefined();
+      expect(suite.get().tests.f2).toBeUndefined();
+      suite();
+      expect(suite.get().hasErrors('f1')).toBe(false);
+      expect(suite.get().hasErrors('f2')).toBe(true);
+      expect(suite.get().tests.f1).toBeUndefined();
+      expect(suite.get().tests.f2).toBeDefined();
+    });
+  });
+
+  describe('When an isolate is present when a test was expected', () => {
+    it('Should erase test history, and re-register', () => {
+      const suite = genSuite(() => {
+        if (firstRun) {
+          dummyTest.failing('f1');
+        } else {
+          Isolate.create({ type: IsolateTypes.EACH }, () => {
+            dummyTest.failing('f2');
+          });
+        }
+      });
+
+      suite();
+      expect(suite.get().hasErrors('f1')).toBe(true);
+      expect(suite.get().hasErrors('f2')).toBe(false);
+      expect(suite.get().tests.f1).toBeDefined();
+      expect(suite.get().tests.f2).toBeUndefined();
+      suite();
+      expect(suite.get().hasErrors('f1')).toBe(false);
+      expect(suite.get().hasErrors('f2')).toBe(true);
+      expect(suite.get().tests.f1).toBeUndefined();
+      expect(suite.get().tests.f2).toBeDefined();
+    });
+
+    describe('Errors', () => {
+      it('should throw a deferred error when the tests are out of order', () => {
+        const suite = genSuite(() => {
+          Isolate.create({ type: IsolateTypes.GROUP }, () => {
+            dummyTest.failing(firstRun ? 'f1' : 'f2');
+          });
+        });
+
+        suite();
+        expect(deferThrow).toHaveBeenCalledTimes(0);
+        suite();
+        expect(deferThrow).toHaveBeenCalledTimes(1);
+        expect(deferThrow).toHaveBeenCalledWith(
+          expect.stringContaining(
+            'Vest Critical Error: Tests called in different order than previous run'
+          )
+        );
+      });
+
+      it('Should allow unordered tests within an each isolate', () => {
+        const suite = genSuite(() => {
+          Isolate.create(IsolateTypes.EACH, () => {
+            dummyTest.failing(firstRun ? 'f1' : 'f2');
+          });
+        });
+
+        suite();
+        expect(deferThrow).toHaveBeenCalledTimes(0);
+        suite();
+        expect(deferThrow).toHaveBeenCalledTimes(0);
+      });
+    });
+  });
+
+  function genSuite(cb: CB) {
+    return vest.create(() => {
+      cb();
+      firstRun = false;
+    });
+  }
+});

package/src/__tests__/state_refill.test.ts

@@ -0,0 +1,41 @@
+import * as vest from 'vest';
+
+describe('state refill', () => {
+  it('Should refill test state according to the execution order', () => {
+    const suiteStates: vest.SuiteResult<string>[][] = [];
+    const suite = vest.create(() => {
+      const currentRun = [suite.get()];
+      expect(suite.get().hasErrors('field1')).toBe(false);
+      vest.test('field1', () => false);
+      expect(suite.get().tests.field1.errorCount).toBe(1);
+      currentRun.push(suite.get());
+      vest.test('field1', () => false);
+      expect(suite.get().tests.field1.errorCount).toBe(2);
+      currentRun.push(suite.get());
+      expect(suite.get().hasErrors('field2')).toBe(false);
+      vest.test('field2', () => false);
+      currentRun.push(suite.get());
+      vest.test('field2', () => true);
+      expect(suite.get().tests.field2.errorCount).toBe(1);
+      currentRun.push(suite.get());
+      expect(suite.get().hasErrors('field3')).toBe(false);
+      vest.test('field3', () => undefined);
+      expect(suite.get().hasErrors('field3')).toBe(false);
+      expect(suite.get().tests.field3.errorCount).toBe(0);
+      currentRun.push(suite.get());
+      expect(suite.get().hasWarnings('field4')).toBe(false);
+      vest.test('field4', () => {
+        vest.warn();
+        return false;
+      });
+      expect(suite.get().hasWarnings('field4')).toBe(true);
+      currentRun.push(suite.get());
+      suiteStates.push(currentRun);
+    });
+
+    expect(suite()).isDeepCopyOf(suite());
+    suiteStates[0].forEach((suiteState, i) => {
+      expect(suiteState).isDeepCopyOf(suiteStates[1][i]);
+    });
+  });
+});

package/src/core/SuiteWalker/SuiteWalker.ts

@@ -0,0 +1,64 @@
+import * as walker from 'walker';
+
+import { useAvailableSuiteRoot } from 'PersistedContext';
+import type { Isolate } from 'isolate';
+
+export class SuiteWalker {
+  static walk(
+    callback: (isolate: Isolate, breakout: () => void) => void,
+    visitOnly?: walker.VisitOnlyPredicate
+  ): void {
+    const root = useAvailableSuiteRoot();
+
+    if (!root) return;
+
+    walker.walk(root, callback, visitOnly);
+  }
+
+  static some(
+    predicate: (node: Isolate) => boolean,
+    visitOnly?: walker.VisitOnlyPredicate
+  ): boolean {
+    const root = useAvailableSuiteRoot();
+
+    if (!root) return false;
+    return walker.some(root, predicate, visitOnly);
+  }
+
+  static has(match: walker.VisitOnlyPredicate): boolean {
+    const root = useAvailableSuiteRoot();
+
+    if (!root) return false;
+    return walker.has(root, match);
+  }
+
+  static find(
+    predicate: (node: Isolate) => boolean,
+    visitOnly?: walker.VisitOnlyPredicate
+  ): Isolate | null {
+    const root = useAvailableSuiteRoot();
+
+    if (!root) return null;
+    return walker.find(root, predicate, visitOnly);
+  }
+
+  static every(
+    predicate: (node: Isolate) => boolean,
+    visitOnly?: walker.VisitOnlyPredicate
+  ): boolean {
+    const root = useAvailableSuiteRoot();
+
+    if (!root) return false;
+    return walker.every(root, predicate, visitOnly);
+  }
+
+  static pluck(
+    predicate: (node: Isolate) => boolean,
+    visitOnly?: walker.VisitOnlyPredicate
+  ): void {
+    const root = useAvailableSuiteRoot();
+
+    if (!root) return;
+    return walker.pluck(root, predicate, visitOnly);
+  }
+}