@dimailn/vuetify 2.7.2-alpha26 → 2.7.2-alpha28

package/src/components/VList/__tests__/VListGroup.spec.ts

@@ -4,12 +4,15 @@ import VListGroup from '../VListGroup'
 // Utilities
 import {
   mount,
-  Wrapper,
+  VueWrapper,
+  enableAutoUnmount,
 } from '@vue/test-utils'
 
 describe('VListGroup.ts', () => {
   type Instance = InstanceType<typeof VListGroup>
-  let mountFunction: (options?: object) => Wrapper<Instance>
+  let mountFunction: (options?: object) => VueWrapper<Instance>
+
+  enableAutoUnmount(afterEach)
 
   beforeEach(() => {
     mountFunction = (options = {}) => {
@@ -29,42 +32,49 @@ describe('VListGroup.ts', () => {
     const $route = { path: '/foo' }
     const listClick = jest.fn()
     const wrapper = mountFunction({
-      provide: {
-        list: {
-          listClick,
-          register: jest.fn(),
-          unregister: jest.fn(),
+      global: {
+        provide: {
+          list: {
+            listClick,
+            register: jest.fn(),
+            unregister: jest.fn(),
+          },
+        },
+        mocks: {
+          $route,
         },
       },
-      propsData: {
+      props: {
         group: 'foo',
       },
-      mocks: {
-        $route,
-      },
     })
 
     await wrapper.vm.$nextTick()
-    expect(listClick).toHaveBeenCalledWith(wrapper.vm._uid)
+    expect(listClick).toHaveBeenCalledWith(wrapper.vm.$.uid)
   })
 
   it('should toggle when clicked', async () => {
-    const wrapper = mountFunction()
+    const wrapper = mountFunction({
+      props: {
+        modelValue: false,
+      },
+    })
 
-    const input = jest.fn()
-    wrapper.vm.$on('input', input)
     wrapper.vm.click()
     await wrapper.vm.$nextTick()
-    expect(input).toHaveBeenCalledWith(true)
+    expect(wrapper.emitted('click')).toBeTruthy()
+    expect(wrapper.vm.isActive).toBe(true)
   })
 
   it('should register when mounted', () => {
     const register = jest.fn()
     const wrapper = mountFunction({
-      provide: {
-        list: {
-          register,
-          unregister: () => {},
+      global: {
+        provide: {
+          list: {
+            register,
+            unregister: () => {},
+          },
         },
       },
     })
@@ -75,15 +85,17 @@ describe('VListGroup.ts', () => {
   it('should unregister when destroyed', async () => {
     const unregister = jest.fn()
     const wrapper = mountFunction({
-      provide: {
-        list: {
-          register: () => {},
-          unregister,
+      global: {
+        provide: {
+          list: {
+            register: () => {},
+            unregister,
+          },
         },
       },
     })
 
-    wrapper.destroy()
+    wrapper.unmount()
     await wrapper.vm.$nextTick()
     expect(unregister).toHaveBeenCalledWith(wrapper.vm)
   })
@@ -91,12 +103,8 @@ describe('VListGroup.ts', () => {
   it('should render a custom affix icons', async () => {
     const wrapper = mountFunction({
       slots: {
-        appendIcon: {
-          render: h => h('span', 'foo'),
-        },
-        prependIcon: {
-          render: h => h('span', 'bar'),
-        },
+        appendIcon: '<span>foo</span>',
+        prependIcon: '<span>bar</span>',
       },
     })
 
@@ -104,10 +112,8 @@ describe('VListGroup.ts', () => {
     expect(wrapper.html()).toContain('<span>bar</span>')
   })
 
-  it('should respond to keydown.enter on header', () => {
-    const click = jest.fn()
+  it('should respond to keydown.enter on header', async () => {
     const wrapper = mountFunction({
-      methods: { click },
       slots: {
         activator: {
           template: '<span>foo</span>',
@@ -117,26 +123,28 @@ describe('VListGroup.ts', () => {
 
     const span = wrapper.find('span')
 
-    span.trigger('keydown.enter')
+    await span.trigger('keydown.enter')
 
-    expect(click).toHaveBeenCalled()
+    expect(wrapper.emitted('update:modelValue')).toBeTruthy()
   })
 
   it('should set active state if route changes and group present', async () => {
     const listClick = jest.fn()
     const $route = { path: '/bar' }
     const wrapper = mountFunction({
-      provide: {
-        list: {
-          listClick,
-          register: () => {},
-          unregister: () => {},
+      global: {
+        provide: {
+          list: {
+            listClick,
+            register: () => {},
+            unregister: () => {},
+          },
         },
+        mocks: { $route },
       },
-      propsData: {
+      props: {
         group: 'foo',
       },
-      mocks: { $route },
     })
 
     expect(wrapper.vm.isActive).toBe(false)
@@ -146,12 +154,12 @@ describe('VListGroup.ts', () => {
     wrapper.vm.onRouteChange(wrapper.vm.$route)
 
     expect(wrapper.vm.isActive).toBe(true)
-    expect(listClick).toHaveBeenCalledWith(wrapper.vm._uid)
+    expect(listClick).toHaveBeenCalledWith(wrapper.vm.$.uid)
   })
 
-  it('should not react to clicks when disabled', () => {
+  it('should not react to clicks when disabled', async () => {
     const wrapper = mountFunction({
-      propsData: {
+      props: {
         disabled: true,
       },
       slots: {
@@ -162,7 +170,7 @@ describe('VListGroup.ts', () => {
     const span = wrapper.find('span.bar')
 
     expect(wrapper.vm.isActive).toBe(false)
-    span.trigger('click')
+    await span.trigger('click')
     expect(wrapper.vm.isActive).toBe(false)
   })
 
@@ -173,20 +181,20 @@ describe('VListGroup.ts', () => {
     wrapper.vm.toggle(100)
     await wrapper.vm.$nextTick()
     expect(wrapper.vm.isActive).toBe(false)
-    wrapper.vm.toggle(wrapper.vm._uid)
+    wrapper.vm.toggle(wrapper.vm.$.uid)
     await wrapper.vm.$nextTick()
     expect(wrapper.vm.isActive).toBe(true)
   })
 
-  it('should have the correct a11y attributes', () => {
+  it('should have the correct a11y attributes', async () => {
     const wrapper = mountFunction()
     const header = wrapper.find('.v-list-group__header')
 
-    expect(header.element.tabIndex).toBe(0)
+    expect(header.element.tabIndex).toBe(-1)
     expect(header.element.getAttribute('aria-expanded')).toBe('false')
     expect(header.element.getAttribute('role')).toBe('button')
 
-    wrapper.setData({ isActive: true })
+    await wrapper.setData({ isActive: true })
 
     expect(header.element.getAttribute('aria-expanded')).toBe('true')
   })

package/src/components/VList/__tests__/VListItem.spec.ts

@@ -4,16 +4,26 @@ import VListItem from '../VListItem'
 // Utilities
 import {
   mount,
-  Wrapper,
+  VueWrapper,
+  enableAutoUnmount,
 } from '@vue/test-utils'
+import { Vue3RouterLinkStub } from '../../../../test/util/stubs'
 
 describe('VListItem.ts', () => {
   type Instance = InstanceType<typeof VListItem>
-  let mountFunction: (options?: object) => Wrapper<Instance>
+  let mountFunction: (options?: any) => VueWrapper<Instance>
+
+  enableAutoUnmount(afterEach)
 
   beforeEach(() => {
     mountFunction = (options = {}) => {
       return mount(VListItem, {
+        global: {
+          stubs: {
+            'router-link': Vue3RouterLinkStub,
+          },
+          ...options.global,
+        },
         ...options,
       })
     }
@@ -21,80 +31,70 @@ describe('VListItem.ts', () => {
 
   it('should render with a div when inactive is true and href is used', () => {
     const wrapper = mountFunction({
-      propsData: {
+      props: {
         href: 'http://www.google.com',
         inactive: true,
       },
     })
 
-    expect(wrapper.is('div')).toBe(true)
+    expect(wrapper.element.tagName.toLowerCase()).toBe('div')
     expect(wrapper.classes('v-list-item--link')).toBe(false)
   })
 
   it('should render with a tag when tag is specified', () => {
     const wrapper = mountFunction({
-      propsData: {
+      props: {
         tag: 'code',
       },
     })
 
-    expect(wrapper.is('code')).toBe(true)
+    expect(wrapper.element.tagName.toLowerCase()).toBe('code')
   })
 
   it('should render with a div when href and to are not used', () => {
     const wrapper = mountFunction()
 
-    expect(wrapper.is('div')).toBe(true)
+    expect(wrapper.element.tagName.toLowerCase()).toBe('div')
     expect(wrapper.html()).toMatchSnapshot()
   })
 
   it('should render with <a> when using href prop', () => {
     const wrapper = mountFunction({
-      propsData: {
+      props: {
         href: 'http://www.google.com',
       },
     })
 
     const a = wrapper.find('a')
 
-    expect(wrapper.is('a')).toBe(true)
+    expect(wrapper.element.tagName.toLowerCase()).toBe('a')
     expect(a.element.getAttribute('href')).toBe('http://www.google.com')
     expect(wrapper.html()).toMatchSnapshot()
   })
 
-  it('should have --link class when href/to prop present or link prop is used', () => {
+  it('should have --link class when href/to prop present or link prop is used', async () => {
     const wrapper = mountFunction({
-      propsData: {
+      props: {
         href: '/home',
       },
     })
 
     expect(wrapper.classes('v-list-item--link')).toBe(true)
 
-    wrapper.setProps({ href: undefined, to: '/foo' })
+    await wrapper.setProps({ href: undefined, to: '/foo' })
     expect(wrapper.classes('v-list-item--link')).toBe(true)
 
-    wrapper.setProps({ to: undefined, link: true })
+    await wrapper.setProps({ to: undefined, link: true })
     expect(wrapper.classes('v-list-item--link')).toBe(true)
 
-    wrapper.setProps({ link: false })
+    await wrapper.setProps({ link: false })
     expect(wrapper.classes('v-list-item--link')).toBe(false)
   })
 
   it('should have --link class when click handler present', () => {
     const wrapper = mountFunction({
-      listeners: {
-        click: () => {},
-      },
-    })
-
-    expect(wrapper.classes('v-list-item--link')).toBe(true)
-  })
-
-  it('should have --link class when click.prevent.stop handler present', () => {
-    const wrapper = mountFunction({
-      listeners: {
-        '!click': () => {},
+      props: {
+        link: true,
       },
     })
 
@@ -103,7 +103,7 @@ describe('VListItem.ts', () => {
 
   it('should have --selectable class if the selectable property is true', () => {
     const wrapper = mountFunction({
-      propsData: {
+      props: {
         selectable: true,
       },
     })
@@ -111,81 +111,82 @@ describe('VListItem.ts', () => {
     expect(wrapper.classes('v-list-item--selectable')).toBe(true)
   })
 
-  it('should react to keydown.enter', () => {
+  it('should react to keydown.enter', async () => {
     const click = jest.fn()
-    const wrapper = mountFunction({
-      methods: { click },
-    })
+    const wrapper = mountFunction({})
 
-    wrapper.trigger('keydown.enter')
+    // Мокируем метод click компонента
+    wrapper.vm.click = click
+
+    await wrapper.trigger('keydown.enter')
 
     expect(click).toHaveBeenCalled()
   })
 
   it('should react to clicks', async () => {
     const blur = jest.fn()
-    const click = jest.fn()
     const toggle = jest.fn()
-    const wrapper = mountFunction({
-      methods: { toggle },
-    })
+    const wrapper = mountFunction({})
 
     wrapper.vm.$el.blur = blur
-    wrapper.vm.$on('click', click)
+    wrapper.vm.toggle = toggle
 
-    wrapper.trigger('click')
+    await wrapper.trigger('click')
     expect(blur).not.toHaveBeenCalled()
-    expect(click).toHaveBeenCalled()
+    expect(wrapper.emitted('click')).toBeTruthy()
     expect(toggle).toHaveBeenCalled()
 
     wrapper.vm.click({ detail: 1 })
 
     expect(blur).toHaveBeenCalled()
 
-    wrapper.setProps({ to: '/foo' })
+    await wrapper.setProps({ to: '/foo' })
     await wrapper.vm.$nextTick()
 
     expect(toggle).toHaveBeenCalledTimes(2)
-    wrapper.trigger('click')
+    await wrapper.trigger('click')
     expect(toggle).toHaveBeenCalledTimes(2)
   })
 
   it('should inherit listItemGroup activeClass', () => {
     const wrapper = mountFunction({
-      provide: {
-        listItemGroup: {
-          activeClass: 'foobar',
-          register: () => {},
-          unregister: () => {},
+      global: {
+        provide: {
+          listItemGroup: {
+            activeClass: 'foobar',
+            register: () => {},
+            unregister: () => {},
+          },
         },
       },
     })
 
-    expect(wrapper.vm.activeClass).toBe('foobar')
+    expect(wrapper.vm.$activeClass).toBe('foobar')
   })
 
-  it('should have the correct aria attributes and tabindex', () => {
+  it('should have the correct aria attributes and tabindex', async () => {
     const wrapper = mountFunction({
-      propsData: { disabled: true },
+      props: { disabled: true },
     })
 
     expect(wrapper.element.getAttribute('aria-disabled')).toBe('true')
     expect(wrapper.element.tabIndex).toBe(-1)
 
-    wrapper.setProps({
+    await wrapper.setProps({
       disabled: false,
-      inputValue: true,
+      modelValue: true,
     })
 
     expect(wrapper.element.getAttribute('aria-disabled')).toBeNull()
     expect(wrapper.element.tabIndex).toBe(-1)
 
-    wrapper.setProps({ link: true })
+    await wrapper.setProps({ link: true })
+    await wrapper.vm.$nextTick()
 
     expect(wrapper.element.tabIndex).toBe(0)
   })
 
-  it('should have the correct role', () => {
+  it('should have the correct role', async () => {
     // Custom provided
     const wrapper = mountFunction({
       attrs: { role: 'item' },
@@ -194,27 +195,37 @@ describe('VListItem.ts', () => {
 
     // In nav
     const wrapper2 = mountFunction({
-      provide: { isInNav: true },
+      global: {
+        provide: { isInNav: true },
+      },
     })
     expect(wrapper2.element.getAttribute('role')).toBeNull()
 
     // In list-item-group
     const wrapper3 = mountFunction({
-      provide: { isInGroup: true },
+      global: {
+        provide: { isInGroup: true },
+      },
     })
     expect(wrapper3.element.getAttribute('role')).toBe('option')
+    expect(wrapper3.element.getAttribute('aria-selected')).toBe('false')
 
     // In menu
     const wrapper4 = mountFunction({
-      provide: { isInMenu: true },
+      global: {
+        provide: { isInMenu: true },
+      },
     })
     expect(wrapper4.element.getAttribute('role')).toBeNull()
-    wrapper4.setProps({ href: '#' }) // could be `to` or `link` as well
+    await wrapper4.setProps({ href: '#' }) // could be `to` or `link` as well
     expect(wrapper4.element.getAttribute('role')).toBe('menuitem')
+    expect(wrapper4.element.getAttribute('id')).toMatch(/^list-item-\d+$/)
 
     // In list not a link
     const wrapper5 = mountFunction({
-      provide: { isInList: true },
+      global: {
+        provide: { isInList: true },
+      },
     })
     expect(wrapper5.element.getAttribute('role')).toBe('listitem')
   })
@@ -228,22 +239,90 @@ describe('VListItem.ts', () => {
     wrapper.vm.toggle()
     expect(wrapper.vm.isActive).toBeFalsy()
 
-    const wrapper2 = mountFunction({ propsData: { to: { name: 'test' } }, stubs: ['router-link'] })
+    const wrapper2 = mountFunction({
+      props: { to: { name: 'test' } },
+      global: {
+        stubs: {
+          'router-link': Vue3RouterLinkStub,
+        },
+      },
+    })
 
     expect(wrapper2.vm.isActive).toBeFalsy()
     wrapper2.vm.toggle()
     expect(wrapper2.vm.isActive).toBeTruthy()
   })
 
-  it('should not react to keydown.enter when disabled', () => {
+  it('should not react to keydown.enter when disabled', async () => {
     const click = jest.fn()
     const wrapper = mountFunction({
-      methods: { click },
-      propsData: { disabled: true },
+      global: {
+        mocks: { click },
+      },
+      props: { disabled: true },
     })
 
-    wrapper.trigger('keydown.enter')
+    await wrapper.trigger('keydown.enter')
 
     expect(click).not.toHaveBeenCalled()
   })
+
+  it('should be clickable when href is provided', () => {
+    const wrapper = mountFunction({
+      props: {
+        href: 'http://www.google.com',
+      },
+    })
+
+    expect(wrapper.vm.isClickable).toBe(true)
+  })
+
+  it('should be clickable when to is provided', () => {
+    const wrapper = mountFunction({
+      props: {
+        to: '/home',
+      },
+    })
+
+    expect(wrapper.vm.isClickable).toBe(true)
+  })
+
+  it('should be clickable when in listItemGroup', () => {
+    const wrapper = mountFunction({
+      global: {
+        provide: {
+          listItemGroup: {
+            register: () => {},
+            unregister: () => {},
+          },
+        },
+      },
+    })
+
+    expect(wrapper.vm.isClickable).toBe(true)
+  })
+
+  it('should not be clickable when no href, to, or listItemGroup', () => {
+    const wrapper = mountFunction()
+
+    expect(wrapper.vm.isClickable).toBe(false)
+  })
+
+  it('should be clickable when both href and listItemGroup are present', () => {
+    const wrapper = mountFunction({
+      props: {
+        href: 'http://www.google.com',
+      },
+      global: {
+        provide: {
+          listItemGroup: {
+            register: () => {},
+            unregister: () => {},
+          },
+        },
+      },
+    })
+
+    expect(wrapper.vm.isClickable).toBe(true)
+  })
 })

package/src/components/VList/__tests__/VListItemAvatar.spec.ts

@@ -4,7 +4,8 @@ import VListItemAvatar from '../VListItemAvatar'
 // Utilities
 import {
   mount,
-  Wrapper,
+  VueWrapper,
+  enableAutoUnmount,
 } from '@vue/test-utils'
 
 // Types
@@ -12,7 +13,9 @@ import { ExtractVue } from '../../../util/mixins'
 
 describe('VListItemAvatar.ts', () => {
   type Instance = ExtractVue<typeof VListItemAvatar>
-  let mountFunction: (options?: object) => Wrapper<Instance>
+  let mountFunction: (options?: object) => VueWrapper<Instance>
+
+  enableAutoUnmount(afterEach)
 
   beforeEach(() => {
     mountFunction = (options = {}) => {

package/src/components/VList/__tests__/VListItemGroup.spec.ts

@@ -4,12 +4,15 @@ import VListItemGroup from '../VListItemGroup'
 // Utilities
 import {
   mount,
-  Wrapper,
+  VueWrapper,
+  enableAutoUnmount,
 } from '@vue/test-utils'
 
 describe('VListItemGroup.ts', () => {
   type Instance = InstanceType<typeof VListItemGroup>
-  let mountFunction: (options?: object) => Wrapper<Instance>
+  let mountFunction: (options?: object) => VueWrapper<Instance>
+
+  enableAutoUnmount(afterEach)
 
   beforeEach(() => {
     mountFunction = (options = {}) => {

package/src/components/VList/__tests__/__snapshots__/VList.spec.ts.snap

@@ -1,36 +1,36 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`VList.ts should render a dense component and match snapshot 1`] = `
-<div role="list"
-     class="v-list v-sheet theme--light v-list--dense"
+<div class="v-sheet theme--light v-list--dense v-list"
+     role="list"
 >
 </div>
 `;
 
 exports[`VList.ts should render a subheader component and match snapshot 1`] = `
-<div role="list"
-     class="v-list v-sheet theme--light v-list--subheader"
+<div class="v-sheet theme--light v-list--subheader v-list"
+     role="list"
 >
 </div>
 `;
 
 exports[`VList.ts should render a threeLine component and match snapshot 1`] = `
-<div role="list"
-     class="v-list v-sheet theme--light v-list--three-line"
+<div class="v-sheet theme--light v-list--three-line v-list"
+     role="list"
 >
 </div>
 `;
 
 exports[`VList.ts should render a twoLine component and match snapshot 1`] = `
-<div role="list"
-     class="v-list v-sheet theme--light v-list--two-line"
+<div class="v-sheet theme--light v-list--two-line v-list"
+     role="list"
 >
 </div>
 `;
 
 exports[`VList.ts should render component and match snapshot 1`] = `
-<div role="list"
-     class="v-list v-sheet theme--light"
+<div class="v-sheet theme--light v-list"
+     role="list"
 >
 </div>
 `;