implab/implabjs-core Commit - r11:b9900835d201

added TraceSource tests

cin -

r11:b9900835d201 propose cancellat...

parent child

Context file:

r11:b9900835d201

Collapse all files

test/js/trace-test.js created 644 +29 0

@@ -0,0 +1,29
	1	define(["tape"], function(tape) {
	2	"use strict";
	3	var sourceId = '73a633f3-eab8-49b0-8601-07cae710f234';
	4	var sourceId2 = '3ba9c7cd-ed77-437b-9a2f-1cbeb1226b5b';
	5	tape('Load TraceSource for the module', function(t) {
	6	require(["core/log/trace!" + sourceId, "core/log/TraceSource"], function(trace, TraceSource) {
	7	t.equal(trace && trace.id, sourceId, "trace should be taken from the loader plugin parameter");
	8
	9	var count = 0;
	10
	11	var h = TraceSource.on(function(x) {
	12	if(x.id == sourceId \|\| x.id == sourceId2)
	13	count++;
	14	});
	15
	16	t.equal(count, 1, "should see created channel immediatelly");
	17	t.equal(trace, TraceSource.get(sourceId), "should get same TraceSource from registry");
	18	t.equal(count, 1);
	19
	20	TraceSource.get(sourceId2);
	21
	22	t.equal(count, 2);
	23
	24	h.destroy();
	25
	26	t.end();
	27	});
	28	});
	29	}); No newline at end of file

test/ts/TraceSourceTests.ts created 644 +14 0

@@ -0,0 +1,14
	1	import * as TraceSource from '@implab/core/log/TraceSource'
	2	import * as tape from 'tape';
	3
	4	const sourceId = 'test/TraceSourceTests';
	5
	6	tape('', t => {
	7	let trace = TraceSource.get(sourceId);
	8
	9	let h = trace.on((sender,level,msg) => {
	10
	11	});
	12
	13	h.destroy();
	14	}); No newline at end of file

src/ts/components/ActivatableMixin.ts +3 -1

             import { IActivationController } from './IActivationController';
             import { IActivatable } from './IActivatable';
             import { AsyncComponent } from './AsyncComponent';
             import { ICancellation } from '../ICancellation';
             import { EmptyCancellation } from '../EmptyCancellation';
-            import * as log from '@implab/core/log/trace!';
+            import * as TraceSource from '../log/TraceSource';
             type Constructor<T = {}> = new (...args: any[]) => T;
+            const log = TraceSource.get('@implab/core/components/ActivatableMixin');
             function ActivatableMixin<TBase extends Constructor<AsyncComponent>>(Base: TBase) {
                 return class extends Base implements IActivatable {
                     _controller: IActivationController;
                     _active: boolean;
                     isActive() {
                         return this._active;
                     }
                     getActivationController() {
                         return this._controller;
                     }
                     setActivationController(controller: IActivationController) {
                         this._controller = controller;
                     }
                     async onActivating(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.activating(this, ct);
                     }
                     async onActivated(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.activated(this, ct);
                     }
                     async activate(ct: ICancellation = EmptyCancellation.default) {
                         if (this.isActive())
                             return;
                         ct = this.startOperation(ct);
                         try {
                             await this.onActivating(ct);
                             this._active = true;
                             try {
                                 await this.onActivated(ct);
                             } catch(e) {
                                 log.error(e);
                                 // TODO log error
                             }
                             this.completeSuccess();
                         } catch (e) {
                             this.completeFail(e);
                         }
                         return this.getCompletion();
                     }
                     async onDeactivating(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.deactivating(this, ct);
                     }
                     async onDeactivated(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.deactivated(this, ct);
                     }
                     async deactivate(ct: ICancellation = EmptyCancellation.default) {
                         if (!this.isActive())
                             return;
                         ct = this.startOperation(ct);
                         try {
                             await this.onDeactivating(ct);
                             this._active = false;
                             try {
                                 await this.onDeactivated(ct);
                             } catch {
                                 // TODO log error
                             }
                             this.completeSuccess();
                         } catch (e) {
                             this.completeFail(e);
                         }
                         return this.getCompletion();
                     }
                 }
             }
             namespace ActivatableMixin {
             }
             export = ActivatableMixin;

