@applicaster/zapp-react-native-utils/equalUtils/__tests__/isEqual/combination.test.ts

Applicaster Zapp React Native utilities package

import { isEqual } from "../..";

const array = [1, 2, 3];
const sameProp = "sameProp";

describe("isEqual - comprehensive tests", () => {
  describe("all conditions together", () => {
    it("all conditions checked and not equal", () => {
      const prev = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: array,
        byComparatorProp: "test",
        extraProp1: 123,
        extraProp2: sameProp,
      };

      const next = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: array,
        byComparatorProp: "different",
        extraProp1: 456,
        extraProp2: sameProp,
      };

      const customComparator = jest.fn().mockReturnValue(true);

      const result = isEqual({
        byValue: ["byValueProp"],
        byReference: ["byRefProp"],
        byComparator: {
          comparator: customComparator,
          keys: ["byComparatorProp"],
        },
        compareRemainingKeysBySameValue: true,
      })(prev, next);

      expect(result).toBe(false);

      expect(customComparator).toHaveBeenCalledWith(
        prev.byComparatorProp,
        next.byComparatorProp
      );
    });

    it("all conditions pass with exact remaining keys check", () => {
      const prev = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: array,
        byComparatorProp: "test",
        extraProp: sameProp,
      };

      const next = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: array,
        byComparatorProp: "test",
        extraProp: sameProp,
      };

      const customComparator = jest.fn().mockReturnValue(true);

      const result = isEqual({
        byValue: ["byValueProp"],
        byReference: ["byRefProp"],
        byComparator: {
          comparator: customComparator,
          keys: ["byComparatorProp"],
        },
        compareRemainingKeysBySameValue: true,
      })(prev, next);

      expect(result).toBe(true);

      expect(customComparator).toHaveBeenCalledWith(
        prev.byComparatorProp,
        next.byComparatorProp
      );
    });

    it("byReference check fails first (early return)", () => {
      const prev = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: array,
        byComparatorProp: sameProp,
      };

      const next = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: [1, 2, 3],
        byComparatorProp: sameProp,
      };

      const customComparator = jest.fn().mockReturnValue(true);

      const result = isEqual({
        byValue: ["byValueProp"],
        byReference: ["byRefProp"],
        byComparator: {
          comparator: customComparator,
          keys: ["byComparatorProp"],
        },
      })(prev, next);

      expect(result).toBe(false);
      expect(customComparator).not.toHaveBeenCalled();
    });

    it("byValue check fails after byReference passes", () => {
      const prev = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: array,
        byComparatorProp: sameProp,
      };

      const next = {
        byValueProp: { a: 1, b: 3 },
        byRefProp: array,
        byComparatorProp: sameProp,
      };

      const customComparator = jest.fn().mockReturnValue(true);

      const result = isEqual({
        byValue: ["byValueProp"],
        byReference: ["byRefProp"],
        byComparator: {
          comparator: customComparator,
          keys: ["byComparatorProp"],
        },
      })(prev, next);

      expect(result).toBe(false);
      expect(customComparator).not.toHaveBeenCalled();
    });

    it("byComparator check fails after other checks pass", () => {
      const prev = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: array,
        byComparatorProp: "test",
      };

      const next = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: array,
        byComparatorProp: "different",
      };

      const customComparator = jest.fn().mockReturnValue(false);

      const result = isEqual({
        byValue: ["byValueProp"],
        byReference: ["byRefProp"],
        byComparator: {
          comparator: customComparator,
          keys: ["byComparatorProp"],
        },
      })(prev, next);

      expect(result).toBe(false);

      expect(customComparator).toHaveBeenCalledWith(
        prev.byComparatorProp,
        next.byComparatorProp
      );
    });

    it("remaining keys comparison fails", () => {
      const sharedArray = [1, 2, 3];

      const prev = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: sharedArray,
        byComparatorProp: "test",
        extraProp: "original",
      };

      const next = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: sharedArray,
        byComparatorProp: "different",
        extraProp: "changed",
      };

      const customComparator = jest.fn().mockReturnValue(true);

      const result = isEqual({
        byValue: ["byValueProp"],
        byReference: ["byRefProp"],
        byComparator: {
          comparator: customComparator,
          keys: ["byComparatorProp"],
        },
        compareRemainingKeysBySameValue: true,
      })(prev, next);

      expect(result).toBe(false);
      expect(customComparator).toHaveBeenCalled();
    });

    it("with debug flag", () => {
      const consoleSpy = jest.spyOn(console, "log").mockImplementation();

      const prev = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: array,
        byComparatorProp: "test",
        extraProp: sameProp,
      };

      const next = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: array,
        byComparatorProp: "different",
        extraProp: sameProp,
      };

      const customComparator = jest.fn().mockReturnValue(true);

      const result = isEqual({
        byValue: ["byValueProp"],
        byReference: ["byRefProp"],
        byComparator: {
          comparator: customComparator,
          keys: ["byComparatorProp"],
        },
        compareRemainingKeysBySameValue: true,
        debug: true,
      })(prev, next);

      expect(result).toBe(true);
      expect(consoleSpy).toHaveBeenCalled();

      consoleSpy.mockRestore();
    });

    it("handles missing properties", () => {
      const prev = {
        byValueProp: { a: 1, b: 2 },
        byRefProp: [1, 2, 3],
      };

      const next = {
        byValueProp: { a: 1, b: 2 },
        byComparatorProp: "test",
      };

      const customComparator = jest.fn().mockReturnValue(true);

      const result = isEqual({
        byValue: ["byValueProp"],
        byReference: ["byRefProp"],
        byComparator: {
          comparator: customComparator,
          keys: ["byComparatorProp"],
        },
      })(prev, next);

      expect(result).toBe(false);
      expect(customComparator).not.toHaveBeenCalled();
    });
  });
});