implab/implabjs-core Commit - r42:3a5e68edd843

Container.configure sync/async tests

cin -

r42:3a5e68edd843 di-typescript

parent child

Context file:

r42:3a5e68edd843

Collapse all files

test/js/mock/config1.js created 644 +17 0

@@ -0,0 +1,17
	1	define({
	2	foo: {
	3	$type: "./Foo#Foo"
	4	},
	5
	6	bar: {
	7	$type: "./Bar#Bar",
	8	params: {
	9	db: {
	10	provider: {
	11	$dependency: "db"
	12	}
	13	}
	14	}
	15	},
	16	db: "db://localhost"
	17	}); No newline at end of file

src/ts/di/ActivationContext.ts +1 -1

             import { TraceSource } from "../log/TraceSource";
             import { argumentNotNull, argumentNotEmptyString, isPrimitive, each, isNull } from "../safe";
-            import { Descriptor, ServiceMap, isDescriptor } from "./interfaces";
+            import { Descriptor, ServiceMap } from "./interfaces";
             import { Container } from "./Container";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");

src/ts/di/Container.ts +32 -20

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { isDescriptor, ActivationType, ServiceMap, isDependencyRegistration, isValueRegistration, ServiceRegistration, DependencyRegistration } from "./interfaces";
+            import { isDescriptor, ActivationType, ServiceMap, isDependencyRegistration, isValueRegistration, ServiceRegistration, DependencyRegistration, ValueRegistration } from "./interfaces";
             import { AggregateDescriptor } from "./AggregateDescriptor";
             import { isPrimitive, pmap } from "../safe";
             import { ReferenceDescriptor } from "./ReferenceDescriptor";
             import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
             import { ModuleResolverBase } from "./ModuleResolverBase";
             import format = require("../text/format");
-            import { throws } from "assert";
+            import { TraceSource } from "../log/TraceSource";
+            import { RequireJsResolver } from "./RequireJsResolver";
+            const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export class Container {
                 _services: ServiceMap;
                     this._cleanup = [];
                     this._root = parent ? parent.getRootContainer() : this;
                     this._services.container = new ValueDescriptor(this);
+                    this._resolver = new RequireJsResolver();
                 }
                 getRootContainer() {
                     }
                 }
+                /**
+                 * @deprecated use resolve() method
+                 */
                 getService(name: string, def?) {
                     return this.resolve.apply(this, arguments);
                 }
                  */
                 async configure(config: string | object, opts?: object) {
                     if (typeof (config) === "string") {
+                        trace.log(`load configuration '${config}'`);
                         const resolver = await this._resolver.createResolver(config, opts);
                         const data = await this._resolver.loadModule(config);
                         return this._configure(data, { resolver });
                     } else {
+                        trace.log(`json configuration`);
                         return this._configure(config);
                     }
                 }
                     this.register(services);
                 }
