用 sinon 调用 yield* function

Question

I'm new to function* / yield / yield* as well as to unit testing, and I'm not sure why my unit test code isn't working. It's using sinon stubbing with mocha testing framework. I've read up on function* / yield / yield* but it's still confusing to me.

Using the Co library, I have a function* with a yield* inside that calls another function* . I'm trying to mock the call to the function* called by yield* with a sinon stub, but the stub returns undefined. The stub returns the correct response if it's simply yield and not yield* .

import:

import * as name from './file';

call to original generator function:

export const func = (a, b, c) => co(secondFunc.bind(this, a, b, c));

function secondFunc:

function* secondFunc(a, b, c) {
  try {
    const x = yield* name.get(a); // this is where x is undefined
    // logic
    return value;
  } catch (err) {
    // logic
  }
}

unit test:

const callback = sinon.stub(name, 'get');
callback.returns(new Promise((resolved, reject) => resolved(response)));

co(func("a", "b", "c")).then((value) => {
    console.log(value);
    done();
}).catch(done);     

(Of note, the original code is not something I wrote. I'm just adding unit tests.)

Answer 1

It can be slightly simpler by stubbing with SinonStub#callsFake

const nameGetStub = sinon.stub(name, "get").callsFake(function * () {
  yield 'fake name'
});

Async generator can also be faked simply by making is async function *

Answer 2

Here is the unit test solution for co module used with yield* [expression] .

file.ts :

export function* get(a) {
  yield "real data";
}

index.ts :

import * as name from "./file";
import co from "co";

export function* secondFunc(a, b, c) {
  try {
    const x = yield* name.get(a);
    return x;
  } catch (err) {
    console.error(err);
  }
}

export const func = (a, b, c) => co(secondFunc.bind(null, a, b, c));

index.spec.ts :

import { secondFunc, func } from "./";
import { expect } from "chai";
import * as name from "./file";
import sinon from "sinon";
import co from "co";

describe("59308604", () => {
  afterEach(() => {
    sinon.restore();
  });
  it("should pass secondFunc", () => {
    function* mGen() {
      yield "fake data";
    }
    const nameGetStub = sinon.stub(name, "get").returns(mGen());
    const gen = secondFunc("a", "b", "c");
    expect(gen.next().value).to.be.eql("fake data");
    expect(gen.next()).to.be.eql({ value: undefined, done: true });
    sinon.assert.calledWith(nameGetStub, "a");
  });

  it("should pass func", async () => {
    function* mGen() {
      return "fake data";
    }
    const nameGetStub = sinon.stub(name, "get").returns(mGen() as any);
    const actual = await func("a", "b", "c");
    expect(actual).to.be.equal("fake data");
    sinon.assert.calledWith(nameGetStub, "a");
  });

  it("test co", () => {
    function* g1() {
      return "123";
    }
    return co(function*() {
      var result = yield* g1();
      return result;
    }).then((value) => {
      expect(value).to.be.eql("123");
    });
  });
});

Unit test result with coverage report:

 59308604
    ✓ should pass secondFunc
    ✓ should pass func
    ✓ test co


  3 passing (17ms)

---------------|----------|----------|----------|----------|-------------------|
File           |  % Stmts | % Branch |  % Funcs |  % Lines | Uncovered Line #s |
---------------|----------|----------|----------|----------|-------------------|
All files      |    95.12 |    66.67 |    92.31 |    94.44 |                   |
 file.ts       |       50 |        0 |        0 |       50 |                 2 |
 index.spec.ts |      100 |      100 |      100 |      100 |                   |
 index.ts      |    88.89 |      100 |      100 |    85.71 |                 9 |
---------------|----------|----------|----------|----------|-------------------|

Source code: https://github.com/mrdulin/mocha-chai-sinon-codelab/tree/master/src/stackoverflow/59308604