使用 Typescript 和 Sinon 传递给构造函数的单元测试参数

Question

I would like to test that a constructor in a function I am testing is called with the correct parameters, my example follows:

I have a class Foo :

export class Foo {

    constructor(param: string) {
    }
}

A function bar() that constructs Foo :

import { Foo } from './foo';

export function bar() {
    const foo = new Foo('test');

    // do some stuff with foo
}

And a unit test that tests function bar() :

import { expect } from 'chai';
import sinon from 'ts-sinon';
import { bar } from '../src/bar';

describe('bar', () => {

    beforeEach(() => {
    });

    it('should call foo with correct parameters', async () => {
        bar();
        // TODO: Something like this must work:
        // expect(fooStub).calledOnceWithExactly('test');
    });
});

Answer 1

You can not test: constructor is called with correct parameter ( Reference ).

But you can verify whether constructor's parameter will be set correctly to property.

Notes:

1. you should see rule no-useless-constructor .
2. from design pattern point of view, IMHO, better if you define function bar inside Foo as Foo's method; if bar depends Foo only.

If you are practicing TDD, this is how usually I do it, test foo and bar separately, so I now that Foo is correct and bar is also correct.

// File: Foo.ts
export default class Foo {
  someAwesomeProperty: string;

  constructor(param: string) {
    // Again, why you define constructor if not do anything?
    // At least set property to some awesome property, right? :D
    this.someAwesomeProperty = param;
  }
}

Unit test for Foo.

// File: test1.spec.ts
import { expect } from 'chai';
import Foo from './Foo';

describe('Foo', function () {
  it('should initiate someAwesomeProperty', function () {
    const foo = new Foo('test');
    // Verify whether object has someAwesomeProperty with correct value.
    expect(foo).to.have.property('someAwesomeProperty', 'test');
  });
});

Then go to bar. If you do TDD, up to your phase, you need to return the foo to check. This action maybe only for temporary to make sure you have a green. For example:

// File: bar.ts
import Foo from './Foo';

export default function bar() {
  const foo = new Foo('test');
  return foo;
}

Then unit test bar.

// File test2.spec.ts
import { expect } from 'chai';
import Foo from './Foo';
import bar from './bar';

describe('bar', function () {
  it('should call foo with correct parameters', function () {
    const test = bar();
    expect(test).to.be.instanceOf(Foo);
    expect(test).to.have.property('someAwesomeProperty', 'test');
  });
});

Then run it, for example using ts-mocha.

$ npx ts-mocha test/*.spec.ts --exit


  Foo
    ✓ should initiate someAwesomeProperty

  bar
    ✓ should call foo with correct parameters


  2 passing (9ms)

$