You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
854 lines
36 KiB
854 lines
36 KiB
import { __awaiter } from 'tslib';
|
|
import { TestKey, _getTextWithExcludedElements, handleAutoChangeDetectionStatus, stopHandlingAutoChangeDetectionStatus, HarnessEnvironment } from '@angular/cdk/testing';
|
|
import { flush } from '@angular/core/testing';
|
|
import { takeWhile } from 'rxjs/operators';
|
|
import { BehaviorSubject } from 'rxjs';
|
|
import * as keyCodes from '@angular/cdk/keycodes';
|
|
import { PERIOD } from '@angular/cdk/keycodes';
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/** Unique symbol that is used to patch a property to a proxy zone. */
|
|
const stateObservableSymbol = Symbol('ProxyZone_PATCHED#stateObservable');
|
|
/**
|
|
* Interceptor that can be set up in a `ProxyZone` instance. The interceptor
|
|
* will keep track of the task state and emit whenever the state changes.
|
|
*
|
|
* This serves as a workaround for https://github.com/angular/angular/issues/32896.
|
|
*/
|
|
class TaskStateZoneInterceptor {
|
|
constructor(_lastState) {
|
|
this._lastState = _lastState;
|
|
/** Subject that can be used to emit a new state change. */
|
|
this._stateSubject = new BehaviorSubject(this._lastState ? this._getTaskStateFromInternalZoneState(this._lastState) : { stable: true });
|
|
/** Public observable that emits whenever the task state changes. */
|
|
this.state = this._stateSubject;
|
|
}
|
|
/** This will be called whenever the task state changes in the intercepted zone. */
|
|
onHasTask(delegate, current, target, hasTaskState) {
|
|
if (current === target) {
|
|
this._stateSubject.next(this._getTaskStateFromInternalZoneState(hasTaskState));
|
|
}
|
|
}
|
|
/** Gets the task state from the internal ZoneJS task state. */
|
|
_getTaskStateFromInternalZoneState(state) {
|
|
return { stable: !state.macroTask && !state.microTask };
|
|
}
|
|
/**
|
|
* Sets up the custom task state Zone interceptor in the `ProxyZone`. Throws if
|
|
* no `ProxyZone` could be found.
|
|
* @returns an observable that emits whenever the task state changes.
|
|
*/
|
|
static setup() {
|
|
if (Zone === undefined) {
|
|
throw Error('Could not find ZoneJS. For test harnesses running in TestBed, ' +
|
|
'ZoneJS needs to be installed.');
|
|
}
|
|
// tslint:disable-next-line:variable-name
|
|
const ProxyZoneSpec = Zone['ProxyZoneSpec'];
|
|
// If there is no "ProxyZoneSpec" installed, we throw an error and recommend
|
|
// setting up the proxy zone by pulling in the testing bundle.
|
|
if (!ProxyZoneSpec) {
|
|
throw Error('ProxyZoneSpec is needed for the test harnesses but could not be found. ' +
|
|
'Please make sure that your environment includes zone.js/dist/zone-testing.js');
|
|
}
|
|
// Ensure that there is a proxy zone instance set up, and get
|
|
// a reference to the instance if present.
|
|
const zoneSpec = ProxyZoneSpec.assertPresent();
|
|
// If there already is a delegate registered in the proxy zone, and it
|
|
// is type of the custom task state interceptor, we just use that state
|
|
// observable. This allows us to only intercept Zone once per test
|
|
// (similar to how `fakeAsync` or `async` work).
|
|
if (zoneSpec[stateObservableSymbol]) {
|
|
return zoneSpec[stateObservableSymbol];
|
|
}
|
|
// Since we intercept on environment creation and the fixture has been
|
|
// created before, we might have missed tasks scheduled before. Fortunately
|
|
// the proxy zone keeps track of the previous task state, so we can just pass
|
|
// this as initial state to the task zone interceptor.
|
|
const interceptor = new TaskStateZoneInterceptor(zoneSpec.lastTaskState);
|
|
const zoneSpecOnHasTask = zoneSpec.onHasTask.bind(zoneSpec);
|
|
// We setup the task state interceptor in the `ProxyZone`. Note that we cannot register
|
|
// the interceptor as a new proxy zone delegate because it would mean that other zone
|
|
// delegates (e.g. `FakeAsyncTestZone` or `AsyncTestZone`) can accidentally overwrite/disable
|
|
// our interceptor. Since we just intend to monitor the task state of the proxy zone, it is
|
|
// sufficient to just patch the proxy zone. This also avoids that we interfere with the task
|
|
// queue scheduling logic.
|
|
zoneSpec.onHasTask = function (...args) {
|
|
zoneSpecOnHasTask(...args);
|
|
interceptor.onHasTask(...args);
|
|
};
|
|
return zoneSpec[stateObservableSymbol] = interceptor.state;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/** Used to generate unique IDs for events. */
|
|
let uniqueIds = 0;
|
|
/**
|
|
* Creates a browser MouseEvent with the specified options.
|
|
* @docs-private
|
|
*/
|
|
function createMouseEvent(type, clientX = 0, clientY = 0, button = 0, modifiers = {}) {
|
|
const event = document.createEvent('MouseEvent');
|
|
const originalPreventDefault = event.preventDefault.bind(event);
|
|
// Note: We cannot determine the position of the mouse event based on the screen
|
|
// because the dimensions and position of the browser window are not available
|
|
// To provide reasonable `screenX` and `screenY` coordinates, we simply use the
|
|
// client coordinates as if the browser is opened in fullscreen.
|
|
const screenX = clientX;
|
|
const screenY = clientY;
|
|
event.initMouseEvent(type,
|
|
/* canBubble */ true,
|
|
/* cancelable */ true,
|
|
/* view */ window,
|
|
/* detail */ 0,
|
|
/* screenX */ screenX,
|
|
/* screenY */ screenY,
|
|
/* clientX */ clientX,
|
|
/* clientY */ clientY,
|
|
/* ctrlKey */ !!modifiers.control,
|
|
/* altKey */ !!modifiers.alt,
|
|
/* shiftKey */ !!modifiers.shift,
|
|
/* metaKey */ !!modifiers.meta,
|
|
/* button */ button,
|
|
/* relatedTarget */ null);
|
|
// `initMouseEvent` doesn't allow us to pass these properties into the constructor.
|
|
// Override them to 1, because they're used for fake screen reader event detection.
|
|
defineReadonlyEventProperty(event, 'buttons', 1);
|
|
defineReadonlyEventProperty(event, 'offsetX', 1);
|
|
defineReadonlyEventProperty(event, 'offsetY', 1);
|
|
// IE won't set `defaultPrevented` on synthetic events so we need to do it manually.
|
|
event.preventDefault = function () {
|
|
defineReadonlyEventProperty(event, 'defaultPrevented', true);
|
|
return originalPreventDefault();
|
|
};
|
|
return event;
|
|
}
|
|
/**
|
|
* Creates a browser `PointerEvent` with the specified options. Pointer events
|
|
* by default will appear as if they are the primary pointer of their type.
|
|
* https://www.w3.org/TR/pointerevents2/#dom-pointerevent-isprimary.
|
|
*
|
|
* For example, if pointer events for a multi-touch interaction are created, the non-primary
|
|
* pointer touches would need to be represented by non-primary pointer events.
|
|
*
|
|
* @docs-private
|
|
*/
|
|
function createPointerEvent(type, clientX = 0, clientY = 0, options = { isPrimary: true }) {
|
|
return new PointerEvent(type, Object.assign({ bubbles: true, cancelable: true, view: window, clientX,
|
|
clientY }, options));
|
|
}
|
|
/**
|
|
* Creates a browser TouchEvent with the specified pointer coordinates.
|
|
* @docs-private
|
|
*/
|
|
function createTouchEvent(type, pageX = 0, pageY = 0, clientX = 0, clientY = 0) {
|
|
// In favor of creating events that work for most of the browsers, the event is created
|
|
// as a basic UI Event. The necessary details for the event will be set manually.
|
|
const event = document.createEvent('UIEvent');
|
|
const touchDetails = { pageX, pageY, clientX, clientY, id: uniqueIds++ };
|
|
// TS3.6 removes the initUIEvent method and suggests porting to "new UIEvent()".
|
|
event.initUIEvent(type, true, true, window, 0);
|
|
// Most of the browsers don't have a "initTouchEvent" method that can be used to define
|
|
// the touch details.
|
|
defineReadonlyEventProperty(event, 'touches', [touchDetails]);
|
|
defineReadonlyEventProperty(event, 'targetTouches', [touchDetails]);
|
|
defineReadonlyEventProperty(event, 'changedTouches', [touchDetails]);
|
|
return event;
|
|
}
|
|
/**
|
|
* Creates a keyboard event with the specified key and modifiers.
|
|
* @docs-private
|
|
*/
|
|
function createKeyboardEvent(type, keyCode = 0, key = '', modifiers = {}) {
|
|
const event = document.createEvent('KeyboardEvent');
|
|
const originalPreventDefault = event.preventDefault.bind(event);
|
|
// Firefox does not support `initKeyboardEvent`, but supports `initKeyEvent`.
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/initKeyEvent.
|
|
if (event.initKeyEvent !== undefined) {
|
|
event.initKeyEvent(type, true, true, window, modifiers.control, modifiers.alt, modifiers.shift, modifiers.meta, keyCode);
|
|
}
|
|
else {
|
|
// `initKeyboardEvent` expects to receive modifiers as a whitespace-delimited string
|
|
// See https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/initKeyboardEvent
|
|
let modifiersList = '';
|
|
if (modifiers.control) {
|
|
modifiersList += 'Control ';
|
|
}
|
|
if (modifiers.alt) {
|
|
modifiersList += 'Alt ';
|
|
}
|
|
if (modifiers.shift) {
|
|
modifiersList += 'Shift ';
|
|
}
|
|
if (modifiers.meta) {
|
|
modifiersList += 'Meta ';
|
|
}
|
|
// TS3.6 removed the `initKeyboardEvent` method and suggested porting to
|
|
// `new KeyboardEvent()` constructor. We cannot use that as we support IE11.
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/initKeyboardEvent.
|
|
event.initKeyboardEvent(type, true, /* canBubble */ true, /* cancelable */ window, /* view */ 0, /* char */ key, /* key */ 0, /* location */ modifiersList.trim(), /* modifiersList */ false /* repeat */);
|
|
}
|
|
// Webkit Browsers don't set the keyCode when calling the init function.
|
|
// See related bug https://bugs.webkit.org/show_bug.cgi?id=16735
|
|
defineReadonlyEventProperty(event, 'keyCode', keyCode);
|
|
defineReadonlyEventProperty(event, 'key', key);
|
|
defineReadonlyEventProperty(event, 'ctrlKey', !!modifiers.control);
|
|
defineReadonlyEventProperty(event, 'altKey', !!modifiers.alt);
|
|
defineReadonlyEventProperty(event, 'shiftKey', !!modifiers.shift);
|
|
defineReadonlyEventProperty(event, 'metaKey', !!modifiers.meta);
|
|
// IE won't set `defaultPrevented` on synthetic events so we need to do it manually.
|
|
event.preventDefault = function () {
|
|
defineReadonlyEventProperty(event, 'defaultPrevented', true);
|
|
return originalPreventDefault();
|
|
};
|
|
return event;
|
|
}
|
|
/**
|
|
* Creates a fake event object with any desired event type.
|
|
* @docs-private
|
|
*/
|
|
function createFakeEvent(type, canBubble = false, cancelable = true) {
|
|
const event = document.createEvent('Event');
|
|
event.initEvent(type, canBubble, cancelable);
|
|
return event;
|
|
}
|
|
/**
|
|
* Defines a readonly property on the given event object. Readonly properties on an event object
|
|
* are always set as configurable as that matches default readonly properties for DOM event objects.
|
|
*/
|
|
function defineReadonlyEventProperty(event, propertyName, value) {
|
|
Object.defineProperty(event, propertyName, { get: () => value, configurable: true });
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* Utility to dispatch any event on a Node.
|
|
* @docs-private
|
|
*/
|
|
function dispatchEvent(node, event) {
|
|
node.dispatchEvent(event);
|
|
return event;
|
|
}
|
|
/**
|
|
* Shorthand to dispatch a fake event on a specified node.
|
|
* @docs-private
|
|
*/
|
|
function dispatchFakeEvent(node, type, canBubble) {
|
|
return dispatchEvent(node, createFakeEvent(type, canBubble));
|
|
}
|
|
/**
|
|
* Shorthand to dispatch a keyboard event with a specified key code and
|
|
* optional modifiers.
|
|
* @docs-private
|
|
*/
|
|
function dispatchKeyboardEvent(node, type, keyCode, key, modifiers) {
|
|
return dispatchEvent(node, createKeyboardEvent(type, keyCode, key, modifiers));
|
|
}
|
|
/**
|
|
* Shorthand to dispatch a mouse event on the specified coordinates.
|
|
* @docs-private
|
|
*/
|
|
function dispatchMouseEvent(node, type, clientX = 0, clientY = 0, button, modifiers) {
|
|
return dispatchEvent(node, createMouseEvent(type, clientX, clientY, button, modifiers));
|
|
}
|
|
/**
|
|
* Shorthand to dispatch a pointer event on the specified coordinates.
|
|
* @docs-private
|
|
*/
|
|
function dispatchPointerEvent(node, type, clientX = 0, clientY = 0, options) {
|
|
return dispatchEvent(node, createPointerEvent(type, clientX, clientY, options));
|
|
}
|
|
/**
|
|
* Shorthand to dispatch a touch event on the specified coordinates.
|
|
* @docs-private
|
|
*/
|
|
function dispatchTouchEvent(node, type, pageX = 0, pageY = 0, clientX = 0, clientY = 0) {
|
|
return dispatchEvent(node, createTouchEvent(type, pageX, pageY, clientX, clientY));
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
function triggerFocusChange(element, event) {
|
|
let eventFired = false;
|
|
const handler = () => eventFired = true;
|
|
element.addEventListener(event, handler);
|
|
element[event]();
|
|
element.removeEventListener(event, handler);
|
|
if (!eventFired) {
|
|
dispatchFakeEvent(element, event);
|
|
}
|
|
}
|
|
/**
|
|
* Patches an elements focus and blur methods to emit events consistently and predictably.
|
|
* This is necessary, because some browsers, like IE11, will call the focus handlers asynchronously,
|
|
* while others won't fire them at all if the browser window is not focused.
|
|
* @docs-private
|
|
*/
|
|
function patchElementFocus(element) {
|
|
element.focus = () => dispatchFakeEvent(element, 'focus');
|
|
element.blur = () => dispatchFakeEvent(element, 'blur');
|
|
}
|
|
/** @docs-private */
|
|
function triggerFocus(element) {
|
|
triggerFocusChange(element, 'focus');
|
|
}
|
|
/** @docs-private */
|
|
function triggerBlur(element) {
|
|
triggerFocusChange(element, 'blur');
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/** Input types for which the value can be entered incrementally. */
|
|
const incrementalInputTypes = new Set(['text', 'email', 'hidden', 'password', 'search', 'tel', 'url']);
|
|
/**
|
|
* Checks whether the given Element is a text input element.
|
|
* @docs-private
|
|
*/
|
|
function isTextInput(element) {
|
|
const nodeName = element.nodeName.toLowerCase();
|
|
return nodeName === 'input' || nodeName === 'textarea';
|
|
}
|
|
function typeInElement(element, ...modifiersAndKeys) {
|
|
const first = modifiersAndKeys[0];
|
|
let modifiers;
|
|
let rest;
|
|
if (typeof first !== 'string' && first.keyCode === undefined && first.key === undefined) {
|
|
modifiers = first;
|
|
rest = modifiersAndKeys.slice(1);
|
|
}
|
|
else {
|
|
modifiers = {};
|
|
rest = modifiersAndKeys;
|
|
}
|
|
const isInput = isTextInput(element);
|
|
const inputType = element.getAttribute('type') || 'text';
|
|
const keys = rest
|
|
.map(k => typeof k === 'string' ?
|
|
k.split('').map(c => ({ keyCode: c.toUpperCase().charCodeAt(0), key: c })) : [k])
|
|
.reduce((arr, k) => arr.concat(k), []);
|
|
// We simulate the user typing in a value by incrementally assigning the value below. The problem
|
|
// is that for some input types, the browser won't allow for an invalid value to be set via the
|
|
// `value` property which will always be the case when going character-by-character. If we detect
|
|
// such an input, we have to set the value all at once or listeners to the `input` event (e.g.
|
|
// the `ReactiveFormsModule` uses such an approach) won't receive the correct value.
|
|
const enterValueIncrementally = inputType === 'number' && keys.length > 0 ?
|
|
// The value can be set character by character in number inputs if it doesn't have any decimals.
|
|
keys.every(key => key.key !== '.' && key.keyCode !== PERIOD) :
|
|
incrementalInputTypes.has(inputType);
|
|
triggerFocus(element);
|
|
// When we aren't entering the value incrementally, assign it all at once ahead
|
|
// of time so that any listeners to the key events below will have access to it.
|
|
if (!enterValueIncrementally) {
|
|
element.value = keys.reduce((value, key) => value + (key.key || ''), '');
|
|
}
|
|
for (const key of keys) {
|
|
dispatchKeyboardEvent(element, 'keydown', key.keyCode, key.key, modifiers);
|
|
dispatchKeyboardEvent(element, 'keypress', key.keyCode, key.key, modifiers);
|
|
if (isInput && key.key && key.key.length === 1) {
|
|
if (enterValueIncrementally) {
|
|
element.value += key.key;
|
|
dispatchFakeEvent(element, 'input');
|
|
}
|
|
}
|
|
dispatchKeyboardEvent(element, 'keyup', key.keyCode, key.key, modifiers);
|
|
}
|
|
// Since we weren't dispatching `input` events while sending the keys, we have to do it now.
|
|
if (!enterValueIncrementally) {
|
|
dispatchFakeEvent(element, 'input');
|
|
}
|
|
}
|
|
/**
|
|
* Clears the text in an input or textarea element.
|
|
* @docs-private
|
|
*/
|
|
function clearElement(element) {
|
|
triggerFocus(element);
|
|
element.value = '';
|
|
dispatchFakeEvent(element, 'input');
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/** Maps `TestKey` constants to the `keyCode` and `key` values used by native browser events. */
|
|
const keyMap = {
|
|
[TestKey.BACKSPACE]: { keyCode: keyCodes.BACKSPACE, key: 'Backspace' },
|
|
[TestKey.TAB]: { keyCode: keyCodes.TAB, key: 'Tab' },
|
|
[TestKey.ENTER]: { keyCode: keyCodes.ENTER, key: 'Enter' },
|
|
[TestKey.SHIFT]: { keyCode: keyCodes.SHIFT, key: 'Shift' },
|
|
[TestKey.CONTROL]: { keyCode: keyCodes.CONTROL, key: 'Control' },
|
|
[TestKey.ALT]: { keyCode: keyCodes.ALT, key: 'Alt' },
|
|
[TestKey.ESCAPE]: { keyCode: keyCodes.ESCAPE, key: 'Escape' },
|
|
[TestKey.PAGE_UP]: { keyCode: keyCodes.PAGE_UP, key: 'PageUp' },
|
|
[TestKey.PAGE_DOWN]: { keyCode: keyCodes.PAGE_DOWN, key: 'PageDown' },
|
|
[TestKey.END]: { keyCode: keyCodes.END, key: 'End' },
|
|
[TestKey.HOME]: { keyCode: keyCodes.HOME, key: 'Home' },
|
|
[TestKey.LEFT_ARROW]: { keyCode: keyCodes.LEFT_ARROW, key: 'ArrowLeft' },
|
|
[TestKey.UP_ARROW]: { keyCode: keyCodes.UP_ARROW, key: 'ArrowUp' },
|
|
[TestKey.RIGHT_ARROW]: { keyCode: keyCodes.RIGHT_ARROW, key: 'ArrowRight' },
|
|
[TestKey.DOWN_ARROW]: { keyCode: keyCodes.DOWN_ARROW, key: 'ArrowDown' },
|
|
[TestKey.INSERT]: { keyCode: keyCodes.INSERT, key: 'Insert' },
|
|
[TestKey.DELETE]: { keyCode: keyCodes.DELETE, key: 'Delete' },
|
|
[TestKey.F1]: { keyCode: keyCodes.F1, key: 'F1' },
|
|
[TestKey.F2]: { keyCode: keyCodes.F2, key: 'F2' },
|
|
[TestKey.F3]: { keyCode: keyCodes.F3, key: 'F3' },
|
|
[TestKey.F4]: { keyCode: keyCodes.F4, key: 'F4' },
|
|
[TestKey.F5]: { keyCode: keyCodes.F5, key: 'F5' },
|
|
[TestKey.F6]: { keyCode: keyCodes.F6, key: 'F6' },
|
|
[TestKey.F7]: { keyCode: keyCodes.F7, key: 'F7' },
|
|
[TestKey.F8]: { keyCode: keyCodes.F8, key: 'F8' },
|
|
[TestKey.F9]: { keyCode: keyCodes.F9, key: 'F9' },
|
|
[TestKey.F10]: { keyCode: keyCodes.F10, key: 'F10' },
|
|
[TestKey.F11]: { keyCode: keyCodes.F11, key: 'F11' },
|
|
[TestKey.F12]: { keyCode: keyCodes.F12, key: 'F12' },
|
|
[TestKey.META]: { keyCode: keyCodes.META, key: 'Meta' }
|
|
};
|
|
/** A `TestElement` implementation for unit tests. */
|
|
class UnitTestElement {
|
|
constructor(element, _stabilize) {
|
|
this.element = element;
|
|
this._stabilize = _stabilize;
|
|
}
|
|
/** Blur the element. */
|
|
blur() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
triggerBlur(this.element);
|
|
yield this._stabilize();
|
|
});
|
|
}
|
|
/** Clear the element's input (for input and textarea elements only). */
|
|
clear() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (!isTextInput(this.element)) {
|
|
throw Error('Attempting to clear an invalid element');
|
|
}
|
|
clearElement(this.element);
|
|
yield this._stabilize();
|
|
});
|
|
}
|
|
click(...args) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
yield this._dispatchMouseEventSequence('click', args, 0);
|
|
yield this._stabilize();
|
|
});
|
|
}
|
|
rightClick(...args) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
yield this._dispatchMouseEventSequence('contextmenu', args, 2);
|
|
yield this._stabilize();
|
|
});
|
|
}
|
|
/** Focus the element. */
|
|
focus() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
triggerFocus(this.element);
|
|
yield this._stabilize();
|
|
});
|
|
}
|
|
/** Get the computed value of the given CSS property for the element. */
|
|
getCssValue(property) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
yield this._stabilize();
|
|
// TODO(mmalerba): Consider adding value normalization if we run into common cases where its
|
|
// needed.
|
|
return getComputedStyle(this.element).getPropertyValue(property);
|
|
});
|
|
}
|
|
/** Hovers the mouse over the element. */
|
|
hover() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
this._dispatchPointerEventIfSupported('pointerenter');
|
|
dispatchMouseEvent(this.element, 'mouseenter');
|
|
yield this._stabilize();
|
|
});
|
|
}
|
|
/** Moves the mouse away from the element. */
|
|
mouseAway() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
this._dispatchPointerEventIfSupported('pointerleave');
|
|
dispatchMouseEvent(this.element, 'mouseleave');
|
|
yield this._stabilize();
|
|
});
|
|
}
|
|
sendKeys(...modifiersAndKeys) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const args = modifiersAndKeys.map(k => typeof k === 'number' ? keyMap[k] : k);
|
|
typeInElement(this.element, ...args);
|
|
yield this._stabilize();
|
|
});
|
|
}
|
|
/**
|
|
* Gets the text from the element.
|
|
* @param options Options that affect what text is included.
|
|
*/
|
|
text(options) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
yield this._stabilize();
|
|
if (options === null || options === void 0 ? void 0 : options.exclude) {
|
|
return _getTextWithExcludedElements(this.element, options.exclude);
|
|
}
|
|
return (this.element.textContent || '').trim();
|
|
});
|
|
}
|
|
/** Gets the value for the given attribute from the element. */
|
|
getAttribute(name) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
yield this._stabilize();
|
|
return this.element.getAttribute(name);
|
|
});
|
|
}
|
|
/** Checks whether the element has the given class. */
|
|
hasClass(name) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
yield this._stabilize();
|
|
return this.element.classList.contains(name);
|
|
});
|
|
}
|
|
/** Gets the dimensions of the element. */
|
|
getDimensions() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
yield this._stabilize();
|
|
return this.element.getBoundingClientRect();
|
|
});
|
|
}
|
|
/** Gets the value of a property of an element. */
|
|
getProperty(name) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
yield this._stabilize();
|
|
return this.element[name];
|
|
});
|
|
}
|
|
/** Sets the value of a property of an input. */
|
|
setInputValue(value) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
this.element.value = value;
|
|
yield this._stabilize();
|
|
});
|
|
}
|
|
/** Selects the options at the specified indexes inside of a native `select` element. */
|
|
selectOptions(...optionIndexes) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let hasChanged = false;
|
|
const options = this.element.querySelectorAll('option');
|
|
const indexes = new Set(optionIndexes); // Convert to a set to remove duplicates.
|
|
for (let i = 0; i < options.length; i++) {
|
|
const option = options[i];
|
|
const wasSelected = option.selected;
|
|
// We have to go through `option.selected`, because `HTMLSelectElement.value` doesn't
|
|
// allow for multiple options to be selected, even in `multiple` mode.
|
|
option.selected = indexes.has(i);
|
|
if (option.selected !== wasSelected) {
|
|
hasChanged = true;
|
|
dispatchFakeEvent(this.element, 'change');
|
|
}
|
|
}
|
|
if (hasChanged) {
|
|
yield this._stabilize();
|
|
}
|
|
});
|
|
}
|
|
/** Checks whether this element matches the given selector. */
|
|
matchesSelector(selector) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
yield this._stabilize();
|
|
const elementPrototype = Element.prototype;
|
|
return (elementPrototype['matches'] || elementPrototype['msMatchesSelector'])
|
|
.call(this.element, selector);
|
|
});
|
|
}
|
|
/** Checks whether the element is focused. */
|
|
isFocused() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
yield this._stabilize();
|
|
return document.activeElement === this.element;
|
|
});
|
|
}
|
|
/**
|
|
* Dispatches an event with a particular name.
|
|
* @param name Name of the event to be dispatched.
|
|
*/
|
|
dispatchEvent(name, data) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const event = createFakeEvent(name);
|
|
if (data) {
|
|
// tslint:disable-next-line:ban Have to use `Object.assign` to preserve the original object.
|
|
Object.assign(event, data);
|
|
}
|
|
dispatchEvent(this.element, event);
|
|
yield this._stabilize();
|
|
});
|
|
}
|
|
/**
|
|
* Dispatches a pointer event on the current element if the browser supports it.
|
|
* @param name Name of the pointer event to be dispatched.
|
|
* @param clientX Coordinate of the user's pointer along the X axis.
|
|
* @param clientY Coordinate of the user's pointer along the Y axis.
|
|
* @param button Mouse button that should be pressed when dispatching the event.
|
|
*/
|
|
_dispatchPointerEventIfSupported(name, clientX, clientY, button) {
|
|
// The latest versions of all browsers we support have the new `PointerEvent` API.
|
|
// Though since we capture the two most recent versions of these browsers, we also
|
|
// need to support Safari 12 at time of writing. Safari 12 does not have support for this,
|
|
// so we need to conditionally create and dispatch these events based on feature detection.
|
|
if (typeof PointerEvent !== 'undefined' && PointerEvent) {
|
|
dispatchPointerEvent(this.element, name, clientX, clientY, { isPrimary: true, button });
|
|
}
|
|
}
|
|
/** Dispatches all the events that are part of a mouse event sequence. */
|
|
_dispatchMouseEventSequence(name, args, button) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let clientX = undefined;
|
|
let clientY = undefined;
|
|
let modifiers = {};
|
|
if (args.length && typeof args[args.length - 1] === 'object') {
|
|
modifiers = args.pop();
|
|
}
|
|
if (args.length) {
|
|
const { left, top, width, height } = yield this.getDimensions();
|
|
const relativeX = args[0] === 'center' ? width / 2 : args[0];
|
|
const relativeY = args[0] === 'center' ? height / 2 : args[1];
|
|
// Round the computed click position as decimal pixels are not
|
|
// supported by mouse events and could lead to unexpected results.
|
|
clientX = Math.round(left + relativeX);
|
|
clientY = Math.round(top + relativeY);
|
|
}
|
|
this._dispatchPointerEventIfSupported('pointerdown', clientX, clientY, button);
|
|
dispatchMouseEvent(this.element, 'mousedown', clientX, clientY, button, modifiers);
|
|
this._dispatchPointerEventIfSupported('pointerup', clientX, clientY, button);
|
|
dispatchMouseEvent(this.element, 'mouseup', clientX, clientY, button, modifiers);
|
|
dispatchMouseEvent(this.element, name, clientX, clientY, button, modifiers);
|
|
// This call to _stabilize should not be needed since the callers will already do that them-
|
|
// selves. Nevertheless it breaks some tests in g3 without it. It needs to be investigated
|
|
// why removing breaks those tests.
|
|
yield this._stabilize();
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/** The default environment options. */
|
|
const defaultEnvironmentOptions = {
|
|
queryFn: (selector, root) => root.querySelectorAll(selector)
|
|
};
|
|
/** Whether auto change detection is currently disabled. */
|
|
let disableAutoChangeDetection = false;
|
|
/**
|
|
* The set of non-destroyed fixtures currently being used by `TestbedHarnessEnvironment` instances.
|
|
*/
|
|
const activeFixtures = new Set();
|
|
/**
|
|
* Installs a handler for change detection batching status changes for a specific fixture.
|
|
* @param fixture The fixture to handle change detection batching for.
|
|
*/
|
|
function installAutoChangeDetectionStatusHandler(fixture) {
|
|
if (!activeFixtures.size) {
|
|
handleAutoChangeDetectionStatus(({ isDisabled, onDetectChangesNow }) => {
|
|
disableAutoChangeDetection = isDisabled;
|
|
if (onDetectChangesNow) {
|
|
Promise.all(Array.from(activeFixtures).map(detectChanges)).then(onDetectChangesNow);
|
|
}
|
|
});
|
|
}
|
|
activeFixtures.add(fixture);
|
|
}
|
|
/**
|
|
* Uninstalls a handler for change detection batching status changes for a specific fixture.
|
|
* @param fixture The fixture to stop handling change detection batching for.
|
|
*/
|
|
function uninstallAutoChangeDetectionStatusHandler(fixture) {
|
|
activeFixtures.delete(fixture);
|
|
if (!activeFixtures.size) {
|
|
stopHandlingAutoChangeDetectionStatus();
|
|
}
|
|
}
|
|
/** Whether we are currently in the fake async zone. */
|
|
function isInFakeAsyncZone() {
|
|
return Zone.current.get('FakeAsyncTestZoneSpec') != null;
|
|
}
|
|
/**
|
|
* Triggers change detection for a specific fixture.
|
|
* @param fixture The fixture to trigger change detection for.
|
|
*/
|
|
function detectChanges(fixture) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
fixture.detectChanges();
|
|
if (isInFakeAsyncZone()) {
|
|
flush();
|
|
}
|
|
else {
|
|
yield fixture.whenStable();
|
|
}
|
|
});
|
|
}
|
|
/** A `HarnessEnvironment` implementation for Angular's Testbed. */
|
|
class TestbedHarnessEnvironment extends HarnessEnvironment {
|
|
constructor(rawRootElement, _fixture, options) {
|
|
super(rawRootElement);
|
|
this._fixture = _fixture;
|
|
/** Whether the environment has been destroyed. */
|
|
this._destroyed = false;
|
|
this._options = Object.assign(Object.assign({}, defaultEnvironmentOptions), options);
|
|
this._taskState = TaskStateZoneInterceptor.setup();
|
|
installAutoChangeDetectionStatusHandler(_fixture);
|
|
_fixture.componentRef.onDestroy(() => {
|
|
uninstallAutoChangeDetectionStatusHandler(_fixture);
|
|
this._destroyed = true;
|
|
});
|
|
}
|
|
/** Creates a `HarnessLoader` rooted at the given fixture's root element. */
|
|
static loader(fixture, options) {
|
|
return new TestbedHarnessEnvironment(fixture.nativeElement, fixture, options);
|
|
}
|
|
/**
|
|
* Creates a `HarnessLoader` at the document root. This can be used if harnesses are
|
|
* located outside of a fixture (e.g. overlays appended to the document body).
|
|
*/
|
|
static documentRootLoader(fixture, options) {
|
|
return new TestbedHarnessEnvironment(document.body, fixture, options);
|
|
}
|
|
/** Gets the native DOM element corresponding to the given TestElement. */
|
|
static getNativeElement(el) {
|
|
if (el instanceof UnitTestElement) {
|
|
return el.element;
|
|
}
|
|
throw Error('This TestElement was not created by the TestbedHarnessEnvironment');
|
|
}
|
|
/**
|
|
* Creates an instance of the given harness type, using the fixture's root element as the
|
|
* harness's host element. This method should be used when creating a harness for the root element
|
|
* of a fixture, as components do not have the correct selector when they are created as the root
|
|
* of the fixture.
|
|
*/
|
|
static harnessForFixture(fixture, harnessType, options) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const environment = new TestbedHarnessEnvironment(fixture.nativeElement, fixture, options);
|
|
yield environment.forceStabilize();
|
|
return environment.createComponentHarness(harnessType, fixture.nativeElement);
|
|
});
|
|
}
|
|
/**
|
|
* Flushes change detection and async tasks captured in the Angular zone.
|
|
* In most cases it should not be necessary to call this manually. However, there may be some edge
|
|
* cases where it is needed to fully flush animation events.
|
|
*/
|
|
forceStabilize() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (!disableAutoChangeDetection) {
|
|
if (this._destroyed) {
|
|
throw Error('Harness is attempting to use a fixture that has already been destroyed.');
|
|
}
|
|
yield detectChanges(this._fixture);
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Waits for all scheduled or running async tasks to complete. This allows harness
|
|
* authors to wait for async tasks outside of the Angular zone.
|
|
*/
|
|
waitForTasksOutsideAngular() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
// If we run in the fake async zone, we run "flush" to run any scheduled tasks. This
|
|
// ensures that the harnesses behave inside of the FakeAsyncTestZone similar to the
|
|
// "AsyncTestZone" and the root zone (i.e. neither fakeAsync or async). Note that we
|
|
// cannot just rely on the task state observable to become stable because the state will
|
|
// never change. This is because the task queue will be only drained if the fake async
|
|
// zone is being flushed.
|
|
if (isInFakeAsyncZone()) {
|
|
flush();
|
|
}
|
|
// Wait until the task queue has been drained and the zone is stable. Note that
|
|
// we cannot rely on "fixture.whenStable" since it does not catch tasks scheduled
|
|
// outside of the Angular zone. For test harnesses, we want to ensure that the
|
|
// app is fully stabilized and therefore need to use our own zone interceptor.
|
|
yield this._taskState.pipe(takeWhile(state => !state.stable)).toPromise();
|
|
});
|
|
}
|
|
/** Gets the root element for the document. */
|
|
getDocumentRoot() {
|
|
return document.body;
|
|
}
|
|
/** Creates a `TestElement` from a raw element. */
|
|
createTestElement(element) {
|
|
return new UnitTestElement(element, () => this.forceStabilize());
|
|
}
|
|
/** Creates a `HarnessLoader` rooted at the given raw element. */
|
|
createEnvironment(element) {
|
|
return new TestbedHarnessEnvironment(element, this._fixture, this._options);
|
|
}
|
|
/**
|
|
* Gets a list of all elements matching the given selector under this environment's root element.
|
|
*/
|
|
getAllRawElements(selector) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
yield this.forceStabilize();
|
|
return Array.from(this._options.queryFn(selector, this.rawRootElement));
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
|
|
export { TestbedHarnessEnvironment, UnitTestElement };
|
|
//# sourceMappingURL=testbed.js.map
|