implab/implabjs-core Commit - r77:04efbdad7679

more tests

cin -

r77:04efbdad7679 default

parent child

Context file:

r77:04efbdad7679

Collapse all files

history.md +1 -1

             HISTORY
             =======
 .2.17
             ------
             Bug fixes
 .2.16
             ------
             Minor fixes and improvements
             - added `isCancellable` type predicate function to `safe` module
             - `isString, isNumber, isInteger, isPrimitive` are now type predicates
 .2.0
             -----
             Major rafactoring, moving to support both browser (rjs) and server (cjs) environments.
             - dependency injection container ported to typescript
             - sources are split to several sets to provide the ability for the conditional build of the project.
 .0.1
             -----
             First release, intorduces the following features
             - `di` - dependency injection container
             - `log` - log4 style logging system
             - `text` - simple and fast text templating and formatting
-            - `Uuid` - uuid generation traits
  No newline at end of file
+            - `Uuid` - uuid generation traits

src/main/ts/safe.ts +11 -13

             import { ICancellable, Constructor } from "./interfaces";
             import { Cancellation } from "./Cancellation";
             let _nextOid = 0;
             const _oid = typeof Symbol === "function" ?
                 Symbol("__implab__oid__") :
                 "__implab__oid__";
             export function oid(instance: object): string {
                 if (isNull(instance))
                     return null;
                 if (_oid in instance)
                     return instance[_oid];
                 else
                     return (instance[_oid] = "oid_" + (++_nextOid));
             }
             export function argumentNotNull(arg: any, name: string) {
                 if (arg === null || arg === undefined)
                     throw new Error("The argument " + name + " can't be null or undefined");
             }
             export function argumentNotEmptyString(arg: any, name: string) {
                 if (typeof (arg) !== "string" || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty string");
             }
             export function argumentNotEmptyArray(arg: any, name: string) {
                 if (!(arg instanceof Array) || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty array");
             }
             export function argumentOfType(arg: any, type: Constructor<{}>, name: string) {
                 if (!(arg instanceof type))
                     throw new Error("The argument '" + name + "' type doesn't match");
             }
             export function isNull(val: any) {
                 return (val === null || val === undefined);
             }
             export function isPrimitive(val: any): val is string | number | boolean | undefined | null {
                 return (val === null || val === undefined || typeof (val) === "string" ||
                     typeof (val) === "number" || typeof (val) === "boolean");
             }
             export function isInteger(val: any): val is number {
                 return parseInt(val, 10) === val;
             }
             export function isNumber(val: any): val is number {
                 return parseFloat(val) === val;
             }
             export function isString(val: any): val is string {
                 return typeof (val) === "string" || val instanceof String;
             }
             export function isPromise(val: any): val is PromiseLike<any> {
                 return val && typeof val.then === "function";
             }
             export function isCancellable(val: any): val is ICancellable {
                 return val && typeof val.cancel === "function";
             }
             export function isNullOrEmptyString(val: any): val is string | null | undefined {
                 if (val === null || val === undefined ||
                     ((typeof (val) === "string" || val instanceof String) && val.length === 0))
                     return true;
             }
             export function isNotEmptyArray(arg: any): arg is Array<any> {
                 return (arg instanceof Array && arg.length > 0);
             }
             function _isStrictMode() {
                 return !this;
             }
             function _getNonStrictGlobal() {
                 return this;
             }
             export function getGlobal() {
                 // in es3 we can't use indirect call to eval, since it will
                 // be executed in the current call context.
                 if (!_isStrictMode()) {
                     return _getNonStrictGlobal();
                 } else {
                     // tslint:disable-next-line:no-eval
                     return eval.call(null, "this");
                 }
             }
             export function get(member: string, context?: object) {
                 argumentNotEmptyString(member, "member");
                 let that = context || getGlobal();
                 const parts = member.split(".");
                 for (const m of parts) {
                     if (!m)
                         continue;
                     if (isNull(that = that[m]))
                         break;
                 }
                 return that;
             }
             /**
              * Выполняет метод для каждого элемента массива, останавливается, когда
              * либо достигнут конец массива, либо функция <c>cb</c> вернула
              * значение.
              *
              * @param {Array | Object} obj массив элементов для просмотра
              * @param {Function} cb функция, вызываемая для каждого элемента
              * @param {Object} thisArg значение, которое будет передано в качестве
              *                <c>this</c> в <c>cb</c>.
              * @returns Результат вызова функции <c>cb</c>, либо <c>undefined</c>
              *          если достигнут конец массива.
              */
             export function each(obj, cb, thisArg?) {
                 argumentNotNull(cb, "cb");
                 if (obj instanceof Array) {
                     for (let i = 0; i < obj.length; i++) {
                         const x = cb.call(thisArg, obj[i], i);
                         if (x !== undefined)
                             return x;
                     }
                 } else {
                     const keys = Object.keys(obj);
                     for (const k of keys) {
                         const x = cb.call(thisArg, obj[k], k);
                         if (x !== undefined)
                             return x;
                     }
                 }
             }
             /** Copies property values from a source object to the destination and returns
              * the destination onject.
              *
              * @param dest The destination object into which properties from the source
              *  object will be copied.
              * @param source The source of values which will be copied to the destination
              *  object.
              * @param template An optional parameter specifies which properties should be
              *  copied from the source and how to map them to the destination. If the
              *  template is an array it contains the list of property names to copy from the
              *  source to the destination. In case of object the templates contains the map
              *  where keys are property names in the source and the values are property
              *  names in the destination object. If the template isn't specified then the
              *  own properties of the source are entirely copied to the destination.
              *
              */
             export function mixin<T, S>(dest: T, source: S, template?: string[] | object): T & S {
                 argumentNotNull(dest, "to");
                 const _res = dest as T & S;
                 if (isPrimitive(source))
                     return _res;
                 if (template instanceof Array) {
                     for (const p of template) {
                         if (p in source)
                             _res[p] = source[p];
                     }
                 } else if (template) {
                     const keys = Object.keys(source);
                     for (const p of keys) {
                         if (p in template)
                             _res[template[p]] = source[p];
                     }
                 } else {
                     const keys = Object.keys(source);
                     for (const p of keys)
                         _res[p] = source[p];
                 }
                 return _res;
             }
             /** Wraps the specified function to emulate an asynchronous execution.
              * @param{Object} thisArg [Optional] Object which will be passed as 'this' to the function.
              * @param{Function|String} fn [Required] Function wich will be wrapped.
              */
             export function async(_fn: (...args: any[]) => any, thisArg): (...args: any[]) => PromiseLike<any> {
                 let fn = _fn;
                 if (arguments.length === 2 && !(fn instanceof Function))
                     fn = thisArg[fn];
                 if (fn == null)
                     throw new Error("The function must be specified");
                 function wrapresult(x, e?): PromiseLike<any> {
                     if (e) {
                         return {
                             then(cb, eb) {
                                 try {
                                     return eb ? wrapresult(eb(e)) : this;
                                 } catch (e2) {
                                     return wrapresult(null, e2);
                                 }
                             }
                         };
                     } else {
                         if (x && x.then)
                             return x;
                         return {
                             then(cb) {
                                 try {
                                     return cb ? wrapresult(cb(x)) : this;
                                 } catch (e2) {
                                     return wrapresult(e2);
                                 }
                             }
                         };
                     }
                 }
                 return (...args) => {
                     try {
                         return wrapresult(fn.apply(thisArg, args));
                     } catch (e) {
                         return wrapresult(null, e);
                     }
                 };
             }
             type _AnyFn = (...args) => any;
             export function delegate<T, K extends keyof T>(target: T, _method: (K | _AnyFn)) {
                 let method;
                 if (!(_method instanceof Function)) {
                     argumentNotNull(target, "target");
                     method = target[_method];
                     if (!(method instanceof Function))
                         throw new Error("'method' argument must be a Function or a method name");
                 } else {
                     method = _method;
                 }
                 return (...args) => {
                     return method.apply(target, args);
                 };
             }
             export function delay(timeMs: number, ct = Cancellation.none) {
+                ct.throwIfRequested();
                 return new Promise((resolve, reject) => {
-                    if (ct.isRequested()) {
+                    const h = ct.register(e => {
-                        ct.register(reject);
+                        clearTimeout(id);
-                    } else {
+                        reject(e);
-                        const h = ct.register(e => {
+                        // we don't nedd to unregister h, since ct is already disposed
-                            clearTimeout(id);
+                    });
-                            reject(e);
+                    const id = setTimeout(() => {
-                            // we don't nedd to unregister h, since ct is already disposed
+                        h.destroy();
-                        });
+                        resolve();
-                        const id = setTimeout(() => {
+                    }, timeMs);
-                            h.destroy();
-                            resolve();
-                        }, timeMs);
                 });
             }
             /**
              * Для каждого элемента массива вызывает указанную функцию и сохраняет
              * возвращенное значение в массиве результатов.
              *
              * @remarks cb может выполняться асинхронно, при этом одновременно будет
              *          только одна операция.
              *
              * @async
              */
             export function pmap(items, cb) {
                 argumentNotNull(cb, "cb");
                 if (isPromise(items))
                     return items.then(data => pmap(data, cb));
                 if (isNull(items) || !items.length)
                     return items;
                 let i = 0;
                 const result = [];
                 function next() {
                     let r;
                     let ri;
                     function chain(x) {
                         result[ri] = x;
                         return next();
                     }
                     while (i < items.length) {
                         r = cb(items[i], i);
                         ri = i;
                         i++;
                         if (isPromise(r)) {
                             return r.then(chain);
                         } else {
                             result[ri] = r;
                         }
                     }
                     return result;
                 }
                 return next();
             }
             export function pfor(items, cb) {
                 argumentNotNull(cb, "cb");
                 if (isPromise(items))
                     return items.then(data => {
                         return pmap(data, cb);
                     });
                 if (isNull(items) || !items.length)
                     return items;
                 let i = 0;
                 function next() {
                     while (i < items.length) {
                         const r = cb(items[i], i);
                         i++;
                         if (isPromise(r))
                             return r.then(next);
                     }
                 }
                 return next();
             }
             export function first<T>(sequence: ArrayLike<T>): T;
             export function first<T>(sequence: PromiseLike<ArrayLike<T>>): PromiseLike<T>;
             export function first<T>(
                 sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 cb: (x: T) => void,
                 err?: (x: Error) => void
             ): void;
             /**
              * Выбирает первый элемент из последовательности, или обещания, если в
              * качестве параметра используется обещание, оно должно вернуть массив.
              *
              * @param {Function} cb обработчик результата, ему будет передан первый
              *                  элемент последовательности в случае успеха
              * @param {Function} err обработчик исключения, если массив пустой, либо
              *                  не массив
              *
              * @remarks Если не указаны ни cb ни err, тогда функция вернет либо
              *          обещание, либо первый элемент.
              * @async
              */
             export function first<T>(
                 sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 cb?: (x: T) => void,
                 err?: (x: Error) => void
             ) {
                 if (isPromise(sequence)) {
                     return sequence.then(res => first(res, cb, err));
                 } else if (sequence && "length" in sequence) {
                     if (sequence.length === 0) {
                         if (err)
                             return err(new Error("The sequence is empty"));
                         else
                             throw new Error("The sequence is empty");
                     } else if (cb) {
                         cb(sequence[0]);
                     } else {
                         return sequence[0];
                     }
                 } else {
                     if (err)
                         err(new Error("The sequence is required"));
                     else
                         throw new Error("The sequence is required");
                 }
             }
             export function firstWhere<T>(
                 sequence: ArrayLike<T>,
                 predicate: (x: T) => boolean
             ): T;
             export function firstWhere<T>(
                 sequence: PromiseLike<ArrayLike<T>>,
                 predicate: (x: T) => boolean
             ): PromiseLike<T>;
             export function firstWhere<T>(
                 sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 predicate: (x: T) => boolean,
                 cb: (x: T) => void,
                 err?: (x: Error) => void
             ): void;
             export function firstWhere<T>(
                 sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 predicate?: (x: T) => boolean,
                 cb?: (x: T) => any,
                 err?: (x: Error) => any
             ) {
                 if (isPromise(sequence)) {
                     return sequence.then(res => firstWhere(res, predicate, cb, err));
                 } else if (sequence && "length" in sequence) {
                     if (sequence.length === 0) {
                         if (err)
                             err(new Error("The sequence is empty"));
                         else
                             throw new Error("The sequence is empty");
                     } else {
                         if (!predicate) {
                             return cb ? cb(sequence[0]) && void (0) : sequence[0];
                         } else {
                             for (let i = 0; i < sequence.length; i++) {
                                 const v = sequence[i];
                                 if (predicate(v))
                                     return cb ? cb(v) : v;
                             }
                             if (err)
                                 err(new Error("The sequence doesn't contain matching items"));
                             else
                                 throw new Error("The sequence doesn't contain matching items");
                         }
                     }
                 } else {
                     if (err)
                         err(new Error("The sequence is required"));
                     else
                         throw new Error("The sequence is required");
                 }
             }
             export function destroy(d: any) {
                 if (d && "destroy" in d)
                     d.destroy();
             }
             /**
              * Used to mark that the async operation isn't awaited intentionally.
              * @param p The promise which represents the async operation.
              */
             export function nowait(p: Promise<any>) {
             }
             /** represents already destroyed object.
              */
             export const destroyed = {
                 /** Calling to this method doesn't affect anything, noop.
                  */
                 destroy() {
                 }
             };

src/test/ts/CancellationTests.ts +1 -2

             import * as tape from "tape";
             import { Cancellation } from "@implab/core/Cancellation";
-            import { ICancellation } from "@implab/core/interfaces";
+            import { delay } from "@implab/core/safe";
-            import { delay } from "./TestTraits";
             tape("standalone cancellation", async t => {
                 let doCancel: (e) => void;
                 const ct = new Cancellation(cancel => {
                     doCancel = cancel;
                 });
                 let counter = 0;
                 const reason = "BILL";
                 t.true(ct.isSupported(), "Cancellation must be supported");
                 t.false(ct.isRequested(), "Cancellation shouldn't be requested");
                 ct.throwIfRequested();
                 t.pass("The exception shouldn't be thrown unless the cancellation is requested");
                 ct.register(() => counter++);
                 t.equals(counter, 0, "counter should be zero");
                 ct.register(() => counter++).destroy();
                 doCancel(reason);
                 t.true(ct.isRequested(), "Cancellation should be requested");
                 t.equals(counter, 1, "The registered callback should be triggered");
                 ct.register(() => counter++);
                 t.equals(counter, 2, "The callback should be triggered immediately");
                 let msg;
                 ct.register(e => msg = e);
                 t.equals(msg, reason, "The cancellation reason should be passed to callback");
                 try {
                     msg = null;
                     ct.throwIfRequested();
                     t.fail("The exception should be thrown");
                 } catch (e) {
                     msg = e;
                 }
                 t.equals(msg, reason, "The cancellation reason should be catched");
                 t.end();
             });
             tape("async cancellation", async t => {
                 const ct = new Cancellation(cancel => {
                     cancel("STOP!");
                 });
                 try {
                     await delay(0, ct);
                     t.fail("Should thow the exception");
                 } catch (e) {
                     t.equals(e, "STOP!", "Should throw the cancellation reason");
                 }
                 t.end();
             });
             tape("cancel with external event", async t => {
                 const ct = new Cancellation(cancel => {
                     setTimeout(x => cancel("STOP!"), 0);
                 });
                 try {
                     await delay(10000, ct);
                     t.fail("Should thow the exception");
                 } catch (e) {
                     t.equals(e, "STOP!", "Should throw the cancellation reason");
                 }
                 t.end();
             });
             tape("operation normal flow", async t => {
                 let htimeout;
                 const ct = new Cancellation(cancel => {
                     htimeout = setTimeout(() => cancel("STOP!"), 1000);
                 });
                 try {
                     await delay(0, ct);
                     t.pass("Should pass");
                 } finally {
                     clearTimeout(htimeout);
                 }
                 t.end();
             });

src/test/ts/ObservableTests.ts +1 -1

             import { TraceSource, DebugLevel } from "@implab/core/log/TraceSource";
             import * as tape from "tape";
-            import { TapeWriter, delay } from "./TestTraits";
             import { Observable } from "@implab/core/Observable";
             import { IObservable } from "@implab/core/interfaces";
+            import { delay } from "@implab/core/safe";
             const trace = TraceSource.get("ObservableTests");
             tape("events sequence example", async t => {
                 let events: IObservable<number>;
                 const done = new Promise<void>(resolve => {
                     events = new Observable<number>(async (notify, fail, finish) => {
                         for (let i = 0; i < 10; i++) {
                             await delay(0);
                             notify(i);
                         }
                         finish();
                         resolve();
                     });
                 });
                 let count = 0;
                 let complete = false;
                 events.on(x => count = count + x, null, () => complete = true);
                 const first = await events.next();
                 t.equals(first, 0, "the first event");
                 t.false(complete, "the sequence is not complete");
                 await done;
                 t.equals(count, 45, "the summ of the evetns");
                 t.true(complete, "the sequence is complete");
                 t.end();
             });
             tape("event sequence termination", async t => {
                 let events: IObservable<number>;
                 const done = new Promise<void>(resolve => {
                     events = new Observable<number>(async (notify, fail, complete) => {
                         await delay(0);
                         notify(1);
                         complete();
                         notify(2);
                         complete();
                         fail("Sequence terminated");
                         resolve();
                     });
                 });
                 let count = 0;
                 events.on(() => {}, e => count++, () => count++);
                 const first = await events.next();
                 t.equals(first, 1, "the first message");
                 try {
                     await events.next();
                     t.fail("shoud throw an exception");
                 } catch (e) {
                     t.pass("the sequence is terminated");
                 }
                 await done;
                 t.equals(count, 1, "the sequence must be terminated once");
                 t.end();
             });

src/test/ts/SafeTests.ts +24 -11

             import tape = require("tape");
-            import { delay } from "./TestTraits";
             import { Cancellation } from "@implab/core/Cancellation";
-            import { first, isPromise } from "@implab/core/safe";
+            import { first, isPromise, firstWhere, delay, nowait } from "@implab/core/safe";
             tape("await delay test", async t => {
                 // schedule delay
                 let resolved = false;
                 let res = delay(0).then(() => resolved = true);
                 t.false(resolved, "the delay should be async");
                 await res;
                 t.pass("await delay");
                 // create cancellation token
                 let cancel: (e?: any) => void;
                 const ct = new Cancellation(c => cancel = c);
                 // schedule delay
                 resolved = false;
                 res = delay(0, ct).then(() => resolved = true);
                 t.false(resolved, "created delay with ct");
                 // cancel
                 cancel();
                 try {
                     await res;
                     t.fail("the delay should fail when it is cancelled");
                 } catch {
                     t.pass("the delay is cancelled");
                 }
-                let died = false;
+                t.throws(() => {
+                    // try schedule delay after the cancellation is requested
-                // try schedule delay after the cancellation is requested
+                    nowait(delay(0, ct));
-                res = delay(0, ct).then(x => true, () => died = true);
+                }, "Should throw if cancelled before start");
-                t.false(died, "The delay should be scheduled even if the cancellation is requested");
-                await res;
-                t.true(died, "the delay should fail when cancelled");
                 t.end();
             });
             tape("sequemce test", async t => {
                 const sequence = ["a", "b", "c"];
                 const empty = [];
                 // synchronous tests
                 t.equals(first(sequence), "a", "Should return the first element");
+                t.equals(firstWhere(sequence, x => x === "b"), "b", "Should get the second element");
                 let v: string;
                 let e: Error;
                 first(sequence, x => v = x);
                 t.equal(v, "a", "The callback should be called for the first element");
+                firstWhere(sequence, x => x === "b", x => v = x);
+                t.equal(v, "b", "The callback should be called for the second element");
                 t.throws(() => {
                     first(empty);
                 }, "Should throw when the sequence is empty");
                 t.throws(() => {
+                    firstWhere(empty, x => x === "b");
+                }, "Should throw when the sequence is empty");
+                t.throws(() => {
                     first(empty, x => v = x);
                 }, "Should throw when the sequence is empty");
+                t.throws(() => {
+                    firstWhere(empty, x => x === "b", x => v = x);
+                }, "Should throw when the sequence is empty");
+                t.throws(() => {
+                    firstWhere(sequence, x => x === "z");
+                }, "Should throw when the element isn't found");
+                t.throws(() => {
+                    firstWhere(sequence, x => x === "z", x => v = x);
+                }, "Should throw when the element isn't found");
                 first(empty, null, x => e = x);
                 t.true(e, "The errorback should be called for the empty sequence");
                 // async tests
                 const asyncSequence = Promise.resolve(sequence);
                 const asyncEmptySequence = Promise.resolve(empty);
                 const promise = first(asyncSequence);
                 t.true(isPromise(promise), "Should return promise");
                 v = await promise;
                 t.equal(v, "a", "Should return the first element");
                 v = await new Promise(resolve => first(asyncSequence, resolve));
                 t.equal(v, "a", "The callback should be called for the first element");
                 t.end();
             });

src/test/ts/TestTraits.ts 0 -23

             import { IObservable, ICancellation, IDestroyable } from "@implab/core/interfaces";
             import { Cancellation } from "@implab/core/Cancellation";
             import { TraceEvent, LogLevel, WarnLevel, DebugLevel, TraceSource } from "@implab/core/log/TraceSource";
             import * as tape from "tape";
             import { argumentNotNull, destroy } from "@implab/core/safe";
             export class TapeWriter implements IDestroyable {
                 readonly _tape: tape.Test;
                 _subscriptions = new Array<IDestroyable>();
                 constructor(t: tape.Test) {
                     argumentNotNull(t, "tape");
                     this._tape = t;
                 }
                 writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
                     const subscription = source.on(this.writeEvent.bind(this));
                     if (ct.isSupported()) {
                         ct.register(subscription.destroy.bind(subscription));
                     }
                     this._subscriptions.push(subscription);
                 }
                 writeEvent(next: TraceEvent) {
                     if (next.level >= DebugLevel) {
                         this._tape.comment(`DEBUG ${next.source.id} ${next.arg}`);
                     } else if (next.level >= LogLevel) {
                         this._tape.comment(`LOG   ${next.source.id} ${next.arg}`);
                     } else if (next.level >= WarnLevel) {
                         this._tape.comment(`WARN  ${next.source.id} ${next.arg}`);
                     } else {
                         this._tape.comment(`ERROR ${next.source.id} ${next.arg}`);
                     }
                 }
                 destroy() {
                     this._subscriptions.forEach(destroy);
                 }
             }
-            export async function delay(timeout: number, ct: ICancellation = Cancellation.none) {
-                let un: IDestroyable;
-                try {
-                    await new Promise((resolve, reject) => {
-                        if (ct.isRequested()) {
-                            un = ct.register(reject);
-                        } else {
-                            const ht = setTimeout(() => {
-                                resolve();
-                            }, timeout);
-                            un = ct.register(e => {
-                                clearTimeout(ht);
-                                reject(e);
-                            });
-                    });
-                } finally {
-                    destroy(un);
             export function test(name: string, cb: (t: tape.Test) => any) {
                 tape(name, async t => {
                     const writer = new TapeWriter(t);
                     TraceSource.on(ts => {
                         ts.level = DebugLevel;
                         writer.writeEvents(ts.events);
                     });
                     try {
                         await cb(t);
                     } catch (e) {
                         // verbose error information
                         // tslint:disable-next-line
                         console.error(e);
                         t.fail(e);
                     } finally {
                         t.end();
                         destroy(writer);
                     }
                 });
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages