CODEWITHSUNDEEP
javascriptjestjs
Cygnini - ShadowRi5ing
Cygnini - ShadowRi5ing

Reputation: 175

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

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?

Upvotes: 3

Views: 3076

Answers (3)

Dipen Shah
Dipen Shah

Reputation: 26085

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.

Upvotes: 2

Sergej Klackovskis
Sergej Klackovskis

Reputation: 453

You can spyOn convertArrayIntoInt function and mockReturnValue. https://jestjs.io/docs/en/jest-object#jestspyonobject-methodname

Upvotes: 0

Sajjad Zaidi
Sajjad Zaidi

Reputation: 169

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.

Upvotes: 1

Related Questions