implab/implabjs-core Commit - r18:a8dda6a00a16

added CancellationTests...

cin -

r18:a8dda6a00a16 propose cancellat...

parent child

Context file:

r18:a8dda6a00a16

Collapse all files

.npmignore created 644 +1 0

	@@ -0,0 +1,1
				1	*.tgz No newline at end of file

docs/cancellations.ru.md created 644 +257 0

@@ -0,0 +1,257
	1	# Cancellations. Отмена асинхронных операций
	2
	3	Использование Promise позволяет организовать обработку результатов работы
	4	асинхронных фукнций. Ключевые слова async/await позволяют работать с
	5	асинхронными вызовами в стиле процедурного программирования, хотя по сути это
	6	событиный подход. При всей своей красоте даннго подхода в нем умышленно
	7	отсутсвует механизм отмены асинхронной операции, т.е. ее можно начать, но нельзя
	8	отказаться от результатов ее выполнения, даже если это уже не требуется.
	9
	10	Примером того, когда может потребоваться отмена является загрузка большого
	11	файла, при которой пользователю отображается окно хода операции с возможностью
	12	ее отмены.
	13
	14	```ts
	15	// имеется некоторый HTTP клиент
	16	let client = new HttpClient();
	17
	18	// загружается большой файл, с использованием медленного канала
	19	let data = await client.getJsonAsync('http://host/large-file.json');
	20
	21	```
	22
	23	Как поступить в данной ситуации, прежде всего нужно, чтобы сама операция
	24	поддерживала возможность отмены, предположим, что для этого есть метод
	25	`client.abort()`.
	26
	27	```ts
	28
	29	// имеется некоторый HTTP клиент
	30	let client = new HttpClient();
	31
	32	// отображаем окно с информацией о хоже операции
	33	let progressView = showProgress("Downloading, please wait...");
	34
	35	// код оборачивается в try/finally поскольку созданную форму нужно закрыть
	36	try {
	37	// загружается большой файл, с использованием медленного канала
	38	// здесь, в отличии от предыдущего примера, мы не дожидаемся результата,
	39	// а запоминаем обещание в переменную downloadTask
	40	let downloadTask = client.getJsonAsync('http://host/large-file.json');
	41
	42	// связываем нажатие кнопки с отменой загрузки
	43	progressView.once('cancel', () => client.abort());
	44
	45	// ожидаем окончания загрузки данных
	46
	47	let data = await downloadTask;
	48	} finally {
	49	// независимот от результата закрываем форму
	50	// при этом также происходит ануллирование подписок на события
	51	progressView.close();
	52	}
	53
	54	```
	55
	56	Технические приведенное решение выглядит не плохо, но проблемы появляются, когда
	57	требуется организовать отмену нескольких операций, особенно если они вложенные.
	58
	59	```ts
	60	// обновление информации о человеке на форме
	61	async function updatePersonInfo(info) {
	62	let client = new RestApiClient();
	63
	64	// выплнение нескольких асинхронных операций
	65	let org = await client.getOrgAsync(info.orgId);
	66	let city = await client.getCityAsync(info.cityId);
	67
	68	// обновление содержимого представления
	69	renderContent({
	70	person: info,
	71	org: org,
	72	city: city
	73	});
	74	}
	75
	76	```
	77
	78	Чтобы реализовать возможность отмены такой операции требуется, чтобы в логике
	79	самой операции была реализована поддержка отмены. Для реализации этого
	80	потребуется чтобы у операции была информация о запросе отмены, причем данная
	81	информация относится именно к текущей операции.
	82
	83	Информацию о состоянии запроса на отмену назовет **маркер отмены (cancellation
	84	token)**. Поскольку маркер отмены тесно связан с операцией, его удобно
	85	передавать в виде параметра, тогда код операции будет выглядеть так:
	86
	87	```ts
	88	// обновление информации о человеке на форме
	89	// ct - маркер отмены
	90	async function updatePersonInfo(info, ct) {
	91	let client = new RestApiClient();
	92
	93	// выплнение нескольких асинхронных операций
	94	// маркер отмены просто передается далее по цепочке вызовов, без
	95	// дополнительных действий
	96	let org = await client.getOrg(info.orgId, ct);
	97	let city = await client.getCity(info.cityId, ct);
	98
	99	// обновление содержимого представления
	100	renderContent({
	101	person: info,
	102	org: org,
	103	city: city
	104	});
	105	}
	106
	107	///////////////////////////////////////////////////////////////////////////////
	108	// ... где-то в другом месте
	109	///////////////////////////////////////////////////////////////////////////////
	110
	111	// отображаем окно с информацией о хоже операции
	112	let progressView = showProgress("Loading, please wait...");
	113
	114	// создаем маркер отмены для операции на основе события 'cancel'.
	115	let ct = new Cancellation(cancel => progressView.on('cancel', cancel));
	116
	117	// код оборачивается в try/finally поскольку созданную форму нужно закрыть
	118	try {
	119	// асинхронно получаем информацию о человеке
	120	let data = await getPersonInfo(personId, ct);
	121
	122	// асинхронно обновляем представление
	123	await updatePersonInfo(data, ct);
	124	} finally {
	125	// независимот от результата закрываем форму
	126	// при этом также происходит ануллирование подписок на события
	127	progressView.close();
	128	}
	129
	130	```
	131
	132	Таким образом тот, кто начинает асинхронную операцию заранее определяет как эта
	133	опреция будет отменена.
	134
	135	Важно понимать, что для реализации отмены операции
	136	могут выделаться ресурсы требующие явного освобождения (DOM, таймеры, события),
	137	об их освобождении по окончанию операции (успешном или нет) должен позаботиться
	138	инициатор этой операции. `Cancellation` выступает только в роли посредника для
	139	доставки события отмены операции до конечного получателя, он не отслеживает и
	140	не освобождает ресурсы, кроме того, асинхронная операция может его попросту
	141	проигнорировать.
	142
	143	## `ICancellation` Маркер отмены операции
	144
	145	Интерфейс маркера отмены операции. Используется асинхронными операциями, чтобы
	146	получить оповещение о требуемой отмене.
	147
	148	### `isSupported(): boolean`
	149
	150	Определяет, может ли быть запрошена отмена операции через данный маркер.
	151
	152	### `isRequested(): boolean`
	153
	154	Возвращает текущее состояние запроса на отмену.
	155
	156	### `throwIfRequested(): void`
	157
	158	Если отмена была запрошена, бросает в качестве исключения причину отмены.
	159
	160	### `register(cb: (e:any) => void): IDestroyable`
	161
	162	Метод, зарегистрировать обработчик на запрос отмены. Если отмена была запрошена
	163	зарегистрированный обработчик будет вызван ровно один раз, независимо от того,
	164	был ли он зарегистрирован до или после запроса отмены.
	165
	166	Если отмена уже была запрошена, обработчик будет вызван сразу при регистрации,
	167	при этом исключения, которые могу возникнуть в обработчике не будут обработаны,
	168	а передадуться наверх.
	169
	170	Вызов данного метода приводит к выделению ресурсов, поэтому операция,
	171	зарегистрировавшая обработчик должна освободить подписку, которую вернет метод.
	172
	173	```ts
	174	async function getAsync(url: string, ct: ICancellation = Cancellation.none) {
	175	// переменная в которой будет запомнена подписка на запрос отмены
	176	let reg;
	177	try {
	178	// оборачиваем операцию загрузки в Promise
	179	return await new Promise<string>((resolve, reject) => {
	180	// объект Xhr
	181	const xhr = new XMLHttpRequest();
	182	xhr.open("GET", url);
	183
	184	// регистрируем обработчики Promise
	185	xhr.onload = () => resolve(xhr.responseText);
	186	xhr.onerror = () => reject(xhr.statusText);
	187
	188	// отправляем запрос
	189	xhr.send();
	190
	191	// подписываемся на запрос отмены
	192	reg = ct.register((e) => {
	193	reject(e);
	194	xhr.abort();
	195	});
	196	});
	197	} finally {
	198	if (reg)
	199	reg.destroy();
	200	}
	201	}
	202
	203	```
	204
	205	Использование метода `register()` предполагается для организации отмены операций
	206	не поддерживающих маркеры отмены.
	207
	208	## `Cancellation` Источник отмены
	209
	210	Класс используется для создания маркеров отмены. Позволяет создать маркер при
	211	начале асинхронной операции и связать его, например, с событием DOM.
	212
	213	Также маркер можно создавать, когда требуется сложное условие отмены текущей и
	214	всех нижележещих операций.
	215
	216	Как правило в большинстве операций достаточно маркера переданного в параметрах,
	217	этот же маркер может передаваться ниже.
	218
	219	### `constructor(exec: (cancel: (reason:any) => void ) => void )`
	220
	221	Создает новый маркер, при помощи параметра и инициализирует его при помощи
	222	фукнции, переданной в параметре `exec`.
	223
	224	```ts
	225
	226	let htimer;
	227	let ct = new Cancellation(cancel => {
	228	htimer = setTimeout(() => cancel("The request is timed out."), 1000);
	229	});
	230
	231	try {
	232	let text = await getAsync(url, ct);
	233	} finally {
	234	// инициатор должен освобождать ресурсы
	235	// передача недействительного htimer не приводит ни к каким последствиям
	236	clearTimeout(htimer);
	237	}
	238
	239	```
	240
	241	## `Cancellation.none: ICancellation`
	242
	243	Статическое свойство только для чтения, в котором находится специальный токен
	244	запроса отмены. Этот токен означает, что отмена никогда не может произойти.
	245
	246	Данный токен рекомендуется использовать как значение по-умолчанию для
	247	параметров, принимающих токен отмены.
	248
	249	```ts
	250
	251	async function load(url: string, ct: ICancellation = Cancellation.none) {
	252	ct.throwIfRequested();
	253
	254	// ... the rest of method
	255	}
	256
	257	``` No newline at end of file

