mir-client/__tests__/get.test.js

A Mir API Client

import axios from 'axios'
import MockAdapter from 'axios-mock-adapter'

import get from '../src/get'

const mockAx = axios.create()
const mock = new MockAdapter(mockAx)

/*
A note on the mocks--on certain tests that involve two sends, the mocks have been reset before the second send,
which is not actually necessary to the passing of the test, but has been done anyway to avoid potential confusion for
when logging out the full result of a promise from a mocked adapter might result in a response that appears incorrect (i.e. a mock returning page 1 has been set, but then next() is called--the test for next sets the factory object to page 2, which is what's being tested, but the mock will still return an object with page 1 until reset).
*/

test('GET', () => {
  mock.onGet(/\/.*/).reply(200, {
    _items: [{
      test: true
    }],
    _meta: {
      max_results: 25,
      page: 1,
      total: 0
    },
  })

  const getter = get(mockAx, 'resource')
  return getter().send().then((result) => {
    // ensure that our request hasn't been mangled by the
    // getter functions
    expect(result.data._items).toEqual([{
      test: true
    }])
    expect(result.data._meta).toEqual({
      max_results: 25,
      page: 1,
      total: 0
    })
  })
})

test('GET functions alter params object', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter().projection('name', true)

  expect(gt).toEqual(expect.objectContaining({
    params: {
      projection: {
        name: 1
      }
    }
  }))
})

test('GET has params, headers, and complete function set', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter()

  expect(gt).toEqual(expect.objectContaining({
    params: expect.any(Object),
    headers: expect.any(Object),
    meta: expect.any(Object),
    projection: expect.any(Function),
    sort: expect.any(Function),
    filter: expect.any(Function),
    page: expect.any(Function),
    limit: expect.any(Function),
    next: expect.any(Function),
    previous: expect.any(Function),
    first: expect.any(Function),
    last: expect.any(Function),
    send: expect.any(Function)
  }))
})

test('GET correctly parses chaining of multiple functions', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter().projection('name', true).sort('name', '-')

  expect(gt.params).toEqual({
    projection: {
      name: 1
    },
    sort: '-name'
  })
})

test('GET sets meta object on send', () => {
  mock.onGet(/\/.*/).reply(200, {
    _items: [{
      test: true
    }],
    _meta: {
      max_results: 25,
      page: 1,
      total: 0
    }
  })

  const getter = get(mockAx, 'resource')
  var gt = getter()

  return gt.send().then(() => {
    expect(gt).toEqual(expect.objectContaining({
      meta: {
        max_results: 25,
        page: 1,
        total: 0
      }
    }))
  })
})

test('GET sets page on send result if page is not set', () => {
  mock.onGet(/\/.*/).reply(200, {
    _items: [{
      test: true
    }],
    _meta: {
      max_results: 25,
      page: 1,
      total: 0
    }
  })

  const getter = get(mockAx, 'resource')
  var gt = getter()

  return gt.send().then(() => {
    expect(gt.params.page).toEqual(1)
  })
})

test('GET projection function', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter().projection('name', false)

  expect(gt.params.projection).toEqual({
    name: 0
  })
})

test('GET projection throws with invalid bool value', () => {
  const getter = get(mockAx, 'resource')
  expect(() => getter().projection('name', 'no')).toThrow()
})

test('GET sort function', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter().sort('name', '-')

  expect(gt.params.sort).toEqual('-name')
})

test('GET sort function throws error if value param other than + or - is passed', () => {
  const getter = get(mockAx, 'resource')
  expect(() => getter().sort('name', 'asc')).toThrow()
})

test('GET filter function one attribute', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter().filter({max_price: {$gt: 5}})

  expect(gt.params.where).toEqual({
    max_price: {
      $gt: 5
    }
  })
})

test('GET filter complex filter', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter().filter({$or: [{unit_of_measure:"gal"}, {unit_of_measure:"pt"}]})

  expect(gt.params.where).toEqual({
    $or: [
      {unit_of_measure: "gal"},
      {unit_of_measure: "pt"}
    ]
  })
})

test('GET filter throws error with non-object parameter', () => {
  const getter = get(mockAx, 'resource')
  expect(() => getter().filter('not an object')).toThrow()
})

test('GET page function', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter().page(3)

  expect(gt.params.page).toEqual(3)
})

