vest 3.3.0-dev-92c1af → 4.0.0-dev-f53683

package/CHANGELOG.md

@@ -4,48 +4,61 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## 3.3.0 - 2021-09-15
+## 4.0.0 - 2021-10-07
+### Changed or removed
+- 0e3af10  major(context): used named export in context (ealush)
+- 1897164  major(vest, enforce): setup next major version (ealush)
+- bf9265e  breaking(vest, enforce): prepare next major (ealush)
+
 ### Added
-- fe6af86  feat(vest): Add a parser export (ealush)
-- 7501303  feat(vest): isValid with field name (ealush)
-- 160071e  feat(vest): handle execution order state refill with memoized tests (ealush)
-- 4122ceb  feat(vest): Make the state rely on execution order. Add skipWhen. (undefined)
-- f38d86d  added(n4s): partial rule modifier (undefined)
-- 362410c  feat(n4s): context propagation within enforce (undefined)
+- b0cbb32  feat(vest): Add a parser export (ealush)
+- fc75f1d  feat(vest): isValid with field name (ealush)
+- c427e4e  feat(vest): handle execution order state refill with memoized tests (ealush)
+- 443c275  feat(vest): Make the state rely on execution order. Add skipWhen. (undefined)
+- 2988655  added(n4s): partial rule modifier (undefined)
+- f41a444  feat(n4s): context propagation within enforce (undefined)
 
 ### Fixed and improved
-- .github/workflows/integration.yml
+- f536834  fix(vest): prevent changing test status once it was finalized (ealush)
+- df64c2e  patch(vest): add cache invalidation for canceled tests (ealush)
+- fd1e31e  types(vest): add safeguard around shouldUseErrorAsMessage (ealush)
+- 8321a36  patch(vest): some cleanups (ealush)
+- 8320956  patch(vest): remove duplicate code handling perv test registration (ealush)
+- 7e3fffb  vx: use context directly from published package (ealush)
+- ac45a64  patch: run done callbacks via event (ealush)
+- e0f05d6  patch(vest): removed state subscription (ealush)
+- package.json
+- packages/anyone/package.json
+- packages/anyone/package.json
 - packages/vast/types/vast.d.ts
-- 59779fc  patch(vest): remove pending and lagging state (ealush)
-- 1d024b2  patch(vest): convert boolean flags to a single status key (ealush)
-- ba3990c  patch: simplify fieldname comparison (ealush)
-- e37d7f2  patch(vest): add useAllIncomplete hook (ealush)
-- 14ae130  patch(vest): invalid accounts for warning tests as well (ealush)
-- 8054ee9  patch(vest): isValid counts all required tests per field (ealush)
-- 5b25f55  chore: cleanups (ealush)
+- 2515275  patch(vest): remove pending and lagging state (ealush)
+- 4c38835  patch(vest): convert boolean flags to a single status key (ealush)
+- e24f0bd  patch: simplify fieldname comparison (ealush)
+- b927b5c  patch(vest): add useAllIncomplete hook (ealush)
+- a88dd38  patch(vest): invalid accounts for warning tests as well (ealush)
+- eaf9bef  patch(vest): isValid counts all required tests per field (ealush)
+- 7a4ba03  chore: cleanups (ealush)
 - .eslintrc.js
-- 85fa7e8  add(n4s): enforce.condition (ealush)
+- 1878ffc  add(n4s): enforce.condition (ealush)
 - package.json
 - packages/anyone/package.json
-- d792787  chore: cleanup residue (undefined)
-- 7c3eaf3  chore: remove duplicate types (undefined)
+- a89af46  chore: cleanup residue (undefined)
+- be86496  chore: remove duplicate types (undefined)
 - packages/anyone/package.json
-- bad36ae  patch: add nodejs exports (undefined)
-- bfbe922  patch: remove unused exports (undefined)
+- 44de93f  patch: add nodejs exports (undefined)
+- abb0efe  patch: remove unused exports (undefined)
 - packages/anyone/package.json
-- 32ce807  chore: reduce complexity, remove all lint errors (undefined)
+- a8540de  chore: reduce complexity, remove all lint errors (undefined)
 - packages/anyone/.npmignore
 - .github/PULL_REQUEST_TEMPLATE.md
-- 8171561  chore: cleanup unused code (ealush)
-- 681021b  lint: handling lint of all packages (ealush)
+- f58327f  chore: cleanup unused code (ealush)
+- 853cee6  lint: handling lint of all packages (ealush)
 - .gitignore
