How Can I Properly Mock an Instance Method for Dependency Injection in Jest?

Below is an explanation and a best-practice solution.

---

Why the Mock Isn’t Working

You’re replacing the prototype’s get method:

TSCopied
http.prototype.get = jest.fn(async (_url: string) =>
  Promise.resolve({
    ok: true,
    status: 200,
    json: async () => ({ name: 'javierhersan.stw', urls: [], ips: [] }),
  } as Response),
)

However, when you inject a new instance (via new http()) into Core, the original implementation is still being used. This happens because of one or more of the following reasons:

1. Method Binding or Early Instantiation – In some transpilation setups, the instance methods may have been bound already. In that case, modifying the prototype afterward does not change the already bound method.

2. Indirect Call via Request – Even if you meant to override get, the original get method calls this.request(...). Your mock may not be in effect if the instance has its own version of the method or if another method (like request) wasn’t mocked.

3. Injection of a Real Instance – When you're passing an actual instance of http (with its real behavior) into Core, the method patches on the prototype might not be reliably applied.

---

The Best Way to Mock an Object Method

The recommended approaches are:

1. Use Dependency Injection with a Custom Mock

Instead of modifying the class prototype, create your own mock object that implements the interface of your http class. For example:

TSCopied
// Create a custom mock object
const mockHttp = {
  get: jest.fn(async (_url: string) =>
    Promise.resolve({
      ok: true,
      status: 200,
      json: async () => ({ name: 'javierhersan.stw', urls: [], ips: [] }),
    } as Response)
  ),
} as Partial<http> as http

// Inject it into Core
const core = new Core(mockHttp)

With this pattern you bypass any real calls to fetch since the dependency is fully mocked.

---

2. Use jest.spyOn on the Class Prototype

Another option is to use jest.spyOn before the instance is created so that calls to http.get are intercepted. For example:

TSCopied
import http from '../http'
import { Core } from '.'

it('Domain Name Entry Test', async () => {
  // Spy on the prototype's get method and mock its implementation.
  jest.spyOn(http.prototype, 'get').mockResolvedValue({
    ok: true,
    status: 200,
    json: async () => ({ name: 'javierhersan.stw', urls: [], ips: [] }),
  } as Response)

  const core = new Core(new http())
  const domainNameEntry = await core.getUserDomainNameEntry(
    'javierhersan.stw',
    'http://localhost:3000',
  )
  
  expect(domainNameEntry).toBeDefined()
  if (domainNameEntry) {
    expect(domainNameEntry).toHaveProperty('name')
    expect(domainNameEntry).toHaveProperty('urls')
    expect(domainNameEntry).toHaveProperty('ips')
  }
})

This ensures that any later instance of the http class uses the mocked method.

---

Summary

Your original approach wasn’t working because the real http instance was still executing its request method (which calls fetch) instead of your mocked behavior. The best practice is to either inject a complete mock object or use jest.spyOn on the class prototype before creating an instance.

Both of these methods will help you avoid the actual fetch call and allow you to safely test your Core method in isolation.