mirror of
https://github.com/DSpace/dspace-angular.git
synced 2025-10-07 01:54:15 +00:00
112 lines
3.5 KiB
TypeScript
112 lines
3.5 KiB
TypeScript
import { ComponentFixture, TestBed } from '@angular/core/testing';
|
|
import { buildPaginatedList, PaginatedList } from '../../core/data/paginated-list.model';
|
|
import { PageInfo } from '../../core/shared/page-info.model';
|
|
import { Observable } from 'rxjs/internal/Observable';
|
|
import { of as observableOf } from 'rxjs/internal/observable/of';
|
|
import { UnCacheableObject } from '../../core/shared/uncacheable-object.model';
|
|
import { RequestEntryState } from '../../core/data/request-entry-state.model';
|
|
import { RequestEntry } from '../../core/data/request-entry.model';
|
|
|
|
/**
|
|
* Returns true if a Native Element has a specified css class.
|
|
*
|
|
* @param element
|
|
* the Native Element
|
|
* @param className
|
|
* the class name to find
|
|
*/
|
|
export const hasClass = (element: any, className: string): boolean => {
|
|
const classes = element.getAttribute('class');
|
|
return classes.split(' ').indexOf(className) !== -1;
|
|
};
|
|
|
|
/**
|
|
* Creates an instance of a component and returns test fixture.
|
|
*
|
|
* @param html
|
|
* the component's template as html
|
|
* @param type
|
|
* the type of the component to instantiate
|
|
*/
|
|
export const createTestComponent = <T>(html: string, type: new (...args: any[]) => T ): ComponentFixture<T> => {
|
|
TestBed.overrideComponent(type, {
|
|
set: { template: html }
|
|
});
|
|
const fixture = TestBed.createComponent(type);
|
|
|
|
fixture.detectChanges();
|
|
return fixture as ComponentFixture<T>;
|
|
};
|
|
|
|
/**
|
|
* Allows you to spy on a read only property
|
|
*
|
|
* @param obj
|
|
* The object to spy on
|
|
* @param prop
|
|
* The property to spy on
|
|
*/
|
|
export function spyOnOperator(obj: any, prop: string): any {
|
|
const oldProp = obj[prop];
|
|
Object.defineProperty(obj, prop, {
|
|
configurable: true,
|
|
enumerable: true,
|
|
value: oldProp,
|
|
writable: true
|
|
});
|
|
|
|
return spyOn(obj, prop);
|
|
}
|
|
|
|
/**
|
|
* Method to create a paginated list for an array of objects
|
|
* @param objects An array representing the paginated list's page
|
|
*/
|
|
export function createPaginatedList<T>(objects?: T[]): PaginatedList<T> {
|
|
return buildPaginatedList(new PageInfo(), objects);
|
|
}
|
|
|
|
/**
|
|
* Creates a jasmine spy for an exported function
|
|
* @param target The object to spy on
|
|
* @param prop The property/function to spy on
|
|
*/
|
|
export function spyOnExported<T>(target: T, prop: keyof T): jasmine.Spy {
|
|
const spy = jasmine.createSpy(`${String(prop)}Spy`);
|
|
spyOnProperty(target, prop).and.returnValue(spy);
|
|
return spy;
|
|
}
|
|
|
|
/**
|
|
* Create a mock request entry to be used in testing
|
|
* @param unCacheableObject
|
|
* @param statusCode
|
|
* @param errorMessage
|
|
*/
|
|
export function createRequestEntry$(unCacheableObject?: UnCacheableObject, statusCode = 200, errorMessage?: string): Observable<RequestEntry> {
|
|
return observableOf({
|
|
request: undefined,
|
|
state: RequestEntryState.Success,
|
|
response: {
|
|
timeCompleted: new Date().getTime(),
|
|
statusCode,
|
|
errorMessage,
|
|
unCacheableObject
|
|
},
|
|
lastUpdated: new Date().getTime()
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get the argument (method parameter) a Spy method got called with first
|
|
* Example case:
|
|
* - We spy on method mock(testNumber: number)
|
|
* - During the tests, mock gets called 3 times with numbers 8, 5 and 7
|
|
* - This function will return 8, as it's the first number mock got called with
|
|
* @param spyMethod The method that got spied on
|
|
* @param argumentIndex The index of the argument, only necessary if the spy method contains more than one parameter
|
|
*/
|
|
export function getFirstUsedArgumentOfSpyMethod(spyMethod: jasmine.Spy, argumentIndex: number = 0): any {
|
|
return spyMethod.calls.argsFor(0)[argumentIndex];
|
|
}
|