Mocking and stubbing in Deno

Introduction

Mocking and stubbing help you test your code by pretending parts of it work in a certain way. This lets you check your code without needing everything to be ready or connected.

When you want to test a function that calls an external API without actually calling it.

When you need to simulate a database response during testing without using a real database.

When you want to isolate a part of your code to test it without interference from other parts.

When you want to control the behavior of a function to test different scenarios.

When you want to speed up tests by avoiding slow or unreliable external services.

Syntax

Deno

import { stub } from "https://deno.land/std/testing/mock.ts";

const myStub = stub(object, "methodName", () => returnValue);

// Use myStub in your test

myStub.restore();

stub replaces a method on an object with a fake function.

Remember to call restore() after the test to reset the original method.

Examples

This example replaces the greet method to return a different greeting during the test.

Deno

import { stub } from "https://deno.land/std/testing/mock.ts";

const obj = {
  greet: () => "Hello",
};

const stubGreet = stub(obj, "greet", () => "Hi there!");

console.log(obj.greet()); // Outputs: Hi there!

stubGreet.restore();

Here, the add method is stubbed to always return 42, no matter the inputs.

Deno

import { stub } from "https://deno.land/std/testing/mock.ts";

const math = {
  add: (a, b) => a + b,
};

const stubAdd = stub(math, "add", (a, b) => 42);

console.log(math.add(1, 2)); // Outputs: 42

stubAdd.restore();

Sample Program

This program shows how to stub a method to return fake data during testing, then restore it back to the original.

Deno

import { stub } from "https://deno.land/std/testing/mock.ts";

// Original object with a method
const api = {
  fetchData: () => {
    return "Real data from API";
  },
};

// Stub the fetchData method to simulate API response
const stubFetch = stub(api, "fetchData", () => "Mocked API data");

// Use the stubbed method
console.log(api.fetchData());

// Restore the original method
stubFetch.restore();

// Use the original method again
console.log(api.fetchData());

Important Notes

Always restore stubs after tests to avoid side effects on other tests.

Stubbing helps isolate the code you want to test by controlling dependencies.

Use stubs to simulate different scenarios like errors or slow responses.

Summary

Mocking and stubbing let you replace parts of your code to test it better.

Use stub from Deno's standard library to fake methods easily.

Remember to restore original methods after testing to keep code clean.

Practice

1. What is the main purpose of mocking and stubbing in Deno testing?

easy

A. To speed up the execution of the entire program

B. To replace parts of code with fake versions for easier testing

C. To permanently change the behavior of functions in production

D. To automatically generate user interface components

Solution

1. Step 1: Understand mocking and stubbing

   Mocking and stubbing are techniques used to replace parts of code with fake versions to isolate and test specific behaviors.

2. Step 2: Identify the purpose in testing context

   They help test code without relying on real dependencies, making tests simpler and more reliable.

3. Final Answer:

   To replace parts of code with fake versions for easier testing -> Option B

4. Quick Check:

   Mocking purpose = Replace code parts [OK]

Hint: Mocking replaces code parts to isolate tests [OK]

Common Mistakes:

• Thinking mocking speeds up the whole program
• Believing mocks change production code permanently
• Confusing mocking with UI generation

2. Which of the following is the correct way to import the stub function from Deno's standard testing library?

easy

A. import { stub } from "https://deno.land/std/testing/stub.ts";

B. import stub from "https://deno.land/std/testing/mock.ts";

C. import { stub } from "https://deno.land/std/testing/mock.ts";

D. import * as stub from "https://deno.land/std/testing/mock.ts";

Solution

1. Step 1: Recall the correct import path and syntax

   The stub function is exported from "https://deno.land/std/testing/mock.ts" and must be imported using named import syntax.

2. Step 2: Check each option

   import { stub } from "https://deno.land/std/testing/mock.ts"; uses named import from the correct path. import stub from "https://deno.land/std/testing/mock.ts"; uses default import which is incorrect. import { stub } from "https://deno.land/std/testing/stub.ts"; uses wrong file name. import * as stub from "https://deno.land/std/testing/mock.ts"; imports all as an object, not the function directly.

3. Final Answer:

   import { stub } from "https://deno.land/std/testing/mock.ts"; -> Option C

4. Quick Check:

   Correct import = named from mock.ts [OK]

Hint: Use named import from mock.ts for stub [OK]

Common Mistakes:

• Using default import instead of named import
• Wrong file path for stub
• Importing everything instead of just stub

3. Given the following code snippet, what will be the output?

import { stub } from "https://deno.land/std/testing/mock.ts";

const obj = {
  greet() {
    return "Hello";
  }
};

const stubGreet = stub(obj, "greet", () => "Hi there!");
console.log(obj.greet());
stubGreet.restore();
console.log(obj.greet());

medium

A. "Hello" then "Hello"

B. "Hi there!" then "Hi there!"

C. Runtime error due to incorrect stub usage

D. "Hi there!" then "Hello"

Solution

1. Step 1: Understand stub behavior on method

   The stub replaces obj.greet with a new function returning "Hi there!" temporarily.

2. Step 2: Analyze console outputs

   First console.log calls stubbed method, outputting "Hi there!". After restore(), original method returns "Hello" on second log.

3. Final Answer:

   "Hi there!" then "Hello" -> Option D

4. Quick Check:

   Stub replaces then restores method [OK]

Hint: Stub changes method until restore is called [OK]

Common Mistakes:

• Expecting original method output before restore
• Thinking stub permanently changes method
• Confusing stub with spy that tracks calls

4. What is the error in the following Deno test code using stub?

import { stub } from "https://deno.land/std/testing/mock.ts";

const obj = {
  value() {
    return 42;
  }
};

const stubValue = stub(obj, "val", () => 100);
console.log(obj.value());
stubValue.restore();

medium

A. Trying to stub a non-existent method 'val' on obj

B. Missing import statement for stub

C. restore() called before stub is created

D. Incorrect arrow function syntax in stub

Solution

1. Step 1: Check stub target method name

   The stub tries to replace method named "val" but obj only has "value" method.

2. Step 2: Understand stub behavior on invalid method

   Stubbing a non-existent method causes an error or does not work as expected.

3. Final Answer:

   Trying to stub a non-existent method 'val' on obj -> Option A

4. Quick Check:

   Stub method must exist on object [OK]

Hint: Stub only existing methods on objects [OK]

Common Mistakes:

• Using wrong method name in stub
• Forgetting to import stub
• Calling restore too early

5. You want to test a function that calls fetchData() which normally fetches data from the internet. Using Deno's stub, how can you replace fetchData to return a fixed value { success: true } only during the test, and ensure the original fetchData is restored after the test?

hard

A. Use const stubFetch = stub(obj, "fetchData", () => ({ success: true })); then call stubFetch.restore() after test

B. Replace fetchData globally without restore, returning fixed value

C. Use stub(obj, "fetchData", async () => Promise.resolve({ success: true })); but forget to restore

D. Call stub(obj, "fetchData", () => { return true; }); without storing stub

Solution

1. Step 1: Create a stub for fetchData returning fixed value

   Use stub on the object containing fetchData, replacing it with a function returning { success: true }.

2. Step 2: Restore original method after test

   Store the stub in a variable and call restore() after the test to revert changes.

3. Final Answer:

   Use const stubFetch = stub(obj, "fetchData", () => ({ success: true })); then call stubFetch.restore() after test -> Option A

4. Quick Check:

   Stub with restore keeps tests clean [OK]

Hint: Always restore stub after test to keep original code [OK]

Common Mistakes:

• Not restoring stub after test
• Replacing globally without control
• Returning wrong stub value type