test/ts/CancellationTests.ts created 644 +97 0

@@ -0,0 +1,97
	1	import * as tape from 'tape';
	2	import { Cancellation } from '@implab/core/Cancellation';
	3	import { ICancellation } from '@implab/core/interfaces';
	4	import { delay } from './TestTraits';
	5
	6	tape('standalone cancellation', async t => {
	7
	8	let doCancel: (e) => void;
	9
	10	let ct = new Cancellation(cancel => {
	11	doCancel = cancel;
	12	});
	13
	14	let counter = 0;
	15	let reason = "BILL";
	16
	17	t.true(ct.isSupported(), "Cancellation must be supported");
	18	t.false(ct.isRequested(), "Cancellation shouldn't be requested");
	19	ct.throwIfRequested();
	20	t.pass("The exception shouldn't be thrown unless the cancellation is requested");
	21
	22	ct.register(() => counter++);
	23	t.equals(counter, 0, "counter should be zero");
	24
	25	ct.register(() => counter++).destroy();
	26
	27	doCancel(reason);
	28
	29	t.true(ct.isRequested(), "Cancellation should be requested");
	30	t.equals(counter, 1, "The registered callback should be triggered");
	31
	32	ct.register(() => counter++);
	33	t.equals(counter, 2, "The callback should be triggered immediately");
	34
	35	let msg;
	36	ct.register((e) => msg = e);
	37	t.equals(msg, reason, "The cancellation reason should be passed to callback");
	38
	39	try {
	40	msg = null;
	41	ct.throwIfRequested();
	42	t.fail("The exception should be thrown");
	43	} catch (e) {
	44	msg = e;
	45	}
	46	t.equals(msg, reason, "The cancellation reason should be catched");
	47
	48	t.end();
	49	});
	50
	51	tape('async cancellation', async t => {
	52
	53	let ct = new Cancellation(cancel => {
	54	cancel("STOP!");
	55	});
	56
	57	try {
	58	await delay(0, ct);
	59	t.fail("Should thow the exception");
	60	} catch (e) {
	61	t.equals(e, "STOP!", "Should throw the cancellation reason");
	62	}
	63
	64	t.end();
	65	});
	66
	67	tape('cancel with external event', async t => {
	68	let ct = new Cancellation((cancel) => {
	69	setTimeout(x => cancel('STOP!'), 0);
	70	})
	71
	72	try {
	73	await delay(10000, ct);
	74	t.fail("Should thow the exception");
	75	} catch (e) {
	76	t.equals(e, "STOP!", "Should throw the cancellation reason");
	77	}
	78
	79	t.end();
	80	});
	81
	82	tape('operation normal flow', async t => {
	83
	84	let htimeout;
	85	let ct = new Cancellation((cancel) => {
	86	htimeout = setTimeout(() => cancel("STOP!"), 1000);
	87	});
	88
	89	try {
	90	await delay(0, ct);
	91	t.pass("Should pass");
	92	} finally {
	93	clearTimeout(htimeout);
	94	}
	95
	96	t.end();
	97	}); No newline at end of file