test('GET limit function', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter().limit(25)

  expect(gt.params.max_results).toEqual(25)
})

test('GET next function increments page number', () => {
  mock.onGet(/\/.*/).reply(200, {
    _items: [{
      test: true
    }],
    _meta: {
      max_results: 25,
      page: 1,
      total: 50
    }
  })

  const getter = get(mockAx, 'resource')
  var gt = getter()

  return gt.page(1).send().then(() => { // simulate get first page, then call next()
    mock.onGet(/\/.*/).reply(200, {
      _items: [{
        test: true
      }],
      _meta: {
        max_results: 25,
        page: 2,
        total: 50
      }
    })
    return gt.next().then((result) => {
      expect(result.config.params.page).toEqual(2)
    })
  })
})

test('GET next function throws error for next on zero results', () => {
  mock.onGet(/\/.*/).reply(200, {
    _items: [{
      test: true
    }],
    _meta: {
      max_results: 25,
      page: 1,
      total: 0
    }
  })

  const getter = get(mockAx, 'resource')
  var gt = getter()

  return gt.send().then(() => {
    expect(() => gt.next().toThrow())
  })
})

test('GET next function returns error for next on last page', () => {
  mock.onGet(/\/.*/).reply(200, {
    _items: [{
      test: true
    }],
    _meta: {
      max_results: 25,
      page: 2,
      total: 49
    }
  })

  const getter = get(mockAx, 'resource')
  var gt = getter()

  return gt.send().then(() => {
    expect(() => gt.next()).toThrow()
  })
})

test('GET next function throws error with no preceding request', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter()

  expect(() => gt.next()).toThrow()
})

test('GET previous function decrements page number', () => {
  mock.onGet(/\/.*/).reply(200, {
    _items: [{
      test: true
    }],
    _meta: {
      max_results: 25,
      page: 2,
      total: 50
    }
  })

  const getter = get(mockAx, 'resource')
  var gt = getter()

  return gt.page(2).send().then(() => { // simulate get second page, then call previous()
    mock.onGet(/\/.*/).reply(200, {
      _items: [{
        test: true
      }],
      _meta: {
        max_results: 25,
        page: 1,
        total: 50
      }
    })
    return gt.previous().then((result) => {
      expect(result.config.params.page).toEqual(1)
    })
  })
})

test('GET previous function on first page throws error', () => {
  mock.onGet(/\/.*/).reply(200, {
    _items: [{
      test: true
    }],
    _meta: {
      max_results: 25,
      page: 1,
      total: 0
    }
  })

  const getter = get(mockAx, 'resource')
  var gt = getter()

  return gt.page(1).send().then(() => {
    expect(() => gt.previous()).toThrow()
  })
})

test('GET previous function throws error with no preceding request', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter()

  expect(() => gt.previous()).toThrow()
})

test('GET first function returns the first page', () => {
  mock.onGet(/\/.*/).reply(200, {
    _items: [{
      test: true
    }],
    _meta: {
      max_results: 25,
      page: 3,
      total: 75
    }
  })

  const getter = get(mockAx, 'resource')
  var gt = getter()

  return gt.page(3).send().then(() => {
    mock.onGet(/\/.*/).reply(200, {
      _items: [{
        test: true
      }],
      _meta: {
        max_results: 25,
        page: 1,
        total: 75
      }
    })
    return gt.first().then((result) => {
      expect(result.config.params.page).toEqual(1)
    })
  })
})

test('GET first function throws error with no preceding request', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter()

  expect(() => gt.first()).toThrow()
})

test('GET last function returns the last page', () => {
  mock.onGet(/\/.*/).reply(200, {
    _items: [{
      test: true
    }],
    _meta: {
      max_results: 25,
      page: 1,
      total: 74
    }
  })

  const getter = get(mockAx, 'resource')
  var gt = getter()

  return gt.page(1).send().then(() => {
    mock.onGet(/\/.*/).reply(200, {
      _items: [{
        test: true
      }],
      _meta: {
        max_results: 25,
        page: 3,
        total: 74
      }
    })
    return gt.last().then((result) => {
      expect(result.config.params.page).toEqual(3)
    })
  })
})

test('GET last function throws error with no preceding request', () => {
  const getter = get(mockAx, 'resource')
  var gt = getter()

  expect(() => gt.last()).toThrow()
})