Блог

У меня возникли проблемы с отслеживанием функции, которая импортируется из модуля узла. Я тестирую дочерний класс, и модуль импортируется в класс прародителя, и мне нужно посмотреть, с какими аргументами вызывается функция.

Код работает, как и ожидалось, но я тестировал со встроенным в Jasmine spyOn , а также sinon.spy , но ни один из шпионов не вызывается.

Код:

 // ChildClass.js

const ParentClass = require('./ParentClass');

module.exports = class ChildClass extends ParentClass {

    constructor () {
        super();
        this.foo();
    }

    foo () {
        this.message = this.importGetter('Some input');
    }

};
 

 // ParentClass.js

const GrandparentClass = require('./GrandparentClass');

module.exports = class ParentClass extends GrandparentClass {

    constructor () {
        super();
        this._message = null;
    }

    get message () {
        return this._message;
    }

    set message (value) {
        this._message = value;
    }

};
 

 // GrandparentClass.js

const nodeModuleFunction = require('./nodeModule').nodeModuleFunction;

module.exports = class GrandparentClass {

    get importGetter () {
        return nodeModuleFunction;
    }

};
 

 // nodeModule.js

async function nodeModuleFunction (input) {

    console.error('Do something with input: ', input);

    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Returned from node module.');
        }, 300);
    });
}

exports.nodeModuleFunction = nodeModuleFunction;
 

Тестовый код:

 // test.spec.js

const ChildClass = require('./ChildClass');
const nodeModule = require('./nodeModule');
const sinon = require('sinon');

describe('ChildClass test', () => {

    describe('Jasmine spy', () => {

        it('should call nodeModule.nodeModuleFunction with given value', done => {

            spyOn(nodeModule, 'nodeModuleFunction').and.callThrough();

            const object = new ChildClass();

            expect(object.message).not.toBeNull();
            expect(nodeModule.nodeModuleFunction).toHaveBeenCalled();
            expect(nodeModule.nodeModuleFunction).toHaveBeenCalledWith('Some input');

            object.message.then(message => {
                expect(message).toBe('Returned from node module.');
                done();
            });

        });

    });

    describe('Sinon spy', () => {

        it('should call nodeModule.nodeModuleFunction with given value', done => {

            const spy = sinon.spy(nodeModule, 'nodeModuleFunction');

            const object = new ChildClass();

            expect(object.message).not.toBeNull();
            expect(spy.called).toBe(true);
            expect(spy.withArgs('Some input').calledOnce).toBe(true);

            object.message.then(message => {
                expect(message).toBe('Returned from node module.');
                done();
            });
        });

    });

});
 

Test results:

 Jasmine started
Do something with input:  Some input

  ChildClass test

    Jasmine spy
      ✗ should call nodeModule.nodeModuleFunction with given value
        - Expected spy nodeModuleFunction to have been called.
        - Expected spy nodeModuleFunction to have been called with [ 'Some input' ] but it was never called.

Do something with input:  Some input
    Sinon spy
      ✗ should call nodeModule.nodeModuleFunction with given value
        - Expected false to be true.
        - Expected false to be true.

 

Редактирование с помощью решения по предложению Брайана:

 const nodeModule = require('./nodeModule');

describe('ChildClass test', () => {

    let ChildClass;

    beforeAll(() => {
        spyOn(nodeModule, 'nodeModuleFunction').and.callThrough();  // create the spy...
        ChildClass = require('./ChildClass');  // ...and now require ChildClass
    });

    afterEach(() => {
        nodeModule.nodeModuleFunction.calls.reset();
    });

    describe('Jasmine spy', () => {

        it('should call nodeModule.nodeModuleFunction with given value', done => {

            const object = new ChildClass();

            expect(object.message).not.toBeNull();
            expect(nodeModule.nodeModuleFunction).toHaveBeenCalled();
            expect(nodeModule.nodeModuleFunction).toHaveBeenCalledWith('Some input');

            object.message.then(message => {
                expect(message).toBe('Returned from node module.');
                done();
            });

        });

        it('should still call nodeModule.nodeModuleFunction with given value', done => {

            const object = new ChildClass();

            expect(object.message).not.toBeNull();
            expect(nodeModule.nodeModuleFunction).toHaveBeenCalled();
            expect(nodeModule.nodeModuleFunction).toHaveBeenCalledWith('Some input');

            object.message.then(message => {
                expect(message).toBe('Returned from node module.');
                done();
            });

        });

    });

});
 

 const nodeModule = require('./nodeModule');
const sinon = require('sinon');

describe('ChildClass test', () => {

    let spy;
    let ChildClass;

    beforeAll(() => {
        spy = sinon.spy(nodeModule, 'nodeModuleFunction');  // create the spy...
        ChildClass = require('./ChildClass');  // ...and now require ChildClass
    });

    afterEach(() => {
        spy.resetHistory();
    });

    afterAll(() => {
        spy.restore();
    });

    describe('Sinon spy', () => {

        it('should call nodeModule.nodeModuleFunction with given value', done => {

            const object = new ChildClass();

            expect(object.message).not.toBeNull();
            expect(spy.called).toBe(true);
            expect(spy.withArgs('Some input').calledOnce).toBe(true);

            object.message.then(message => {
                expect(message).toBe('Returned from node module.');
                done();
            });
        });

        it('should still call nodeModule.nodeModuleFunction with given value', done => {

            const object = new ChildClass();

            expect(object.message).not.toBeNull();
            expect(spy.called).toBe(true);
            expect(spy.withArgs('Some input').calledOnce).toBe(true);

            object.message.then(message => {
                expect(message).toBe('Returned from node module.');
                done();
            });
        });

    });

});
 

GrandparentClass.js требует nodeModule.js и получает ссылку на него, nodeModuleFunction как только он запускается…

..так что вам просто нужно убедиться, что ваш шпион на месте, прежде чем он запустится:

 const nodeModule = require('./nodeModule');
const sinon = require('sinon');

describe('ChildClass test', () => {

  describe('Sinon spy', () => {

    it('should call nodeModule.nodeModuleFunction with given value', done => {

      const spy = sinon.spy(nodeModule, 'nodeModuleFunction');  // create the spy...
      const ChildClass = require('./ChildClass');  // ...and now require ChildClass

      const object = new ChildClass();

      expect(object.message).not.toBeNull();  // Success!
      expect(spy.called).toBe(true);  // Success!
      expect(spy.withArgs('Some input').calledOnce).toBe(true);  // Success!

      object.message.then(message => {
        expect(message).toBe('Returned from node module.');  // Success!
        done();
      });
    });

  });

});
 

Я обновил Sinon тест, но этот подход работает и для Jasmine теста.