QueryRange = require('../../src/flux/models/query-range').default

describe "QueryRange", ->
  describe "@infinite", ->
    it "should return a query range with a null limit and offset", ->
      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", ->
      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", ->
      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", ->
      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", ->
      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", ->
      a = new QueryRange(offset:3, limit:4)
      b = new QueryRange(offset:0, limit:2)
      c = new QueryRange(offset:0, limit:3)
      d = new QueryRange(offset:7, limit:10)
      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)