🧩 Mocking Modules and Dependencies in Jest — Expense Tracker Edition

🧩 Mocking Modules and Dependencies in Jest — Expense Tracker Edition

Our Expense Tracker is growing like a startup that just got funding.

It has logic, tests, even spies watching its every move.

But now, it is hiring new “employees” helpers, modules, and third-party tools.

And like every team in the world, not all new hires behave. 😅

Some work perfectly on day one.

Some break things the moment you’re not watching.

And some refuse to come to work at all.

That’s why we need mocking for modules — a way to test your code without trusting your teammates too much.

💡 The Problem with Dependencies

Let’s be honest.

No developer ever said,

“Wow, I love debugging this third-party library I did not write!”

Your code might depend on something tiny — like a utility that converts currency,

but if that utility breaks, your tests explode like fireworks.

So instead of letting those modules run wild, we replace them with perfect clones that behave exactly how we want.

That’s Jest mocking — or as I like to call it:

“Professional-level lying for good reasons.” 😎

⚙️ Step 1 — Meet the New Employee

📁 currencyConverter.js

exports.convertToINR = (usd) => {
  // Imagine this calls an external API
  console.log('Converting USD to INR...');
  return usd * 83;
};

And here’s the main code that uses it:

📁 expenseCurrency.js

const { convertToINR } = require('./currencyConverter');

exports.calculateExpenseInINR = (usdAmount) => {
  const inr = convertToINR(usdAmount);
  return { usd: usdAmount, inr };
};

This looks fine, until one day the API crashes or returns undefined.

Your tests fail. Your morning coffee tastes bitter. ☕

We can fix that.

🧪 Step 2 — Fire the Real One, Hire a Mock 😏

📁 expenseCurrency.test.js

jest.mock('./currencyConverter', () => ({
  convertToINR: jest.fn(),
}));

const { calculateExpenseInINR } = require('./expenseCurrency');
const { convertToINR } = require('./currencyConverter');

test('should use mocked convertToINR', () => {
  convertToINR.mockReturnValue(8300);

  const result = calculateExpenseInINR(100);
  expect(convertToINR).toHaveBeenCalledWith(100);
  expect(result.inr).toBe(8300);
});

✅ We just replaced the real convertToINR with a fake one that always behaves.

It never forgets, never breaks, never calls the internet.

It’s like the world’s best intern.

Imagine Explaining This to a Non-Dev

“So, you fired your real function and replaced it with a fake one that pretends to do the job?”

“Exactly!”

“And this makes you trust your code more?”

“Yes.”

“You’re insane.”

Welcome to testing. 😎

🧠 Step 3 — Mocking Third-Party Packages

Let’s take it up a notch.

Say your app uses axios for API calls.

You don’t want your test waiting for the internet — so you replace it too.

📁 expenseApi.test.js

jest.mock('axios');
const axios = require('axios');
const { fetchExpenses } = require('./expenseApi');

test('should mock axios get call', async () => {
  axios.get.mockResolvedValue({ data: [{ id: 1, amount: 500 }] });

  const result = await fetchExpenses();
  expect(result.length).toBe(1);
});

Boom 💥

you just controlled axios itself.

You told it what to say, and it obeyed like a polite bot.

⚙️ Step 4 — The Jedi Trick: Partial Mocking

Sometimes you don’t want to replace the whole module, just one noisy function inside it.

That’s where partial mocking comes in.

jest.mock('./currencyConverter', () => {
  const originalModule = jest.requireActual('./currencyConverter');
  return {
    ...originalModule,
    convertToINR: jest.fn().mockReturnValue(9000),
  };
});

Now, you keep everything else real, but replace one part.

It’s like hiring a clone who’s just a little smarter at one thing.

🧩 Step 5 — Don’t Forget to Clean the Mess

After every test, always restore order:

afterEach(() => {
  jest.resetAllMocks();
});

It’s like telling your test suite,

“Alright team, break’s over — back to normal behavior!”

This keeps your next tests clean and drama-free.

✅ Summary

Today,

Our Expense Tracker learned how to manage its relationships like a pro.

It now knows which functions to trust, which to replace, and when to keep things real.

We mocked:

• Our own modules
• Third-party libraries like Axios
• And even learned partial mocking for finer control

In short,

our code stopped chasing bad dependencies — it hired replacements that never fail. 😎

In the next Part we will see Mocking Configurations and Chained Dependencies in Jest — where your app will start mocking its own brain.