vue-select/tests/unit/ReactiveOptions.spec.js

import { mount, shallowMount } from '@vue/test-utils'
import VueSelect from '../../src/components/Select'
import { mountDefault } from '../helpers'

describe('Reset on options change', () => {
  it('should not reset the selected value by default when the options property changes', () => {
    const Select = shallowMount(VueSelect, {
      propsData: { options: ['one'] },
    })

    Select.vm.$data._value = 'one'

    Select.setProps({ options: ['four', 'five', 'six'] })
    expect(Select.vm.selectedValue).toEqual(['one'])
  })

  describe('resetOnOptionsChange as a function', () => {
    it('will yell at you if resetOnOptionsChange is not a function or boolean', () => {
      const spy = jest.spyOn(console, 'error').mockImplementation(() => {})

      mountDefault({ resetOnOptionsChange: 1 })
      expect(spy.mock.calls[0][0]).toContain(
        'Invalid prop: custom validator check failed for prop "resetOnOptionsChange"'
      )

      mountDefault({ resetOnOptionsChange: 'one' })
      expect(spy.mock.calls[1][0]).toContain(
        'Invalid prop: custom validator check failed for prop "resetOnOptionsChange"'
      )

      mountDefault({ resetOnOptionsChange: [] })
      expect(spy.mock.calls[2][0]).toContain(
        'Invalid prop: custom validator check failed for prop "resetOnOptionsChange"'
      )

      mountDefault({ resetOnOptionsChange: {} })
      expect(spy.mock.calls[3][0]).toContain(
        'Invalid prop: custom validator check failed for prop "resetOnOptionsChange"'
      )
    })

    it('should receive the new options, old options, and current value', async () => {
      let resetOnOptionsChange = jest.fn((option) => option)
      const Select = mountDefault({
        resetOnOptionsChange,
        options: ['bear'],
        value: 'selected',
      })

      Select.setProps({ options: ['lake', 'kite'] })
      await Select.vm.$nextTick()

      expect(resetOnOptionsChange).toHaveBeenCalledTimes(1)
      expect(resetOnOptionsChange).toHaveBeenCalledWith(
        ['lake', 'kite'],
        ['bear'],
        ['selected']
      )
    })

    it('should allow resetOnOptionsChange to be a function that returns true', async () => {
      let resetOnOptionsChange = () => true
      const Select = shallowMount(VueSelect, {
        propsData: { resetOnOptionsChange, options: ['one'], value: 'one' },
      })
      const spy = jest.spyOn(Select.vm, 'clearSelection')

      Select.setProps({ options: ['one', 'two'] })
      await Select.vm.$nextTick()

      expect(spy).toHaveBeenCalledTimes(1)
    })

    it('should allow resetOnOptionsChange to be a function that returns false', () => {
      let resetOnOptionsChange = () => false
      const Select = shallowMount(VueSelect, {
        propsData: { resetOnOptionsChange, options: ['one'], value: 'one' },
      })
      const spy = jest.spyOn(Select.vm, 'clearSelection')

      Select.setProps({ options: ['one', 'two'] })
      expect(spy).not.toHaveBeenCalled()
    })

    it('should reset the options if the selectedValue does not exist in the new options', async () => {
      let resetOnOptionsChange = (options, old, val) =>
        val.some((val) => options.includes(val))
      const Select = shallowMount(VueSelect, {
        propsData: { resetOnOptionsChange, options: ['one'], value: 'one' },
      })
      const spy = jest.spyOn(Select.vm, 'clearSelection')

      Select.setProps({ options: ['one', 'two'] })
      await Select.vm.$nextTick()

      expect(Select.vm.selectedValue).toEqual(['one'])

      Select.setProps({ options: ['two'] })
      await Select.vm.$nextTick()

      expect(spy).toHaveBeenCalledTimes(1)
    })
  })

  it('should reset the selected value when the options property changes', async () => {
    const Select = shallowMount(VueSelect, {
      propsData: { resetOnOptionsChange: true, options: ['one'] },
    })

    Select.vm.$data._value = 'one'

    Select.setProps({ options: ['four', 'five', 'six'] })
    await Select.vm.$nextTick()

    expect(Select.vm.selectedValue).toEqual([])
  })

  it('should return correct selected value when the options property changes and a new option matches', async () => {
    const Select = shallowMount(VueSelect, {
      propsData: {
        value: 'one',
        options: [],
        reduce(option) {
          return option.value
        },
      },
    })

    Select.setProps({ options: [{ label: 'oneLabel', value: 'one' }] })
    await Select.vm.$nextTick()

    expect(Select.vm.selectedValue).toEqual([
      { label: 'oneLabel', value: 'one' },
    ])
  })

  it('clearSearchOnBlur returns false when multiple is true', () => {
    const Select = mountDefault({})
    let clearSearchOnBlur = jest.spyOn(Select.vm, 'clearSearchOnBlur')
    Select.find({ ref: 'search' }).trigger('click')
    Select.setData({ search: 'one' })
    Select.find({ ref: 'search' }).trigger('blur')

    expect(clearSearchOnBlur).toHaveBeenCalledTimes(1)
    expect(clearSearchOnBlur).toHaveBeenCalledWith({
      clearSearchOnSelect: true,
      multiple: false,
    })
    expect(Select.vm.search).toBe('')
  })

  it('clearSearchOnBlur accepts a function', () => {
    let clearSearchOnBlur = jest.fn(() => false)
    const Select = mountDefault({ clearSearchOnBlur })

    Select.find({ ref: 'search' }).trigger('click')
    Select.setData({ search: 'one' })
    Select.find({ ref: 'search' }).trigger('blur')

    expect(clearSearchOnBlur).toHaveBeenCalledTimes(1)
    expect(Select.vm.search).toBe('one')
  })
})