Stubbing a Javascript Generator function



Recently, I had to test a generator function, which was calling another generator function from within it. I learnt something on how to stub a generator function.

(Note: Code is not tested for accuracy. The code is only used to illustrate the concept).

Use case:

Following is a simplified example which describes the scenario:

The use case here is to check the database if a user already exists in the database. If so, the user should be added. If not the user should be added.

Project Structure:

Objects
Functions
UserDao
1)    function* findUser(userId:String):User
2)    function* saveUser(user:User):User
UserHelper
1)    function* saveUser(user:User):User
UserController
1)    function saveUser(user:User):User

When a request is made to add the user, the request lands in the saveUser function in the UserController. The controller uses a co-generator to call the saveUser generator function in the helper.

If the user is created (i.e if duplicate does not exist), it logs ‘Success’. Otherwise it logs 'user already exists'.

Code:

const co = require('co');

//Test user
const user={
  name:'name',
  id: 'id',
};

//The makeshift Database
var users = [];

//The Dao layer
const userDao = {
  saveUser: function* (user){ //Saves a given user to users array
     users = users.concat(user);
     yield users;
  },
  fetchUser: function* (user){ //Fetches user from the users array
    console.log('users found = ',users);
    const found = users.find(u=>u.name === user.name);
    if(found){
      return yield [found];
    } else {
      return yield [];
    }
  }
};

//The helper layer
const userHelper = {
  saveUser: function* (user){ //Checks if the user is present. If not present, it saves
    const userFetched = yield* userDao.fetchUser(user);
    if(!userFetched || !userFetched.length) {
      yield* userDao.saveUser(user);
      return 'Success';
    } else{
      return 'user already exists';
    }
  }
};

//Controller
const saveUser = (user) =>{
  co(userHelper.saveUser.bind(null,user))
  .then(u=>{
    console.log('inside then = ' ,u);
  })
  .catch(err=>{
    console.log('inside else = ',err);
  });
};

As you can see the Controller calls the helper through a co-generator. The helper calls the dao method to check if the user exists. If the user does not the user is created.

Note: For simplicity, I have used a local array as the database. In a more real scenario, this will be an asynchronous call to the Database synchronized by the yield keyword.

Unit Testing:

The issue I faced was when I tried to unit test the saveUser method in the helper. Since it was a unit test, I didn’t want the fetchUser or saveUser in the Dao to be invoked. Instead, I wanted to stub these methods. Stubbing saveUser is easy, because we are not expecting a response from saveUser.

The requirements we have for saveUser are:

  •       It should be called synchronously
  •      The call should not throw an exception.

So, creating a simple stub would suffice for this method, because all we want to test here is the callCount.

const saveUserDaoStub = sinon.stub(userDao,'saveUser');

However, the tricky part to test is the fetchUser method in Dao. This is a generator function and we are using yield* to call this function. The yield* expects a generatorFunctionHeader. Apart from that, we also need to be able to manipulate the output of fetchUser Dao method to return the result as if the user is found and also as if the user is not found. So using the normal way to stub as in:
const fetchUserDaoStub = sinon.stub(userDao,'fetchUser').returns([{name:’name’,id:’id’}]);

is not going to work. This is because yield* is expecting a generatorFunctionHeader. So how do we create a generatorFunctionHeader? Its quite simple. We can just stub the method and make it return a generatorFunctionHeader as follows:

const fetchUserDaoStub = sinon.stub(userDao,'fetchUser').returns(function* () {
    return [user];
      }());

We are returning the result we want from inside a generator function. This function call is passed as parameter to the returns method of the stub.

An example of the final test case:

describe('something',()=>{
  it('some other thing',()=>{
    const fetchUserDaoStub = sinon.stub(userDao,'fetchUser').returns(function* () {
    return [user];
      }());
    const saveUserDaoStub = sinon.stub(userDao,'saveUser');
    co(userHelper.saveUser.bind(null,user)).then(()=>{
      sinon.assert.callCount(fetchUserDaoStub,1);
      sinon.assert.callCount(saveUserDaoStub,0);
    }).catch((err)=>{
      console.log(err);
    })
  })
})



Comments

Post a Comment

Popular posts from this blog

Docker Commands

This post serves as a quick set of notes on some of the Docker commands. The intent of this post is not to explain what is Docker or how it works. Instead it is just a quick access to various Docker commands. Docker Machine   1) List of all Docker machines   docker-machine ls    2)  Start a Docker machine   docker-machine start <machine-name>    Ex: docker-machine start default   3)  Stop a Docker Machine:   docker-machine stop <machine-name>   Ex: docker-machine stop default   4)  Set the environment:   docker-machine env <machine-name>   Ex: docker-machine env default   Docker Client:   1) Pull an image from the docker hub:   docker pull <image-name>   Ex: docker pull hello-world   2) List of images installed on the current computer:   docker images   3) Remove an image from the computer:   docker rmi <image-name | image-id>   Ex:  docker rmi hello-world   Ex:  docker rmi 12324   4)
Read more

Dockerfile

This post serves as a quick note on how to create a Dockerfile. It is not intended to be a comprehensive guide for the same. 1) FROM   = The image from dockerhub on which the   current image should be based on   2) MAINTAINER   = This is just a free text field where you put in your Name or email id, just so that people can identify the maintainer   3) EXPOSE = The port on which the container should be exposed. This can be overridden while doing a docker run command.   4)   ENTRYPOINT = The command to be executed when the container   strats   up.   For Example: npm start   5) COPY   = used to copy the source code into the docker machine.   For   exmple : COPY . /var/www   Where .(dot) represents that the whole of current directory needs to be copied.   6) WORKDIR   = The root directory from where the commands need to be run. For example, while running npm start, the directory in the container from where it should be run.   7) RUN   = A command tha
Read more

ES-6 classes

Code for this and several other ES-6 features can be found in my  github ES-6 has introduced a “class” keyword and “extends” keyword which are similar looking to classes in Java. In reality these are nothing but a syntactic sugar over prototypical inheritance in ES-5. In ES-5 classes were depicted as follows: var PersonEs5 = function(firstName, lastName){ this.firstName = firstName; this.lastName =lastName; } var p1 = new PersonEs5('first','last'); With ES-6 the same class can be written as follows: class Person{ constructor(firstName,lastName){ this.firstName = firstName; this.lastName = lastName; } } Classes are nothing but functions under the cover. If the ES-6 code is compiled down to ES-5, the compiled version will be as follows: function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } var Pers
Read more