Figuring out Contract testing and mocking with Jest

[a-straus]

Hi there,
I'm encountering some difficulty writing tests for my node typescript application that uses Ethers and Jest.

I am using an Ethers contract that is of the type Uniswap NonFungiblePositionManager.

I would like to write unit tests that make use of the ethers contract. I have a class with private member called nfpContract and a method called getPositions

export class PositionService {
  private nfpContract: NFPContract;
  constructor() {
    this.nfpContract = new Contract(
      NONFUNGIBLE_POSITION_MANAGER_ADDRESS,
      NFPManangerAbi,
      this.provider
    ) as NFPContract;
  }

  async getPositions(
    address: string
  ): Promise<BigNumber> {
    try {
      return const numPositions = (
        await this.nfpContract.balanceOf(address)
    } catch(err){ 
      console.log(err)
    }
  }
}

Let's say this is my code. I would like to write a unit test for getPositions. My first instinct is to mock "@ethersproject/contracts" and then overwrite the constructor to return a mock with the method getPositions. The problem I am having is that the Contract constructor returns an object instance that has no pre-set methods on it, so this doesn't seem to be working:

jest.mock("@ethersproject/contracts", () => {
  const ethers = jest.requireActual("@ethersproject/contracts");
  return {
    __esModule: true,
    ...Contract,
    balanceOf: jest.fn().mockResolvedValue(BigNumber.from(2)),
  };
});

In this case, I can't do any tests on PositionService.nfpContract.balanceOf because it doesn't recognize it as a mocked method, because that method isn't known by the Contract class. Am I missing something here?

This thread suggests bypassing the contract itself in the unit test and instead mocking the provider. As I write this, this seems to make sense because what I really care about is the proper method being called on the provider, not the exact implementation of the library that that actually formats the RPC call. Any confirmations or suggestions in this matter would be helpful.

P.S. How would I go about mocking callStatic on any of these methods then? Would that also just be easier if I mocked the provider?

[zemse]

because that method isn't known by the Contract class

You are correct, so Contract class adds these methods at construction time using abi provided.

Would that also just be easier if I mocked the provider?

Mocking provider can be the general approach if you cannot mock contracts. Just that you'd have to deal with ABI encoding and decoding, which should be fine if there are just a few methods that you want to mock. But if it's possible to use a different Contract class, you might be able to avoid that.

class MyContract extends ethers.Conctract {
  constructor() {
    super(ethers.constants.AddressZero, []);
  }
  balanceOf() {} // you might be able to mock this method using jest
}

[risinek]

You were almost there. You have to mock the Contract constructor and return an object with the contract methods you want to mock.

jest.mock('@ethersproject/contracts', () => {
    return {
      Contract: jest.fn().mockImplementation(() => {
        return {
          balanceOf: jest.fn()
        };
      }),
    };
  }

Then you can work with Contract.balanceOf the same as with jest.fn() function. What I do is first I create a variable that holds jest.fn() for balanceOf method and then assign it inside mock. It allows me to later spy on it and change implementation etc. Like this

cons mockedBalanceOf = jest.fn();
jest.mock('@ethersproject/contracts', () => {
    return {
      Contract: jest.fn().mockImplementation(() => {
        return {
          balanceOf: mockedBalanceOf
        };
      }),
    };
  }
...
test('balanceOf', () => {
...
mockedBalanceOf.mockReturnValue(123)
...
//test logic, where somewhere `contract.balanceOf('abc')` is called
...
expect(mockedBalanceOf).toBeCalledWith('abc')
}

Or if you are using ethers module (that includes @ethersproject/contract alongside with other @ethersproject modules), you can mock Contract like this:

jest.mock('ethers', () => {
  const originalModule =
    jest.requireActual<typeof import('ethers')>('ethers')

  return {
    ...originalModule,
    providers: {
      Contract: jest.fn().mockImplementation(() => {
        return {
          balanceOf: jest.fn()
          deposit: mockedContractDeposit
        }
      }),
      Wallet: {
        fromMnemonic: () => mockedEthersWallet
      }
    }
  }
)

[meanMonk]

Here is also solution which I have prepared with better control over mock function to help asserting on mock functions!

https://stackoverflow.com/a/78819446/7785198