javascript/ionic-framework
1
0
Fork 0
mirror of https://github.com/ionic-team/ionic-framework.git synced 2025-08-20 20:33:32 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor(module-loader): fix tests, don't purge loaded module promise from the map

Browse Source 
fix tests, don't purge loaded module promise from the map
This commit is contained in:
Dan Bucholtz
2017-04-18 15:05:52 -05:00
parent f88823a30f
commit ff467db339
2 changed files with 79 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/util/module-loader.ts
View File

@ -36,11 +36,8 @@ export class ModuleLoader {
} }
return promise.then(loadedModule => { return promise.then(loadedModule => {
// clear it from the cache
this._promiseMap.delete(modulePath);
console.timeEnd(`ModuleLoader, load: ${modulePath}'`); console.timeEnd(`ModuleLoader, load: ${modulePath}'`);
const ref = loadedModule.create(this._injector); const ref = loadedModule.create(this._injector);
const component = ref.injector.get(LAZY_LOADED_TOKEN); const component = ref.injector.get(LAZY_LOADED_TOKEN);
this._cfrMap.set(component, ref.componentFactoryResolver); this._cfrMap.set(component, ref.componentFactoryResolver);

139
src/util/test/module-loader.spec.ts
View File

@ -1,4 +1,4 @@
import { ModuleLoader } from '../module-loader'; import { ModuleLoader, LAZY_LOADED_TOKEN } from '../module-loader';
import { mockModuleLoader, mockNgModuleLoader } from '../mock-providers'; import { mockModuleLoader, mockNgModuleLoader } from '../mock-providers';
import { NgModuleLoader } from '../ng-module-loader'; import { NgModuleLoader } from '../ng-module-loader';
@ -8,90 +8,109 @@ describe('module-loader', () => {
describe('load', () => { describe('load', () => {
it('should call ngModuleLoader and receive a promise back', (done: Function) => { it('should call ngModuleLoader and receive a promise back', (done: Function) => {
spyOn(ngModuleLoader, 'load').and.returnValue(Promise.resolve()); const mockLoadedModule = {
create: () => { }
};
const mockComponentFactoryResolver = {};
const mockInjector = {
get: () => { }
};
const mockNgModuleRef = {
injector: mockInjector,
componentFactoryResolver: mockComponentFactoryResolver
};
const mockComponent = {};
spyOn(mockInjector, mockInjector.get.name).and.returnValue(mockComponent);
spyOn(mockLoadedModule, mockLoadedModule.create.name).and.returnValue(mockNgModuleRef);
spyOn(ngModuleLoader, 'load').and.returnValue(Promise.resolve(mockLoadedModule));
let pathPrefix = '../some/known/path'; let pathPrefix = '../some/known/path';
let exportSuffix = 'SomeModule'; let exportSuffix = 'SomeModule';
let loadChildren = pathPrefix + '#' + exportSuffix; let loadChildren = pathPrefix + '#' + exportSuffix;
let promise = moduleLoader.load(loadChildren); let promise = moduleLoader.load(loadChildren);
promise.then((response) => { promise.then((response) => {
expect(ngModuleLoader.load).toHaveBeenCalledWith(pathPrefix, exportSuffix); expect(ngModuleLoader.load).toHaveBeenCalledWith(pathPrefix, exportSuffix);
}).catch((err: Error) => { expect(mockLoadedModule.create).toHaveBeenCalledWith(null); // whatever the injector is
fail(err); expect(mockInjector.get).toHaveBeenCalledWith(LAZY_LOADED_TOKEN);
done(err); expect(response.component).toEqual(mockComponent);
}); expect(response.componentFactoryResolver).toEqual(mockComponentFactoryResolver);
done();
}).catch((err: Error) => {
fail(err);
done(err);
});
}); });
it('should only call the ngModuleLoader when there is not an active request', () => { it('should only call the ngModuleLoader when there is not an active request', () => {
let resolve: any = null; let resolve: any = null;
let reject: any = null; let reject: any = null;
let promise = new Promise((scopedResolved, scopedReject) => { let promise = new Promise((scopedResolved, scopedReject) => {
resolve = scopedResolved; resolve = scopedResolved;
reject = scopedReject; reject = scopedReject;
}); });
spyOn(ngModuleLoader, 'load').and.returnValue(promise); spyOn(ngModuleLoader, 'load').and.returnValue(promise);
let pathPrefix = '../some/known/path'; let pathPrefix = '../some/known/path';
let exportSuffix = 'SomeModule'; let exportSuffix = 'SomeModule';
let loadChildren = pathPrefix + '#' + exportSuffix; let loadChildren = pathPrefix + '#' + exportSuffix;
promise = moduleLoader.load(loadChildren); promise = moduleLoader.load(loadChildren);
// the promise is not resolved // the promise is not resolved
let secondPromise = moduleLoader.load(loadChildren); let secondPromise = moduleLoader.load(loadChildren);
// The promise returned should be the cached promise // The promise returned should be the cached promise
expect(promise).toEqual(secondPromise); expect(promise).toEqual(secondPromise);
expect(ngModuleLoader.load).toHaveBeenCalledTimes(1); expect(ngModuleLoader.load).toHaveBeenCalledTimes(1);
}); });
it('should call the ngModuleLoader twice and return the active request', () => { it('should call the ngModuleLoader twice and return the active request', () => {
let resolve: any = null; let resolve: any = null;
let reject: any = null; let reject: any = null;
let promise = new Promise((scopedResolved, scopedReject) => { let promise = new Promise((scopedResolved, scopedReject) => {
resolve = scopedResolved; resolve = scopedResolved;
reject = scopedReject; reject = scopedReject;
}); });
let promise2 = new Promise((scopedResolved, scopedReject) => { let promise2 = new Promise((scopedResolved, scopedReject) => {
resolve = scopedResolved; resolve = scopedResolved;
reject = scopedReject; reject = scopedReject;
}); });
spyOn(ngModuleLoader, 'load').and.returnValue(promise); spyOn(ngModuleLoader, 'load').and.returnValue(promise);
// Load the first module // Load the first module
let pathPrefix = '../some/known/path'; let pathPrefix = '../some/known/path';
let exportSuffix = 'SomeModule'; let exportSuffix = 'SomeModule';
let loadChildren = pathPrefix + '#' + exportSuffix; let loadChildren = pathPrefix + '#' + exportSuffix;
promise = moduleLoader.load(loadChildren); promise = moduleLoader.load(loadChildren);
expect(ngModuleLoader.load).toHaveBeenCalledWith(pathPrefix, exportSuffix); expect(ngModuleLoader.load).toHaveBeenCalledWith(pathPrefix, exportSuffix);
// Load the second module // Load the second module
let pathPrefix2 = '../another/known/path'; let pathPrefix2 = '../another/known/path';
let exportSuffix2 = 'AnotherModule'; let exportSuffix2 = 'AnotherModule';
let loadChildren2 = pathPrefix2 + '#' + exportSuffix2; let loadChildren2 = pathPrefix2 + '#' + exportSuffix2;
promise2 = moduleLoader.load(loadChildren2); promise2 = moduleLoader.load(loadChildren2);
expect(ngModuleLoader.load).toHaveBeenCalledWith(pathPrefix2, exportSuffix2); expect(ngModuleLoader.load).toHaveBeenCalledWith(pathPrefix2, exportSuffix2);
// Load the first module before the promise has resolved // Load the first module before the promise has resolved
let secondPromise = moduleLoader.load(loadChildren); let secondPromise = moduleLoader.load(loadChildren);
// The promise returned from the first module should be the cached promise // The promise returned from the first module should be the cached promise
expect(promise).toEqual(secondPromise); expect(promise).toEqual(secondPromise);
// Load the second module before the promise has resolved // Load the second module before the promise has resolved
let thirdPromise = moduleLoader.load(loadChildren2); let thirdPromise = moduleLoader.load(loadChildren2);
// The promise returned from the second module should be the cached promise // The promise returned from the second module should be the cached promise
expect(promise2).toEqual(thirdPromise); expect(promise2).toEqual(thirdPromise);
expect(ngModuleLoader.load).toHaveBeenCalledTimes(2); expect(ngModuleLoader.load).toHaveBeenCalledTimes(2);
}); });
}); });