src/ts/log/TraceSource.ts +1 -1

             import * as format from '../text/format'
             import { argumentNotNull } from '../safe';
             interface TraceEventHandler {
                 (sender: TraceSource, level: number, arg: any): void;
             }
             interface TraceSourceHandler {
                 (source: TraceSource): void;
             }
             interface Destroyable {
                 destroy();
             }
             class Registry {
                 static readonly instance = new Registry();
                 private _registry: object = new Object();
                 private _listeners: object = new Object();
                 private _nextCookie: number = 1;
                 get(id: any): TraceSource {
                     argumentNotNull(id, "id");
                     if (this._registry[id])
                         return this._registry[id];
                     var source = new TraceSource(id);
                     this._registry[id] = source;
                     this._onNewSource(source);
                     return source;
                 }
                 add(id: any, source: TraceSource) {
                     argumentNotNull(id, "id");
                     argumentNotNull(source, "source");
                     this._registry[id] = source;
                     this._onNewSource(source);
                 }
                 _onNewSource(source: TraceSource) {
                     for (let i in this._listeners)
                         this._listeners[i].call(null, source);
                 }
                 on(handler: TraceSourceHandler): Destroyable {
                     argumentNotNull(handler, "handler");
                     var me = this;
                     var cookie = this._nextCookie++;
                     this._listeners[cookie] = handler;
                     for (let i in this._registry)
                         handler(this._registry[i]);
                     return {
                         destroy() {
                             delete me._listeners[cookie];
                         }
                     };
                 }
             }
             class TraceSource {
                 readonly id: any
                 // using array will provide faster iteration the with object
                 private _handlers: Array<TraceEventHandler> = new Array<TraceEventHandler>();
                 level: number
                 constructor(id: any) {
                     this.id = id || new Object();
                 }
                 on(handler: TraceEventHandler): Destroyable {
                     argumentNotNull(handler, "handler");
                     var me = this;
                     me._handlers.push(handler);
                     return {
                         destroy() {
                             me.remove(handler);
                         }
                     }
                 }
                 remove(handler: TraceEventHandler): void {
                     let i = this._handlers.indexOf(handler);
                     if (i >= 0)
                         this._handlers.splice(i, 1);
                 }
                 protected emit(level: number, arg: any) {
                     this._handlers.forEach(h => {
                         try {
                             h(this, level, arg);
                         } catch (e) {
                             // suppress error in log handlers
                         }
                     });
                 }
                 isDebugEnabled() {
                     return this.level >= TraceSource.DebugLevel;
                 }
                 debug(msg: string, ...args: any[]) {
                     if (this.isEnabled(TraceSource.DebugLevel))
                         this.emit(TraceSource.DebugLevel, format(msg, args));
                 }
                 isLogEnabled() {
                     return this.level >= TraceSource.LogLevel;
                 }
                 log(msg: string, ...args: any[]) {
                     if (this.isEnabled(TraceSource.LogLevel))
                         this.emit(TraceSource.LogLevel, format(msg, args));
                 }
                 isWarnEnabled() {
                     return this.level >= TraceSource.WarnLevel;
                 }
                 warn(msg: string, ...args: any[]) {
                     if (this.isEnabled(TraceSource.WarnLevel))
                         this.emit(TraceSource.WarnLevel, format(msg, args));
                 }
                 isErrorEnabled() {
                     return this.level >= TraceSource.ErrorLevel;
                 }
                 error(msg: string, ...args: any[]) {
                     if (this.isEnabled(TraceSource.ErrorLevel))
                         this.emit(TraceSource.ErrorLevel, format(msg, args));
                 }
                 isEnabled(level: number) {
                     return (this.level >= level);
                 }
                 traceEvent(level: number, arg: any) {
                     if (this.isEnabled(level))
                         this.emit(level, arg);
                 }
                 static on(handler: TraceSourceHandler) {
-                    Registry.instance.on(handler);
+                    return Registry.instance.on(handler);
                 }
                 static get(id: any) {
                     return Registry.instance.get(id);
                 }
             }
             namespace TraceSource {
                 export const DebugLevel = 400;
                 export const LogLevel = 300;
                 export const WarnLevel = 200;
                 export const ErrorLevel = 100;
                 export const SilentLevel = 0;
             }
             export = TraceSource;

test/js/plan.js +1 -1

	@@ -1,1 +1,1
	1	define(["./~~dummy~~", "./~~example"~~, ~~"./ActivatableTests~~"]); No newline at end of file		1	define(["./ActivatableTests", "./trace-test"]); No newline at end of file

src/ts/log/trace.ts removed 0 -12

NO CONTENT: file was removed

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