build.gradle +1 -1

             println "version: $version"
             def distDir = "$buildDir/dist"
             def testDir = "$buildDir/test"
             task clean {
                 doLast {
                     delete buildDir
                     delete 'node_modules/@implab'
                 }
             }
             task cleanNpm {
                 doLast {
                     delete 'node_modules'
                 }
             }
             task _npmInstall() {
                 inputs.file("package.json")
                 outputs.dir("node_modules")
                 doLast {
                     exec {
                         commandLine 'npm', 'install'
                     }
                 }
             }
             task _legacyJs(type:Copy) {
                 from 'src/js/'
                 into distDir
             }
             task _buildTs(dependsOn: _npmInstall, type:Exec) {
                 inputs.dir('src/ts')
                 inputs.file('tsc.json')
                 outputs.dir(distDir)
                 commandLine 'node_modules/.bin/tsc', '-p', 'tsc.json'
             }
             task _packageMeta(type: Copy) {
                 inputs.property("version", version)
                 from('.') {
-                    include 'package.json', 'readme.md', 'license', 'history.md'
+                    include 'package.json', '.npmignore', 'readme.md', 'license', 'history.md'
                 }
                 into distDir
                 doLast {
                     exec {
                         workingDir distDir
                         commandLine 'npm', 'version', version
                     }
                 }
             }
             task build(dependsOn: [_npmInstall, _buildTs, _legacyJs, _packageMeta]) {
             }
             task _localInstall(dependsOn: build, type: Exec) {
                 inputs.file("$distDir/package.json")
                 outputs.upToDateWhen {
                     new File("$projectDir/node_modules/@implab/core").exists()
                 }
                 commandLine 'npm', 'install', '--no-save', '--force', distDir
             }
             task copyJsTests(type: Copy) {
                 from 'test/js'
                 into testDir
             }
             task buildTests(dependsOn: _localInstall, type: Exec) {
                 inputs.dir('test/ts')
                 inputs.file('tsc.test.json')
                 outputs.dir(testDir)
                 commandLine 'node_modules/.bin/tsc', '-p', 'tsc.test.json'
             }
             task test(dependsOn: [copyJsTests, buildTests], type: Exec) {
                 commandLine 'node', 'run-amd-tests.js'
             }
             task pack(dependsOn: build, type: Exec) {
                 workingDir = distDir
                 commandLine 'npm', 'pack'
             }

