- Version
2.x
and above requires RxJS 6.0 and above. - Version
3.x
and above requires TypeScript 2.8 and above.
Creating spies has never been EASIER! πͺπ
If you need to create a spy from any class, just do:
const myServiceSpy = createSpyFromClass(MyService);
THAT'S IT!
If you're using TypeScript, you get EVEN MORE BENEFITS:
const myServiceSpy: Spy<MyService> = createSpyFromClass(MyService);
Now you can autocomplete AND have an auto spy for each method, returning Observable / Promise specific control methods.
β Keep you tests DRY - no more repeated spy setup code, no need for separate spy files
β Type completion for both the original Class and the spy methods
β Automatic return type detection by using a conditional types
npm install -D jasmine-auto-spies
export class MyComponent {
constructor(myService) {
this.myService = myService;
}
init() {
this.compData = this.myService.getData();
}
}
export class MyService{
getData{
return [
{ ...someRealData... }
]
}
}
import { createSpyFromClass } from 'jasmine-auto-spies';
import { MyService } from './my-service';
import { MyComponent } from './my-component';
describe('MyComponent', () => {
let myServiceSpy;
let componentUnderTest;
beforeEach(() => {
myServiceSpy = createSpyFromClass(MyService); // <- THIS IS THE IMPORTANT LINE
componentUnderTest = new MyComponent(myServiceSpy);
});
it('should fetch data on init', () => {
const fakeData = [{ fake: 'data' }];
myServiceSpy.getData.and.returnWith(fakeData);
componentUnderTest.init();
expect(myServiceSpy.getData).toHaveBeenCalled();
expect(componentUnderTest.compData).toEqual(fakeData);
});
});
// my-spec.ts
import { Spy, createSpyFromClass } from 'jasmine-auto-spies';
import { MyService } from './my-service';
let myServiceSpy: Spy<MyService>; // <- THIS IS THE IMPORTANT LINE
beforeEach( ()=> {
myServiceSpy = createSpyFromClass( MyService );
});
it('should do something' ()=> {
myServiceSpy.getName.and.returnValue('Fake Name');
... (the rest of the test) ...
});
// my-service.ts
class MyService{
getName(): string{
return 'Bonnie';
}
}
Use the resolveWith
or rejectWith
methods -
import { Spy, createSpyFromClass } from 'jasmine-auto-spies';
let myServiceSpy: Spy<MyService>;
beforeEach(() => {
myServiceSpy = createSpyFromClass(MyService);
});
it(() => {
myServiceSpy.getItems.and.resolveWith(fakeItemsList);
// OR
myServiceSpy.getItems.and.rejectWith(fakeError);
});
Use the nextWith
or throwWith
and other methods -
import { Spy, createSpyFromClass } from 'jasmine-auto-spies';
let myServiceSpy: Spy<MyService>;
beforeEach(() => {
myServiceSpy = createSpyFromClass(MyService);
});
it(() => {
myServiceSpy.getProducts.and.nextWith(fakeProductsList);
// OR
myServiceSpy.getProducts.and.nextOneTimeWith(fakeProductsList); // emits one value and completes
// OR
myServiceSpy.getProducts.and.throwWith(fakeError);
// OR
myServiceSpy.getProducts.and.complete();
});
You can setup the expected arguments ahead of time
by using calledWith
like so:
myServiceSpy.getProducts.calledWith(1).returnValue(true);
and it will only return this value if your subject was called with getProducts(1)
.
myServiceSpy.getProductsPromise.calledWith(1).resolveWith(true);
// OR
myServiceSpy.getProducts$.calledWith(1).nextWith(true);
// OR ANY OTHER ASYNC CONFIGURATION METHOD...
myServiceSpy.getProducts.mustBeCalledWith(1).returnValue(true);
is equal to:
myServiceSpy.getProducts.and.returnValue(true);
expect(myServiceSpy.getProducts).toHaveBeenCalledWith(1);
But the difference is that the error is being thrown during getProducts()
call and not in the expect(...)
call.
If you need to manually add methods that you want to be spies by passing an array of names as the second param of the createSpyFromClass
function:
let spy = createSpyFromClass(MyClass, ['customMethod1', 'customMethod2']);
This is good for times where a method is not part of the prototype
of the Class but instead being defined in its constructor.
class MyClass {
constructor() {
this.customMethod1 = function() {
// This definition is not part of MyClass' prototype
};
}
}