@gravity-ui/data-source/build/cjs/react-query/hooks/__tests__/useRefetchInterval.test.js

A wrapper around data fetching

"use strict";

var _reactQuery = require("@tanstack/react-query");
var _react = require("@testing-library/react");
var _useRefetchInterval = require("../useRefetchInterval");
describe('useRefetchInterval', function () {
  it('should return undefined when no refetchInterval is provided', function () {
    var _renderHook = (0, _react.renderHook)(function () {
        return (0, _useRefetchInterval.useRefetchInterval)();
      }),
      result = _renderHook.result;
    expect(result.current.refetchInterval).toBeUndefined();
    expect(result.current.queryFn).toBeUndefined();
  });
  it('should return the provided refetchInterval when it is a number', function () {
    var interval = 5000;
    var _renderHook2 = (0, _react.renderHook)(function () {
        return (0, _useRefetchInterval.useRefetchInterval)(interval);
      }),
      result = _renderHook2.result;
    expect(result.current.refetchInterval).toBe(interval);
  });
  it('should return the provided refetchInterval when it is false', function () {
    var interval = false;
    var _renderHook3 = (0, _react.renderHook)(function () {
        return (0, _useRefetchInterval.useRefetchInterval)(interval);
      }),
      result = _renderHook3.result;
    expect(result.current.refetchInterval).toBe(interval);
  });
  it('should wrap the provided refetchInterval function', function () {
    var mockQuery = {
      state: {
        data: {
          value: 42
        },
        status: 'success'
      }
    };
    var refetchInterval = jest.fn(function (_query, count) {
      return count > 3 ? false : 1000;
    });
    var _renderHook4 = (0, _react.renderHook)(function () {
        return (0, _useRefetchInterval.useRefetchInterval)(refetchInterval);
      }),
      result = _renderHook4.result;
    expect(result.current.refetchInterval).toEqual(expect.any(Function));
    var resultInterval = result.current.refetchInterval(mockQuery);
    expect(refetchInterval).toHaveBeenCalledWith(mockQuery, 0);
    expect(resultInterval).toBe(1000);
  });
  it('should wrap the provided queryFn and increment count on each call', function () {
    var mockContext = {};
    var mockQuery = {
      state: {
        data: {
          value: 42
        },
        status: 'success'
      }
    };
    var queryFn = jest.fn().mockResolvedValue({
      value: 42
    });
    var refetchInterval = jest.fn(function (_query, count) {
      return count > 3 ? false : 1000;
    });
    var _renderHook5 = (0, _react.renderHook)(function () {
        return (0, _useRefetchInterval.useRefetchInterval)(refetchInterval, queryFn);
      }),
      result = _renderHook5.result;
    expect(result.current.queryFn).toEqual(expect.any(Function));
    expect(result.current.refetchInterval).toEqual(expect.any(Function));
    result.current.queryFn(mockContext);
    result.current.refetchInterval(mockQuery);
    result.current.queryFn(mockContext);
    result.current.refetchInterval(mockQuery);
    result.current.queryFn(mockContext);
    result.current.refetchInterval(mockQuery);
    result.current.queryFn(mockContext);
    result.current.refetchInterval(mockQuery);
    expect(queryFn.mock.calls).toEqual([[mockContext], [mockContext], [mockContext], [mockContext]]);
    expect(refetchInterval.mock.calls).toEqual([[mockQuery, 1], [mockQuery, 2], [mockQuery, 3], [mockQuery, 4]]);
    expect(refetchInterval.mock.results).toEqual([{
      type: 'return',
      value: 1000
    }, {
      type: 'return',
      value: 1000
    }, {
      type: 'return',
      value: 1000
    }, {
      type: 'return',
      value: false
    }]);
  });
  it('should return the provided queryFn when it is not a function', function () {
    var _renderHook6 = (0, _react.renderHook)(function () {
        return (0, _useRefetchInterval.useRefetchInterval)(undefined, _reactQuery.skipToken);
      }),
      result = _renderHook6.result;
    expect(result.current.queryFn).toBe(_reactQuery.skipToken);
  });
  it('should memoize the wrapped functions', function () {
    var refetchInterval = jest.fn(function () {
      return 1000;
    });
    var queryFn = jest.fn().mockResolvedValue({
      value: 42
    });
    var _renderHook7 = (0, _react.renderHook)(function () {
        return (0, _useRefetchInterval.useRefetchInterval)(refetchInterval, queryFn);
      }),
      result = _renderHook7.result,
      rerender = _renderHook7.rerender;
    var firstRefetchInterval = result.current.refetchInterval;
    var firstQueryFn = result.current.queryFn;
    rerender();
    expect(result.current.refetchInterval).toBe(firstRefetchInterval);
    expect(result.current.queryFn).toBe(firstQueryFn);
  });
  it('should create new functions when dependencies change', function () {
    var refetchInterval1 = jest.fn(function () {
      return 1000;
    });
    var queryFn1 = jest.fn().mockResolvedValue({
      value: 42
    });
    var _renderHook8 = (0, _react.renderHook)(function (props) {
        return (0, _useRefetchInterval.useRefetchInterval)(props.refetchInterval, props.queryFn);
      }, {
        initialProps: {
          refetchInterval: refetchInterval1,
          queryFn: queryFn1
        }
      }),
      result = _renderHook8.result,
      rerender = _renderHook8.rerender;
    var firstRefetchInterval = result.current.refetchInterval;
    var firstQueryFn = result.current.queryFn;
    var refetchInterval2 = jest.fn(function () {
      return 2000;
    });
    var queryFn2 = jest.fn().mockResolvedValue({
      value: 100
    });
    rerender({
      refetchInterval: refetchInterval2,
      queryFn: queryFn2
    });
    expect(result.current.refetchInterval).not.toBe(firstRefetchInterval);
    expect(result.current.queryFn).not.toBe(firstQueryFn);
  });
});
// #sourceMappingURL=useRefetchInterval.test.js.map