src/ts/Cancellation.ts +25 -3

-            import { ICancellation } from "./interfaces";
+            import { ICancellation, IDestroyable } from "./interfaces";
             import { argumentNotNull } from "./safe";
+            const destroyed = {
+                destroy() {
+                }
+            };
             export class Cancellation implements ICancellation {
                 private _reason: any;
                 private _cbs: Array<(e) => void>;
                 constructor(action: (cancel: (e) => void) => void) {
                     argumentNotNull(action, "action");
                     action(this._cancel.bind(this));
                 }
                 isSupported(): boolean {
                     return true;
                 }
                 throwIfRequested(): void {
                     if (this._reason)
                         throw this._reason;
                 }
                 isRequested(): boolean {
                     return !!this._reason;
                 }
-                register(cb: (e: any) => void): void {
+                register(cb: (e: any) => void): IDestroyable {
                     argumentNotNull(cb, "cb");
                     if (this._reason) {
                         cb(this._reason);
+                        return destroyed;
                     } else {
                         if (!this._cbs)
                             this._cbs = [cb];
                         else
                             this._cbs.push(cb);
+                        let me = this;
+                        return {
+                    	destroy() {
+                    	    me._unregister(cb);
+                    	}
+                        };
+                    }
+                }
+                private _unregister(cb) {
+            	if(this._cbs) {
+            	    let i = this._cbs.indexOf(cb);
+            	    if ( i>=0 )
+            		this._cbs.splice(i,1);
             	}
                 }
                 private _cancel(reason) {
                     if (this._reason)
                         return;
                     this._reason = (reason = reason || new Error("Operation cancelled"));
                     if (this._cbs) {
                         this._cbs.forEach(cb => cb(reason));
                         this._cbs = null;
                     }
                 }
                 static readonly none: ICancellation = {
                     isSupported(): boolean {
                         return false;
                     },
                     throwIfRequested(): void {
                     },
                     isRequested(): boolean {
                         return false;
                     },
-                    register(_cb: (e: any) => void): void {
+                    register(_cb: (e: any) => void): IDestroyable {
+                	    return destroyed;
                     }
                 };
             }

src/ts/components/Observable.ts +10 -27

             import { IObservable, IDestroyable, ICancellation } from '../interfaces';
             import { Cancellation } from '../Cancellation'
             import { argumentNotNull } from '../safe';
             interface Handler<T> {
                 (x: T): void
             }
             interface Initializer<T> {
-                (notify: Handler<T>, error?: (e: any) => void, complete?: () => void): (() => void) | void;
+                (notify: Handler<T>, error?: (e: any) => void, complete?: () => void): void;
             }
             // TODO: think about to move this interfaces.ts and make it public
             interface IObserver<T> {
                 next(event: T): void
                 error(e: any): void
                 complete(): void
             }
-            class Observable<T> implements IObservable<T>, IDestroyable {
+            const noop = () => {};
+            class Observable<T> implements IObservable<T> {
                 private _once = new Array<IObserver<T>>();
                 private _observers = new Array<IObserver<T>>();
-                private _cleanup: (() => void) | void;
                 private _complete: boolean
                 private _error: any
                 constructor(func?: Initializer<T>) {
-                    this._cleanup = func && func(
+                    if (func)
+                        func(
                             this._notifyNext.bind(this),
                             this._notifyError.bind(this),
                             this._notifyCompleted.bind(this)
                         );
                 }
                 /**
                  * Registers handlers for the current observable object.
                  *
                  * @param next the handler for events
                  * @param error the handler for a error
                  * @param complete the handler for a completion
                  * @returns {IDestroyable} the handler for the current subscription, this
                  *  handler can be used to unsubscribe from events.
                  *
                  */
                 on(next: Handler<T>, error?: Handler<any>, complete?: () => void): IDestroyable {
                     argumentNotNull(next, "next");
                     let me = this;
                     let observer: IObserver<T> & IDestroyable = {
                         next: next,
+                        error: error ? error.bind(null) : noop,
-                        error(e: any) {
+                        complete: complete ? complete.bind(null) : noop,
-                            if (error)
-                                error(e);
-                        },
-                        complete() {
-                            if (complete)
-                                complete();
-                        },
                         destroy() {
                             me._removeObserver(this);
                         }
                     }
                     this._addObserver(observer);
                     return observer;
                 }
                 private _addObserver(observer: IObserver<T>) {
                     if (this._complete) {
                         try {
                             if (this._error)
                                 observer.error(this._error);
                             else
                                 observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     } else {
                         this._observers.push(observer);
                     }
                 }
                 /**
                  * Waits for the next event. This method can't be used to read messages
                  * as a sequence since it can skip some messages between calls.
                  *
                  * @param ct a cancellation token
                  */
                 next(ct: ICancellation = Cancellation.none): Promise<T> {
                     return new Promise<T>((resolve, reject) => {
                         let observer: IObserver<T> = {
                             next: resolve,
                             error: reject,
                             complete: () => reject("No more events are available")
                         };
                         if (this._addOnce(observer) && ct.isSupported()) {
                             ct.register((e) => {
                                 this._removeOnce(observer);
                                 reject(e);
                             });
                         }
                     });
                 }
                 private _addOnce(observer: IObserver<T>) {
                     if (this._complete) {
                         try {
                             if (this._error)
                                 observer.error(this._error);
                             else
                                 observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                         return false;
                     }
                     this._once.push(observer);
                     return true;
                 }
-                destroy() {
-                    if (this._complete)
-                        this._notifyCompleted();
-                    let cleanup = this._cleanup;
-                    if (cleanup) {
-                        this._cleanup = null;
-                        cleanup();
                 protected onObserverException(e: any) {
                 }
                 private _removeOnce(d: IObserver<T>) {
                     let i = this._once.indexOf(d);
                     if (i >= 0)
-                        this._once.splice(i);
+                        this._once.splice(i, 1);
                 }
                 private _removeObserver(d: IObserver<T>) {
                     let i = this._observers.indexOf(d);
                     if (i >= 0)
-                        this._observers.splice(i);
+                        this._observers.splice(i, 1);
                 }
                 private _notify(guard: (observer: IObserver<T>) => void) {
                     if (this._once.length) {
                         for (let i = 0; i < this._once.length; i++)
                             guard(this._once[i]);
                         this._once = [];
                     }
                     for (let i = 0; i < this._observers.length; i++)
                         guard(this._observers[i]);
                 }
                 protected _notifyNext(evt: T) {
                     let guard = (observer: IObserver<T>) => {
                         try {
                             observer.next(evt);
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     }
                     this._notify(guard);
                 }
                 protected _notifyError(e: any) {
                     let guard = (observer: IObserver<T>) => {
                         try {
                             observer.error(e);
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     }
                     this._notify(guard);
                     this._observers = [];
                 }
                 protected _notifyCompleted() {
                     let guard = (observer: IObserver<T>) => {
                         try {
                             observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     }
                     this._notify(guard);
                     this._observers = [];
                 }
             }
             namespace Observable {
             }
             export = Observable;

src/ts/interfaces.ts +1 -1

             export interface IDestroyable {
                 destroy();
             }
             export interface ICancellation {
                 throwIfRequested(): void;
                 isRequested(): boolean;
                 isSupported(): boolean;
-                register(cb: (e: any) => void): void;
+                register(cb: (e: any) => void): IDestroyable;
             }
             /**
              * Интерфейс поддерживающий асинхронную активацию
              */
             export interface IActivatable {
                 /**
                  * @returns Boolean indicates the current state
                  */
                 isActive(): boolean;
                 /**
                  * Starts the component activation
                  * @param ct cancellation token for this operation
                  */
                 activate(ct?: ICancellation) : Promise<void>;
                 /**
                  * Starts the component deactivation
                  * @param ct cancellation token for this operation
                  */
                 deactivate(ct?: ICancellation) : Promise<void>;
                 /**
                  * Sets the activation controller for this component
                  * @param controller The activation controller
                  *
                  * Activation controller checks whether this component
                  * can be activated and manages the active state of the
                  * component
                  */
                 setActivationController(controller: IActivationController);
                 /**
                  * Gets the current activation controller for this component
                  */
                 getActivationController(): IActivationController;
             }
             export interface IActivationController {
                 activating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 activated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivate(ct?: ICancellation): Promise<void>;
                 activate(component: IActivatable, ct?: ICancellation): Promise<void>;
                 getActive(): IActivatable;
             }
             export interface IAsyncComponent {
                 getCompletion(): Promise<void>;
             }
             export interface ICancellable {
                 cancel(reason?: any): void;
             }
             export interface IObservable<T> {
                 on(next: (x:T) => void, error?: (e:any) => void, complete?:() => void): IDestroyable;
                 next(ct?: ICancellation) : Promise<T>;
             }

test/js/plan.js +2 -1

@@ -1,1 +1,2
1	define(["./ActivatableTests", "./trace-test", "./TraceSourceTests"]); No newline at end of file	1	define(["./ActivatableTests", "./trace-test", "./TraceSourceTests", "./CancellationTests"]);
		2	//define(["./CancellationTests"]); No newline at end of file

test/ts/TestTraits.ts +24 0

             import { IObservable, ICancellation, IDestroyable } from "../../build/dist/interfaces";
             import * as TraceEvent from '../../build/dist/log/TraceEvent';
             import { Cancellation } from "../../build/dist/Cancellation";
             import * as TraceSource from "../../build/dist/log/TraceSource";
             import * as tape from 'tape';
             import { argumentNotNull } from "../../build/dist/safe";
             export class TapeWriter implements IDestroyable {
                 readonly _tape: tape.Test
                 _subscriptions = new Array<IDestroyable>();
                 constructor(tape: tape.Test) {
                     argumentNotNull(tape, "tape");
                     this._tape = tape;
                 }
                 writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
                     let 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 >= TraceSource.LogLevel) {
                         this._tape.comment("LOG " + next.arg);
                     } else if (next.level >= TraceSource.WarnLevel) {
                         this._tape.comment("WARN " + next.arg);
                     } else {
                         this._tape.comment("ERROR " + next.arg);
                     }
                 }
                 destroy() {
                     this._subscriptions.forEach(x => x.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 {
+                		let ht = setTimeout(() => {
+                		    resolve();
+                    	    }, timeout);
+            	    	un = ct.register(e => {
+                	    	    clearTimeout(ht);
+                		    reject(e);
+                	        });
+                	    }
+            	});
+                } finally {
+            	if(un)
+            	    un.destroy();
+                };
             }

test/ts/TraceSourceTests.ts +1 -2

-            import * as TraceSource from '../../build/dist/log/TraceSource'
+            import * as TraceSource from '@implab/core/log/TraceSource'
             import * as tape from 'tape';
-            import * as ConsoleWriter from '../../build/dist/log/writers/ConsoleWriter';
             import { TapeWriter } from './TestTraits';
             const sourceId = 'test/TraceSourceTests';
             tape('trace message', t => {
                 let trace = TraceSource.get(sourceId);
                 trace.level = TraceSource.DebugLevel;
                 let h = trace.on((ev) => {
                     t.equal(ev.source, trace, "sender should be the current trace source");
                     t.equal(ev.level, TraceSource.DebugLevel, "level should be debug level");
                     t.equal(ev.arg, "Hello, World!", "The message should be a formatted message");
                     t.end();
                 });
                 trace.debug("Hello, {0}!", "World");
                 h.destroy();
             });
             tape('trace event', t => {
                 let trace = TraceSource.get(sourceId);
                 trace.level = TraceSource.DebugLevel;
                 let event = {
                     name: "custom event"
                 };
                 let h = trace.on((ev) => {
                     t.equal(ev.source, trace, "sender should be the current trace source");
                     t.equal(ev.level, TraceSource.DebugLevel, "level should be debug level");
                     t.equal(ev.arg, event, "The message should be the specified object");
                     t.end();
                 });
                 trace.traceEvent(TraceSource.DebugLevel, event);
                 h.destroy();
             });
             tape('tape comment writer', async t => {
                 let writer = new TapeWriter(t);
                 TraceSource.on(ts => {
                     writer.writeEvents(ts);
                 });
                 let trace = TraceSource.get(sourceId);
                 trace.level = TraceSource.DebugLevel;
                 trace.log("Hello, {0}!", 'World');
                 trace.log("Multi\n  line");
                 trace.warn("Look at me!");
                 trace.error("DIE!");
                 writer.destroy();
                 trace.log("You shouldn't see it!");
                 t.comment("DONE");
                 t.end();
             });

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