Mocking

Test spies are function stand-ins that are used to assert if a function’s internal behavior matches expectations. Test spies on methods keep the original behavior but allow you to test how the method is called and what it returns. Test stubs are an extension of test spies that also replaces the original methods behavior.

Spying

Say we have two functions, square and multiply, if we want to assert that the multiply function is called during execution of the square function we need a way to spy on the multiply function. There are a few ways to achieve this with Spies, one is to have the square function take the multiply multiply as a parameter.

  1. // https://deno.land/std@$STD_VERSION/testing/mock_examples/parameter_injection.ts
  2. export function multiply(a: number, b: number): number {
  3.   return a * b;
  4. }
  6. export function square(
  7.   multiplyFn: (a: number, b: number) => number,
  8.   value: number,
  9. ): number {
  10.   return multiplyFn(value, value);
  11. }

This way, we can call square(multiply, value) in the application code or wrap a spy function around the multiply function and call square(multiplySpy, value) in the testing code.

  1. // https://deno.land/std@$STD_VERSION/testing/mock_examples/parameter_injection_test.ts
  2. import {
  3.   assertSpyCall,
  4.   assertSpyCalls,
  5.   spy,
  6. } from "https://deno.land/std@$STD_VERSION/testing/mock.ts";
  7. import { assertEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
  8. import {
  9.   multiply,
  10.   square,
  11. } from "https://deno.land/std@$STD_VERSION/testing/mock_examples/parameter_injection.ts";
  13. Deno.test("square calls multiply and returns results", () => {
  14.   const multiplySpy = spy(multiply);
  16.   assertEquals(square(multiplySpy, 5), 25);
  18.   // asserts that multiplySpy was called at least once and details about the first call.
  19.   assertSpyCall(multiplySpy, 0, {
  20.     args: [5, 5],
  21.     returned: 25,
  22.   });
  24.   // asserts that multiplySpy was only called once.
  25.   assertSpyCalls(multiplySpy, 1);
  26. });

If you prefer not adding additional parameters for testing purposes only, you can use spy to wrap a method on an object instead. In the following example, the exported _internals object has the multiply function we want to call as a method and the square function calls _internals.multiply instead of multiply.

  1. // https://deno.land/std@$STD_VERSION/testing/mock_examples/internals_injection.ts
  2. export function multiply(a: number, b: number): number {
  3.   return a * b;
  4. }
  6. export function square(value: number): number {
  7.   return _internals.multiply(value, value);
  8. }
  10. export const _internals = { multiply };

This way, we can call square(value) in both the application code and testing code. Then spy on the multiply method on the _internals object in the testing code to be able to spy on how the square function calls the multiply function.

  1. // https://deno.land/std@$STD_VERSION/testing/mock_examples/internals_injection_test.ts
  2. import {
  3.   assertSpyCall,
  4.   assertSpyCalls,
  5.   spy,
  6. } from "https://deno.land/std@$STD_VERSION/testing/mock.ts";
  7. import { assertEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
  8. import {
  9.   _internals,
  10.   square,
  11. } from "https://deno.land/std@$STD_VERSION/testing/mock_examples/internals_injection.ts";
  13. Deno.test("square calls multiply and returns results", () => {
  14.   const multiplySpy = spy(_internals, "multiply");
  16.   try {
  17.     assertEquals(square(5), 25);
  18.   } finally {
  19.     // unwraps the multiply method on the _internals object
  20.     multiplySpy.restore();
  21.   }
  23.   // asserts that multiplySpy was called at least once and details about the first call.
  24.   assertSpyCall(multiplySpy, 0, {
  25.     args: [5, 5],
  26.     returned: 25,
  27.   });
  29.   // asserts that multiplySpy was only called once.
  30.   assertSpyCalls(multiplySpy, 1);
  31. });

One difference you may have noticed between these two examples is that in the second we call the restore method on multiplySpy function. That is needed to remove the spy wrapper from the _internals object’s multiply method. The restore method is called in a finally block to ensure that it is restored whether or not the assertion in the try block is successful. The restore method didn’t need to be called in the first example because the multiply function was not modified in any way like the _internals object was in the second example.

Stubbing

Say we have two functions, randomMultiple and randomInt, if we want to assert that randomInt is called during execution of randomMultiple we need a way to spy on the randomInt function. That could be done with either of the spying techniques previously mentioned. To be able to verify that the randomMultiple function returns the value we expect it to for what randomInt returns, the easiest way would be to replace the randomInt function’s behavior with more predictable behavior.

You could use the first spying technique to do that but that would require adding a randomInt parameter to the randomMultiple function.

You could also use the second spying technique to do that, but your assertions would not be as predictable due to the randomInt function returning random values.

Say we want to verify it returns correct values for both negative and positive random integers. We could easily do that with stubbing. The below example is similar to the second spying technique example but instead of passing the call through to the original randomInt function, we are going to replace randomInt with a function that returns pre-defined values.

  1. // https://deno.land/std@$STD_VERSION/testing/mock_examples/random.ts
  2. export function randomInt(lowerBound: number, upperBound: number): number {
  3.   return lowerBound + Math.floor(Math.random() * (upperBound - lowerBound));
  4. }
  6. export function randomMultiple(value: number): number {
  7.   return value * _internals.randomInt(-10, 10);
  8. }
  10. export const _internals = { randomInt };

The mock module includes some helper functions to make creating common stubs easy. The returnsNext function takes an array of values we want it to return on consecutive calls.

  1. // https://deno.land/std@$STD_VERSION/testing/mock_examples/random_test.ts
  2. import {
  3.   assertSpyCall,
  4.   assertSpyCalls,
  5.   returnsNext,
  6.   stub,
  7. } from "https://deno.land/std@$STD_VERSION/testing/mock.ts";
  8. import { assertEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
  9. import {
  10.   _internals,
  11.   randomMultiple,
  12. } from "https://deno.land/std@$STD_VERSION/testing/mock_examples/random.ts";
  14. Deno.test("randomMultiple uses randomInt to generate random multiples between -10 and 10 times the value", () => {
  15.   const randomIntStub = stub(_internals, "randomInt", returnsNext([-3, 3]));
  17.   try {
  18.     assertEquals(randomMultiple(5), -15);
  19.     assertEquals(randomMultiple(5), 15);
  20.   } finally {
  21.     // unwraps the randomInt method on the _internals object
  22.     randomIntStub.restore();
  23.   }
  25.   // asserts that randomIntStub was called at least once and details about the first call.
  26.   assertSpyCall(randomIntStub, 0, {
  27.     args: [-10, 10],
  28.     returned: -3,
  29.   });
  30.   // asserts that randomIntStub was called at least twice and details about the second call.
  31.   assertSpyCall(randomIntStub, 1, {
  32.     args: [-10, 10],
  33.     returned: 3,
  34.   });
  36.   // asserts that randomIntStub was only called twice.
  37.   assertSpyCalls(randomIntStub, 2);
  38. });

Faking time

Say we have a function that has time based behavior that we would like to test. With real time, that could cause tests to take much longer than they should. If you fake time, you could simulate how your function would behave over time starting from any point in time. Below is an example where we want to test that the callback is called every second.

  1. // https://deno.land/std@$STD_VERSION/testing/mock_examples/interval.ts
  2. export function secondInterval(cb: () => void): number {
  3.   return setInterval(cb, 1000);
  4. }

With FakeTime we can do that. When the FakeTime instance is created, it splits from real time. The Date, setTimeout, clearTimeout, setInterval and clearInterval globals are replaced with versions that use the fake time until real time is restored. You can control how time ticks forward with the tick method on the FakeTime instance.

  1. // https://deno.land/std@$STD_VERSION/testing/mock_examples/interval_test.ts
  2. import {
  3.   assertSpyCalls,
  4.   spy,
  5. } from "https://deno.land/std@$STD_VERSION/testing/mock.ts";
  6. import { FakeTime } from "https://deno.land/std@$STD_VERSION/testing/time.ts";
  7. import { secondInterval } from "https://deno.land/std@$STD_VERSION/testing/mock_examples/interval.ts";
  9. Deno.test("secondInterval calls callback every second and stops after being cleared", () => {
  10.   const time = new FakeTime();
  12.   try {
  13.     const cb = spy();
  14.     const intervalId = secondInterval(cb);
  15.     assertSpyCalls(cb, 0);
  16.     time.tick(500);
  17.     assertSpyCalls(cb, 0);
  18.     time.tick(500);
  19.     assertSpyCalls(cb, 1);
  20.     time.tick(3500);
  21.     assertSpyCalls(cb, 4);
  23.     clearInterval(intervalId);
  24.     time.tick(1000);
  25.     assertSpyCalls(cb, 4);
  26.   } finally {
  27.     time.restore();
  28.   }
  29. });