tsmockit 1.1.3 → 1.2.0

package/README.md

@@ -48,7 +48,12 @@ static EmitKeyEventAtElement(
 ): void
 ```
 ```typescript
-static async TimeLapsedCondition(condition: () => boolean, interval = 10): Promise<boolean>
+static async Expect<T>(
+  selector: () => T,
+  assertion: (m: jasmine.Matchers<T>) => void,
+  interval = 0,
+  getTimeFunc = () => Date.now()
+): Promise<void>
 ```
 
 ## Usage

package/Utility/TestHelpers.d.ts

@@ -1,5 +1,30 @@
+/// <reference types="jasmine" />
 export declare class TestHelpers {
+    /**
+     * Emit an event at a given element
+     * @param element
+     * @param eventType
+     */
     static EmitEventAtElement(element: HTMLElement, eventType: string): void;
+    /**
+     * Emit a key event at a given element
+     * @param element
+     * @param key
+     * @param keyEvent
+     */
     static EmitKeyEventAtElement(element: HTMLInputElement, key: string, keyEvent: 'keydown' | 'keypress' | 'keyup' | 'input'): void;
+    /**
+     * Wait up to 1 second for a given condition to be true
+     * @deprecated Will be removed in version 2 - Use "Expect" instead
+     * @param condition
+     * @param interval
+     * @returns true if condition is met before 1 second limit, false otherwise
+     */
     static TimeLapsedCondition(condition: () => boolean, interval?: number): Promise<boolean>;
+    /**
+     * Performs an asynchronous assertion, allowing up to one second to pass before failing
+     * @param selector A function that returns the subject of the assertion once it is expected to pass.
+     * @param assertion A function that is given the result of the selector function for normal jasmine assertions.
+     */
+    static Expect<T>(selector: () => T, assertion: (m: jasmine.Matchers<T>) => void, interval?: number, getTimeFunc?: () => number): Promise<void>;
 }

package/Utility/TestHelpers.js

@@ -5,11 +5,22 @@ var tslib_1 = require("tslib");
 var TestHelpers = /** @class */ (function () {
     function TestHelpers() {
     }
+    /**
+     * Emit an event at a given element
+     * @param element
+     * @param eventType
+     */
     TestHelpers.EmitEventAtElement = function (element, eventType) {
         var event = document.createEvent('Event');
         event.initEvent(eventType);
         element.dispatchEvent(event);
     };
+    /**
+     * Emit a key event at a given element
+     * @param element
+     * @param key
+     * @param keyEvent
+     */
     TestHelpers.EmitKeyEventAtElement = function (element, key, keyEvent) {
         var event = document.createEvent('Event');
         event['keyCode'] = key;
@@ -17,6 +28,13 @@ var TestHelpers = /** @class */ (function () {
         event.initEvent(keyEvent);
         element.dispatchEvent(event);
     };
+    /**
+     * Wait up to 1 second for a given condition to be true
+     * @deprecated Will be removed in version 2 - Use "Expect" instead
+     * @param condition
+     * @param interval
+     * @returns true if condition is met before 1 second limit, false otherwise
+     */
     TestHelpers.TimeLapsedCondition = function (condition, interval) {
         if (interval === void 0) { interval = 10; }
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
@@ -45,6 +63,34 @@ var TestHelpers = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Performs an asynchronous assertion, allowing up to one second to pass before failing
+     * @param selector A function that returns the subject of the assertion once it is expected to pass.
+     * @param assertion A function that is given the result of the selector function for normal jasmine assertions.
+     */
+    TestHelpers.Expect = function (selector, assertion, interval, getTimeFunc) {
+        if (interval === void 0) { interval = 0; }
+        if (getTimeFunc === void 0) { getTimeFunc = function () { return Date.now(); }; }
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve) {
+                        var startTime = getTimeFunc();
+                        var timedOut = function () { return getTimeFunc() - startTime > 1000; };
+                        var execute = function () {
+                            var selection = selector();
+                            if (selection || timedOut()) {
+                                assertion(expect(selection));
+                                resolve();
+                            }
+                            else {
+                                setTimeout(function () { return execute(); }, interval);
+                            }
+                        };
+                        execute();
+                    })];
+            });
+        });
+    };
     return TestHelpers;
 }());
 exports.TestHelpers = TestHelpers;

package/package.json

@@ -14,7 +14,7 @@
     "dependency injection"
   ],
   "license": "MIT",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "Generic mocking library for TypeScript",
   "private": false,
   "main": "./public_api.js",