Mocking JavaScript a little code examples

authoriser.js

'use strict';

/** @constructor */
function Authoriser() { }

/**
 * @public
 *
 * @param {String} username
 * @param {String} password
 *
 * @returns {Boolean}
 */
Authoriser.prototype.authorise = function(username, password) {

    // connects to LDAP or some database, verifies user credentials
    // returns true if the username/password pair is valid, false otherwise
    // ...
};

dummy-system.spec.js

describe('A newly created System', function() {

    var dummy_authoriser = { };

    it('has no logged in users', function() {
        var system = new System(dummy_authoriser);

        expect(system.loginCount()).to.equal(0);
    });
});

fake-sinon-system.spec.js

describe('A System', function () {
    var fake_authoriser = sinon.createStubInstance(Authoriser);
        fake_authoriser.authorise
            .returns(false)
            .withArgs('bob', 'SecretPassword').returns(true),

        system = new System(fake_authoriser);

    it('allows Bob in', function () {
        system.login('bob', 'SecretPassword');

        expect(system.loginCount()).to.equal(1);
    });

    it('does not allow Alice in', function () {
        system.login('alice', 'password');

        expect(system.loginCount()).to.equal(0);
    });
});

fake-system.spec.js

describe('A System', function() {
    var fake_authoriser = {
            authorise: function(username, password) {
                return (username === 'bob' && password === 'SecretPassword');
            }
        },

        system = new System(fake_authoriser);

    it('allows Bob in', function() {
        system.login('bob', 'SecretPassword');

        expect(system.loginCount()).to.equal(1);
    });

    it('does not allow Alice in', function() {
        system.login('alice', 'password');

        expect(system.loginCount()).to.equal(0);
    });
});

mock-object_create.js

var authoriser = Object.create(Authoriser.prototype),
    mock       = sinon.mock(authoriser);

mock-sinon-system.spec.js

describe('A System', function() {
    var authoriser = new Authoriser(),
        mock       = sinon.mock(authoriser);

    afterEach(function() {
        mock.restore();
    });

    it('delegates logging users in to the authoriser', function() {
        // prepare
        var system = new System(authoriser);

        // expect
        mock.expects('authorise').once().returns(true);

        // act
        system.login('bob', 'SecretPassword');

        // assert
        mock.verify();
    });
});

mock-system.spec.js

describe('A System', function() {
    var accepting_authoriser_mock = {

        authorise_was_called: false,

        authorise: function() {
            this.authorise_was_called  = true;
            return true;
        },

        verify: function() {
            expect(this.authorise_was_called).to.equal(true);
        }
    };

    it('delegates logging users in to the authoriser', function() {
        var system = new System(accepting_authoriser_mock);

        system.login('bob', 'SecretPassword');

        accepting_authoriser_mock.verify(); // assertions moved to #verify
    });
});

spy-real_authoriser.js

var authoriser    = new Authoriser(),
    system        = new System(authoriser),
    authorise_spy = sinon.spy(authoriser, 'authorise');

system.login('bob', 'SecretPassword');

expect(authorise_spy).to.have.been.called;

spy-sinon-system.spec.js

describe('A System', function() {
    var accepting_authoriser = sinon.createStubInstance(Authoriser);

    accepting_authoriser.authorise.returns(true);

    afterEach(function() {
        accepting_authoriser.authorise.restore();
    });

    it('delegates logging users in to the authoriser', function() {
        var system = new System(accepting_authoriser);

        system.login('bob', 'SecretPassword');

        expect(accepting_authoriser.authorise).to.have.been.called;
    });
});

spy-system.spec.js

describe('A System', function() {
    var accepting_authoriser_spy = {

        authorise_was_called: false,

        authorise: function() {
            this.authorise_was_called = true;

            return true;
        }
    }

    afterEach(function() {
        accepting_authoriser_spy.authorise_was_called = false
    };

    it('delegates logging users in to the authoriser', function() {
        var system = new System(accepting_authoriser_spy);

        system.login('bob', 'SecretPassword');

        expect(accepting_authoriser_spy.authorise_was_called).to.equal(true);
    });
});

stub-rejecting_authoriser.js

var rejecting_authoriser = { authorise: function() { return false; } };

stub-sinon-system.spec.js

describe('A System with a logged in user', function() {

    var accepting_authoriser = sinon.createStubInstance(Authoriser);
    accepting_authoriser.authorise.returns(true);

    it('has a loginCount of 1', function() {
        var system = new System(accepting_authoriser);

        system.login('bob', 'SecretPassword');

        expect(system.loginCount()).to.equal(1);
    });
});

stub-system.spec.js

describe('A System with a logged in user', function() {

    var accepting_authoriser = { authorise: function() { return true; } };

    it('has a loginCount of 1', function() {
        var system = new System(accepting_authoriser);

        system.login('bob', 'SecretPassword');

        expect(system.loginCount()).to.equal(1);
    });
});

system.js

'use strict';

/**
 * @constructor
 * @param {Authoriser} authoriser
 */
function System(authoriser) {

    /** @private */
    var login_count = 0;

    /** @public */
    this.login = function(username, password) {
        if (authoriser.authorise(username, password)) {
            ++login_count;
        }
    };

    /** @public */
    this.loginCount: function() {
        return login_count;
    };
}