import QueryRange from '../../src/flux/models/query-range';

describe('QueryRange', function QueryRangeSpecs() {
  describe('@infinite', () =>
    it('should return a query range with a null limit and offset', () => {
      const infinite = QueryRange.infinite();
      expect(infinite.limit).toBe(null);
      expect(infinite.offset).toBe(null);
    }));

  describe('@rangesBySubtracting', () => {
    it('should throw an exception if either range is infinite', () => {
      const infinite = QueryRange.infinite();

      expect(() =>
        QueryRange.rangesBySubtracting(infinite, new QueryRange({ offset: 0, limit: 10 }))
      ).toThrow();

      expect(() =>
        QueryRange.rangesBySubtracting(new QueryRange({ offset: 0, limit: 10 }), infinite)
      ).toThrow();
    });

    it('should return one or more ranges created by punching the provided range', () => {
      const test = ({ a, b, result }) =>
        expect(QueryRange.rangesBySubtracting(a, b)).toEqual(result);
      test({
        a: new QueryRange({ offset: 0, limit: 10 }),
        b: new QueryRange({ offset: 3, limit: 3 }),
        result: [new QueryRange({ offset: 0, limit: 3 }), new QueryRange({ offset: 6, limit: 4 })],
      });

      test({
        a: new QueryRange({ offset: 0, limit: 10 }),
        b: new QueryRange({ offset: 3, limit: 10 }),
        result: [new QueryRange({ offset: 0, limit: 3 })],
      });

      test({
        a: new QueryRange({ offset: 0, limit: 10 }),
        b: new QueryRange({ offset: 0, limit: 10 }),
        result: [],
      });

      test({
        a: new QueryRange({ offset: 5, limit: 10 }),
        b: new QueryRange({ offset: 0, limit: 4 }),
        result: [new QueryRange({ offset: 5, limit: 10 })],
      });

      test({
        a: new QueryRange({ offset: 5, limit: 10 }),
        b: new QueryRange({ offset: 0, limit: 8 }),
        result: [new QueryRange({ offset: 8, limit: 7 })],
      });
    });
  });

  describe('isInfinite', () =>
    it('should return true for an infinite range, false otherwise', () => {
      const infinite = QueryRange.infinite();
      expect(infinite.isInfinite()).toBe(true);
      expect(new QueryRange({ offset: 0, limit: 4 }).isInfinite()).toBe(false);
    }));

  describe('start', () =>
    it('should be an alias for offset', () =>
      expect(new QueryRange({ offset: 3, limit: 4 }).start).toBe(3)));

  describe('end', () =>
    it('should be offset + limit', () =>
      expect(new QueryRange({ offset: 3, limit: 4 }).end).toBe(7)));

  describe('isContiguousWith', () => {
    it('should return true if either range is infinite', () => {
      const a = new QueryRange({ offset: 3, limit: 4 });
      expect(a.isContiguousWith(QueryRange.infinite())).toBe(true);
      expect(QueryRange.infinite().isContiguousWith(a)).toBe(true);
    });

    it('should return true if the ranges intersect or touch, false otherwise', () => {
      const a = new QueryRange({ offset: 3, limit: 4 });
      const b = new QueryRange({ offset: 0, limit: 2 });
      const c = new QueryRange({ offset: 0, limit: 3 });
      const d = new QueryRange({ offset: 7, limit: 10 });
      const e = new QueryRange({ offset: 8, limit: 10 });

      // True

      expect(a.isContiguousWith(d)).toBe(true);
      expect(d.isContiguousWith(a)).toBe(true);

      expect(a.isContiguousWith(c)).toBe(true);
      expect(c.isContiguousWith(a)).toBe(true);

      // False

      expect(a.isContiguousWith(b)).toBe(false);
      expect(b.isContiguousWith(a)).toBe(false);

      expect(a.isContiguousWith(e)).toBe(false);
      expect(e.isContiguousWith(a)).toBe(false);

      expect(b.isContiguousWith(e)).toBe(false);
      expect(e.isContiguousWith(b)).toBe(false);
    });
  });
});