@gitlab/duo-ui 0.1.0 → 0.3.0

package/src/vendor/bootstrap-vue/src/components/form-input/form-input.spec.js

@@ -0,0 +1,986 @@
+import Vue from 'vue'
+import { mount } from '@vue/test-utils'
+import { waitNT, waitRAF } from '../../../tests/utils'
+import { BFormInput } from './form-input'
+
+describe('form-input', () => {
+  it('has class form-control', async () => {
+    const wrapper = mount(BFormInput)
+
+    const $input = wrapper.find('input')
+    expect($input.classes()).toContain('form-control')
+
+    wrapper.destroy()
+  })
+
+  it('has class form-control-lg when size=lg and plane=false', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        size: 'lg'
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.classes()).toContain('form-control-lg')
+
+    wrapper.destroy()
+  })
+
+  it('has class form-control-sm when size=lg and plain=false', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        size: 'sm'
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.classes()).toContain('form-control-sm')
+
+    wrapper.destroy()
+  })
+
+  it('does not have class form-control-plaintext when plaintext not set', async () => {
+    const wrapper = mount(BFormInput)
+
+    const $input = wrapper.find('input')
+    expect($input.classes()).not.toContain('form-control-plaintext')
+    expect($input.attributes('readonly')).toBeUndefined()
+
+    wrapper.destroy()
+  })
+
+  it('has class form-control-plaintext when plaintext=true', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        plaintext: true
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.classes()).toContain('form-control-plaintext')
+
+    wrapper.destroy()
+  })
+
+  it('has attribute read-only when plaintext=true', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        plaintext: true
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.classes()).toContain('form-control-plaintext')
+    expect($input.attributes('readonly')).toBeDefined()
+
+    wrapper.destroy()
+  })
+
+  it('has class custom-range instead of form-control when type=range', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        type: 'range'
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.classes()).toContain('custom-range')
+    expect($input.classes()).not.toContain('form-control')
+
+    wrapper.destroy()
+  })
+
+  it('does not have class form-control-plaintext when type=range and plaintext=true', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        type: 'range',
+        plaintext: true
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.classes()).toContain('custom-range')
+    expect($input.classes()).not.toContain('form-control')
+    expect($input.classes()).not.toContain('form-control-plaintext')
+
+    wrapper.destroy()
+  })
+
+  it('does not have class form-control-plaintext when type=color and plaintext=true', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        type: 'color',
+        plaintext: true
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.classes()).not.toContain('custom-range')
+    expect($input.classes()).not.toContain('form-control-plaintext')
+    expect($input.classes()).toContain('form-control')
+
+    wrapper.destroy()
+  })
+
+  it('has user supplied id', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        id: 'foobar'
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('id')).toBe('foobar')
+
+    wrapper.destroy()
+  })
+
+  it('has safeId after mount when no id provided', async () => {
+    const wrapper = mount(BFormInput, {
+      attachTo: document.body
+    })
+
+    // We need to wait a tick for `safeId` to be generated
+    await waitNT(wrapper.vm)
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('id')).toBeDefined()
+
+    wrapper.destroy()
+  })
+
+  it('has form attribute when form prop set', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        form: 'foobar'
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('form')).toBe('foobar')
+
+    wrapper.destroy()
+  })
+
+  it('does not have list attribute when list prop not set', async () => {
+    const wrapper = mount(BFormInput)
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('list')).toBeUndefined()
+
+    wrapper.destroy()
+  })
+
+  it('has list attribute when list prop set', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        list: 'foobar'
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('list')).toBe('foobar')
+
+    wrapper.destroy()
+  })
+
+  it('does not have list attribute when list prop set and type=password', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        list: 'foobar',
+        type: 'password'
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('list')).toBeUndefined()
+
+    wrapper.destroy()
+  })
+
+  it('renders text input by default', async () => {
+    const wrapper = mount(BFormInput)
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('type')).toBe('text')
+
+    wrapper.destroy()
+  })
+
+  it('renders number input when type set to number', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        type: 'number'
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('type')).toBe('number')
+
+    wrapper.destroy()
+  })
+
+  it('renders text input when type not supported', async () => {
+    const { warnHandler } = Vue.config
+    Vue.config.warnHandler = jest.fn()
+
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        type: 'foobar'
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('type')).toBe('text')
+
+    expect(Vue.config.warnHandler).toHaveBeenCalled()
+    Vue.config.warnHandler = warnHandler
+
+    wrapper.destroy()
+  })
+
+  it('does not have is-valid or is-invalid classes when state is default', async () => {
+    const wrapper = mount(BFormInput)
+
+    const $input = wrapper.find('input')
+    expect($input.classes()).not.toContain('is-valid')
+    expect($input.classes()).not.toContain('is-invalid')
+
+    wrapper.destroy()
+  })
+
+  it('has class is-valid when state=true', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        state: true
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.classes()).toContain('is-valid')
+    expect($input.classes()).not.toContain('is-invalid')
+
+    wrapper.destroy()
+  })
+
+  it('has class is-invalid when state=false', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        state: false
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.classes()).toContain('is-invalid')
+    expect($input.classes()).not.toContain('is-valid')
+
+    wrapper.destroy()
+  })
+
+  it('does not have aria-invalid attribute by default', async () => {
+    const wrapper = mount(BFormInput)
+
+    expect(wrapper.attributes('aria-invalid')).toBeUndefined()
+
+    wrapper.destroy()
+  })
+
+  it('does not have aria-invalid attribute when state is true', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        state: true
+      }
+    })
+
+    expect(wrapper.attributes('aria-invalid')).toBeUndefined()
+
+    wrapper.destroy()
+  })
+
+  it('has aria-invalid attribute when state=false', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        state: false
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('aria-invalid')).toBe('true')
+
+    wrapper.destroy()
+  })
+
+  it('has aria-invalid attribute when aria-invalid="true"', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        ariaInvalid: 'true'
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('aria-invalid')).toBe('true')
+
+    wrapper.destroy()
+  })
+
+  it('has aria-invalid attribute when aria-invalid=true', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        ariaInvalid: true
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('aria-invalid')).toBe('true')
+
+    wrapper.destroy()
+  })
+
+  it('has aria-invalid attribute when aria-invalid="spelling"', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        ariaInvalid: 'spelling'
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.attributes('aria-invalid')).toBe('spelling')
+
+    wrapper.destroy()
+  })
+
+  it('is disabled when disabled=true', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        disabled: true
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect(!!$input.attributes('disabled')).toBe(true)
+    expect($input.element.disabled).toBe(true)
+
+    wrapper.destroy()
+  })
+
+  it('is not disabled when disabled=false', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        disabled: false
+      }
+    })
+
+    const $input = wrapper.find('input')
+    expect(!!$input.attributes('disabled')).toBe(false)
+    expect($input.element.disabled).toBe(false)
+
+    wrapper.destroy()
+  })
+
+  it('emits an input event', async () => {
+    const wrapper = mount(BFormInput)
+
+    const $input = wrapper.find('input')
+    $input.element.value = 'test'
+    await $input.trigger('input')
+
+    expect(wrapper.emitted('input')).toBeDefined()
+    expect(wrapper.emitted().input[0].length).toEqual(1)
+    expect(wrapper.emitted().input[0][0]).toEqual('test')
+
+    wrapper.destroy()
+  })
+
+  it('emits a native focus event', async () => {
+    const spy = jest.fn()
+    const wrapper = mount(BFormInput, {
+      attachTo: document.body,
+      listeners: {
+        focus: spy
+      }
+    })
+
+    const $input = wrapper.find('input')
+
+    await $input.trigger('focus')
+    expect(wrapper.emitted()).toMatchObject({})
+    expect(spy).toHaveBeenCalled()
+
+    wrapper.destroy()
+  })
+
+  it('emits a blur event with native event as only arg', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        value: 'TEST'
+      }
+    })
+
+    const $input = wrapper.find('input')
+    await $input.trigger('blur')
+
+    expect(wrapper.emitted('blur')).toBeDefined()
+    expect(wrapper.emitted('blur')[0].length).toEqual(1)
+    expect(wrapper.emitted('blur')[0][0] instanceof Event).toBe(true)
+    expect(wrapper.emitted('blur')[0][0].type).toEqual('blur')
+
+    wrapper.destroy()
+  })
+
+  it('applies formatter on input when not lazy', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        formatter(value) {
+          return value.toLowerCase()
+        }
+      },
+      attachTo: document.body
+    })
+
+    const $input = wrapper.find('input')
+    $input.element.value = 'TEST'
+    await $input.trigger('input')
+
+    expect(wrapper.emitted('update')).toBeDefined()
+    expect(wrapper.emitted('update').length).toEqual(1)
+    expect(wrapper.emitted('update')[0][0]).toEqual('test')
+
+    expect(wrapper.emitted('input')).toBeDefined()
+    expect(wrapper.emitted('input').length).toEqual(1)
+    expect(wrapper.emitted('input')[0][0]).toEqual('test')
+
+    wrapper.destroy()
+  })
+
+  it('does not apply formatter on input when lazy', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        formatter(value) {
+          return value.toLowerCase()
+        },
+        lazyFormatter: true
+      },
+      attachTo: document.body
+    })
+
+    const $input = wrapper.findComponent('input')
+    $input.element.value = 'TEST'
+    await $input.trigger('input')
+
+    expect(wrapper.emitted('update')).toBeDefined()
+    expect(wrapper.emitted('update').length).toEqual(1)
+    expect(wrapper.emitted('update')[0][0]).toEqual('TEST')
+    expect(wrapper.emitted('input')).toBeDefined()
+    expect(wrapper.emitted('input').length).toEqual(1)
+    expect(wrapper.emitted('input')[0][0]).toEqual('TEST')
+    expect(wrapper.emitted('change')).toBeUndefined()
+    expect($input.vm.localValue).toEqual('TEST')
+
+    wrapper.destroy()
+  })
+
+  it('applies formatter on blur when lazy', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        value: '',
+        formatter(value) {
+          return value.toLowerCase()
+        },
+        lazyFormatter: true
+      },
+      attachTo: document.body
+    })
+
+    const $input = wrapper.findComponent('input')
+
+    // Input event needed to set initial value
+    $input.element.value = 'TEST'
+    await $input.trigger('input')
+
+    expect($input.vm.localValue).toEqual('TEST')
+    expect(wrapper.emitted('update')).toBeDefined()
+    expect(wrapper.emitted('update').length).toEqual(1)
+    expect(wrapper.emitted('update')[0][0]).toEqual('TEST')
+
+    await $input.trigger('blur')
+
+    expect(wrapper.emitted('update')).toBeDefined()
+    expect(wrapper.emitted('update').length).toEqual(2)
+    expect(wrapper.emitted('update')[1][0]).toEqual('test')
+    expect(wrapper.emitted('input')).toBeDefined()
+    expect(wrapper.emitted('change')).toBeUndefined()
+    expect(wrapper.emitted('blur')).toBeDefined()
+    expect(wrapper.emitted('blur').length).toEqual(1)
+    expect($input.vm.localValue).toEqual('test')
+
+    wrapper.destroy()
+  })
+
+  it('does not apply formatter when value supplied on mount and not lazy', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        value: 'TEST',
+        formatter(value) {
+          return String(value).toLowerCase()
+        }
+      },
+      attachTo: document.body
+    })
+
+    const $input = wrapper.findComponent('input')
+    expect($input.vm.localValue).toEqual('TEST')
+    expect(wrapper.emitted('update')).toBeUndefined()
+    expect(wrapper.emitted('input')).toBeUndefined()
+    expect(wrapper.emitted('change')).toBeUndefined()
+    expect(wrapper.emitted('blur')).toBeUndefined()
+
+    wrapper.destroy()
+  })
+
+  it('does not apply formatter when value prop updated and not lazy', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        value: '',
+        formatter(value) {
+          return value.toLowerCase()
+        }
+      },
+      attachTo: document.body
+    })
+
+    const $input = wrapper.find('input')
+    await wrapper.setProps({ value: 'TEST' })
+
+    expect($input.element.value).toEqual('TEST')
+    expect(wrapper.emitted('update')).toBeUndefined() // Note emitted as value hasn't changed
+    expect(wrapper.emitted('input')).toBeUndefined()
+    expect(wrapper.emitted('change')).toBeUndefined()
+    expect(wrapper.emitted('blur')).toBeUndefined()
+
+    wrapper.destroy()
+  })
+
+  it('does not apply formatter when value prop updated and lazy', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        value: '',
+        formatter(value) {
+          return value.toLowerCase()
+        },
+        lazyFormatter: true
+      },
+      attachTo: document.body
+    })
+
+    const $input = wrapper.find('input')
+    await wrapper.setProps({ value: 'TEST' })
+
+    expect($input.element.value).toEqual('TEST')
+    expect(wrapper.emitted('update')).toBeUndefined() // Not emitted when value doesnt change
+    expect(wrapper.emitted('input')).toBeUndefined()
+    expect(wrapper.emitted('change')).toBeUndefined()
+    expect(wrapper.emitted('blur')).toBeUndefined()
+
+    wrapper.destroy()
+  })
+
+  it('does not update value when non-lazy formatter returns false', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        value: 'abc',
+        formatter() {
+          return false
+        }
+      },
+      attachTo: document.body
+    })
+
+    const $input = wrapper.find('input')
+    expect($input.exists()).toBe(true)
+
+    await $input.trigger('focus')
+    await $input.setValue('TEST')
+
+    expect(wrapper.emitted('input')).toBeUndefined()
+    expect(wrapper.emitted('update')).toBeUndefined()
+    // v-model should not change
+    expect(wrapper.vm.localValue).toBe('abc')
+    // Value in input should remain the same as entered
+    expect($input.element.value).toEqual('TEST')
+
+    wrapper.destroy()
+  })
+
+  it('focused number input with no-wheel set to true works', async () => {
+    const spy = jest.fn()
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        noWheel: true,
+        type: 'number',
+        value: '123'
+      },
+      listeners: {
+        blur: spy
+      },
+      attachTo: document.body
+    })
+
+    expect(wrapper.element.type).toBe('number')
+    expect(wrapper.props().noWheel).toBe(true)
+
+    wrapper.element.focus()
+    await wrapper.trigger('focus')
+    await wrapper.trigger('wheel', { deltaY: 33.33, deltaX: 0, deltaZ: 0, deltaMode: 0 })
+
+    // `:no-wheel="true"` will fire a blur event on the input when wheel fired
+    expect(spy).toHaveBeenCalled()
+
+    wrapper.destroy()
+  })
+
+  it('focused number input with no-wheel set to false works', async () => {
+    const spy = jest.fn(() => {})
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        noWheel: false,
+        type: 'number',
+        value: '123'
+      },
+      listeners: {
+        blur: spy
+      },
+      attachTo: document.body
+    })
+
+    expect(wrapper.element.type).toBe('number')
+    expect(wrapper.props().noWheel).toBe(false)
+    expect(document.activeElement).not.toBe(wrapper.element)
+
+    wrapper.element.focus()
+    await wrapper.trigger('focus')
+    expect(document.activeElement).toBe(wrapper.element)
+    await wrapper.trigger('wheel', { deltaY: 33.33, deltaX: 0, deltaZ: 0, deltaMode: 0 })
+
+    // `:no-wheel="false"` will not fire a blur event on the input when wheel fired
+    expect(spy).not.toHaveBeenCalled()
+
+    wrapper.destroy()
+  })
+
+  it('changing no-wheel after mount works', async () => {
+    const spy = jest.fn(() => {})
+    const wrapper = mount(BFormInput, {
+      attachTo: document.body,
+      propsData: {
+        noWheel: false,
+        type: 'number',
+        value: '123'
+      },
+      listeners: {
+        blur: spy
+      }
+    })
+
+    expect(wrapper.element.type).toBe('number')
+    expect(wrapper.props().noWheel).toBe(false)
+    expect(document.activeElement).not.toBe(wrapper.element)
+
+    wrapper.element.focus()
+    await wrapper.trigger('focus')
+    expect(document.activeElement).toBe(wrapper.element)
+    await wrapper.trigger('wheel', { deltaY: 33.33, deltaX: 0, deltaZ: 0, deltaMode: 0 })
+
+    // no-wheel=false will not fire a blur event on the input when wheel fired
+    expect(spy).not.toHaveBeenCalled()
+
+    await wrapper.setProps({ noWheel: true })
+    expect(wrapper.props().noWheel).toBe(true)
+
+    wrapper.element.focus()
+    await wrapper.trigger('focus')
+    expect(document.activeElement).toBe(wrapper.element)
+
+    // `no-wheel="true"` will fire a blur event on the input when wheel fired
+    wrapper.element.blur()
+    await wrapper.trigger('wheel', { deltaY: 33.33, deltaX: 0, deltaZ: 0, deltaMode: 0 })
+    expect(document.activeElement).not.toBe(wrapper.element)
+    expect(spy).toHaveBeenCalled()
+
+    wrapper.destroy()
+  })
+
+  it('"number" modifier prop works', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        type: 'text',
+        number: true
+      }
+    })
+
+    const $input = wrapper.find('input')
+    $input.element.value = '123.450'
+    await $input.trigger('input')
+
+    expect($input.element.value).toBe('123.450')
+    // `v-model` update event (should emit a numerical value)
+    expect(wrapper.emitted('update')).toBeDefined()
+    expect(wrapper.emitted('update').length).toBe(1)
+    expect(wrapper.emitted('update')[0].length).toEqual(1)
+    expect(wrapper.emitted('update')[0][0]).toBeCloseTo(123.45)
+    // Pre converted value as string (raw input value)
+    expect(wrapper.emitted('input')).toBeDefined()
+    expect(wrapper.emitted('input').length).toBe(1)
+    expect(wrapper.emitted('input')[0].length).toEqual(1)
+    expect(wrapper.emitted('input')[0][0]).toEqual('123.450')
+
+    // Update the input to be different string-wise, but same numerically
+    $input.element.value = '123.4500'
+    await $input.trigger('input')
+
+    expect($input.element.value).toBe('123.4500')
+    // Should emit a new input event
+    expect(wrapper.emitted('input').length).toEqual(2)
+    expect(wrapper.emitted('input')[1][0]).toEqual('123.4500')
+    // `v-model` value stays the same and update event shouldn't be emitted again
+    expect(wrapper.emitted('update').length).toBe(1)
+    expect(wrapper.emitted('update')[0][0]).toBeCloseTo(123.45)
+
+    // Updating the `v-model` to new numeric value
+    await wrapper.setProps({ value: 45.6 })
+    expect($input.element.value).toBe('45.6')
+
+    wrapper.destroy()
+  })
+
+  it('"lazy" modifier prop works', async () => {
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        type: 'text',
+        lazy: true
+      }
+    })
+
+    const $input = wrapper.find('input')
+    $input.element.value = 'a'
+    await $input.trigger('input')
+    expect($input.element.value).toBe('a')
+    // `v-model` update event should not have emitted
+    expect(wrapper.emitted('update')).toBeUndefined()
+
+    $input.element.value = 'ab'
+    await $input.trigger('input')
+    expect($input.element.value).toBe('ab')
+    // `v-model` update event should not have emitted
+    expect(wrapper.emitted('update')).toBeUndefined()
+
+    // trigger a change event
+    await $input.trigger('change')
+    expect($input.element.value).toBe('ab')
+    // `v-model` update event should have emitted
+    expect(wrapper.emitted('update')).toBeDefined()
+    expect(wrapper.emitted('update').length).toEqual(1)
+    expect(wrapper.emitted('update')[0][0]).toBe('ab')
+
+    $input.element.value = 'abc'
+    await $input.trigger('input')
+    expect($input.element.value).toBe('abc')
+    // `v-model` update event should not have emitted new event
+    expect(wrapper.emitted('update').length).toEqual(1)
+
+    $input.element.value = 'abcd'
+    await $input.trigger('input')
+    expect($input.element.value).toBe('abcd')
+    // `v-model` update event should not have emitted new event
+    expect(wrapper.emitted('update').length).toEqual(1)
+
+    // Trigger a blur event
+    await $input.trigger('blur')
+    expect($input.element.value).toBe('abcd')
+    // `v-model` update event should have emitted
+    expect(wrapper.emitted('update').length).toEqual(2)
+    expect(wrapper.emitted('update')[1][0]).toBe('abcd')
+
+    wrapper.destroy()
+  })
+
+  it('"debounce" prop works', async () => {
+    jest.useFakeTimers()
+    const wrapper = mount(BFormInput, {
+      propsData: {
+        type: 'text',
+        value: '',
+        debounce: 100
+      }
+    })
+
+    const $input = wrapper.find('input')
+    $input.element.value = 'a'
+    await $input.trigger('input')
+    expect($input.element.value).toBe('a')
+    // `v-model` update event should not have emitted
+    expect(wrapper.emitted('update')).toBeUndefined()
+    // `input` event should be emitted
+    expect(wrapper.emitted('input')).toBeDefined()
+    expect(wrapper.emitted('input').length).toBe(1)
+    expect(wrapper.emitted('input')[0][0]).toBe('a')
+
+    $input.element.value = 'ab'
+    await $input.trigger('input')
+    expect($input.element.value).toBe('ab')
+    // `v-model` update event should not have emitted
+    expect(wrapper.emitted('update')).toBeUndefined()
+    // `input` event should be emitted
+    expect(wrapper.emitted('input').length).toBe(2)
+    expect(wrapper.emitted('input')[1][0]).toBe('ab')
+
+    // Advance timer
+    jest.runOnlyPendingTimers()
+    // Should update the v-model
+    expect($input.element.value).toBe('ab')
+    // `v-model` update event should have emitted
+    expect(wrapper.emitted('update')).toBeDefined()
+    expect(wrapper.emitted('update').length).toBe(1)
+    expect(wrapper.emitted('update')[0][0]).toBe('ab')
+    // `input` event should not have emitted new event
+    expect(wrapper.emitted('input').length).toBe(2)
+
+    // Update input
+    $input.element.value = 'abc'
+    await $input.trigger('input')
+    expect($input.element.value).toBe('abc')
+    // `v-model` update event should not have emitted new event
+    expect(wrapper.emitted('update').length).toBe(1)
+    // `input` event should be emitted
+    expect(wrapper.emitted('input').length).toBe(3)
+    expect(wrapper.emitted('input')[2][0]).toBe('abc')
+
+    // Update input
+    $input.element.value = 'abcd'
+    await $input.trigger('input')
+    expect($input.element.value).toBe('abcd')
+    // `v-model` update event should not have emitted new event
+    expect(wrapper.emitted('update').length).toEqual(1)
+    // `input` event should be emitted
+    expect(wrapper.emitted('input').length).toBe(4)
+    expect(wrapper.emitted('input')[3][0]).toBe('abcd')
+
+    // Trigger a `change` event
+    await $input.trigger('change')
+    expect($input.element.value).toBe('abcd')
+    // `v-model` update event should have emitted (change overrides debounce)
+    expect(wrapper.emitted('update').length).toEqual(2)
+    expect(wrapper.emitted('update')[1][0]).toBe('abcd')
+    // `input` event should not have emitted new event
+    expect(wrapper.emitted('input').length).toBe(4)
+
+    $input.element.value = 'abc'
+    await $input.trigger('input')
+    expect($input.element.value).toBe('abc')
+    // `v-model` update event should not have emitted new event
+    expect(wrapper.emitted('update').length).toBe(2)
+    // `input` event should be emitted
+    expect(wrapper.emitted('input').length).toBe(5)
+    expect(wrapper.emitted('input')[4][0]).toBe('abc')
+
+    $input.element.value = 'abcd'
+    await $input.trigger('input')
+    expect($input.element.value).toBe('abcd')
+    // `v-model` update event should not have emitted new event
+    expect(wrapper.emitted('update').length).toBe(2)
+    // `input` event should be emitted
+    expect(wrapper.emitted('input').length).toBe(6)
+    expect(wrapper.emitted('input')[5][0]).toBe('abcd')
+
+    // Advance timer
+    jest.runOnlyPendingTimers()
+    // Should update the v-model
+    expect($input.element.value).toBe('abcd')
+    // `v-model` update event should not have emitted new event
+    expect(wrapper.emitted('update').length).toBe(2)
+    // `input` event should not have emitted new event
+    expect(wrapper.emitted('input').length).toBe(6)
+
+    wrapper.destroy()
+  })
+
+  it('focus() and blur() methods work', async () => {
+    const wrapper = mount(BFormInput, {
+      attachTo: document.body
+    })
+
+    const $input = wrapper.find('input')
+
+    expect(typeof wrapper.vm.focus).toBe('function')
+    expect(typeof wrapper.vm.blur).toBe('function')
+
+    expect(document.activeElement).not.toBe($input.element)
+    wrapper.vm.focus()
+    expect(document.activeElement).toBe($input.element)
+    wrapper.vm.blur()
+    expect(document.activeElement).not.toBe($input.element)
+
+    wrapper.destroy()
+  })
+
+  // These tests are wrapped in a new describe to limit the scope of the getBCR Mock
+  describe('prop `autofocus`', () => {
+    const origGetBCR = Element.prototype.getBoundingClientRect
+
+    beforeEach(() => {
+      // Mock `getBoundingClientRect()` so that the `isVisible(el)` test returns `true`
+      Element.prototype.getBoundingClientRect = jest.fn(() => ({
+        width: 24,
+        height: 24,
+        top: 0,
+        left: 0,
+        bottom: 0,
+        right: 0
+      }))
+    })
+
+    afterEach(() => {
+      // Restore prototype
+      Element.prototype.getBoundingClientRect = origGetBCR
+    })
+
+    it('works when true', async () => {
+      const wrapper = mount(BFormInput, {
+        attachTo: document.body,
+        propsData: {
+          autofocus: true
+        }
+      })
+
+      expect(wrapper.vm).toBeDefined()
+      await waitNT(wrapper.vm)
+      await waitRAF()
+
+      const $input = wrapper.find('input')
+      expect($input.exists()).toBe(true)
+      expect(document).toBeDefined()
+      expect(document.activeElement).toBe($input.element)
+
+      wrapper.destroy()
+    })
+
+    it('does not autofocus when false', async () => {
+      const wrapper = mount(BFormInput, {
+        attachTo: document.body,
+        propsData: {
+          autofocus: false
+        }
+      })
+
+      expect(wrapper.vm).toBeDefined()
+      await waitNT(wrapper.vm)
+      await waitRAF()
+
+      const $input = wrapper.find('input')
+      expect($input.exists()).toBe(true)
+      expect(document).toBeDefined()
+      expect(document.activeElement).not.toBe($input.element)
+
+      wrapper.destroy()
+    })
+  })
+})