You can mock the module like this:

import calculate from '../../calculate'
jest.mock('../xyz', ()=> () => Promise.resolve('mocked value'))

it('does something', async()=>{
  const op = await calculate()
  expect(op).toBe('mocked value')
})

if you need different return values from your mock you need to mock the module so it returns a spy. Then you have to import the module and you can set the return value during your tests:

import calculate from '../../calculate'
import myModule from '../xyz'
jest.mock('../xyz', ()=> jest.fn())

it('does something', async() => {
  myModule.mockImplementation(() => () =>  Promise.resolve('mocked value'))

  const op = calculate()
  expect(op).toBe('mocked value')
})

it('does something else', async() => {
  myModule.mockImplementation(() => () =>  Promise.resolve('another value'))
  const op = await calculate()
  expect(op).toBe('another value')
})


it('does fail', async() => {
  myModule.mockImplementation(() => () =>  Promise.reject('some Error')
  try{
    const op = await calculate()
  }catch (e){
    expect(e).toBe('some Error')
  }
})

You can mock the module like this:

import calculate from '../../calculate'
jest.mock('../xyz', ()=> () => Promise.resolve('mocked value'))

it('does something', async()=>{
  const op = await calculate()
  expect(op).toBe('mocked value')
})

if you need different return values from your mock you need to mock the module so it returns a spy. Then you have to import the module and you can set the return value during your tests:

import calculate from '../../calculate'
import myModule from '../xyz'
jest.mock('../xyz', ()=> jest.fn())

it('does something', async() => {
  myModule.mockImplementation(() => () =>  Promise.resolve('mocked value'))

  const op = calculate()
  expect(op).toBe('mocked value')
})

it('does something else', async() => {
  myModule.mockImplementation(() => () =>  Promise.resolve('another value'))
  const op = await calculate()
  expect(op).toBe('another value')
})


it('does fail', async() => {
  myModule.mockImplementation(() => () =>  Promise.reject('some Error')
  try{
    const op = await calculate()
  }catch (e){
    expect(e).toBe('some Error')
  }
})

Ideally you should test function independent. One test is not responsible for another function test functionality.

Not a best approach but you could do something like this:

util.js

export function add(a, b) {
  return a + b;
}

export function showMessage(a, b, addNew = add) {
  let sum = addNew(a, b);
  return `The sum is ${sum}`;
}

And in your test you could do like this: util.test.js

import * as Logics from "./util";

describe("showMessage", () => {
  it("should return message with sum", () => {
    let addSpy = jest.spyOn(Logics, "add");
    addSpy.mockReturnValue(123);
    let showMessageResponse = Logics.showMessage(2, 2, addSpy);
    expect(addSpy).toHaveBeenCalledTimes(1);
    expect(showMessageResponse).toBe(`The sum is 123`);
  });
});

Here is the sandbox you can play with: https://codesandbox.io/s/jest-test-forked-9zk1s4?file=/util.test.js:0-366

Only methods can be spied. There is no way to spy on funcB if it's called directly like funcB() within same module.

In order for exported function to be spied or mocked, funcA and funcB should reside in different modules.

This allows to spy on funcB in transpiled ES module (module object is read-only in native ESM):

import { funcB } from './b';

export const funcA = () => {
    funcB()
}

Due to that module imports are representations of modules, this is transpiled to:

var _b = require('./b');

var funcA = exports.funcA = function funcA() {
    (0, _b.funcB)();
};

Where funcB method is tied to _b module object, so it's possible to spy on it.

Your updated implementation fails because the code under test is no longer using the fs module object your test is spying on - the named import brings in the relevant function directly. However this tells you a few things:

• Firstly, that it's not a useful test - tests should give you the confidence to refactor your implementation, but here a behaviour-preserving change gives a false positive failing test; and
• Secondly, that the code doesn't work - if the real statSync returns undefined, surely the function should return false (or at least throw a more informative error)?

Using jest.spyOn(fs, 'statSync') means your test is coupled to the implementation detail that the code it's testing uses import fs from 'node:fs'. To successfully mock the whole fs module instead, you need to refer to Module mocking in ESM. Applying this guidance to your specific case:

Copyimport { jest } from '@jest/globals';

const mock = jest.fn().mockReturnValue({ isDirectory: () => true });

// 1. need to use (unstable!) ES module mocking
jest.unstable_mockModule('node:fs', () => {
  const module = { statSync: mock };
  // 2. to tolerate default or named import, provide both
  return { default: module, ...module };
});

// 3. module needs dynamically importing _after_ mock is registered
const { myFunc } = await import('./my-func.js');

it('should work', () => {
  expect(myFunc('/test')).toBeTruthy();

  expect(mock).toHaveBeenCalled();
});

Note that it's not always the case that the default export is an object containing all of the named exports; as always, it's important to ensure that the test double has the same interface as the thing it's replacing.

This test will now pass with either implementation (using named or default export to access statSync).

However, given what you're trying to test, another way to test it (that depends on even fewer implementation details - you can now use methods other than statSync if desired) is to actually try it on the local file system. For example, assuming it's in the root of a conventional npm project (alternatively you could use a test fixtures directory with a known setup):

Copyimport { myFunc } from "./my-func.js";

it('should work for a directory', () => {
  expect(myFunc('./node_modules')).toBe(true);
});

it('should work for a file', () => {
  expect(myFunc('./package.json')).toBe(false);
});

it('should work for a missing object', () => {
  expect(myFunc('./missing')).toBe(false);
  // or something like:
  // expect(() => myFunc('./missing')).toThrow(/could not be found/);
});

As noted above, this shows that there's one case where the behaviour probably isn't correct:

Copy FAIL  ./my-func.test.js
  ✓ should work for a directory (1 ms)
  ✓ should work for a file
  ✕ should work for a missing object (1 ms)

  ● should work for a missing object

    TypeError: Cannot read properties of undefined (reading 'isDirectory')

I ended up ditching the default export:

// UniqueIdGenerator.js
export const uniqueIdGenerator = () => Math.random().toString(36).substring(2, 8);

And then I could use and spy it like this:

import * as UniqueIdGenerator from './UniqueIdGenerator';
// ...
const spy = jest.spyOn(UniqueIdGenerator, 'uniqueIdGenerator');

Some recommend wrapping them in a const object, and exporting that. I suppose you can also use a class for wrapping.

However, if you can't modify the class there's still a (not-so-nice) solution:

import * as UniqueIdGenerator from './UniqueIdGenerator';
// ...
const spy = jest.spyOn(UniqueIdGenerator, 'default');