30 Days of JavaScript: Unit Testing in JavaScript — Day 15

30 Days of Javascript Series by DopeThemes

In the field of software development, writing code is just one part of the journey. Ensuring that the code behaves as expected is equally critical. This is where unit testing comes into play. Unit tests evaluate small, individual parts of the code for correctness, often referred to as “units.”

Understanding the importance of unit testing starts with recognizing that even a tiny error can lead to significant problems in a live application. By implementing unit tests, you can catch these issues early, streamline development, and instill confidence in your codebase.

Why Unit Testing?

  • Quality Assurance: Catch errors early and ensure code quality.
  • Efficient Debugging: Identify precisely where things are going wrong.
  • Facilitates Changes: Allows for refactoring and adding new features without breaking existing functionality.
  • Promotes Collaboration: Helps teams to understand codebase and collaborate effectively.
Jest and Mocha: Testing Frameworks in JavaScript

Developed by Facebook, Jest is a popular testing framework that aims to work out of the box with zero configuration. Here’s an introduction to some of its primary features:

  • Zero Configuration: Comes with built-in setup.
  • Snapshot Testing: Helps in capturing snapshots of React trees or other serializable values to simplify testing.
  • Parallel Test Running: Runs tests in parallel for efficient execution.

Getting Started with Jest

First, install Jest using npm:

npm install --save-dev jest

A simple test with Jest may look like this:

test('adds 1 + 2 to equal 3', () => {
  expect(1 + 2).toBe(3);

To run the test, simply use:

npm run test

Mocha is another testing library widely used for unit testing in JavaScript. Here’s a glimpse of what Mocha offers:

  • Flexible and Modular: Choose assertion libraries like Chai.
  • Async Support: Handles promises and async/await smoothly.
  • Rich Plugin Architecture: Extend with a multitude of plugins.

Getting Started with Mocha

You can install Mocha using npm:

npm install --save-dev mocha

A basic Mocha test might look like this:

var assert = require('assert');
describe('Simple Test', function() {
  it('should return -1 when the value is not present', function() {
    assert.equal([1,2,3].indexOf(4), -1);

Run the tests using:

npm run test
Writing and Running Test Cases

Writing test cases involves understanding what you expect from a function and then writing tests that ensure the function meets those expectations.

Beginner Level Example

Let’s start with a function that adds two numbers:

function add(a, b) {
  return a + b;

Test Case with Jest:

test('adds 3 + 7 to equal 10', () => {
  expect(add(3, 7)).toBe(10);
Intermediate Level Example

For something more complex, consider a function that filters out negative numbers from an array:

function filterNegative(numbers) {
  return numbers.filter(number => number >= 0);

Test Case with Mocha and Chai:

var expect = require('chai').expect;
describe('Filter Negative Numbers', function() {
  it('should filter out negative numbers', function() {
    var numbers = [-1, 2, -3, 4];
    var result = filterNegative(numbers);
    expect(result).to.eql([2, 4]);
Advanced Unit Testing Techniques

Unit testing is more than writing simple tests. Advanced techniques include mocking, spying, stubbing, and more. Libraries like Sinon can aid in these areas, allowing more robust and nuanced testing.

For example, testing a function that fetches data from an API might require mocking that API to return controlled data during the test.

Example Using Jest and Mocking:
// Fetch function
function fetchData(callback) {
  // Simulating an API call

// Test with Jest
test('fetches data', () => {
  const data = 'some data';


Today, on Day 15, we’ve embraced the essential practice of Unit Testing in JavaScript. Starting from the importance of testing, we delved into popular frameworks like Jest and Mocha, crafted various levels of test cases, and even explored advanced techniques like mocking.

The mastery of testing doesn’t just enhance code quality; it becomes a philosophy that guides you in writing more robust, maintainable, and resilient code. The tools and techniques learned today will serve as a strong foundation for any software project.

Tomorrow, we’ll continue our journey into JavaScript’s diverse landscape, focusing on Day 16, where we will explore the intriguing world of Web Components and Custom Elements. These powerful concepts are shaping the modern web, and we’ll dive deep into understanding their structure, usage, and benefits.

Until then, let the lessons of today resonate, experiment with writing your tests, and prepare to take another step forward. See you in the next chapter!

Stay in the loop with our web development newsletter - no spam, just juicy updates! Join us now. Join our web development newsletter to stay updated on the latest industry news, trends, and tips. No spam, just juicy updates delivered straight to your inbox. Don't miss out - sign up now!

We’ve tried our best to explain everything thoroughly, even though there’s so much information out there. If you found our writing helpful, we’d really appreciate it if you could buy us a coffee as a token of support.

Also, if you’re interested in learning more about WordPress, Javascript, HTML, CSS, and programming in general, you can subscribe to our MailChimp for some extra insights.


This site uses Akismet to reduce spam. Learn how your comment data is processed.