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

package/src/core/test/__tests__/__snapshots__/test.test.ts.snap

@@ -0,0 +1,231 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Test Vest's \`test\` function test params creates a test with a message and with a key 1`] = `
+IsolateTest {
+  "children": null,
+  "fieldName": "field_name",
+  "id": "23",
+  "key": "keyboardcat",
+  "keys": {},
+  "message": "failure message",
+  "output": undefined,
+  "parent": Isolate {
+    "children": [
+      [Circular],
+    ],
+    "key": null,
+    "keys": {
+      "keyboardcat": [Circular],
+    },
+    "output": {
+      "done": [Function],
+      "errorCount": 0,
+      "getErrors": [Function],
+      "getErrorsByGroup": [Function],
+      "getWarnings": [Function],
+      "getWarningsByGroup": [Function],
+      "groups": {},
+      "hasErrors": [Function],
+      "hasErrorsByGroup": [Function],
+      "hasWarnings": [Function],
+      "hasWarningsByGroup": [Function],
+      "isValid": [Function],
+      "isValidByGroup": [Function],
+      "suiteName": undefined,
+      "testCount": 1,
+      "tests": {
+        "field_name": {
+          "errorCount": 0,
+          "errors": [],
+          "testCount": 1,
+          "valid": true,
+          "warnCount": 0,
+          "warnings": [],
+        },
+      },
+      "valid": true,
+      "warnCount": 0,
+    },
+    "parent": null,
+    "type": "SUITE",
+  },
+  "severity": "error",
+  "stateMachine": {
+    "getState": [Function],
+    "transition": [Function],
+  },
+  "testFn": [Function],
+  "type": "TEST",
+}
+`;
+
+exports[`Test Vest's \`test\` function test params creates a test without a key 1`] = `
+IsolateTest {
+  "children": null,
+  "fieldName": "field_name",
+  "id": "19",
+  "key": null,
+  "keys": {},
+  "message": "failure message",
+  "output": undefined,
+  "parent": Isolate {
+    "children": [
+      [Circular],
+    ],
+    "key": null,
+    "keys": {},
+    "output": {
+      "done": [Function],
+      "errorCount": 0,
+      "getErrors": [Function],
+      "getErrorsByGroup": [Function],
+      "getWarnings": [Function],
+      "getWarningsByGroup": [Function],
+      "groups": {},
+      "hasErrors": [Function],
+      "hasErrorsByGroup": [Function],
+      "hasWarnings": [Function],
+      "hasWarningsByGroup": [Function],
+      "isValid": [Function],
+      "isValidByGroup": [Function],
+      "suiteName": undefined,
+      "testCount": 1,
+      "tests": {
+        "field_name": {
+          "errorCount": 0,
+          "errors": [],
+          "testCount": 1,
+          "valid": true,
+          "warnCount": 0,
+          "warnings": [],
+        },
+      },
+      "valid": true,
+      "warnCount": 0,
+    },
+    "parent": null,
+    "type": "SUITE",
+  },
+  "severity": "error",
+  "stateMachine": {
+    "getState": [Function],
+    "transition": [Function],
+  },
+  "testFn": [Function],
+  "type": "TEST",
+}
+`;
+
+exports[`Test Vest's \`test\` function test params creates a test without a message and with a key 1`] = `
+IsolateTest {
+  "children": null,
+  "fieldName": "field_name",
+  "id": "21",
+  "key": "keyboardcat",
+  "keys": {},
+  "output": undefined,
+  "parent": Isolate {
+    "children": [
+      [Circular],
+    ],
+    "key": null,
+    "keys": {
+      "keyboardcat": [Circular],
+    },
+    "output": {
+      "done": [Function],
+      "errorCount": 0,
+      "getErrors": [Function],
+      "getErrorsByGroup": [Function],
+      "getWarnings": [Function],
+      "getWarningsByGroup": [Function],
+      "groups": {},
+      "hasErrors": [Function],
+      "hasErrorsByGroup": [Function],
+      "hasWarnings": [Function],
+      "hasWarningsByGroup": [Function],
+      "isValid": [Function],
+      "isValidByGroup": [Function],
+      "suiteName": undefined,
+      "testCount": 1,
+      "tests": {
+        "field_name": {
+          "errorCount": 0,
+          "errors": [],
+          "testCount": 1,
+          "valid": true,
+          "warnCount": 0,
+          "warnings": [],
+        },
+      },
+      "valid": true,
+      "warnCount": 0,
+    },
+    "parent": null,
+    "type": "SUITE",
+  },
+  "severity": "error",
+  "stateMachine": {
+    "getState": [Function],
+    "transition": [Function],
+  },
+  "testFn": [Function],
+  "type": "TEST",
+}
+`;
+
+exports[`Test Vest's \`test\` function test params creates a test without a message and without a key 1`] = `
+IsolateTest {
+  "children": null,
+  "fieldName": "field_name",
+  "id": "17",
+  "key": null,
+  "keys": {},
+  "output": undefined,
+  "parent": Isolate {
+    "children": [
+      [Circular],
+    ],
+    "key": null,
+    "keys": {},
+    "output": {
+      "done": [Function],
+      "errorCount": 0,
+      "getErrors": [Function],
+      "getErrorsByGroup": [Function],
+      "getWarnings": [Function],
+      "getWarningsByGroup": [Function],
+      "groups": {},
+      "hasErrors": [Function],
+      "hasErrorsByGroup": [Function],
+      "hasWarnings": [Function],
+      "hasWarningsByGroup": [Function],
+      "isValid": [Function],
+      "isValidByGroup": [Function],
+      "suiteName": undefined,
+      "testCount": 1,
+      "tests": {
+        "field_name": {
+          "errorCount": 0,
+          "errors": [],
+          "testCount": 1,
+          "valid": true,
+          "warnCount": 0,
+          "warnings": [],
+        },
+      },
+      "valid": true,
+      "warnCount": 0,
+    },
+    "parent": null,
+    "type": "SUITE",
+  },
+  "severity": "error",
+  "stateMachine": {
+    "getState": [Function],
+    "transition": [Function],
+  },
+  "testFn": [Function],
+  "type": "TEST",
+}
+`;

package/src/core/test/__tests__/key.test.ts

@@ -0,0 +1,195 @@
+import { TDeferThrow } from 'vest-utils/src/deferThrow';
+
+import { TVestMock } from '../../../../testUtils/TVestMock';
+import mockThrowError from '../../../../testUtils/mockThrowError';
+
+import * as vest from 'vest';
+
+describe('key', () => {
+  describe('When key is provided', () => {
+    describe('When tests change their order between runs', () => {
+      it('Should retain test results', () => {
+        let count = 0;
+        const suite = vest.create(() => {
+          /**
+           * This test is pretty confusing, but its the most effective way to test this behavior.
+           *
+           * It basically checks that when provided, key is used to override default test order behavior.
+           * We don't mind the order of tests, because the key tells us which test really needs to get which state.
+           *
+           * The reason we have both skipWhen and and if block is this:
+           * if/else: to simulate reordering between runs
+           * skipWhen: to prevent running the tests so they have to get the previous state
+           */
+
+          vest.skipWhen(count === 1, () => {
+            if (count === 0) {
+              vest.test('field_1', () => false, 'field_1_key_1');
+              vest.test('field_1', () => undefined, 'field_1_key_2');
+              vest.test('field_2', () => false, 'field_2_key_1');
+              vest.test('field_2', () => undefined, 'field_2_key_2');
+            } else {
+              vest.test('field_2', () => undefined, 'field_2_key_2');
+              vest.test('field_2', () => false, 'field_2_key_1');
+              vest.test('field_1', () => undefined, 'field_1_key_2');
+              vest.test('field_1', () => false, 'field_1_key_1');
+            }
+          });
+          count++;
+        });
+
+        const res1 = suite();
+        const res2 = suite();
+
+        expect(res1.tests).toEqual(res2.tests);
+      });
+    });
+
+    describe('When two tests in two different isolates have the same key', () => {
+      it('Should regarad each key as unique and retain each tests individual result', () => {
+        const calls: vest.IsolateTest[][] = [];
+        const suite = vest.create(() => {
+          const currentCall: vest.IsolateTest[] = [];
+
+          vest.skipWhen(calls.length === 1, () => {
+            vest.group('group_1', () => {
+              currentCall.push(vest.test('field1', () => false, 'key_1'));
+            });
+
+            vest.group('group_2', () => {
+              currentCall.push(vest.test('field2', () => false, 'key_1'));
+            });
+          });
+
+          calls.push(currentCall);
+        });
+
+        const res1 = suite();
+        const res2 = suite();
+
+        expect(calls[0][0]).toBe(calls[1][0]);
+        expect(calls[0][1]).toBe(calls[1][1]);
+        expect(calls[0][0]).not.toBe(calls[0][1]);
+        expect(calls[1][0]).not.toBe(calls[1][1]);
+        expect(res1.tests).toEqual(res2.tests);
+      });
+    });
+
+    describe('When tests without a key reorder get added above a test with a key', () => {
+      let vest: TVestMock;
+      beforeEach(() => {
+        vest = mockThrowError().vest;
+      });
+      afterEach(() => {
+        jest.resetModules();
+        jest.resetAllMocks();
+      });
+      it('Should retain keyd tests', () => {
+        const calls: vest.IsolateTest[][] = [];
+        const suite = vest.create(() => {
+          const currentCall: vest.IsolateTest[] = [];
+          vest.skipWhen(calls.length === 1, () => {
+            if (calls.length === 1) {
+              vest.test('reordered', () => false);
+            }
+
+            currentCall.push(vest.test('field1', () => false, 'key_1'));
+            currentCall.push(vest.test('field2', () => false, 'key_2'));
+            currentCall.push(vest.test('field3', () => false, 'key_3'));
+
+            if (calls.length === 0) {
+              vest.test('reordered', () => false);
+            }
+          });
+          calls.push(currentCall);
+        });
+
+        const res1 = suite();
+        const res2 = suite();
+
+        expect(calls[0][0]).toBe(calls[1][0]);
+        expect(calls[0][1]).toBe(calls[1][1]);
+        expect(calls[0][2]).toBe(calls[1][2]);
+        expect(res1.tests.reordered).toEqual({
+          errorCount: 1,
+          errors: [],
+          testCount: 1,
+          valid: false,
+          warnCount: 0,
+          warnings: [],
+        });
+        expect(res2.tests.reordered).toEqual({
+          errorCount: 0,
+          errors: [],
+          testCount: 0,
+          valid: false,
+          warnCount: 0,
+          warnings: [],
+        });
+        expect(res1.tests).not.toEqual(res2.tests);
+        expect(res2.tests).toMatchInlineSnapshot(`
+          {
+            "field1": {
+              "errorCount": 1,
+              "errors": [],
+              "testCount": 1,
+              "valid": false,
+              "warnCount": 0,
+              "warnings": [],
+            },
+            "field2": {
+              "errorCount": 1,
+              "errors": [],
+              "testCount": 1,
+              "valid": false,
+              "warnCount": 0,
+              "warnings": [],
+            },
+            "field3": {
+              "errorCount": 1,
+              "errors": [],
+              "testCount": 1,
+              "valid": false,
+              "warnCount": 0,
+              "warnings": [],
+            },
+            "reordered": {
+              "errorCount": 0,
+              "errors": [],
+              "testCount": 0,
+              "valid": false,
+              "warnCount": 0,
+              "warnings": [],
+            },
+          }
+        `);
+      });
+    });
+
+    describe('When the same key is encountered twice', () => {
+      let deferThrow: TDeferThrow, vest: TVestMock;
+      beforeEach(() => {
+        const mock = mockThrowError();
+
+        deferThrow = mock.deferThrow;
+        vest = mock.vest;
+      });
+
+      afterEach(() => {
+        jest.resetAllMocks();
+        jest.resetModules();
+      });
+
+      it('Should throw a deferred error', () => {
+        const suite = vest.create(() => {
+          vest.test('field1', () => false, 'key_1');
+          vest.test('field2', () => false, 'key_1');
+        });
+        suite();
+        expect(deferThrow).toHaveBeenCalledWith(
+          `Encountered the same test key "key_1" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted.`
+        );
+      });
+    });
+  });
+});

package/src/core/test/__tests__/memo.test.ts

@@ -0,0 +1,218 @@
+import wait from 'wait';
+
+import { TestPromise } from '../../../../testUtils/testPromise';
+
+import promisify from 'promisify';
+import * as vest from 'vest';
+import { test as vestTest, enforce } from 'vest';
+
+describe('test.memo', () => {
+  describe('cache hit', () => {
+    it('Should return without calling callback', () => {
+      const cb1 = jest.fn();
+      const cb2 = jest.fn(() => TestPromise(() => undefined));
+      const suite = vest.create(() => {
+        vestTest.memo('f1', cb1, [1]);
+        vestTest.memo('f1', cb2, [2]);
+      });
+
+      suite();
+      expect(cb1).toHaveBeenCalledTimes(1);
+      expect(cb2).toHaveBeenCalledTimes(1);
+      suite();
+      expect(cb1).toHaveBeenCalledTimes(1);
+      expect(cb2).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should produce correct initial result', () => {
+      const res = vest.create(() => {
+        vestTest.memo('field1', 'msg1', () => false, [{}]);
+        vestTest.memo('field1', 'msg2', () => undefined, [{}]);
+        vestTest.memo('field2', () => undefined, [{}]);
+        vestTest.memo(
+          'field3',
+          () => {
+            vest.warn();
+            return false;
+          },
+          [{}]
+        );
+      })();
+
+      expect(res.hasErrors('field1')).toBe(true);
+      expect(res.hasErrors('field2')).toBe(false);
+      expect(res.hasWarnings('field3')).toBe(true);
+      expect(res).toMatchSnapshot();
+    });
+    describe('sync', () => {
+      it('Should restore previous result on re-run', () => {
+        const suite = vest.create(() => {
+          vestTest.memo('field1', 'msg1', () => false, [1]);
+          vestTest.memo('field1', 'msg2', () => undefined, [2]);
+          vestTest.memo('field2', () => undefined, [3]);
+          vestTest.memo(
+            'field3',
+            () => {
+              vest.warn();
+              return false;
+            },
+            [4]
+          );
+        });
+
+        const res = suite();
+
+        expect(res.hasErrors('field1')).toBe(true);
+        expect(res.hasErrors('field2')).toBe(false);
+        expect(res.hasWarnings('field3')).toBe(true);
+        expect(res).toMatchSnapshot();
+
+        const res2 = suite();
+        expect(res2.hasErrors('field1')).toBe(true);
+        expect(res2.hasErrors('field2')).toBe(false);
+        expect(res2.hasWarnings('field3')).toBe(true);
+        expect(res).isDeepCopyOf(res2);
+      });
+    });
+
+    describe('async', () => {
+      it('Should immediately return previous result on re-run', async () => {
+        {
+          const suite = vest.create(() => {
+            vestTest.memo(
+              'field1',
+              async () => {
+                await wait(500);
+                enforce(1).equals(2);
+              },
+              [1]
+            );
+            vestTest.memo(
+              'field2',
+              async () => {
+                await wait(500);
+                enforce(1).equals(2);
+              },
+              [2]
+            );
+          });
+
+          const asyncSuite = promisify(suite);
+
+          let start = Date.now();
+          const res1 = await asyncSuite();
+          enforce(Date.now() - start).gte(500);
+
+          start = Date.now();
+          const res2 = suite();
+
+          expect(res1).isDeepCopyOf(res2);
+        }
+      });
+    });
+
+    describe('Test is canceled', () => {
+      it('Should refresh', async () => {
+        let count = 0;
+        const tests: vest.IsolateTest[] = [];
+        const suite = vest.create(() => {
+          count++;
+
+          tests.push(
+            vestTest.memo(
+              'f1',
+              async () => {
+                await wait(10);
+              },
+              [true]
+            )
+          );
+
+          if (count === 1) {
+            tests[0].cancel();
+          }
+        });
+
+        suite();
+        suite();
+        suite();
+
+        expect(tests[0]).not.toBe(tests[1]);
+        expect(tests[1]).toBe(tests[2]);
+      });
+    });
+  });
+
+  describe('cache miss', () => {
+    it('Should run test normally', () => {
+      const cb1 = jest.fn(res => res);
+      const cb2 = jest.fn(
+        res => new Promise<void>((resolve, rej) => (res ? resolve() : rej()))
+      );
+      const suite = vest.create((key, res) => {
+        vestTest.memo('f1', () => cb1(res), [1, key]);
+        vestTest.memo('f2', () => cb2(res), [2, key]);
+      });
+
+      expect(cb1).toHaveBeenCalledTimes(0);
+      expect(cb2).toHaveBeenCalledTimes(0);
+      suite('a', false);
+      expect(cb1).toHaveBeenCalledTimes(1);
+      expect(cb2).toHaveBeenCalledTimes(1);
+      expect(suite.get().hasErrors()).toBe(true);
+      suite('b', true);
+      expect(cb1).toHaveBeenCalledTimes(2);
+      expect(cb2).toHaveBeenCalledTimes(2);
+      expect(suite.get().hasErrors()).toBe(false);
+    });
+  });
+
+  describe('Collision detection', () => {
+    describe('cross-field collision', () => {
+      it('Should factor in field name', () => {
+        const suite = vest.create(() => {
+          vestTest.memo('f1', () => false, [1]);
+          vestTest.memo('f2', () => true, [1]);
+        });
+
+        suite();
+        suite();
+        expect(suite.get().hasErrors('f1')).toBe(true);
+        expect(suite.get().hasErrors('f2')).toBe(false);
+      });
+    });
+
+    describe('same-field-same-suite collision', () => {
+      it('Should factor in execution order', () => {
+        const suite = vest.create(() => {
+          vestTest.memo('f1', () => false, [1]);
+          vestTest.memo('f1', () => true, [1]);
+        });
+
+        suite();
+        suite();
+        expect(suite.get().hasErrors('f1')).toBe(true);
+        expect(suite.get().errorCount).toBe(1);
+      });
+    });
+    describe('cross-suite collision', () => {
+      it('Should factor in field name', () => {
+        const suite1 = vest.create(() => {
+          vestTest.memo('f1', () => false, [1]);
+          vestTest.memo('f2', () => true, [1]);
+        });
+        const suite2 = vest.create(() => {
+          vestTest.memo('f1', () => true, [1]);
+          vestTest.memo('f2', () => false, [1]);
+        });
+
+        suite1();
+        suite2();
+        expect(suite1.get().hasErrors('f1')).toBe(true);
+        expect(suite1.get().hasErrors('f2')).toBe(false);
+        expect(suite2.get().hasErrors('f1')).toBe(false);
+        expect(suite2.get().hasErrors('f2')).toBe(true);
+      });
+    });
+  });
+});