@terminus/ngx-tools
Version:
[![CircleCI][circle-badge]][circle-link] [![codecov][codecov-badge]][codecov-project] [![semantic-release][semantic-release-badge]][semantic-release] [![MIT License][license-image]][license-url] <br> [![NPM version][npm-version-image]][npm-url] [![Github
722 lines (671 loc) • 30.8 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@terminus/ngx-tools/utilities'), require('@angular/core/testing'), require('@angular/platform-browser')) :
typeof define === 'function' && define.amd ? define('@terminus/ngx-tools/testing', ['exports', '@angular/core', '@terminus/ngx-tools/utilities', '@angular/core/testing', '@angular/platform-browser'], factory) :
(global = global || self, factory((global.terminus = global.terminus || {}, global.terminus['ngx-tools'] = global.terminus['ngx-tools'] || {}, global.terminus['ngx-tools'].testing = {}), global.ng.core, global.terminus['ngx-tools'].utilities, global.ng.core.testing, global.ng.platformBrowser));
}(this, (function (exports, core, utilities, testing, platformBrowser) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(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;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __exportStar(m, exports) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
return cooked;
};
function __importStar(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result.default = mod;
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
}
function __classPrivateFieldSet(receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
}
/**
* A mock of the Angular ChangeDetectorRefMock class
*/
var ChangeDetectorRefMock = /** @class */ (function () {
function ChangeDetectorRefMock() {
this.markForCheck = utilities.noop;
this.detach = utilities.noop;
this.detectChanges = utilities.noop;
this.checkNoChanges = utilities.noop;
this.reattach = utilities.noop;
}
ChangeDetectorRefMock = __decorate([
core.Injectable()
], ChangeDetectorRefMock);
return ChangeDetectorRefMock;
}());
/**
* Default stubbed items for `nativeElement`
*/
var defaults = {
innerText: 'foo',
style: {},
classList: {
add: utilities.noop,
remove: utilities.noop,
},
};
/**
* A mock of the Angular ElementRef class
*/
var ElementRefMock = /** @class */ (function () {
function ElementRefMock(nativeElementAdditions) {
this.nativeElement = __assign(__assign({}, defaults), nativeElementAdditions || {});
}
return ElementRefMock;
}());
/**
* A mock of the Angular Renderer
*/
var rendererMock = {
setElementStyle: utilities.noop,
setElementClass: utilities.noop,
selectRootElement: utilities.noop,
createElement: utilities.noop,
createViewRoot: utilities.noop,
createText: utilities.noop,
setElementProperty: utilities.noop,
setElementAttribute: utilities.noop,
setText: utilities.noop,
setBindingDebugInfo: utilities.noop,
createTemplateAnchor: utilities.noop,
projectNodes: utilities.noop,
attachViewAfter: utilities.noop,
detachView: utilities.noop,
destroyView: utilities.noop,
listen: utilities.noop,
listenGlobal: utilities.noop,
invokeElementMethod: utilities.noop,
animate: utilities.noop,
};
/**
* A mock of the Angular Renderer2
*/
var Renderer2Mock = /** @class */ (function () {
function Renderer2Mock() {
}
Renderer2Mock.prototype.addClass = function () { };
Renderer2Mock.prototype.appendChild = function () { };
Renderer2Mock.prototype.createComment = function () { };
Object.defineProperty(Renderer2Mock.prototype, "data", {
get: function () {
return this._data;
},
set: function (v) {
this._data = v;
},
enumerable: true,
configurable: true
});
Renderer2Mock.prototype.destroy = function () { };
Renderer2Mock.prototype.destroyNode = function () { };
Renderer2Mock.prototype.insertBefore = function () { };
Renderer2Mock.prototype.nextSibling = function () { };
Renderer2Mock.prototype.parentNode = function () { };
Renderer2Mock.prototype.removeAttribute = function () { };
Renderer2Mock.prototype.removeChild = function () { };
Renderer2Mock.prototype.removeClass = function () { };
Renderer2Mock.prototype.removeStyle = function () { };
Renderer2Mock.prototype.setAttribute = function () { };
Renderer2Mock.prototype.setProperty = function () { };
Renderer2Mock.prototype.setStyle = function () { };
Renderer2Mock.prototype.setValue = function () { };
Renderer2Mock.prototype.animate = function () { };
Renderer2Mock.prototype.attachViewAfter = function () { };
Renderer2Mock.prototype.createElement = function () { };
Renderer2Mock.prototype.createTemplateAnchor = function () { };
Renderer2Mock.prototype.createText = function () { };
Renderer2Mock.prototype.createViewRoot = function () { };
Renderer2Mock.prototype.destroyView = function () { };
Renderer2Mock.prototype.detachView = function () { };
Renderer2Mock.prototype.invokeElementMethod = function () { };
Renderer2Mock.prototype.listen = function () {
return utilities.noop;
};
Renderer2Mock.prototype.listenGlobal = function () {
return utilities.noop;
};
Renderer2Mock.prototype.projectNodes = function () { };
Renderer2Mock.prototype.selectRootElement = function () { };
Renderer2Mock.prototype.setBindingDebugInfo = function () { };
Renderer2Mock.prototype.setElementAttribute = function () { };
Renderer2Mock.prototype.setElementClass = function () { };
Renderer2Mock.prototype.setElementProperty = function () { };
Renderer2Mock.prototype.setElementStyle = function () { };
Renderer2Mock.prototype.setText = function () { };
return Renderer2Mock;
}());
/**
* Create an instance of the TestBed and compile components
*
* @param configureFn - The configuration function for the TestBed
* @param compilerOptions
* @returns A promise-wrapped TestBed instance
*/
function configureTestBedWhitespace(configureFn, compilerOptions) {
if (compilerOptions === void 0) { compilerOptions = {}; }
var compilerConfig = __assign({ preserveWhitespaces: false }, compilerOptions);
var configuredTestBed = testing.TestBed.configureCompiler(compilerConfig);
configureFn(configuredTestBed);
return configuredTestBed.compileComponents().then(function () { return configuredTestBed; });
}
/**
* Set up the TestBed without resetting the TestBed for every test
*
* https://github.com/angular/angular/issues/12409
*
* @param moduleDef - The module definition
*/
function configureTestBedWithoutReset(moduleDef) {
var resetTestingModule = testing.TestBed.resetTestingModule;
var preventAngularFromResetting = function () {
testing.TestBed.resetTestingModule = function () { return testing.TestBed; };
return testing.TestBed.resetTestingModule;
};
var allowAngularToReset = function () {
testing.TestBed.resetTestingModule = resetTestingModule;
return testing.TestBed.resetTestingModule;
};
// eslint-disable-next-line no-undef
beforeAll(testing.async(function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
resetTestingModule();
preventAngularFromResetting();
testing.TestBed.configureTestingModule(moduleDef);
return [4 /*yield*/, testing.TestBed.compileComponents()];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
}));
// eslint-disable-next-line no-undef
afterAll(function () { return allowAngularToReset(); });
}
/**
* Create a TestBed fixture with a single component registered
*
* @param component - The test component
* @param providers - Any providers to register to the test module
* @param imports - Any items to import to the test module
* @returns The test fixture
*
* @example
* const myComponent = createComponent(MyComponent);
* const myComponent = createComponent(MyComponent, MyProviders, MyImports);
*/
function createComponent(component, providers,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
imports) {
if (providers === void 0) { providers = []; }
if (imports === void 0) { imports = []; }
testing.TestBed.configureTestingModule({
imports: __spread(imports),
declarations: [component],
providers: __spread(providers),
}).compileComponents();
return testing.TestBed.createComponent(component);
}
/**
* Creates a fake event object with any desired event type.
*
* @param type - The event type
* @param canBubble - Define if the event can bubble up the DOM
* @param cancelable
* @returns The event
*
* @example
* createFakeEvent('focus');
* createFakeEvent('focus', false, false);
*/
function createFakeEvent(type, canBubble, cancelable) {
if (canBubble === void 0) { canBubble = true; }
if (cancelable === void 0) { cancelable = true; }
var event = document.createEvent('Event');
event.initEvent(type, canBubble, cancelable);
return event;
}
/**
* Dispatches a keydown event from an element.
*
* @param type - The event type
* @param key - The KeyCode type
* @param target - The target element
* @returns The event
*
* @example
* createKeyboardEvent('keydown', ENTER, myInputNativeElement);
*/
function createKeyboardEvent(type, key, target) {
// NOTE: Cannot 'type' the event here due to the note about FireFox below
// eslint-disable-next-line @typescript-eslint/no-explicit-any
var event = document.createEvent('KeyboardEvent');
event.initEvent(type, true, false);
var originalPreventDefault = event.preventDefault;
// NOTE: Webkit Browsers don't set the keyCode when calling the init function.
// See related bug https://bugs.webkit.org/show_bug.cgi?id=16735
Object.defineProperties(event, {
code: { get: function () { return key.code; } },
key: { get: function () { return key.code; } },
keyCode: { get: function () { return key.keyCode; } },
target: { get: function () { return target; } },
});
// NOTE: IE won't set `defaultPrevented` on synthetic events so we need to do it manually.
event.preventDefault = function () {
Object.defineProperty(event, 'defaultPrevented', { get: function () { return true; } });
// FIXME: Not sure why this `as any` is needed now
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return originalPreventDefault.apply(this, arguments);
};
return event;
}
/**
* Create a browser MouseEvent with the specified options
*
* @param type - The event type
* @param x - The location on the X axis
* @param y - The location on the Y axis
* @returns The event
*
* @example
* createMouseEvent('click');
* createMouseEvent('click', 212, 433);
*/
function createMouseEvent(type, x, y) {
if (x === void 0) { x = 0; }
if (y === void 0) { y = 0; }
var event = document.createEvent('MouseEvent');
/* eslint-disable line-comment-position */
event.initMouseEvent(type, false, // canBubble
false, // cancelable
window, // view
0, // detail
x, // screenX
y, // screenY
x, // clientX
y, // clientY
false, // ctrlKey
false, // altKey
false, // shiftKey
false, // metaKey
0, // button
null);
/* eslint-enable line-comment-position */
return event;
}
/**
* Creates a browser TouchEvent with the specified pointer coordinates.
*
* @param type - The touch event type
* @param pageX - The location on the X axis
* @param pageY - The location on the Y axis
*
* @example
* createTouchEvent('touchstart');
* createTouchEvent('touchstart', 212, 433);
*/
function createTouchEvent(type, pageX, pageY) {
if (pageX === void 0) { pageX = 0; }
if (pageY === void 0) { pageY = 0; }
// NOTE: 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.
var event = document.createEvent('UIEvent');
var touchDetails = {
pageX: pageX,
pageY: pageY,
};
event.initEvent(type, true, true);
// NOTE: Most of the browsers don't have a "initTouchEvent" method that can be used to define the touch details.
Object.defineProperties(event, { touches: { value: [touchDetails] } });
return event;
}
/**
* Utility to dispatch any event on a Node.
*
* @param node - The Node that should dispatch the event
* @param event - The event to be dispatched
* @returns The dispatched event
*
* @example
* dispatchEvent(myNativeElement, 'blur');
*/
function dispatchEvent(node, event) {
node.dispatchEvent(event);
return event;
}
/**
* Shorthand to dispatch a fake event on a specified node.
*
* @param node - The Node that should dispatch the fake event
* @param type - The event type
* @param canBubble - Define if the event can bubble up the DOM
* @returns The event
*
* @example
* dispatchFakeEvent(myNativeElement, 'mousedown');
* dispatchFakeEvent(myNativeElement, 'mousedown', true);
*/
var dispatchFakeEvent = function (node, type, canBubble) { return dispatchEvent(node, createFakeEvent(type, canBubble)); };
/**
* Shorthand to dispatch a keyboard event with a specified key code
*
* @param node - The Node that should dispatch the keyboard event
* @param type - The event type
* @param key - The KeycodesConst type (contains code and keyCode)
* @param target - The target event element
* @returns The keyboard event
*
* @example
* dispatchKeyboardEvent(myNativeElement, 'keyup', ENTER);
* dispatchKeyboardEvent(myNativeElement, 'keyup', ENTER, myTargetElement);
*/
var dispatchKeyboardEvent = function (node, type, key, target) { return dispatchEvent(node, createKeyboardEvent(type, key, target)); };
/**
* Shorthand to dispatch a mouse event on the specified coordinates.
*
* @param node - The Node that should dispatch the mouse event
* @param type - The event type
* @param x - The location on the X axis
* @param y - The location on the Y axis
* @param event - The event
* @returns The mouse event
*
* @example
* dispatchMouseEvent(myNativeElement, 'mousedown');
* dispatchMouseEvent(myNativeElement, 'mousedown', 10, 10, myCustomEvent);
*/
var dispatchMouseEvent = function (node, type, x, y, event) {
if (x === void 0) { x = 0; }
if (y === void 0) { y = 0; }
if (event === void 0) { event = createMouseEvent(type, x, y); }
return dispatchEvent(node, event);
};
/**
* Shorthand to dispatch a touch event on the specified coordinates.
*
* @param node - The Node that should dispatch the touch event
* @param type - The event type
* @param x - The location on the X axis
* @param y - The location on the Y axis
* @returns The touch event
*
* @example
* dispatchTouchEvent(myNativeElement, 'touchstart');
* dispatchTouchEvent(myNativeElement, 'touchstart', 10, 10);
*/
var dispatchTouchEvent = function (node, type, x, y) {
if (x === void 0) { x = 0; }
if (y === void 0) { y = 0; }
return dispatchEvent(node, createTouchEvent(type, x, y));
};
/**
* Reusable expect statement to check for the nativeElement
*
* NOTE: This helper only accesses the 1st-level child within a component.
*
* @param fixture - The test fixture
* @returns expect statement
*
* @example
* test('My test', () => {
* expectNativeEl(myEl);
* });
*/
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function expectNativeEl(fixture) {
fixture.detectChanges();
// eslint-disable-next-line no-undef
return expect(fixture.debugElement.children[0].nativeElement);
}
/**
* Return a component's instance from within a ComponentFixture
*
* @param fixture - The component fixture
* @param component - The component to find
* @returns The instance of the found component
*
* @example
* const myItem = getChildComponentInstanceFromFixture(myFixture, MyComponent);
*/
function getChildComponentInstanceFromFixture(fixture, component) {
var debugElForDumbComponent = fixture.debugElement.query(platformBrowser.By.directive(component));
return debugElForDumbComponent.injector.get(component);
}
/**
* Helper to query a fixture for a selector
*
* @param fixture - The test fixture
* @param selector - The selector to query for
* @returns The query result
*
* @example
* const myItem = queryFor(myFixture, '.my-class');
*/
var queryFor = function (fixture, selector) { return fixture.debugElement.query(platformBrowser.By.css(selector)); };
/**
* Focuses an input, sets it's value and dispatches the `input` event, simulating the user typing.
*
* @param value - Value to be set on the input.
* @param element - Element onto which to set the value.
*
* @example
* typeInElement('test@test.com', myEmailInputElement);
*/
function typeInElement(value, element) {
element.focus();
element.value = value;
dispatchFakeEvent(element, 'input');
}
/**
* Gets a RegExp used to detect an angular wrapped error message.
*
* See https://github.com/angular/angular/issues/8348
*
* @param e - The error
* @returns The regex
*/
function wrappedErrorMessage(e) {
var escapedMessage = e.message.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
return new RegExp(escapedMessage);
}
exports.ChangeDetectorRefMock = ChangeDetectorRefMock;
exports.ElementRefMock = ElementRefMock;
exports.Renderer2Mock = Renderer2Mock;
exports.configureTestBedWhitespace = configureTestBedWhitespace;
exports.configureTestBedWithoutReset = configureTestBedWithoutReset;
exports.createComponent = createComponent;
exports.createFakeEvent = createFakeEvent;
exports.createKeyboardEvent = createKeyboardEvent;
exports.createMouseEvent = createMouseEvent;
exports.createTouchEvent = createTouchEvent;
exports.dispatchEvent = dispatchEvent;
exports.dispatchFakeEvent = dispatchFakeEvent;
exports.dispatchKeyboardEvent = dispatchKeyboardEvent;
exports.dispatchMouseEvent = dispatchMouseEvent;
exports.dispatchTouchEvent = dispatchTouchEvent;
exports.expectNativeEl = expectNativeEl;
exports.getChildComponentInstanceFromFixture = getChildComponentInstanceFromFixture;
exports.queryFor = queryFor;
exports.rendererMock = rendererMock;
exports.typeInElement = typeInElement;
exports.wrappedErrorMessage = wrappedErrorMessage;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=terminus-ngx-tools-testing.umd.js.map