How do I test a function that calls another function in jest?

user_3426772 0
Viewed 1071

I have a function that converts an array of 8 bit integers into a x-bit integer. This function has extensive unit tests in Jest. This function is called convertArrayIntoInt().

I have another functions that relies on convertArrayIntoInt() called getSignature().

/**
 * @param {Uint8Array} fileContents The file contents
 * @param {number} position The position in the file where the signature is.
 * @return {number} the 32 bit signature
 */
function getSignature(fileContents, position) {
    let signature = fileContents.slice(position, position + 4);
    signature = convertArrayIntoInt(signature);
    for(let s in Enums.Signatures) {
        if(signature === parseInt(s)) {
            return signature;
        }
    }
    return Enums.Signatures.BAD_SIGNATURE;
}

I want to write a test for this function that tests whether Uint8Array.of(0x04, 0x03, 0x4b, 0x50), 0) returns 0x04034b50 or Enums.BAD_SIGNATURE. I heard that with unit testing, you don't want to test a function that relies on the output of another function. How do I go about doing this in Jest?

jestjs javascript
3 Answers

Update: Looks like I had some issue in my original response when I merged different files in to a single files I expected it to work as before but it didn't so make sure to put function(s) you want to inject in to separate file(s).

As mentioned earlier, unit test should just test functionality of function it self while mocking dependencies.

I moved functions in to separate files, in one file all functions are defined and in another test.

enums.js

export const Enums = {
  Signatures: {
    SIGNATURE_1: 1,
    SIGNATURE_2: 2,
    SIGNATURE_3: 3,
    BAD_SIGNATURE: -1
  }
};

convertArrayIntoInt.js

export function convertArrayIntoInt(array) {
  // processing...
  return array.length;
}

getSignature.js

import { convertArrayIntoInt } from "./convertArrayIntoInt";
import { Enums } from "./enums";

export const getSignature = (fileContents, position) => {
  let signature = convertArrayIntoInt(
    fileContents.slice(position, position + 4)
  );

  for (let s in Enums.Signatures) {
    if (signature === parseInt(s, 10)) {
      return signature;
    }
  }

  return signature;
};

tests.spec.js

import { getSignature } from "./getSignature";
import { Enums } from "./enums";
import * as convertArrayIntoIntModule from "./convertArrayIntoInt";

it("Function check", () => {
  // arrange
  const spy = jest.spyOn(convertArrayIntoIntModule, "convertArrayIntoInt");
  spy.mockReturnValue(Enums.Signatures.SIGNATURE_1);

  // act
  const expected = Enums.Signatures.SIGNATURE_1;
  const actual = getSignature([1, 2, 3, 4, 5, 6], 1);

  // assert
  expect(spy).toBeCalledTimes(1);
  expect(actual).toEqual(expected);

  // clean up
  spy.mockRestore();
});

You can take a look at this sandbox that I created to test dummy function similar to yours.

user_11778140

Yes, you have heard it right. A unit test should only test a single unit/function. What you can do is, you can make another unit test to check convertArrayIntoInt() function, and for this function, you can set dummy return values for convertArrayIntoInt() in order to verify other logic is working correctly or not.

user_114832960
user_142696960
Related