This package has been deprecated

Author message:

Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

mochaccino

mochaccino 1.2.0

United js test tools

Mocha is great but having asserts, assert plugins and spies spread out as separate projects is a bit frustrating, especially when you have to jump around all of the different documentations or setup test environment.

Mochaccino goals:

• documentation for expectations/spies/tests in ONE place
• providing all of the mocha important components together already setup
• shallow learning curve, quick to start and work with

Quick start

npm install --save-dev mochaccino mocha babel-core babel-register babel-preset-es2015

add the following to your package.json :

{
 ...
 "scripts": {
   "test": "mocha --compilers js:babel-register"
 }
 "babel": {
   "presets": ["es2015"]
 }
 ...
}

create a directory test with a file index.js:

import {expect, spy, dom} from 'mochaccino';
 
describe('mochaccino', () => {
  it('do basic expectations', () => {
    expect(true).toBeTruthy();
  });
  
  it('do spy expectations', () => {
    let s = spy();
    s(1, 2);
    expect(s).toHaveBeenCalledWith(1, 2);
  });
  
  it('do DOM testing', () => {
    dom.create();
    document.body.appendChild(document.createElement('p'));
    expect(document.getElementsByTagName('p').length).toEqual(1);
    dom.destroy();
  });
});

and then just run in the command line:

npm test

Expectations

• expect(a).toBe(b)
• expect(a).toEqual(b)
• expect(a).toBeTruthy()
• expect(a).toBeFalsy()
• expect(a).toBeDefined()
• expect(a).toBeUndefined()
• expect(a).toBeNull()
• expect(a).toBeLessThan(b)
• expect(a).toBeGreaterThan(b)
• expect([1,2]).toContain(1)
• expect(f).toThrow()
• expect(f).toThrowError(ErrorType)
• expect(s).toMatch(regexp)

for spies:

• expect(s).toHaveBeenCalled()
• expect(s).toHaveBeenCalledWith(a1, a2)
• expect(s).toHaveBeenCalledTimes(n)

each expectation can be combined with not flag:

expect(a).not.toBe(b)

Spies

import {spy} from 'mochaccino';

spy(obj, 'funcName'); - spy on objects

spy(obj, 'funcName');
obj.funcName();
expect(obj.funcName).toHaveBeenCalled();

spy(); - create standalone spy

let s = spy();
s();
expect(s).toHaveBeenCalled();

spy(obj, 'funcName').and.callFake(func); - spy on object and call given function instead original one

spy(obj, 'funcName').and.callFake(() => {
  return 123;
});
expect(obj.funcName()).toEqual(123);
expect(obj.funcName).toHaveBeenCalled();

spy(obj, 'funcName').restore(); - restore original behaviour by removing the spy

spy(obj, 'funcName');
obj.funcName.restore();

spy(obj, 'funcName').and.callThrough(); - spy on object but call original method

spy(obj, 'funcName').and.returnValue(5); - spy will return a value when called

DOM testing

Mochaccino dom helper lets you run a dom implementation (jsdom) inside the node enviroment. No browser required.

import {expect, dom} from 'mochaccino';
 
describe('dom testing', () => {
    beforeEach(() => {
        dom.create();
    });
 
    afterEach(() => {
        dom.destroy();
    });
 
    it('should append a child to the body', () => {
        let par = document.createElement('P');
        let text = document.createTextNode('some text');
        par.appendChild(text);
        document.body.appendChild(par);
        let parCount = document.getElementsByTagName('P');
 
        expect(document.body.innerHTML).toBeDefined();
        expect(parCount.length).toEqual(1);
    });
 
    it('should not find the previously appended child', () => {
        let parCount = document.getElementsByTagName('P');
 
        expect(document.body.innerHTML).toEqual('');
        expect(parCount.length).toEqual(0);
    });
});

Unfortunately approach above is not recommended for testing React component as React's source code makes several assumptions about the environment it is running in, and one of them is that the document that is found at "require time" is going to be the one and only document it ever needs to worry about. As a result, this type of "reloading" ends up causing more pain than it prevents.

In that case document needs to be created only once before requiring React. This can be done by:

mocha --require mochaccino/dom-setup --compilers js:babel-register

and then "clearing" existing document between the tests to make sure that components do not leak:

import {expect, dom} from 'mochaccino';
 
describe('dom testing', () => {
    beforeEach(() => {
        dom.clear();
    });
 
    afterEach(() => {
        dom.clear();
    });
 
    it('should append a child to the body', () => {
        let par = document.createElement('P');
        let text = document.createTextNode('some text');
        par.appendChild(text);
        document.body.appendChild(par);
        let parCount = document.getElementsByTagName('P');
 
        expect(document.body.innerHTML).toBeDefined();
        expect(parCount.length).toEqual(1);
    });
 
    it('should not find the previously appended child', () => {
        let parCount = document.getElementsByTagName('P');
 
        expect(document.body.innerHTML).toEqual('');
        expect(parCount.length).toEqual(0);
    });
});