“More than the act of testing, the act of designing tests is one of the best bug preventers known. The thinking that must be done to create a useful test can discover and eliminate bugs before they are coded — indeed, test-design thinking can discover and eliminate bugs at every stage in the creation of software, from conception to specification, to design, coding and the rest.”
 — Boris Beizer

Unit Testing lets a developer validate a unit (class, function) of software. A developer may unknowingly make a change to an existing unit which could make the software go awry. Unit testing prevents such accidental cases. As soon as the developer writes some awry code for a unit, the test runner will let the person know which test case has failed.

Coming to Javascript, various testing frameworks are available. Few popular ones are:
Mocha
Chai
Jasmine

In the rest of the article, I would focus on few basics of the Jasmine framework.

“Jasmine is a behavior-driven development framework for testing JavaScript code. It does not depend on any other JavaScript frameworks. It does not require a DOM (Document Object Model). And it has a clean, obvious syntax so that you can easily write tests.” -Jasmine Official Documentation

Getting started with Jasmine is fairly easy with below mentioned instructions:

Installation:

npm install –save-dev jasmine
Initialise Project:
jasmine init
Seed Project with Examples:
jasmine examples
Run Test Suite:
jasmine

A sample test case from the official doc looks like:

describe(“A suite is just a function”, function() {
var a;
it(“and so is a spec”, function() {
a = true;
expect(a).toBe(true);
});
});

I would dig more into this sample code.
The test case typically comprises of:
Suite
Spec
Matcher
Custom Matcher
beforeEach
afterEach

Suite:
A test suite is a collection of test cases. The test suite does have a name (mentioned in the quotes). Below provided snippet is a typical jasmine test suite with 0 test cases.

describe(“This is a jasmine test suite”, function() {
});

Spec:
A test spec is a test specification for a unit. In jasmine, a spec starts with the keyword ‘it’ and has a spec message. Below provided snippet is a typical jasmine test spec not doing anything.

it(“This is a jasmine test spec”, function() {
});

Matcher:
Matcher is a check that lets you evaluate the output of a unit against a test result. Below provided snippet is a typical jasmine matcher.

expect(func()).toBe(0);

Let’s say, there is a function named func and it always returns a value 0. This function is a unit. If something goes awry with this function, the matcher will fail and hence, the unit test for the unit will fail.

Custom Matchers, beforeEach, afterEach:
Jasmine provides a number of inbuilt matchers. However, we can write our own custom matchers.

beforeEach lets a developer define something before a spec is executed.

An example would be to define a custom matcher in beforeEach and use the custom matcher in the spec. Below is a sample snippet:

beforeEach(function () {
this.addMatchers({
toBeEven: function () {
return (this.actual % 2) === 0;
}
});
});
it(‘should be even’, function () {
expect(isEvenNumber()).toBeEven();
});

afterEach lets a developer define something after a spec is executed.

How do I run tests:
Jasmine provides a spec runner where you may run your tests. Another option would be to use a test runner like karma.
As terminal is always fancier, a headless browser (like PhantomJS) should be preferred over Chrome.