-                async _parse(registration: any, resolver: ModuleResolverBase) {
+                async _parse(data: any, resolver: ModuleResolverBase) {
-                    if (isPrimitive(registration) || isDescriptor(registration))
+                    if (isPrimitive(data) || isDescriptor(data))
-                        return registration;
+                        return data;
-                    if (isDependencyRegistration(registration)) {
+                    if (isDependencyRegistration(data)) {
-                        return this._paseReference(registration, resolver);
+                        return this._makeReferenceDescriptor(data, resolver);
-                    } else if (isValueRegistration(registration)) {
+                    } else if (isValueRegistration(data)) {
-                        return !registration.parse ?
+                        return this._makeValueDescriptor(data, resolver);
-                            new ValueDescriptor(registration.$value) :
+                    } else if (data.$type || data.$factory) {
-                            new AggregateDescriptor(this._parse(registration.$value, resolver));
+                        return this._makeServiceDescriptor(data, resolver);
+                    } else if (data instanceof Array) {
-                    } else if (registration.$type || registration.$factory) {
+                        return this._parseArray(data, resolver);
-                        return this._parseService(registration, resolver);
-                    } else if (registration instanceof Array) {
-                        return this._parseArray(registration, resolver);
                     }
-                    return this._parseObject(registration, resolver);
+                    return this._parseObject(data, resolver);
                 }
-                async _paseReference(registration: DependencyRegistration, resolver: ModuleResolverBase) {
+                async _makeValueDescriptor(data: ValueRegistration, resolver: ModuleResolverBase) {
+                    return !data.parse ?
+                        new ValueDescriptor(data.$value) :
+                        new AggregateDescriptor(this._parse(data.$value, resolver));
+                }
+                async _makeReferenceDescriptor(registration: DependencyRegistration, resolver: ModuleResolverBase) {
                     return new ReferenceDescriptor({
                         name: registration.$dependency,
                         lazy: registration.lazy,
                     });
                 }
-                async _parseService(data: ServiceRegistration, resolver: ModuleResolverBase) {
+                async _makeServiceDescriptor(data: ServiceRegistration, resolver: ModuleResolverBase) {
                     const opts: ServiceDescriptorParams = {
                         owner: this
                     };
                     }
                     if (data.params)
-                        opts.params = this._parse(data.params, resolver);
+                        opts.params = await this._parse(data.params, resolver);
                     if (data.activation) {
                         if (typeof (data.activation) === "string") {

src/ts/di/RequireJsResolver.ts +37 -11

             import { argumentNotEmptyString } from "../safe";
             import { TraceSource } from "../log/TraceSource";
-            declare function require(modules: string[], cb?: (...args: any[]) => any): void;
+            type RequireFn = (modules: string[], cb?: (...args: any[]) => any) => void;
-            declare function define(name: string, modules: string[], cb?: (...args: any[]) => any): void;
+            declare const require: RequireFn;
+            declare function define(name: string, modules: string[], cb?: (...args: any[]) => any, eb?: (e) => any): void;
+            declare function define(modules: string[], cb?: (...args: any[]) => any, eb?: (e) => any): void;
             interface RequireJsResolverParams {
                 contextRequire: (modules: string[], cb?: (...args: any[]) => any) => void;
                 base: string;
             }
-            TraceSource.get("RequireJsResolver");
+            const trace = TraceSource.get("@implab/core/di/RequireJsResolver");
             export class RequireJsResolver extends ModuleResolverBase {
                 _contextRequire = require;
                 _base: string;
-                constructor(opts) {
+                constructor(opts?: RequireJsResolverParams) {
                     super();
                     if (opts) {
                 async createResolver(moduleName: string): Promise<ModuleResolverBase> {
                     argumentNotEmptyString(moduleName, "moduleName");
+                    trace.log("createResolver({0})", moduleName);
                     const parts = moduleName.split("/");
                     if (parts[0] === ".") {
                         if (this._base)
                     const shim = parts.join("/");
-                    const contextRequire = await new Promise(
+                    trace.debug(`define shim ${shim}`);
-                        resolve => define(shim, ["require"], resolve)
-                    );
-                    return new RequireJsResolver({
+                    try {
-                        base: parts.slice(0, -1).join("/"),
+                        const contextRequire = await new Promise<RequireFn>(
-                        contextRequire
+                            (resolve, reject) => {
-                    });
+                                try {
+                                    define(shim, ["require"], r => {
+                                        trace.debug("shim resolved");
+                                        resolve(r);
+                                    }, reject);
+                                    require([shim]);
+                                } catch (e) {
+                                    reject(e);
+                                }
+                            }
+                        );
+                        trace.debug("creating new moduleResolver");
+                        return new RequireJsResolver({
+                            base: parts.slice(0, -1).join("/"),
+                            contextRequire
+                        });
+                    } catch (e) {
+                        trace.error(e);
+                        throw e;
+                    }
                 }
                 async loadModule(moduleName: string): Promise<object> {
+                    trace.log(`loadModule(${moduleName})`);
                     return new Promise<object>(
                         resolve => this._contextRequire.call(null, [moduleName], resolve)
                     );

src/ts/di/ServiceDescriptor.ts +5 -3

                 if (isPrimitive(value))
                     return value;
+                trace.debug("parse {0}", path);
                 if (isDescriptor(value))
                     return context.activate(value, path);
                 if (value instanceof Array)
-                    return value.map((x, i) => this._parse(x, context, `${path}[${i}]`));
+                    return value.map((x, i) => _parse(x, context, `${path}[${i}]`));
                 const t = {};
                 for (const p of Object.keys(value))
-                    t[p] = this._parse(value[p], context, `${path}.${p}`);
+                    t[p] = _parse(value[p], context, `${path}.${p}`);
                 return t;
             }
             export interface ServiceDescriptorParams {

src/ts/di/interfaces.ts +1 -1

             }
             export function isDependencyRegistration(x): x is DependencyRegistration {
-                return (!isPrimitive(x)) && ("$depdendency" in x);
+                return (!isPrimitive(x)) && ("$dependency" in x);
             }

src/ts/log/TraceSource.ts +6 -7

-            import * as format from '../text/format'
+            import * as format from "../text/format";
-            import { argumentNotNull } from '../safe';
+            import { argumentNotNull } from "../safe";
-            import { Observable } from '../Observable'
+            import { Observable } from "../Observable";
-            import { IDestroyable } from '../interfaces';
+            import { IDestroyable } from "../interfaces";
             export const DebugLevel = 400;
             export class TraceEvent {
                 readonly source: TraceSource;
-                readonly level: Number;
+                readonly level: number;
                 readonly arg: any;
-                constructor(source: TraceSource, level: Number, arg: any) {
+                constructor(source: TraceSource, level: number, arg: any) {
                     this.source = source;
                     this.level = level;
                     this.arg = arg;
                     return Registry.instance.get(id);
                 }
             }

test/ts/ContainerTests.ts +53 -9

@@ -20,20 +20,31 test("Container register/resolve tests",
20		20
21	const connection1 = "db://localhost";	21	const connection1 = "db://localhost";
22		22
23	container.register("connection", new ValueDescriptor(connection1));	23	t.throws(
		24	() => container.register("bla-bla", "bla-bla"),
		25	"Do not allow to register anything other than descriptors"
		26	);
24		27
25	t.equals(container.getService("connection"), connection1);	28	t.doesNotThrow(
		29	() => container.register("connection", new ValueDescriptor(connection1)),
		30	"register ValueDescriptor"
		31	);
26		32
27	container.register(	33	t.equals(container.getService("connection"), connection1, "resolve string value");
28	"dbParams",	34
29	new AggregateDescriptor({	35	t.doesNotThrow(
30	timeout: 10,	36	() => container.register(
31	connection: new ReferenceDescriptor({ name: "connection" })	37	"dbParams",
32	})	38	new AggregateDescriptor({
		39	timeout: 10,
		40	connection: new ReferenceDescriptor({ name: "connection" })
		41	})
		42	),
		43	"register AggregateDescriptor"
33	);	44	);
34		45
35	const dbParams = container.getService("dbParams");	46	const dbParams = container.getService("dbParams");
36	t.equals(dbParams.connection, connection1, "should get connection");	47	t.equals(dbParams.connection, connection1, "should get string value 'dbParams.connection'");
37		48
38	writer.destroy();	49	writer.destroy();
39	});	50	});
@@ -53,6 +64,13 test("Container configure/resolve tests"
53	$type: Foo	64	$type: Foo
54	},	65	},
55		66
		67	box: {
		68	$type: Bar,
		69	params: {
		70	$dependency: "foo"
		71	}
		72	},
		73
56	bar: {	74	bar: {
57	$type: Bar,	75	$type: Bar,
58	params: {	76	params: {
@@ -64,11 +82,37 test("Container configure/resolve tests"
64	}	82	}
65	}	83	}
66	});	84	});
		85	t.pass("should configure from js object");
67		86
68	const f1 = container.resolve("foo");	87	const f1 = container.resolve("foo");
		88
		89	t.assert(!isNull(f1), "foo should be not null");
		90
		91	t.throws(() => container.resolve("bar"), "should not resolve dependency 'db'");
		92
		93	writer.destroy();
		94	});
		95
		96	test("Load configuration from module", async t => {
		97	const writer = new TapeWriter(t);
		98
		99	TraceSource.on(ts => {
		100	ts.level = DebugLevel;
		101	writer.writeEvents(ts.events);
		102	});
		103
		104	const container = new Container();
		105
		106	await container.configure("test/mock/config1");
		107	t.pass("The configuration should load");
		108
		109	const f1 = container.resolve("foo");
		110
69	t.assert(!isNull(f1), "foo should be not null");	111	t.assert(!isNull(f1), "foo should be not null");
70		112
71	const b1 = container.resolve("bar");	113	const b1 = container.resolve("bar");
72		114
		115	t.assert(!isNull(b1), "foo should be not null");
		116
73	writer.destroy();	117	writer.destroy();
74	});	118	});

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