angular2
Version:
Angular 2 - a web framework for modern web apps
217 lines (216 loc) • 8.71 kB
JavaScript
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { DynamicComponentLoader, Injector, Injectable } from 'angular2/core';
import { DirectiveResolver, ViewResolver } from 'angular2/compiler';
import { isPresent } from 'angular2/src/facade/lang';
import { PromiseWrapper } from 'angular2/src/facade/async';
import { MapWrapper } from 'angular2/src/facade/collection';
import { el } from './utils';
import { DOCUMENT } from 'angular2/src/platform/dom/dom_tokens';
import { DOM } from 'angular2/src/platform/dom/dom_adapter';
import { getDebugNode } from 'angular2/src/core/debug/debug_node';
import { tick } from './fake_async';
/**
* Fixture for debugging and testing a component.
*/
export class ComponentFixture {
constructor(componentRef) {
this.changeDetectorRef = componentRef.changeDetectorRef;
this.elementRef = componentRef.location;
this.debugElement = getDebugNode(this.elementRef.nativeElement);
this.componentInstance = componentRef.instance;
this.nativeElement = this.elementRef.nativeElement;
this.componentRef = componentRef;
}
/**
* Trigger a change detection cycle for the component.
*/
detectChanges(checkNoChanges = true) {
this.changeDetectorRef.detectChanges();
if (checkNoChanges) {
this.checkNoChanges();
}
}
checkNoChanges() { this.changeDetectorRef.checkNoChanges(); }
/**
* Trigger component destruction.
*/
destroy() { this.componentRef.destroy(); }
}
var _nextRootElementId = 0;
/**
* Builds a ComponentFixture for use in component level tests.
*/
let TestComponentBuilder_1;
export let TestComponentBuilder = TestComponentBuilder_1 = class TestComponentBuilder {
constructor(_injector) {
this._injector = _injector;
/** @internal */
this._bindingsOverrides = new Map();
/** @internal */
this._directiveOverrides = new Map();
/** @internal */
this._templateOverrides = new Map();
/** @internal */
this._viewBindingsOverrides = new Map();
/** @internal */
this._viewOverrides = new Map();
}
/** @internal */
_clone() {
var clone = new TestComponentBuilder_1(this._injector);
clone._viewOverrides = MapWrapper.clone(this._viewOverrides);
clone._directiveOverrides = MapWrapper.clone(this._directiveOverrides);
clone._templateOverrides = MapWrapper.clone(this._templateOverrides);
clone._bindingsOverrides = MapWrapper.clone(this._bindingsOverrides);
clone._viewBindingsOverrides = MapWrapper.clone(this._viewBindingsOverrides);
return clone;
}
/**
* Overrides only the html of a {@link ComponentMetadata}.
* All the other properties of the component's {@link ViewMetadata} are preserved.
*
* @param {Type} component
* @param {string} html
*
* @return {TestComponentBuilder}
*/
overrideTemplate(componentType, template) {
var clone = this._clone();
clone._templateOverrides.set(componentType, template);
return clone;
}
/**
* Overrides a component's {@link ViewMetadata}.
*
* @param {Type} component
* @param {view} View
*
* @return {TestComponentBuilder}
*/
overrideView(componentType, view) {
var clone = this._clone();
clone._viewOverrides.set(componentType, view);
return clone;
}
/**
* Overrides the directives from the component {@link ViewMetadata}.
*
* @param {Type} component
* @param {Type} from
* @param {Type} to
*
* @return {TestComponentBuilder}
*/
overrideDirective(componentType, from, to) {
var clone = this._clone();
var overridesForComponent = clone._directiveOverrides.get(componentType);
if (!isPresent(overridesForComponent)) {
clone._directiveOverrides.set(componentType, new Map());
overridesForComponent = clone._directiveOverrides.get(componentType);
}
overridesForComponent.set(from, to);
return clone;
}
/**
* Overrides one or more injectables configured via `providers` metadata property of a directive
* or
* component.
* Very useful when certain providers need to be mocked out.
*
* The providers specified via this method are appended to the existing `providers` causing the
* duplicated providers to
* be overridden.
*
* @param {Type} component
* @param {any[]} providers
*
* @return {TestComponentBuilder}
*/
overrideProviders(type, providers) {
var clone = this._clone();
clone._bindingsOverrides.set(type, providers);
return clone;
}
/**
* @deprecated
*/
overrideBindings(type, providers) {
return this.overrideProviders(type, providers);
}
/**
* Overrides one or more injectables configured via `providers` metadata property of a directive
* or
* component.
* Very useful when certain providers need to be mocked out.
*
* The providers specified via this method are appended to the existing `providers` causing the
* duplicated providers to
* be overridden.
*
* @param {Type} component
* @param {any[]} providers
*
* @return {TestComponentBuilder}
*/
overrideViewProviders(type, providers) {
var clone = this._clone();
clone._viewBindingsOverrides.set(type, providers);
return clone;
}
/**
* @deprecated
*/
overrideViewBindings(type, providers) {
return this.overrideViewProviders(type, providers);
}
/**
* Builds and returns a ComponentFixture.
*
* @return {Promise<ComponentFixture>}
*/
createAsync(rootComponentType) {
var mockDirectiveResolver = this._injector.get(DirectiveResolver);
var mockViewResolver = this._injector.get(ViewResolver);
this._viewOverrides.forEach((view, type) => mockViewResolver.setView(type, view));
this._templateOverrides.forEach((template, type) => mockViewResolver.setInlineTemplate(type, template));
this._directiveOverrides.forEach((overrides, component) => {
overrides.forEach((to, from) => { mockViewResolver.overrideViewDirective(component, from, to); });
});
this._bindingsOverrides.forEach((bindings, type) => mockDirectiveResolver.setBindingsOverride(type, bindings));
this._viewBindingsOverrides.forEach((bindings, type) => mockDirectiveResolver.setViewBindingsOverride(type, bindings));
var rootElId = `root${_nextRootElementId++}`;
var rootEl = el(`<div id="${rootElId}"></div>`);
var doc = this._injector.get(DOCUMENT);
// TODO(juliemr): can/should this be optional?
var oldRoots = DOM.querySelectorAll(doc, '[id^=root]');
for (var i = 0; i < oldRoots.length; i++) {
DOM.remove(oldRoots[i]);
}
DOM.appendChild(doc.body, rootEl);
var promise = this._injector.get(DynamicComponentLoader)
.loadAsRoot(rootComponentType, `#${rootElId}`, this._injector);
return promise.then((componentRef) => { return new ComponentFixture(componentRef); });
}
createFakeAsync(rootComponentType) {
var result;
var error;
PromiseWrapper.then(this.createAsync(rootComponentType), (_result) => { result = _result; }, (_error) => { error = _error; });
tick();
if (isPresent(error)) {
throw error;
}
return result;
}
};
TestComponentBuilder = TestComponentBuilder_1 = __decorate([
Injectable(),
__metadata('design:paramtypes', [Injector])
], TestComponentBuilder);