-- 527e3e1  patch(n4s): add ruleReturn default values (ealush)
-- 6c89f6c  fix(n4s): make enforce compound runners fall back to correct response (ealush)
-- 9f2caca  fix(n4s): make enforce chaining work (ealush)
-- 0ff7a9b  chore: some lint fixes (ealush)
-- dbd7d13  add cli options support (ealush)
-- 3d0393c  Vest 4 Infra Setup (ealush)
-- 6ee296e  Vest 4 Infra Setup (ealush)
+- d148f6d  patch(n4s): add ruleReturn default values (ealush)
+- c722fbd  fix(n4s): make enforce compound runners fall back to correct response (ealush)
+- fa65911  fix(n4s): make enforce chaining work (ealush)
+- a2437a3  chore: some lint fixes (ealush)
+- aabb5f4  add cli options support (ealush)
 
 ## 3.2.7 - 2021-07-17
 

package/dist/cjs/vest.development.js

@@ -198,7 +198,7 @@ function compounds() {
     return { allOf: allOf, anyOf: anyOf, noneOf: noneOf, oneOf: oneOf, optional: optional$1 };
 }
 
-function isStringValue (v) {
+function isStringValue(v) {
     return String(v) === v;
 }
 
@@ -609,7 +609,7 @@ function transformResult(result, ruleName, value) {
         return ruleReturn(result);
     }
     else {
-        return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args)));
+        return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args, false)));
     }
 }
 function validateResult(result) {
@@ -643,9 +643,9 @@ function enforceEager(value) {
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            var transformedResult = transformResult.apply(void 0, __spreadArray([ctx$1.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args)); }),
+            var transformedResult = transformResult.apply(void 0, __spreadArray([ctx$1.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args, false)); }),
                 ruleName,
