12 Getting started with exercises

Throughout most chapters, there are boxes that point to exercises. These are a paid feature, but a comprehensive preview is available. This chapter explains how to get started with them.

12.1 Exercises

12.1.1 Installing the exercises

To install the exercises:

• Download and unzip exploring-js-code.zip
• Follow the instructions in README.txt

12.1.2 Running exercises

• Exercises are referred to by path in this book.
  • For example: exercises/exercises/first_module_test.mjs
• Within each file:
  • The first line contains the command for running the exercise.
  • The following lines describe what you have to do.

12.2 Unit tests in JavaScript

All exercises in this book are tests that are run via the test framework Mocha. This section gives a brief introduction.

12.2.1 A typical test

Typical test code is split into two parts:

• Part 1: the code to be tested.
• Part 2: the tests for the code.

Take, for example, the following two files:

• id.mjs (code to be tested)
• id_test.mjs (tests)

12.2.1.1 Part 1: the code

The code itself resides in id.mjs:

export function id(x) {
  return x;
}

The key thing here is: everything we want to test must be exported. Otherwise, the test code can’t access it.

12.2.1.2 Part 2: the tests

The tests for the code reside in id_test.mjs:

// npm t demos/exercises/id_test.mjs
suite('id_test.mjs');

import assert from 'node:assert/strict'; // (A)
import {id} from './id.mjs'; // (B)

test('My test', () => { // (C)
  assert.equal(id('abc'), 'abc'); // (D)
});

The core of this test file is line D – an assertion: assert.equal() specifies that the expected result of id('abc') is 'abc'.

As for the other lines:

• The comment at the very beginning shows the shell command for running the test.
• Line A: We import the Node.js assertion library (in strict assertion mode).
• Line B: We import the function to test.
• Line C: We define a test. This is done by calling the function test():
  • First parameter: the name of the test.
  • Second parameter: the test code, which is provided via an arrow function. The parameter t gives us access to AVA’s testing API (assertions, etc.).

To run the test, we execute the following in a command line:

npm t demos/exercises/id_test.mjs

The t is an abbreviation for test. That is, the long version of this command is:

npm test demos/exercises/id_test.mjs

12.2.2 Asynchronous tests in Mocha

Writing tests for asynchronous code requires extra work: The test receives its results later and has to signal to Mocha that it isn’t finished yet when it returns. The following subsections examine three ways of doing so.

12.2.2.1 Asynchronicity via callbacks

If the callback we pass to test() has a parameter (e.g., done), Mocha switches to callback-based asynchronicity. When we are done with our asynchronous work, we have to call done:

test('divideCallback', (done) => {
  divideCallback(8, 4, (error, result) => {
    if (error) {
      done(error);
    } else {
      assert.strictEqual(result, 2);
      done();
    }
  });
});

This is what divideCallback() looks like:

function divideCallback(x, y, callback) {
  if (y === 0) {
    callback(new Error('Division by zero'));
  } else {
    callback(null, x / y);
  }
}

12.2.2.2 Asynchronicity via Promises

If a test returns a Promise, Mocha switches to Promise-based asynchronicity. A test is considered successful if the Promise is fulfilled and failed if the Promise is rejected or if a settlement takes longer than a timeout.

test('dividePromise 1', () => {
  return dividePromise(8, 4)
  .then(result => {
    assert.strictEqual(result, 2);
  });
});

dividePromise() is implemented as follows:

function dividePromise(x, y) {
  return new Promise((resolve, reject) => {
    if (y === 0) {
      reject(new Error('Division by zero'));
    } else {
      resolve(x / y);
    }
  });
}

12.2.2.3 Async functions as test “bodies”

Async functions always return Promises. Therefore, an async function is a convenient way of implementing an asynchronous test. The following code is equivalent to the previous example.

test('dividePromise 2', async () => {
  const result = await dividePromise(8, 4);
  assert.strictEqual(result, 2);
  // No explicit return necessary!
});

We don’t need to explicitly return anything: The implicitly returned undefined is used to fulfill the Promise returned by this async function. And if the test code throws an exception, then the async function takes care of rejecting the returned Promise.