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

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

@@ -0,0 +1,341 @@
+import { TTestSuite, TVestMock } from '../../../../testUtils/TVestMock';
+import mockThrowError from '../../../../testUtils/mockThrowError';
+import { dummyTest } from '../../../../testUtils/testDummy';
+
+import * as vest from 'vest';
+
+describe('Merging of previous test runs', () => {
+  let suite: TTestSuite;
+  let counter = 0;
+  let testContainer: vest.IsolateTest[][] = [];
+
+  beforeEach(() => {
+    counter = 0;
+    testContainer = [];
+  });
+  describe('When test skipped in subsequent run', () => {
+    it('Should merge its result from previous runs', () => {
+      suite = vest.create(() => {
+        vest.skipWhen(counter === 1, () => {
+          testContainer.push([
+            dummyTest.failing('f1'),
+            dummyTest.failing('f2'),
+            dummyTest.passing('f3'),
+            dummyTest.failingWarning('f5'),
+            dummyTest.passingWarning('f6'),
+          ]);
+        });
+        counter++;
+      });
+
+      const resA = suite();
+      const resB = suite();
+
+      const [testsA, testsB] = testContainer;
+
+      // This checks the the suite result is the same for both runs
+      expect(resA).isDeepCopyOf(resB);
+
+      // This checks that the test objects are the same for both runs
+      expect(testsA).toEqual(testsB);
+    });
+  });
+
+  describe('When test changes in subsequent run', () => {
+    it('Should update the result accordingly', () => {
+      suite = vest.create(() => {
+        testContainer.push([
+          counter === 0 ? dummyTest.passing('f1') : dummyTest.failing('f1'),
+        ]);
+
+        dummyTest.failing('f2');
+        counter++;
+      });
+
+      const resA = suite();
+
+      // Checking that the result is correct
+      expect(resA.isValid('f1')).toBe(true);
+      expect(resA.isValid('f2')).toBe(false);
+      const resB = suite();
+      // Checking that the result is correct
+      expect(resB.isValid('f1')).toBe(false);
+      expect(resA.isValid('f2')).toBe(false);
+
+      const [f1A, f1B] = testContainer;
+
+      // Checking that the result updated
+      expect(resA).not.isDeepCopyOf(resB);
+
+      // Checking that the test updated
+      expect(f1A).not.toBe(f1B);
+    });
+  });
+
+  describe('When tests are passed in a different order between runs', () => {
+    let deferThrow: (message: string) => void, vest: TVestMock;
+    beforeEach(() => {
+      const mock = mockThrowError();
+      deferThrow = mock.deferThrow;
+      vest = mock.vest;
+    });
+
+    afterAll(() => {
+      jest.resetAllMocks();
+    });
+
+    it('Should defer-throw an error', () => {
+      suite = vest.create(() => {
+        testContainer.push([
+          counter === 0
+            ? vest.test('f1', jest.fn())
+            : vest.test('f2', () => false),
+        ]);
+        counter++;
+      });
+
+      suite();
+      expect(deferThrow).not.toHaveBeenCalled();
+
+      suite();
+
+      expect(deferThrow).toHaveBeenCalledWith(
+        expect.stringContaining(
+          'Vest Critical Error: Tests called in different order than previous run.'
+        )
+      );
+    });
+
+    describe('When test is omitted in subsequent run', () => {
+      it('Should omit the test from the results', () => {
+        suite = vest.create(() => {
+          vest.test('f1', () => false);
+          if (counter === 0) {
+            vest.test('f2', () => false);
+          }
+          vest.test('f3', () => false);
+          counter++;
+        });
+
+        const resA = suite();
+        expect(resA.tests.f2).toBeDefined();
+        expect(resA.hasErrors('f1')).toBe(true);
+        expect(resA.hasErrors('f2')).toBe(true);
+        expect(resA.hasErrors('f3')).toBe(true);
+        expect(resA.tests).toMatchInlineSnapshot(`
+          {
+            "f1": {
+              "errorCount": 1,
+              "errors": [],
+              "testCount": 1,
+              "valid": false,
+              "warnCount": 0,
+              "warnings": [],
+            },
+            "f2": {
+              "errorCount": 1,
+              "errors": [],
+              "testCount": 1,
+              "valid": false,
+              "warnCount": 0,
+              "warnings": [],
+            },
+            "f3": {
+              "errorCount": 1,
+              "errors": [],
+              "testCount": 1,
+              "valid": false,
+              "warnCount": 0,
+              "warnings": [],
+            },
+          }
+        `);
+
+        const resB = suite();
+        expect(resB.tests.f2).toBeUndefined();
+        expect(resB.hasErrors('f1')).toBe(true);
+        expect(resB.hasErrors('f2')).toBe(false);
+        expect(resB.hasErrors('f3')).toBe(true);
+        expect(resB.tests).toMatchInlineSnapshot(`
+          {
+            "f1": {
+              "errorCount": 1,
+              "errors": [],
+              "testCount": 1,
+              "valid": false,
+              "warnCount": 0,
+              "warnings": [],
+            },
+            "f3": {
+              "errorCount": 1,
+              "errors": [],
+              "testCount": 1,
+              "valid": false,
+              "warnCount": 0,
+              "warnings": [],
+            },
+          }
+        `);
+      });
+
+      describe('When multiple tests are omitted between a test', () => {
+        it('Should omit the tests from the results', () => {
+          suite = vest.create(() => {
+            vest.test('f1', () => false);
+            if (counter === 0) {
+              vest.test('f2', () => false);
+              vest.test('f3', () => false);
+            }
+            vest.test('f4', () => false);
+            if (counter === 0) {
+              vest.test('f5', () => false);
+              vest.test('f6', () => false);
+              vest.test('f7', () => false);
+            }
+            vest.test('f4', () => false);
+            counter++;
+          });
+
+          const resA = suite();
+          expect(resA.tests.f2).toBeDefined();
+          expect(resA.tests.f3).toBeDefined();
+          expect(resA.tests.f5).toBeDefined();
+          expect(resA.tests.f6).toBeDefined();
+          expect(resA.tests.f7).toBeDefined();
+          expect(resA.hasErrors('f1')).toBe(true);
+          expect(resA.hasErrors('f2')).toBe(true);
+          expect(resA.hasErrors('f3')).toBe(true);
+          expect(resA.hasErrors('f4')).toBe(true);
+          expect(resA.hasErrors('f5')).toBe(true);
+          expect(resA.hasErrors('f6')).toBe(true);
+          expect(resA.hasErrors('f7')).toBe(true);
+          expect(resA.tests).toMatchInlineSnapshot(`
+            {
+              "f1": {
+                "errorCount": 1,
+                "errors": [],
+                "testCount": 1,
+                "valid": false,
+                "warnCount": 0,
+                "warnings": [],
+              },
+              "f2": {
+                "errorCount": 1,
+                "errors": [],
+                "testCount": 1,
+                "valid": false,
+                "warnCount": 0,
+                "warnings": [],
+              },
+              "f3": {
+                "errorCount": 1,
+                "errors": [],
+                "testCount": 1,
+                "valid": false,
+                "warnCount": 0,
+                "warnings": [],
+              },
+              "f4": {
+                "errorCount": 2,
+                "errors": [],
+                "testCount": 2,
+                "valid": false,
+                "warnCount": 0,
+                "warnings": [],
+              },
+              "f5": {
+                "errorCount": 1,
+                "errors": [],
+                "testCount": 1,
+                "valid": false,
+                "warnCount": 0,
+                "warnings": [],
+              },
+              "f6": {
+                "errorCount": 1,
+                "errors": [],
+                "testCount": 1,
+                "valid": false,
+                "warnCount": 0,
+                "warnings": [],
+              },
+              "f7": {
+                "errorCount": 1,
+                "errors": [],
+                "testCount": 1,
+                "valid": false,
+                "warnCount": 0,
+                "warnings": [],
+              },
+            }
+          `);
+          const resB = suite();
+          expect(resB.tests.f2).toBeUndefined();
+          expect(resB.tests.f3).toBeUndefined();
+          expect(resB.tests.f5).toBeUndefined();
+          expect(resB.tests.f6).toBeUndefined();
+          expect(resB.tests.f7).toBeUndefined();
+          expect(resB.hasErrors('f1')).toBe(true);
+          expect(resB.hasErrors('f2')).toBe(false);
+          expect(resB.hasErrors('f3')).toBe(false);
+          expect(resB.hasErrors('f4')).toBe(true);
+          expect(resB.hasErrors('f5')).toBe(false);
+          expect(resB.hasErrors('f6')).toBe(false);
+          expect(resB.hasErrors('f7')).toBe(false);
+          expect(resB.tests).toMatchInlineSnapshot(`
+            {
+              "f1": {
+                "errorCount": 1,
+                "errors": [],
+                "testCount": 1,
+                "valid": false,
+                "warnCount": 0,
+                "warnings": [],
+              },
+              "f4": {
+                "errorCount": 2,
+                "errors": [],
+                "testCount": 2,
+                "valid": false,
+                "warnCount": 0,
+                "warnings": [],
+              },
+            }
+          `);
+        });
+      });
+
+      describe('When tests are added inbetween tests', () => {
+        it('Should remove next tests in line', () => {
+          const suite = vest.create(() => {
+            vest.test('f1', () => false);
+            if (counter === 1) {
+              vest.test('f2', () => false);
+              vest.test('f3', () => false);
+            }
+
+            vest.skipWhen(
+              () => counter === 1,
+              () => {
+                vest.test('f4', () => false);
+                vest.test('f5', () => false);
+              }
+            );
+            counter++;
+          });
+
+          const resA = suite();
+          expect(resA.hasErrors('f4')).toBe(true);
+          expect(resA.hasErrors('f5')).toBe(true);
+
+          // This is testing that fact that the next test in line after f2 and f3
+          // got removed. We can see it because in normal situation, the test result is
+          // merged into the next test result.
+          const resB = suite();
+          expect(resB.hasErrors('f4')).toBe(false);
+          expect(resB.hasErrors('f5')).toBe(false);
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,175 @@
+import wait from 'wait';
+
+import { asVestTest } from 'asVestTest';
+import * as vest from 'vest';
+
+describe('runAsyncTest', () => {
+  describe('State Updates', () => {
+    it('Should remove pending status from test object', async () => {
+      let testObject: void | vest.IsolateTest = undefined;
+      const suite = vest.create(() => {
+        testObject = vest.test('field_1', async () => {
+          await wait(100);
+        });
+      });
+      suite();
+
+      testObject = asVestTest(testObject);
+
+      expect(testObject.isPending()).toBe(true);
+      await wait(100);
+      expect(testObject.isPending()).toBe(false);
+    });
+  });
+
+  describe('Callbacks', () => {
+    describe('When there are no remaining pending tests', () => {
+      it('Should run all callbacks', async () => {
+        const cb1 = jest.fn();
+        const cb2 = jest.fn();
+        const cb3 = jest.fn();
+
+        const suite = vest.create(() => {
+          vest.test('field_1', async () => {
+            await wait(100);
+          });
+          vest.test('field_2', () => {});
+          vest.test('field_3', async () => {
+            await wait(50);
+          });
+        });
+
+        suite().done(cb1).done(cb2).done('field_1', cb3);
+
+        expect(cb1).not.toHaveBeenCalled();
+        expect(cb2).not.toHaveBeenCalled();
+        expect(cb3).not.toHaveBeenCalled();
+        await wait(50);
+        expect(cb1).not.toHaveBeenCalled();
+        expect(cb2).not.toHaveBeenCalled();
+        expect(cb3).not.toHaveBeenCalled();
+        await wait(50);
+        expect(cb1).toHaveBeenCalled();
+        expect(cb2).toHaveBeenCalled();
+        expect(cb3).toHaveBeenCalled();
+      });
+    });
+
+    describe('When there are remaining pending tests', () => {
+      it('Should only run callbacks for completed tests', async () => {
+        const cb1 = jest.fn();
+        const cb2 = jest.fn();
+        const cb3 = jest.fn();
+
+        const suite = vest.create(() => {
+          vest.test('field_1', async () => {
+            await wait(100);
+          });
+          vest.test('field_2', () => {});
+          vest.test('field_3', async () => {
+            await wait(50);
+          });
+        });
+
+        suite().done(cb1).done('field_2', cb2).done('field_3', cb3);
+
+        expect(cb1).not.toHaveBeenCalled();
+        expect(cb2).toHaveBeenCalled();
+        expect(cb3).not.toHaveBeenCalled();
+        await wait(50);
+        expect(cb1).not.toHaveBeenCalled();
+        expect(cb3).toHaveBeenCalled();
+        await wait(50);
+        expect(cb1).toHaveBeenCalled();
+        expect(cb2).toHaveBeenCalled();
+        expect(cb3).toHaveBeenCalled();
+      });
+    });
+
+    describe('When the test run was canceled', () => {
+      it('Should not run the callbacks', async () => {
+        const cb1 = jest.fn();
+        const cb2 = jest.fn();
+        const cb3 = jest.fn();
+
+        const testObject: Array<vest.IsolateTest> = [];
+
+        const suite = vest.create(() => {
+          testObject.push(
+            vest.test('field_1', async () => {
+              await wait(10);
+            })
+          );
+          vest.test('field_2', () => {});
+        });
+
+        suite().done(cb1).done(cb2).done('field_1', cb3);
+
+        expect(cb1).not.toHaveBeenCalled();
+        expect(cb2).not.toHaveBeenCalled();
+        expect(cb3).not.toHaveBeenCalled();
+
+        suite();
+
+        await wait(10);
+        expect(cb1).not.toHaveBeenCalled();
+        expect(cb2).not.toHaveBeenCalled();
+        expect(cb3).not.toHaveBeenCalled();
+      });
+    });
+  });
+  describe('Final test status', () => {
+    describe('When passing', () => {
+      it('Should set the test status to passing', async () => {
+        let testObject: void | vest.IsolateTest = undefined;
+        const suite = vest.create(() => {
+          testObject = vest.test('field_1', async () => {
+            await wait(100);
+          });
+        });
+        suite();
+
+        testObject = asVestTest(testObject);
+
+        expect(testObject.isPassing()).toBe(false);
+        await wait(100);
+        expect(testObject.isPassing()).toBe(true);
+      });
+    });
+    describe('When failing', () => {
+      it('Should set the test status to failing', async () => {
+        let testObject: void | vest.IsolateTest = undefined;
+        const suite = vest.create(() => {
+          testObject = vest.test('field_1', async () => {
+            throw new Error('');
+          });
+        });
+        suite();
+
+        testObject = asVestTest(testObject);
+
+        expect(testObject.isFailing()).toBe(false);
+        await wait(100);
+        expect(testObject.isFailing()).toBe(true);
+      });
+    });
+    describe('When warning', () => {
+      it('Should set the test status to failing', async () => {
+        let testObject: void | vest.IsolateTest = undefined;
+        const suite = vest.create(() => {
+          testObject = vest.test('field_1', async () => {
+            vest.warn();
+            throw new Error('');
+          });
+        });
+        suite();
+
+        testObject = asVestTest(testObject);
+
+        expect(testObject.isWarning()).toBe(false);
+        await wait(100);
+        expect(testObject.isWarning()).toBe(true);
+      });
+    });
+  });
+});