Mocking and stubbing in Deno - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this mocked function call?

Consider the following Deno test code using a stub to replace a function. What will be printed when the test runs?

Deno

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

function fetchData() {
  return "real data";
}

const fetchDataStub = stub(globalThis, "fetchData", () => "mocked data");

console.log(fetchData());

fetchDataStub.restore();

A "real data"

B undefined

C "mocked data"

D Throws ReferenceError

💡 Hint

Think about where fetchData is defined and what window refers to in Deno.

In Deno, window is an alias for globalThis, so stubbing globalThis.fetchData works if fetchData is defined on globalThis. However, in this code, fetchData is a local function and not a property of globalThis, so stubbing globalThis.fetchData adds a new property. The call to fetchData() calls the local function, returning "real data". But since the stub is on globalThis.fetchData, it does not affect the local function. Therefore, the output is "real data".

❓ state_output

intermediate

What is the value of call count after stubbing?

Given the following code using Deno's stub, what is the value of callCount after the calls?

Deno

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

const obj = {
  greet(name) {
    return `Hello, ${name}`;
  }
};

const greetStub = stub(obj, "greet", (name) => `Hi, ${name}`);

obj.greet("Alice");
obj.greet("Bob");

const callCount = greetStub.calls.length;

greetStub.restore();

A Throws TypeError

B 1

C 0

D 2

💡 Hint

Count how many times the stubbed function is called.

The stub replaces obj.greet. It is called twice, so greetStub.calls.length is 2.

📝 Syntax

advanced

Which option correctly stubs a method with async behavior?

Which code snippet correctly stubs an async method fetchUser on api to return a resolved promise with {id: 1}?

A stub(api, "fetchUser", async () => { return {id: 1}; })

B stub(api, "fetchUser", () => { return {id: 1}; })

C stub(api, "fetchUser", () => Promise.resolve({id: 1}))

D stub(api, "fetchUser", async () => Promise.resolve({id: 1}))

💡 Hint

Remember how async functions return promises automatically.

Option A defines an async function that returns the object, automatically wrapping it in a resolved promise. Option A returns a promise from within an async function, resulting in Promise<Promise<{id: 1}>> (incorrect). Option A returns a promise but lacks the async keyword. Option A returns a plain object (not a promise). Deno stubs work with either async functions or functions returning promises, but D best matches an async original method.

🔧 Debug

advanced

Why does this stub not record calls?

Given this code, why does stub.calls.length remain 0 after calling obj.method()?

Deno

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

const obj = {
  method() {
    return "original";
  }
};

const callResult = obj.method.bind(obj)();

const stubMethod = stub(obj, "method", () => "stubbed");

const callCount = stubMethod.calls.length;

stubMethod.restore();

A Because the stub function does not return a value

B Because the stub was not called; binding creates a new function that bypasses the stub

C Because the stub was restored before the call

D Because the stub was created on the wrong object

💡 Hint

Think about what bind does to a function reference.

Using obj.method.bind(obj)() *before* stubbing captures and calls the original method via the bound function. The stub replacement happens afterward, so the stub is never called, and calls.length stays 0.

🧠 Conceptual

expert

What is the main difference between mocking and stubbing in Deno tests?

Choose the best explanation of the difference between mocking and stubbing when testing with Deno's standard library.

A Stubbing replaces a function's behavior with a fixed response; mocking also tracks calls and can verify call order and arguments

B Stubbing is used only for async functions; mocking is for synchronous functions

C Mocking replaces functions with empty implementations; stubbing records calls but does not change behavior

D Mocking and stubbing are the same in Deno and can be used interchangeably

💡 Hint

Think about what extra features mocks provide beyond stubs.

Stubs replace function behavior with fixed responses. Mocks do that too but also track how functions are called, allowing verification of call counts, arguments, and order.

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