-                value], args));
+                value], args, false));
             if (!transformedResult.pass) {
                 if (isEmpty(transformedResult.message)) {
                     throwError("enforce/" + ruleName + " failed with " + JSON.stringify(value));
@@ -675,7 +675,7 @@ function genEnforceLazy(key) {
             }
             var rule = getRule(ruleName);
             registeredRules.push(function (value) {
-                return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args)), ruleName, value], args));
+                return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args, false)), ruleName, value], args, false));
             });
             var proxy = {
                 run: function (value) {
@@ -895,10 +895,6 @@ function matchingFieldName(testObject, fieldName) {
 function createCache(maxSize) {
     if (maxSize === void 0) { maxSize = 10; }
     var cacheStorage = [];
-    /**
-     * @param {any[]} deps  dependency array.
-     * @param {Function}    cache action function.
-     */
     var cache = function (deps, cacheAction) {
         var cacheHit = cache.get(deps);
         // cache hit is not null
@@ -906,15 +902,21 @@ function createCache(maxSize) {
             return cacheHit[1];
         var result = cacheAction();
         cacheStorage.unshift([deps.concat(), result]);
-        if (cacheStorage.length > maxSize) {
+        if (cacheStorage.length > maxSize)
             cacheStorage.length = maxSize;
-        }
         return result;
     };
-    /**
-     * Retrieves an item from the cache.
-     * @param {deps} deps Dependency array
-     */
+    // invalidate an item in the cache by its dependencies
+    cache.invalidate = function (deps) {
+        var index = cacheStorage.findIndex(function (_a) {
+            var cachedDeps = _a[0];
+            return lengthEquals(deps, cachedDeps.length) &&
+                deps.every(function (dep, i) { return dep === cachedDeps[i]; });
+        });
+        if (index > -1)
+            cacheStorage.splice(index, 1);
+    };
+    // Retrieves an item from the cache.
     cache.get = function (deps) {
         return cacheStorage[cacheStorage.findIndex(function (_a) {
             var cachedDeps = _a[0];
@@ -1107,6 +1109,13 @@ function noMatch(testObject, severity, group, fieldName) {
     return false;
 }
 
+function getFailuresArrayOrObject(group, fieldName) {
+    if (fieldName) {
+        return group[fieldName];
+    }
+    return group;
+}
+
 function getErrors(fieldName) {
     return getFailures('errors', fieldName);
 }
@@ -1121,25 +1130,16 @@ function getFailures(severityKey, fieldName) {
     var failureMessages = collectFailureMessages(severityKey, testObjects, {
         fieldName: fieldName
     });
-    if (fieldName) {
-        return failureMessages[fieldName];
-    }
-    return failureMessages;
+    return getFailuresArrayOrObject(failureMessages, fieldName);
 }
 
 function getErrorsByGroup(groupName, fieldName) {
     var errors = getByGroup('errors', groupName, fieldName);
-    if (fieldName) {
-        return errors[fieldName];
-    }
-    return errors;
+    return getFailuresArrayOrObject(errors, fieldName);
 }
 function getWarningsByGroup(groupName, fieldName) {
-    var errors = getByGroup('warnings', groupName, fieldName);
-    if (fieldName) {
-        return errors[fieldName];
-    }
-    return errors;
+    var warnings = getByGroup('warnings', groupName, fieldName);
+    return getFailuresArrayOrObject(warnings, fieldName);
 }
 /**
  * Gets failure messages by group.
@@ -1321,22 +1321,90 @@ function deferDoneCallback(doneCallback, fieldName) {
     });
 }
 
+function createBus() {
+    var listeners = {};
+    return {
+        emit: function (event, data) {
+            if (!listeners[event]) {
+                return;
+            }
+            listeners[event].forEach(function (listener) {
+                listener(data);
+            });
+        },
+        on: function (event, handler) {
+            if (!listeners[event]) {
+                listeners[event] = [];
+            }
+            listeners[event].push(handler);
+            return {
+                off: function () {
+                    listeners[event] = listeners[event].filter(function (h) { return h !== handler; });
+                }
+            };
+        }
+    };
+}
+
+function callEach(arr) {
+    return arr.forEach(function (fn) { return fn(); });
+}
+
+/**
+ * Runs done callback per field when async tests are finished running.
+ */
+function runFieldCallbacks(fieldName) {
+    var fieldCallbacks = useTestCallbacks()[0].fieldCallbacks;
+    if (fieldName) {
+        if (!hasRemainingTests(fieldName) &&
+            Array.isArray(fieldCallbacks[fieldName])) {
+            callEach(fieldCallbacks[fieldName]);
+        }
+    }
+}
+/**
+ * Runs unlabelled done callback when async tests are finished running.
+ */
+function runDoneCallbacks() {
+    var doneCallbacks = useTestCallbacks()[0].doneCallbacks;
+    if (!hasRemainingTests()) {
+        callEach(doneCallbacks);
+    }
+}
+
+function initBus() {
+    var bus = createBus();
+    bus.on(Events.TEST_COMPLETED, function (testObject) {
+        if (testObject.isCanceled()) {
+            return;
+        }
+        testObject.done();
+        runFieldCallbacks(testObject.fieldName);
+        runDoneCallbacks();
+    });
+    return bus;
+}
+function useBus() {
+    var context = ctx.useX();
+    if (!context.bus) {
+        throwError();
+    }
+    return context.bus;
+}
+var Events;
+(function (Events) {
+    Events["TEST_COMPLETED"] = "test_completed";
+})(Events || (Events = {}));
+
 // eslint-disable-next-line max-lines-per-function
 function create(suiteCallback) {
     if (!isFunction(suiteCallback)) {
         throwError('Suite initialization error. Expected `tests` to be a function.');
     }
-    var handlers = [];
-    var state = createState(function () {
-        handlers.forEach(function (fn) {
-            return fn({
-                suiteState: stateRef,
-                type: 'suiteStateUpdate'
-            });
-        });
-    });
+    var bus = initBus();
+    var state = createState();
     var stateRef = createStateRef(state, { suiteId: genId() });
-    var suite = assign(ctx.bind({ stateRef: stateRef }, function () {
+    var suite = assign(ctx.bind({ stateRef: stateRef, bus: bus }, function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
@@ -1360,16 +1428,7 @@ function create(suiteCallback) {
                 }
             });
         }),
-        reset: state.reset,
-        subscribe: function (handler) {
-            if (!isFunction(handler))
-                return;
-            handlers.push(handler);
-            handler({
-                type: 'suiteSubscribeInit',
-                suiteState: stateRef
-            });
-        }
+        reset: state.reset
     });
     return suite;
 }
@@ -1501,16 +1560,16 @@ function skipWhen(conditional, callback) {
  */
 function group(groupName, tests) {
     if (!isStringValue(groupName)) {
-        throwGroupError(groupName);
+        throwGroupError('name must be a string');
     }
     if (!isFunction(tests)) {
-        throwGroupError(tests);
+        throwGroupError('callback must be a function');
     }
     // Running with the context applied
-    ctx.bind({ groupName: groupName }, tests)();
+    ctx.run({ groupName: groupName }, tests);
 }
-function throwGroupError(value) {
-    throwError("group initialization error. Expected \"" + value + "\" to be a string.");
+function throwGroupError(error) {
+    throwError("Wrong arguments passed to group. Group " + error + ".");
 }
 
 function optional(optionals) {
@@ -1547,6 +1606,7 @@ function removeTestFromState (testObject) {
 }
 
 function shouldUseErrorAsMessage(message, error) {
+    // kind of cheating with this safe guard, but it does the job
     return isUndefined(message) && isStringValue(error);
 }
 
@@ -1582,7 +1642,7 @@ var VestTest = /** @class */ (function () {
         return result;
     };
     VestTest.prototype.setStatus = function (status) {
-        if (this.isCanceled()) {
+        if (this.isFinalStatus()) {
             return;
         }
         this.status = status;
@@ -1594,7 +1654,7 @@ var VestTest = /** @class */ (function () {
         this.setStatus(this.warns ? STATUS_WARNING : STATUS_FAILED);
     };
     VestTest.prototype.done = function () {
-        if (this.isWarning() || this.isCanceled() || this.isFailing()) {
+        if (this.isFinalStatus()) {
             return;
         }
         this.setStatus(STATUS_PASSING);
@@ -1602,6 +1662,9 @@ var VestTest = /** @class */ (function () {
     VestTest.prototype.warn = function () {
         this.warns = true;
     };
+    VestTest.prototype.isFinalStatus = function () {
+        return this.hasFailures() || this.isCanceled() || this.isPassing();
+    };
     VestTest.prototype.skip = function () {
         this.setStatus(STATUS_SKIPPED);
     };
@@ -1621,6 +1684,9 @@ var VestTest = /** @class */ (function () {
     VestTest.prototype.isTested = function () {
         return this.hasFailures() || this.isPassing();
     };
+    VestTest.prototype.isUntested = function () {
+        return this.status === STATUS_UNTESTED;
+    };
     VestTest.prototype.isFailing = function () {
         return this.status === STATUS_FAILED;
     };
@@ -1646,27 +1712,23 @@ var STATUS_PASSING = 'PASSING';
 var STATUS_PENDING = 'PENDING';
 var STATUS_CANCELED = 'CANCELED';
 
+function isPromise(value) {
+    return value && isFunction(value.then);
+}
+
 function isSameProfileTest(testObject1, testObject2) {
     return (testObject1.fieldName === testObject2.fieldName &&
         testObject1.groupName === testObject2.groupName);
 }
 
 function cancelOverriddenPendingTest(prevRunTestObject, currentRunTestObject) {
-    if (isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
-        prevRunTestObject.isPending() &&
-        currentRunTestObject !== prevRunTestObject) {
+    if (currentRunTestObject !== prevRunTestObject &&
+        isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
+        prevRunTestObject.isPending()) {
         prevRunTestObject.cancel();
     }
 }
 
-function isPromise(value) {
-    return value && isFunction(value.then);
-}
-
-function callEach(arr) {
-    return arr.forEach(function (fn) { return fn(); });
-}
-
 /**
  * Runs async test.
  */
@@ -1674,16 +1736,10 @@ function runAsyncTest(testObject) {
     var asyncTest = testObject.asyncTest, message = testObject.message;
     if (!isPromise(asyncTest))
         return;
+    var emit = useBus().emit;
     var stateRef = useStateRef();
     var done = ctx.bind({ stateRef: stateRef }, function () {
-        testObject.done();
-        // This is for cases in which the suite state was already reset
-        if (testObject.isCanceled()) {
-            return;
-        }
-        // Perform required done callback calls and cleanups after the test is finished
-        runFieldCallbacks(testObject.fieldName);
-        runDoneCallbacks();
+        emit(Events.TEST_COMPLETED, testObject);
     });
     var fail = ctx.bind({ stateRef: stateRef }, function (rejectionMessage) {
         if (testObject.isCanceled()) {
@@ -1704,27 +1760,6 @@ function runAsyncTest(testObject) {
         fail();
     }
 }
-/**
- * Runs done callback per field when async tests are finished running.
- */
-function runFieldCallbacks(fieldName) {
-    var fieldCallbacks = useTestCallbacks()[0].fieldCallbacks;
-    if (fieldName) {
-        if (!hasRemainingTests(fieldName) &&
-            Array.isArray(fieldCallbacks[fieldName])) {
-            callEach(fieldCallbacks[fieldName]);
-        }
-    }
-}
-/**
- * Runs unlabelled done callback when async tests are finished running.
- */
-function runDoneCallbacks() {
-    var doneCallbacks = useTestCallbacks()[0].doneCallbacks;
-    if (!hasRemainingTests()) {
-        callEach(doneCallbacks);
-    }
-}
 
 /**
  * Runs sync tests - or extracts promise.
@@ -1752,6 +1787,7 @@ function runSyncTest(testObject) {
  * Registers test, if async - adds to pending array
  */
 function registerTest(testObject) {
+    var emit = useBus().emit;
     // Run test callback.
     // If a promise is returned, set as async and
     // Move to pending list.
@@ -1765,7 +1801,7 @@ function registerTest(testObject) {
             runAsyncTest(testObject);
         }
         else {
-            testObject.done();
+            emit(Events.TEST_COMPLETED, testObject);
         }
     }
     catch (_a) {
@@ -1773,6 +1809,29 @@ function registerTest(testObject) {
     }
 }
 
+function registerPrevRunTest(testObject) {
+    var prevRunTest = useTestAtCursor(testObject);
+    if (isExcluded(testObject)) {
+        testObject.skip();
+        useSetNextCursorAt();
+        return prevRunTest;
+    }
+    cancelOverriddenPendingTest(prevRunTest, testObject);
+    useSetTestAtCursor(testObject);
+    useSetNextCursorAt();
+    registerTestObjectByTier(testObject);
+    return testObject;
+}
+function registerTestObjectByTier(testObject) {
+    if (testObject.isUntested()) {
+        registerTest(testObject);
+    }
+    else if (isPromise(testObject.asyncTest)) {
+        testObject.setPending();
+        runAsyncTest(testObject);
+    }
+}
+
 function bindTestEach(test) {
     /**
      * Run multiple tests using a parameter table
@@ -1789,7 +1848,7 @@ function bindTestEach(test) {
             var _a = args.reverse(), testFn = _a[0], message = _a[1];
             return table.map(function (item) {
                 item = asArray(item);
-                return test(optionalFunctionValue.apply(void 0, __spreadArray([fieldName], item)), optionalFunctionValue.apply(void 0, __spreadArray([message], item)), function () { return testFn.apply(void 0, item); });
+                return test(optionalFunctionValue.apply(void 0, __spreadArray([fieldName], item, false)), optionalFunctionValue.apply(void 0, __spreadArray([message], item, false)), function () { return testFn.apply(void 0, item); });
             });
         }
         return eachReturn;
@@ -1812,32 +1871,20 @@ function bindTestMemo(test) {
         // Implicit dependency for more specificity
         var dependencies = [suiteId, fieldName, cursorAt].concat(deps);
         var cached = cache.get(dependencies);
-        // Cache miss. Start fresh
         if (isNull(cached)) {
+            // cache miss
             return cache(dependencies, function () { return test(fieldName, msg, testFn); });
         }
-        var testObject = cached[1];
-        var prevRunTest = useTestAtCursor(testObject);
-        if (isExcluded(testObject)) {
-            useSetNextCursorAt();
-            return prevRunTest;
+        if (cached[1].isCanceled()) {
+            // cache hit, but test is canceled
+            cache.invalidate(dependencies);
+            return cache(dependencies, function () { return test(fieldName, msg, testFn); });
         }
-        cancelOverriddenPendingTest(prevRunTest, testObject);
-        useSetTestAtCursor(testObject);
-        useSetNextCursorAt();
-        handleAsyncTest(testObject);
-        return testObject;
+        return registerPrevRunTest(cached[1]);
     }
     return memo;
 }
-function handleAsyncTest(testObject) {
-    if (testObject && isPromise(testObject.asyncTest)) {
-        testObject.setPending();
-        runAsyncTest(testObject);
-    }
-}
 
-// eslint-disable-next-line max-statements
 function testBase(fieldName) {
     var args = [];
     for (var _i = 1; _i < arguments.length; _i++) {
@@ -1849,26 +1896,14 @@ function testBase(fieldName) {
         message: message,
         groupName: context === null || context === void 0 ? void 0 : context.groupName
     });
-    var prevRunTest = useTestAtCursor(testObject);
-    if (isExcluded(testObject)) {
-        testObject.skip();
-        useSetNextCursorAt();
-        return prevRunTest;
-    }
-    cancelOverriddenPendingTest(prevRunTest, testObject);
-    useSetTestAtCursor(testObject);
-    useSetNextCursorAt(); // maybe somehow do this only in one place?
-    if (!isFunction(testFn))
-        return testObject;
-    registerTest(testObject);
-    return testObject;
+    return registerPrevRunTest(testObject);
 }
 var test = assign(testBase, {
     each: bindTestEach(testBase),
     memo: bindTestMemo(testBase)
 });
 
-var VERSION = "3.3.0-dev-92c1af";
+var VERSION = "4.0.0-dev-f53683";
 
 exports.VERSION = VERSION;
 exports.create = create;