I am not expert in jest, but my recommendation to think about:

1) When the function is exported as default I use something like:

import Funct1 from "../../../src/components/Funct1";
...
jest.mock("../../../src/components/Funct1");
...
expect(Funct1).toHaveBeenCalledWith(params);

2) When the module (utils.js) has multiple exports as

export const f1 = () => {};
...
export const f8 = () => {};

You can try

import * as Utils from "../../../src/components/utils"
const f8Spy = jest.spyOn(Utils, 'f8');
...
expect(f8Spy).toHaveBeenCalledWith(params);

Similar discussion here

Found great help from the answer here: Jest spyOn function called

This was the important step I was missing:

const instance = wrapper.instance()
const spy = jest.spyOn(instance, 'yearOnChange')

Updated working test with 2 working expects.

it('yearOnChange method is called', function() {
    const instance = wrapper.instance();  // <-- Needed to do this here
    const spy = jest.spyOn(instance, 'yearOnChange');  // <-- Then use instance here
    wrapper.instance().forceUpdate();
    
    const event = {
        target: {
            value: '1999'
        }
    };

    wrapper.instance().yearOnChange(event);
    wrapper.simulate('change', event);

    const result = wrapper.state('year');
    console.log('result', result); // result = 1999
    expect(result).toEqual('1999');
    expect(spy).toHaveBeenCalled();
});

When you call the jest.spyOn method you have to provide as first argument the object that contains the method you want to spy (documentation).

You are probably importing the handleError method like:

import { handleError } from 'file-where-handle-error-is';

Therefore, your imported handleError is directly the function and not an object that contains the function.

To solve your problem you can import the module where handleError is located and then mock the handleError method:

const utils = require('file-where-handle-error-is');
const spyHandleError = jest.spyOn(utils, 'handleError');

Another solution would be to mock the module where handleError is located with jest.mock:

jest.mock('../../../src/utils/handle-error', () => {
return {
    handleError: jest.fn()
};

Figured the solution:

const spy = jest.spyOn(global.Date.prototype, 'toISOString').mockImplementation(() => {
        return '123123123'
      })

More than likely, your UserService class has other dependencies and as such, Nest cannot instantiate the UserService class. When you are trying to do userService = module.get(UserService) you are retrieving an undefined hence the error about jest.spyOn(). In unit tests, you should be providing a mock provider to take the place of your actual provider, like so:

describe("User Controller", () => {
  let usercontroller: UserController;
  let userservice: UserService;
  // let fireBaseAuthService: FireBaseAuthService;
  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [UserController],
      providers: [
        {
          provide: UserService,
          useValue: {
            updateUser: jest.fn(),
            // other UserService methods
          }
        }
      ],
    }).compile();

    usercontroller = module.get<UserController>(UserController);

    userservice = module.get<UserService>(UserService);
  });
  // rest of tests
});

Now when you retrieve the UserService you'll have an object with the proper functions back, which can then be jest.spyOned and mocked