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

A wrapper around data fetching

"use strict";

var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
var _ClientDataManager = require("../ClientDataManager");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
describe('QueryNormalizer API', function () {
  var dataManager;
  beforeEach(function () {
    dataManager = new _ClientDataManager.ClientDataManager({
      defaultOptions: {
        queries: {
          retry: false
        },
        mutations: {
          retry: false
        }
      },
      normalizerConfig: {
        devLogging: false
      }
    });
  });
  afterEach(function () {
    dataManager.queryClient.clear();
  });
  it('should create queryNormalizer with required methods', function () {
    var _dataManager$queryNor, _dataManager$queryNor2, _dataManager$queryNor3, _dataManager$queryNor4, _dataManager$queryNor5, _dataManager$queryNor6, _dataManager$queryNor7, _dataManager$queryNor8, _dataManager$queryNor9;
    expect(dataManager.queryNormalizer).toBeDefined();
    expect((_dataManager$queryNor = dataManager.queryNormalizer) === null || _dataManager$queryNor === void 0 ? void 0 : _dataManager$queryNor.getNormalizedData).toBeDefined();
    expect((_dataManager$queryNor2 = dataManager.queryNormalizer) === null || _dataManager$queryNor2 === void 0 ? void 0 : _dataManager$queryNor2.setNormalizedData).toBeDefined();
    expect((_dataManager$queryNor3 = dataManager.queryNormalizer) === null || _dataManager$queryNor3 === void 0 ? void 0 : _dataManager$queryNor3.clear).toBeDefined();
    expect((_dataManager$queryNor4 = dataManager.queryNormalizer) === null || _dataManager$queryNor4 === void 0 ? void 0 : _dataManager$queryNor4.getObjectById).toBeDefined();
    expect((_dataManager$queryNor5 = dataManager.queryNormalizer) === null || _dataManager$queryNor5 === void 0 ? void 0 : _dataManager$queryNor5.getQueryFragment).toBeDefined();
    expect((_dataManager$queryNor6 = dataManager.queryNormalizer) === null || _dataManager$queryNor6 === void 0 ? void 0 : _dataManager$queryNor6.getDependentQueries).toBeDefined();
    expect((_dataManager$queryNor7 = dataManager.queryNormalizer) === null || _dataManager$queryNor7 === void 0 ? void 0 : _dataManager$queryNor7.getDependentQueriesByIds).toBeDefined();
    expect((_dataManager$queryNor8 = dataManager.queryNormalizer) === null || _dataManager$queryNor8 === void 0 ? void 0 : _dataManager$queryNor8.subscribe).toBeDefined();
    expect((_dataManager$queryNor9 = dataManager.queryNormalizer) === null || _dataManager$queryNor9 === void 0 ? void 0 : _dataManager$queryNor9.unsubscribe).toBeDefined();
  });
  it('getNormalizedData should return normalized data', function () {
    expect(dataManager.queryNormalizer).toBeDefined();
    var data = dataManager.queryNormalizer.getNormalizedData();
    expect(data).toBeDefined();
    expect(data.objects).toBeDefined();
    expect(data.queries).toBeDefined();
  });
  it('setNormalizedData should update queries', function () {
    expect(dataManager.normalizer).toBeDefined();
    expect(dataManager.queryNormalizer).toBeDefined();
    var queryKey = ['users'];
    dataManager.queryClient.setQueryData(queryKey, [{
      id: '1',
      name: 'Old'
    }]);
    dataManager.normalizer.setQuery(JSON.stringify(queryKey), [{
      id: '1',
      name: 'Old'
    }]);
    dataManager.queryNormalizer.setNormalizedData({
      id: '1',
      name: 'New'
    });
    var data = dataManager.queryClient.getQueryData(queryKey);
    expect(data[0].name).toBe('New');
  });
  it('clear should clear normalized data', function () {
    expect(dataManager.normalizer).toBeDefined();
    expect(dataManager.queryNormalizer).toBeDefined();
    var queryKey = ['users'];
    dataManager.queryClient.setQueryData(queryKey, [{
      id: '1',
      name: 'User'
    }]);
    dataManager.normalizer.setQuery(JSON.stringify(queryKey), [{
      id: '1',
      name: 'User'
    }]);
    dataManager.queryNormalizer.clear();
    var data = dataManager.queryNormalizer.getNormalizedData();
    expect(Object.keys(data.objects)).toHaveLength(0);
  });
  it('getObjectById should return object by ID', function () {
    expect(dataManager.normalizer).toBeDefined();
    expect(dataManager.queryNormalizer).toBeDefined();
    var queryKey = ['users'];
    var userData = [{
      id: '1',
      name: 'User 1'
    }];

    // Add to normalizer
    dataManager.normalizer.setQuery(JSON.stringify(queryKey), userData);

    // Get normalized data
    var normalized = dataManager.queryNormalizer.getNormalizedData();
    expect(Object.keys(normalized.objects).length).toBeGreaterThan(0);

    // getObjectById should be defined and available
    expect(dataManager.queryNormalizer.getObjectById).toBeDefined();
    expect((0, _typeof2.default)(dataManager.queryNormalizer.getObjectById)).toBe('function');
  });
  it('getDependentQueries should return dependent queries', function () {
    expect(dataManager.normalizer).toBeDefined();
    expect(dataManager.queryNormalizer).toBeDefined();
    var queryKey1 = ['users'];
    var queryKey2 = ['user', '1'];
    dataManager.queryClient.setQueryData(queryKey1, [{
      id: '1',
      name: 'User'
    }]);
    dataManager.queryClient.setQueryData(queryKey2, {
      id: '1',
      name: 'User'
    });
    dataManager.normalizer.setQuery(JSON.stringify(queryKey1), [{
      id: '1',
      name: 'User'
    }]);
    dataManager.normalizer.setQuery(JSON.stringify(queryKey2), {
      id: '1',
      name: 'User'
    });
    var dependentQueries = dataManager.queryNormalizer.getDependentQueries({
      id: '1',
      name: 'Updated'
    });
    expect(dependentQueries.length).toBeGreaterThan(0);
  });
  it('getDependentQueriesByIds should be available', function () {
    expect(dataManager.queryNormalizer).toBeDefined();

    // getDependentQueriesByIds should be defined and available
    expect(dataManager.queryNormalizer.getDependentQueriesByIds).toBeDefined();
    expect((0, _typeof2.default)(dataManager.queryNormalizer.getDependentQueriesByIds)).toBe('function');

    // Call with empty array should not throw
    var result = dataManager.queryNormalizer.getDependentQueriesByIds([]);
    expect(Array.isArray(result)).toBe(true);
  });
  it('should not create queryNormalizer when normalizerConfig is false', function () {
    var dmWithoutNormalizer = new _ClientDataManager.ClientDataManager({
      normalizerConfig: false
    });
    expect(dmWithoutNormalizer.normalizer).toBeUndefined();
    expect(dmWithoutNormalizer.queryNormalizer).toBeUndefined();
  });
  it('should not create queryNormalizer when normalizerConfig is undefined', function () {
    var dmWithoutNormalizer = new _ClientDataManager.ClientDataManager({});
    expect(dmWithoutNormalizer.normalizer).toBeUndefined();
    expect(dmWithoutNormalizer.queryNormalizer).toBeUndefined();
  });
  it('should create queryNormalizer when normalizerConfig is true', function () {
    var dmWithNormalizer = new _ClientDataManager.ClientDataManager({
      normalizerConfig: true
    });
    expect(dmWithNormalizer.normalizer).toBeDefined();
    expect(dmWithNormalizer.queryNormalizer).toBeDefined();
  });
  it('should work correctly with optimisticUpdate via setNormalizedData', function () {
    expect(dataManager.normalizer).toBeDefined();
    expect(dataManager.queryNormalizer).toBeDefined();
    var queryKey = ['users'];
    var initialData = [{
      id: '1',
      name: 'Old Name'
    }];
    dataManager.queryClient.setQueryData(queryKey, initialData);
    dataManager.normalizer.setQuery(JSON.stringify(queryKey), initialData);
    var mutationData = {
      id: '1',
      name: 'New Name'
    };
    dataManager.queryNormalizer.setNormalizedData(mutationData);
    var updatedData = dataManager.queryClient.getQueryData(queryKey);
    expect(updatedData[0].name).toBe('New Name');
  });
});
// #sourceMappingURL=createQueryNormalizer.test.js.map