kami-parse-server/spec/graphQLObjectsQueries.js

const { offsetToCursor } = require('graphql-relay');
const {
  calculateSkipAndLimit,
} = require('../lib/GraphQL/helpers/objectsQueries');

describe('GraphQL objectsQueries', () => {
  describe('calculateSkipAndLimit', () => {
    it('should fail with invalid params', () => {
      expect(() => calculateSkipAndLimit(-1)).toThrow(
        jasmine.stringMatching('Skip should be a positive number')
      );
      expect(() => calculateSkipAndLimit(1, -1)).toThrow(
        jasmine.stringMatching('First should be a positive number')
      );
      expect(() => calculateSkipAndLimit(1, 1, offsetToCursor(-1))).toThrow(
        jasmine.stringMatching('After is not a valid curso')
      );
      expect(() => calculateSkipAndLimit(1, 1, offsetToCursor(1), -1)).toThrow(
        jasmine.stringMatching('Last should be a positive number')
      );
      expect(() =>
        calculateSkipAndLimit(1, 1, offsetToCursor(1), 1, offsetToCursor(-1))
      ).toThrow(jasmine.stringMatching('Before is not a valid curso'));
    });

    it('should work only with skip', () => {
      expect(calculateSkipAndLimit(10)).toEqual({
        skip: 10,
        limit: undefined,
        needToPreCount: false,
      });
    });

    it('should work only with after', () => {
      expect(
        calculateSkipAndLimit(undefined, undefined, offsetToCursor(9))
      ).toEqual({
        skip: 10,
        limit: undefined,
        needToPreCount: false,
      });
    });

    it('should work with limit and after', () => {
      expect(calculateSkipAndLimit(10, undefined, offsetToCursor(9))).toEqual({
        skip: 20,
        limit: undefined,
        needToPreCount: false,
      });
    });

    it('first alone should set the limit', () => {
      expect(calculateSkipAndLimit(10, 30, offsetToCursor(9))).toEqual({
        skip: 20,
        limit: 30,
        needToPreCount: false,
      });
    });

    it('if before cursor is less than skipped items, no objects will be returned', () => {
      expect(
        calculateSkipAndLimit(
          10,
          30,
          offsetToCursor(9),
          undefined,
          offsetToCursor(5)
        )
      ).toEqual({
        skip: 20,
        limit: 0,
        needToPreCount: false,
      });
    });

    it('if before cursor is greater than returned objects set by limit, nothing is changed', () => {
      expect(
        calculateSkipAndLimit(
          10,
          30,
          offsetToCursor(9),
          undefined,
          offsetToCursor(100)
        )
      ).toEqual({
        skip: 20,
        limit: 30,
        needToPreCount: false,
      });
    });

    it('if before cursor is less than returned objects set by limit, limit is adjusted', () => {
      expect(
        calculateSkipAndLimit(
          10,
          30,
          offsetToCursor(9),
          undefined,
          offsetToCursor(40)
        )
      ).toEqual({
        skip: 20,
        limit: 20,
        needToPreCount: false,
      });
    });

    it('last should work alone but requires pre count', () => {
      expect(
        calculateSkipAndLimit(undefined, undefined, undefined, 10)
      ).toEqual({
        skip: undefined,
        limit: 10,
        needToPreCount: true,
      });
    });

    it('last should be adjusted to max limit', () => {
      expect(
        calculateSkipAndLimit(undefined, undefined, undefined, 10, undefined, 5)
      ).toEqual({
        skip: undefined,
        limit: 5,
        needToPreCount: true,
      });
    });

    it('no objects will be returned if last is equal to 0', () => {
      expect(calculateSkipAndLimit(undefined, undefined, undefined, 0)).toEqual(
        {
          skip: undefined,
          limit: 0,
          needToPreCount: false,
        }
      );
    });

    it('nothing changes if last is bigger than the calculared limit', () => {
      expect(
        calculateSkipAndLimit(10, 30, offsetToCursor(9), 30, offsetToCursor(40))
      ).toEqual({
        skip: 20,
        limit: 20,
        needToPreCount: false,
      });
    });

    it('If last is small than limit, new limit is calculated', () => {
      expect(
        calculateSkipAndLimit(10, 30, offsetToCursor(9), 10, offsetToCursor(40))
      ).toEqual({
        skip: 30,
        limit: 10,
        needToPreCount: false,
      });
    });
  });
});