implab/implabjs-core Commit - r136:17c7de5d346c

tests

cin -

r136:17c7de5d346c ioc ts support

parent child

Context file:

r136:17c7de5d346c

Collapse all files

.project +11 0

             <?xml version="1.0" encoding="UTF-8"?>
             <projectDescription>
             	<name>core</name>
             	<comment>Project implabjs-core created by Buildship.</comment>
             	<projects>
             	</projects>
             	<buildSpec>
             		<buildCommand>
             			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
             			<arguments>
             			</arguments>
             		</buildCommand>
             	</buildSpec>
             	<natures>
             		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
             	</natures>
+            	<filteredResources>
+            		<filter>
+            			<id>1599549685358</id>
+            			<name></name>
+            			<type>30</type>
+            			<matcher>
+            				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+            				<arguments>node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+            			</matcher>
+            		</filter>
+            	</filteredResources>
             </projectDescription>

src/main/ts/di/Configuration.ts +3 -2

             import {
                 PartialServiceMap,
                 ActivationType,
                 ContainerKeys,
                 TypeOfService,
                 ILifetime
             } from "./interfaces";
             import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get, primitive } from "../safe";
             import { AggregateDescriptor } from "./AggregateDescriptor";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { Container } from "./Container";
             import { ReferenceDescriptor } from "./ReferenceDescriptor";
             import { TypeServiceDescriptor } from "./TypeServiceDescriptor";
             import { FactoryServiceDescriptor } from "./FactoryServiceDescriptor";
             import { TraceSource } from "../log/TraceSource";
             import { ConfigError } from "./ConfigError";
             import { Cancellation } from "../Cancellation";
             import { makeResolver } from "./ResolverHelper";
             import { ICancellation } from "../interfaces";
             import { isDescriptor } from "./traits";
             import { LazyReferenceDescriptor } from "./LazyReferenceDescriptor";
             import { LifetimeManager } from "./LifetimeManager";
             export interface RegistrationScope<S extends object> {
                 /** сервисы, которые регистрируются в контексте активации и таким образом
                  * могут переопределять ранее зарегистрированные сервисы. за это свойство
                  * нужно платить, кроме того порядок активации будет влиять на результат
                  * разрешения зависимостей.
                  */
                 services?: RegistrationMap<S>;
             }
             /**
              * Базовый интерфейс конфигурации сервисов
              */
             export interface ServiceRegistration<T, S extends object> extends RegistrationScope<S> {
                 activation?: ActivationType;
                 params?: any;
                 /** Специальный идентификатор используется при активации singleton, если
                  * не указан для TypeRegistration вычисляется как oid($type)
                  */
                 typeId?: string;
                 inject?: object | object[];
                 cleanup?: ((instance: T) => void) | string;
             }
             export interface TypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
                 $type: string | C;
                 params?: Registration<ConstructorParameters<C>, S>;
             }
             export interface StrictTypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
                 $type: C;
                 params?: Registration<ConstructorParameters<C>, S>;
             }
             export interface FactoryRegistration<F extends (...args: any[]) => any, S extends object> extends ServiceRegistration<ReturnType<F>, S> {
                 $factory: string | F;
             }
             export interface ValueRegistration<T> {
                 $value: T;
                 parse?: boolean;
             }
             export interface DependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends RegistrationScope<S> {
                 $dependency: K;
                 lazy?: boolean;
                 optional?: boolean;
                 default?: TypeOfService<S, K>;
             }
             export interface LazyDependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends DependencyRegistration<S, K> {
                 lazy: true;
             }
             export type Registration<T, S extends object> = T extends primitive ? T :
                 (
                     T |
                     { [k in keyof T]: Registration<T[k], S> } |
                     TypeRegistration<new (...args: any[]) => T, S> |
                     FactoryRegistration<(...args: any[]) => T, S> |
                     ValueRegistration<any> |
                     DependencyRegistration<S, keyof S>
                 );
             export type RegistrationMap<S extends object> = {
                 [k in keyof S]?: Registration<S[k], S>;
             };
             const _activationTypes: { [k in ActivationType]: number; } = {
                 singleton: 1,
                 container: 2,
                 hierarchy: 3,
                 context: 4,
                 call: 5
             };
             export function isTypeRegistration(x: any): x is TypeRegistration<new () => any, any> {
                 return (!isPrimitive(x)) && ("$type" in x);
             }
             export function isFactoryRegistration(x: any): x is FactoryRegistration<() => any, any> {
                 return (!isPrimitive(x)) && ("$factory" in x);
             }
             export function isValueRegistration(x: any): x is ValueRegistration<any> {
                 return (!isPrimitive(x)) && ("$value" in x);
             }
             export function isDependencyRegistration<S extends object>(x: any): x is DependencyRegistration<S, keyof S> {
                 return (!isPrimitive(x)) && ("$dependency" in x);
             }
             export function isActivationType(x: string): x is ActivationType {
                 return typeof x === "string" && x in _activationTypes;
             }
             const trace = TraceSource.get("@implab/core/di/Configuration");
             async function mapAll(data: any[], map?: (v: any, k: number) => any): Promise<any[]>;
             async function mapAll(data: any, map?: (v: any, k: string) => any): Promise<any>;
             async function mapAll(data: any, map?: (v: any, k: any) => any): Promise<any> {
                 if (data instanceof Array) {
                     return Promise.all(map ? data.map(map) : data);
                 } else {
                     const keys = Object.keys(data);
                     const o: any = {};
                     await Promise.all(keys.map(async k => {
                         const v = map ? map(data[k], k) : data[k];
                         o[k] = isPromise(v) ? await v : v;
                     }));
                     return o;
                 }
             }
             export type ModuleResolver = (moduleName: string, ct?: ICancellation) => any;
             export class Configuration<S extends object> {
                 _hasInnerDescriptors = false;
                 readonly _container: Container<S>;
                 _path: Array<string>;
                 _configName: string | undefined;
                 _require: ModuleResolver | undefined;
                 constructor(container: Container<S>) {
                     argumentNotNull(container, "container");
                     this._container = container;
                     this._path = [];
                 }
                 async loadConfiguration(moduleName: string, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotEmptyString(moduleName, "moduleName");
                     trace.log(
                         "loadConfiguration moduleName={0}, contextRequire={1}",
                         moduleName,
                         contextRequire ? typeof (contextRequire) : "<nil>"
                     );
                     this._configName = moduleName;
                     const r = await makeResolver(undefined, contextRequire);
                     const config = await r(moduleName, ct);
                     await this._applyConfiguration(
                         config,
                         await makeResolver(moduleName, contextRequire),
                         ct
                     );
                 }
-                async applyConfiguration(data: RegistrationMap<S>, contextRequire?: any, ct = Cancellation.none) {
+                async applyConfiguration(data: RegistrationMap<S>, opts: { contextRequire?: any; baseModule?: string }, ct = Cancellation.none) {
                     argumentNotNull(data, "data");
+                    const _opts = opts || {};
-                    await this._applyConfiguration(data, await makeResolver(void (0), contextRequire), ct);
+                    await this._applyConfiguration(data, await makeResolver(_opts.baseModule, _opts.contextRequire), ct);
                 }
                 async _applyConfiguration(data: RegistrationMap<S>, resolver?: ModuleResolver, ct = Cancellation.none) {
                     trace.log("applyConfiguration");
                     this._configName = "$";
                     if (resolver)
                         this._require = resolver;
                     let services: PartialServiceMap<S>;
                     try {
                         services = await this._visitRegistrations(data, "$");
                     } catch (e) {
                         throw this._makeError(e);
                     }
                     this._container.register(services);
                 }
                 _makeError(inner: any) {
                     const e = new ConfigError("Failed to load configuration", inner);
                     e.configName = this._configName || "<inline>";
                     e.path = this._makePath();
                     return e;
                 }
                 _makePath() {
                     return this._path
                         .reduce(
                             (prev, cur) => typeof cur === "number" ?
                                 `${prev}[${cur}]` :
                                 `${prev}.${cur}`
                         )
                         .toString();
                 }
                 async _resolveType(moduleName: string, localName: string) {
                     trace.log("resolveType moduleName={0}, localName={1}", moduleName, localName);
                     try {
                         const m = await this._loadModule(moduleName);
                         if (localName) {
                             return get(localName, m);
                         } else {
                             if (m instanceof Function)
                                 return m;
                             if ("default" in m)
                                 return m.default;
                             return m;
                         }
                     } catch (e) {
                         trace.error("Failed to resolve type moduleName={0}, localName={1}", moduleName, localName);
                         throw e;
                     }
                 }
                 _loadModule(moduleName: string) {
                     trace.debug("loadModule {0}", moduleName);
                     if (!this._require)
                         throw new Error("Module loader isn't specified");
                     return this._require(moduleName);
                 }
                 async _visitRegistrations(data: RegistrationMap<S>, name: string) {
                     this._enter(name);
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         throw new Error("Configuration must be a simple object");
                     const services = await mapAll(data, async (v, k) => {
                         const d = await this._visit(v, k.toString());
                         return isDescriptor(d) ? d : new AggregateDescriptor(d);
                     }) as PartialServiceMap<S>;
                     this._leave();
                     return services;
                 }
                 _enter(name: string) {
                     this._path.push(name.toString());
                     trace.debug(">{0}", name);
                 }
                 _leave() {
                     const name = this._path.pop();
                     trace.debug("<{0}", name);
                 }
                 _visit(data: any, name: string): Promise<any> {
                     if (isPrimitive(data))
                         return Promise.resolve(new ValueDescriptor(data));
                     if (isDescriptor(data))
                         return Promise.resolve(data);
                     if (isDependencyRegistration<S>(data)) {
                         return this._visitDependencyRegistration(data, name);
                     } else if (isValueRegistration(data)) {
                         return this._visitValueRegistration(data, name);
                     } else if (isTypeRegistration(data)) {
                         return this._visitTypeRegistration(data, name);
                     } else if (isFactoryRegistration(data)) {
                         return this._visitFactoryRegistration(data, name);
                     } else if (data instanceof Array) {
                         return this._visitArray(data, name);
                     }
                     return this._visitObject(data, name);
                 }
                 async _visitObject(data: any, name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     // TODO: handle inline descriptors properly
                     // const ex = {
                     //     activate(ctx) {
                     //         const value = ctx.activate(this.prop, "prop");
                     //         // some code
                     //     },
                     //     // will be turned to ReferenceDescriptor
                     //     prop: { $dependency: "depName" }
                     // };
                     this._leave();
                     return v;
                 }
                 async _visitArray(data: any[], name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     this._leave();
                     return v;
                 }
                 _makeServiceParams(data: ServiceRegistration<any, S>) {
                     const opts: any = {
                     };
                     if (data.services)
                         opts.services = this._visitRegistrations(data.services, "services");
                     if (data.inject) {
                         this._enter("inject");
                         opts.inject = mapAll(
                             data.inject instanceof Array ?
                                 data.inject :
                                 [data.inject],
                             delegate(this, "_visitObject")
                         );
                         this._leave();
                     }
                     if ("params" in data)
                         opts.params = data.params instanceof Array ?
                             this._visitArray(data.params, "params") :
                             this._visit(data.params, "params");
                     if (data.activation) {
                         opts.activation = this._getLifetimeManager(data.activation, data.typeId);
                     }
                     if (data.cleanup)
                         opts.cleanup = data.cleanup;
                     return opts;
                 }
                 async _visitValueRegistration<T>(data: ValueRegistration<T>, name: string) {
                     this._enter(name);
                     const d = data.parse ? new AggregateDescriptor(data.$value) : new ValueDescriptor(data.$value);
                     this._leave();
                     return d;
                 }
                 async _visitDependencyRegistration<K extends keyof S>(data: DependencyRegistration<S, K>, name: string) {
                     argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                     this._enter(name);
                     const options = {
                         name: data.$dependency,
                         optional: data.optional,
                         default: data.default,
                         services: data.services && await this._visitRegistrations(data.services, "services")
                     };
                     const d = data.lazy ? new LazyReferenceDescriptor<S, K>(options) : new ReferenceDescriptor<S, K>(options);
                     this._leave();
                     return d;
                 }
                 async _visitTypeRegistration(data: TypeRegistration<new () => any, S>, name: string) {
                     argumentNotNull(data.$type, "data.$type");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     if (data.$type instanceof Function) {
                         opts.type = data.$type;
                     } else {
                         const [moduleName, typeName] = data.$type.split(":", 2);
                         opts.type = this._resolveType(moduleName, typeName).then(t => {
                             if (!(t instanceof Function))
                                 throw Error("$type (" + data.$type + ") is not a constructable");
                             return t;
                         });
                     }
                     const d = new TypeServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
                 async _visitFactoryRegistration(data: FactoryRegistration<() => any, S>, name: string) {
                     argumentOfType(data.$factory, Function, "data.$factory");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     opts.factory = data.$factory;
                     const d = new FactoryServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
                 _getLifetimeManager(activation: ActivationType, typeId: string | undefined): ILifetime {
                     switch (activation) {
                         case "container":
                             return LifetimeManager.containerLifetime(this._container);
                         case "hierarchy":
                             return LifetimeManager.hierarchyLifetime();
                         case "context":
                             return LifetimeManager.contextLifetime();
                         case "singleton":
                             if (typeId === undefined)
                                 throw Error("The singleton activation requires a typeId");
                             return LifetimeManager.singletonLifetime(typeId);
                         default:
                             return LifetimeManager.empty();
                     }
                 }
             }

src/main/ts/di/Container.ts +16 -6

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
             import { ServiceMap, Descriptor, PartialServiceMap, ServiceLocator, ContainerServiceMap, ContainerKeys, TypeOfService } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
             import { Configuration, RegistrationMap } from "./Configuration";
             import { Cancellation } from "../Cancellation";
             import { MapOf, IDestroyable } from "../interfaces";
             import { isDescriptor } from "./traits";
             import { LifetimeManager } from "./LifetimeManager";
             import { each } from "../safe";
             import { FluentRegistrations } from "./fluent/interfaces";
             import { FluentConfiguration } from "./fluent/FluentConfiguration";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export class Container<S extends object = any> implements ServiceLocator<S>, IDestroyable {
                 readonly _services: ContainerServiceMap<S>;
                 readonly _lifetimeManager: LifetimeManager;
                 readonly _cleanup: (() => void)[];
                 readonly _root: Container<S>;
                 readonly _parent?: Container<S>;
                 _disposed: boolean;
                 constructor(parent?: Container<S>) {
                     this._parent = parent;
                     this._services = parent ? Object.create(parent._services) : {};
                     this._cleanup = [];
                     this._root = parent ? parent.getRootContainer() : this;
                     this._services.container = new ValueDescriptor(this) as any;
                     this._disposed = false;
                     this._lifetimeManager = new LifetimeManager();
                 }
                 getRootContainer() {
                     return this._root;
                 }
                 getParent() {
                     return this._parent;
                 }
                 getLifetimeManager() {
                     return this._lifetimeManager;
                 }
                 resolve<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>): TypeOfService<S, K> {
                     trace.debug("resolve {0}", name);
                     const d = this._services[name];
                     if (d === undefined) {
                         if (def !== undefined)
                             return def;
                         else
                             throw new Error("Service '" + name + "' isn't found");
                     } else {
                         const context = new ActivationContext<S>(this, this._services, String(name), d);
                         try {
                             return d.activate(context);
                         } catch (error) {
                             throw new ActivationError(name.toString(), context.getStack(), error);
                         }
                     }
                 }
                 /**
                  * @deprecated use resolve() method
                  */
                 getService<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>) {
                     return this.resolve(name, def);
                 }
                 register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>): this;
                 register(services: PartialServiceMap<S>): this;
                 register<K extends keyof S>(nameOrCollection: K | ServiceMap<S>, service?: Descriptor<S, S[K]>) {
                     if (arguments.length === 1) {
                         const data = nameOrCollection as ServiceMap<S>;
                         each(data, (v, k) => this.register(k, v));
                     } else {
                         if (!isDescriptor(service))
                             throw new Error("The service parameter must be a descriptor");
                         this._services[nameOrCollection as K] = service as any;
                     }
                     return this;
                 }
                 onDispose(callback: () => void) {
                     if (!(callback instanceof Function))
                         throw new Error("The callback must be a function");
                     this._cleanup.push(callback);
                 }
                 destroy() {
                     return this.dispose();
                 }
                 dispose() {
                     if (this._disposed)
                         return;
                     this._disposed = true;
                     for (const f of this._cleanup)
                         f();
                 }
                 /**
                  * @param{String|Object} config
-                 *  The configuration of the contaier. Can be either a string or an object,
+                 *  The configuration of the container. Can be either a string or an object,
                  *  if the configuration is an object it's treated as a collection of
-                 *  services which will be registed in the contaier.
+                 *  services which will be registered in the container.
                  *
                  * @param{Function} opts.contextRequire
                  *  The function which will be used to load a configuration or types for services.
                  *
                  */
-                async configure(config: string | RegistrationMap<S>, opts?: any, ct = Cancellation.none) {
+                async configure(config: string | RegistrationMap<S>, opts?: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
-                    const c = new Configuration<S>(this);
+                    const _opts = Object.create(opts || null);
                     if (typeof (config) === "string") {
-                        return c.loadConfiguration(config, opts && opts.contextRequire, ct);
+                        _opts.baseModule = config;
+                        const module = await import(config);
+                        if (module && module.default && typeof (module.default.apply) === "function")
+                            return module.default.apply(this);
+                        else
+                            return this._applyLegacyConfig(module, _opts, ct);
                     } else {
-                        return c.applyConfiguration(config, opts && opts.contextRequire, ct);
+                        return this._applyLegacyConfig(config, _opts, ct);
+                    }
                 }
+                async _applyLegacyConfig(config: RegistrationMap<S>, opts: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
+                    return new Configuration<S>(this).applyConfiguration(config, opts);
                 }
                 async fluent<K extends keyof S>(config: FluentRegistrations<K, S>, ct = Cancellation.none): Promise<this> {
                     await new FluentConfiguration<S>().register(config).apply(this, ct);
                     return this;
                 }
                 createChildContainer<S2 extends object = S>(): Container<S & S2> {
                     return new Container<S & S2>(this as any);
                 }
             }

src/main/ts/di/fluent/FluentConfiguration.ts +7 -5

             import { Container } from "../Container";
             import { argumentNotNull, each, isPrimitive, isPromise } from "../../safe";
             import { DescriptorBuilder } from "./DescriptorBuilder";
             import { RegistrationBuilder, FluentRegistrations } from "./interfaces";
             import { Cancellation } from "../../Cancellation";
             export class FluentConfiguration<S extends object, Y extends keyof S = keyof S> {
                 _builders: { [k in keyof S]?: RegistrationBuilder<S, S[k]> } = {};
                 register<K extends Y>(name: K, builder: RegistrationBuilder<S, S[K]>): FluentConfiguration<S, Exclude<Y, K>>;
                 register<K extends Y>(config: FluentRegistrations<K, S>): FluentConfiguration<S, Exclude<Y, K>>;
                 register<K extends Y>(nameOrConfig: K | FluentRegistrations<K, S>, builder?: RegistrationBuilder<S, S[K]>): FluentConfiguration<S, Exclude<Y, K>> {
                     if (isPrimitive(nameOrConfig)) {
                         argumentNotNull(builder, "builder");
                         this._builders[nameOrConfig] = builder;
                     } else {
                         each(nameOrConfig, (v, k) => this.register(k, v));
                     }
                     return this;
                 }
-                apply(target: Container<S>, ct = Cancellation.none) {
+                apply<SC extends object>(target: Container<SC>, ct = Cancellation.none) {
                     let pending = 1;
-                    return new Promise((resolve, reject) => {
+                    const _t2 = target as unknown as Container<SC & S>;
+                    return new Promise<Container<SC & S>>((resolve, reject) => {
                         function guard(v: void | Promise<void>) {
                             if (isPromise(v))
                                 v.catch(reject);
                         }
                         function complete() {
                             if (!--pending)
-                                resolve();
+                                resolve(_t2);
                         }
                         each(this._builders, (v, k) => {
                             pending++;
-                            const d = new DescriptorBuilder<S, any>(target,
+                            const d = new DescriptorBuilder<SC & S, any>(_t2,
                                 result => {
-                                    target.register(k, result);
+                                    _t2.register(k, result);
                                     complete();
                                 },
                                 reject
                             );
                             try {
                                 guard(v(d, ct));
                             } catch (e) {
                                 reject(e);
                             }
                         });
                         complete();
                     });
                 }
             }

src/test/ts/mock/config.ts +7 -19

@@ -1,26 +1,14
1	import { Services } from "./services";	1	import { Services } from "./services";
2	import { fluent } from "../di/traits";	2	import { fluent } from "../di/traits";
		3	import { Box } from "./Box";
3		4
4	export default fluent<Services>().register({	5	export default fluent<Services>().register({
5	host: it => it.value("example.com"),	6	host: it => it.value("example.com"),
6		7
7	bar2: it => Promise.all([import("./Foo"), import("./Bar")])	8	foo: it => import("./Foo").then(({ Foo }) => it
8	.then(([{ Foo }, { Bar }]) => it	9	.factory(() => new Foo())
9	.lifetime("container")	10	),
10	.override({	11
11	host: it2 => it2.value("simple.org"),	12	box: it => it
12	foo: it2 => it2.value(new Foo())	13	.factory($dependency => new Box($dependency("foo")))
13	})
14	.factory(resolve => {
15	const bar = new Bar({
16	foo: new Foo(),
17	nested: {
18	lazy: resolve("foo", { lazy: true })
19	},
20	host: resolve("host")
21	}, "some text");
22	bar.setName(resolve("host"));
23	return bar;
24	})
25	)
26	});	14	});

src/test/ts/mock/services.ts +1 -5

             import { Foo } from "./Foo";
             import { Bar } from "./Bar";
             import { Box } from "./Box";
             /**
              * Сервисы доступные внутри контейнера
              */
             export interface Services {
                 foo: Foo;
-                bar: Bar;
+                box: Box<Foo>;
-                bar2: Bar;
-                box: Box<Bar>;
                 host: string;
             }

src/test/ts/tests/FluentContainerTests.ts +11 -2

             import { test } from "./TestTraits";
             import { fluent } from "../di/traits";
             import { Bar } from "../mock/Bar";
             import { Container } from "../di/Container";
             import { Foo } from "../mock/Foo";
             import { Box } from "../mock/Box";
             import { delay } from "../safe";
+            import { Services } from "../mock/services";
             test("Simple fluent config", async t => {
                 const config = fluent<{ host: string; bar: Bar; foo: Foo }>()
                     .register({
                         host: it => it.value("example.com"),
                         bar: it => it.factory(resolve => new Bar({ host: resolve("host") }, "s-bar")),
                         foo: it => import("../mock/Foo").then(m => it.lifetime("container").factory(() => new m.Foo()))
                     });
-                const container = new Container<{ host: string; bar: Bar; foo: Foo; }>();
+                const c1 = new Container<{}>();
-                await config.apply(container);
+                const container = await config.apply(c1);
                 t.equal(container.resolve("host"), "example.com", "The value should be resolved");
                 t.assert(container.resolve("bar"), "The service should de activated");
                 t.equal(container.resolve("foo"), container.resolve("foo"), "The service should be activated once");
             });
             test("Nested async configuration", async t => {
                 const container = await new Container<{
                     foo: Foo;
                     box: Box<Foo>
                 }>().fluent({
                     foo: it => delay(0).then(() => it.factory(() => new Foo())),
                     box: it => it.lifetime("context").factory($dependency => new Box($dependency("foo")))
                 });
                 t.assert(container.resolve("box").getValue(), "The dependency should be set");
                 t.equals(container.resolve("box").getValue(), container.resolve("box").getValue(), "The service should be activated once")
             });
             test("Bad fluent config", async t => {
                 try {
                     await new Container<{
                         foo: Foo;
                         box: Box<Foo>
                     }>().fluent({
                         foo: it => delay(0).then(() => it.factory(() => new Foo())),
                         box: it => it.lifetime("context")
                             .override("foo", () => { throw new Error("bad override"); })
                             .factory($dependency => new Box($dependency("foo")))
                     });
                     t.fail("Should throw");
                 } catch (e) {
                     t.pass("The configuration should fail");
                     t.equal(e.message, "bad override", "the error should pass");
                 }
             });
+            test("Load fluent config", async t => {
+                const container = new Container<Services>();
+                await container.configure("../mock/config", { contextRequire: require });
+                t.assert(container.resolve("host"), "Should resolve simple value");
+            });

src/testCjs/ts/tests/plan.ts +1 0

             import "./ActivatableTests";
             import "./TraceSourceTests";
             import "./CancellationTests";
             import "./ObservableTests";
             import "./ContainerTests";
             import "./SafeTests";
             import "./TextTests";
+            import "./FluentContainerTests";

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