cloud-ui.vusion/src/components/u-select.vue/__tests__/demo.test.js

Vusion Cloud UI

/**
 * 以下测试用例根据 docs/*.md 自动生成，请勿修改和提交！！！
 */

import { mount, createLocalVue } from '@vue/test-utils';
import VueRouter from 'vue-router'

import Demo1 from './__demos__/demo1.vue';
import Demo2 from './__demos__/demo2.vue';
import Demo3 from './__demos__/demo3.vue';
import Demo4 from './__demos__/demo4.vue';
import Demo5 from './__demos__/demo5.vue';
import Demo6 from './__demos__/demo6.vue';
import Demo7 from './__demos__/demo7.vue';
import Demo8 from './__demos__/demo8.vue';
import Demo9 from './__demos__/demo9.vue';
import Demo10 from './__demos__/demo10.vue';
import Demo11 from './__demos__/demo11.vue';
import Demo12 from './__demos__/demo12.vue';
import Demo13 from './__demos__/demo13.vue';
import Demo14 from './__demos__/demo14.vue';
import Demo15 from './__demos__/demo15.vue';
import Demo16 from './__demos__/demo16.vue';
import Demo17 from './__demos__/demo17.vue';
import Demo18 from './__demos__/demo18.vue';
import Demo19 from './__demos__/demo19.vue';
import Demo20 from './__demos__/demo20.vue';
import Demo21 from './__demos__/demo21.vue';
import Demo22 from './__demos__/demo22.vue';
import Demo23 from './__demos__/demo23.vue';
import Demo24 from './__demos__/demo24.vue';
import Demo25 from './__demos__/demo25.vue';
import Demo26 from './__demos__/demo26.vue';
import Demo27 from './__demos__/demo27.vue';
import Demo28 from './__demos__/demo28.vue';
import Demo29 from './__demos__/demo29.vue';
import Demo30 from './__demos__/demo30.vue';
import Demo31 from './__demos__/demo31.vue';
import Demo32 from './__demos__/demo32.vue';
import Demo33 from './__demos__/demo33.vue';
import Demo34 from './__demos__/demo34.vue';
import Demo35 from './__demos__/demo35.vue';
import Demo36 from './__demos__/demo36.vue';
import Demo37 from './__demos__/demo37.vue';
import Demo38 from './__demos__/demo38.vue';
import Demo39 from './__demos__/demo39.vue';
import Demo40 from './__demos__/demo40.vue';
import Demo41 from './__demos__/demo41.vue';
import Demo42 from './__demos__/demo42.vue';
import Demo43 from './__demos__/demo43.vue';
import Demo44 from './__demos__/demo44.vue';
import Demo45 from './__demos__/demo45.vue';
import Demo46 from './__demos__/demo46.vue';
import Demo47 from './__demos__/demo47.vue';
import Demo48 from './__demos__/demo48.vue';
import Demo49 from './__demos__/demo49.vue';
import Demo50 from './__demos__/demo50.vue';
import Demo51 from './__demos__/demo51.vue';
import Demo52 from './__demos__/demo52.vue';
import Demo53 from './__demos__/demo53.vue';
import Demo54 from './__demos__/demo54.vue';
import Demo55 from './__demos__/demo55.vue';
import Demo56 from './__demos__/demo56.vue';
import Demo57 from './__demos__/demo57.vue';
import Demo58 from './__demos__/demo58.vue';
import Demo59 from './__demos__/demo59.vue';
import Demo60 from './__demos__/demo60.vue';
import Demo61 from './__demos__/demo61.vue';
import Demo62 from './__demos__/demo62.vue';
import Demo63 from './__demos__/demo63.vue';

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const localVue = createLocalVue()
localVue.use(VueRouter)
const router = new VueRouter()

describe('u-select.vue', () => {

    it('Demo-数据选择框', async () => {
        const wrapper = mount(Demo1,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-基本用法', async () => {
        const wrapper = mount(Demo2,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-appendTo:body', async () => {
        const wrapper = mount(Demo3,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-双向绑定', async () => {
        const wrapper = mount(Demo4,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-双向绑定', async () => {
        const wrapper = mount(Demo5,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-只读、禁用、禁用某一项', async () => {
        const wrapper = mount(Demo6,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-分隔符', async () => {
        const wrapper = mount(Demo7,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-定位', async () => {
        const wrapper = mount(Demo8,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-分组', async () => {
        const wrapper = mount(Demo9,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-可清除', async () => {
        const wrapper = mount(Demo10,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-Layer', async () => {
        const wrapper = mount(Demo11,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-数据源', async () => {
        const wrapper = mount(Demo12,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-基本用法', async () => {
        const wrapper = mount(Demo13,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-双向绑定', async () => {
        const wrapper = mount(Demo14,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-Tags 风格', async () => {
        const wrapper = mount(Demo15,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-Tags 风格', async () => {
        const wrapper = mount(Demo16,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-Tags 展示icon', async () => {
        const wrapper = mount(Demo17,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-对齐和清空问题', async () => {
        const wrapper = mount(Demo18,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-保持顺序', async () => {
        const wrapper = mount(Demo19,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-选项初始值', async () => {
        const wrapper = mount(Demo20,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-前端过滤', async () => {
        const wrapper = mount(Demo21,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-有空的项', async () => {
        const wrapper = mount(Demo22,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-清除缓存', async () => {
        const wrapper = mount(Demo23,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-Tag 方式', async () => {
        const wrapper = mount(Demo24,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-Data 方式', async () => {
        const wrapper = mount(Demo25,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-列表与 value 同时改变的问题', async () => {
        const wrapper = mount(Demo26,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-一次性后端数据，前端过滤', async () => {
        const wrapper = mount(Demo27,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-后端过滤，后端分页', async () => {
        const wrapper = mount(Demo28,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-一次性后端数据，前端分页', async () => {
        const wrapper = mount(Demo29,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-prefix, suffix', async () => {
        const wrapper = mount(Demo30,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-反色', async () => {
        const wrapper = mount(Demo31,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-标签和数据源混合使用', async () => {
        const wrapper = mount(Demo32,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-自定义选中值的展示形式，项可添加描述', async () => {
        const wrapper = mount(Demo33,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-自定义可扩展下拉项', async () => {
        const wrapper = mount(Demo34,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-选中值是下一页数据的选中处理', async () => {
        const wrapper = mount(Demo35,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-tag 方式', async () => {
        const wrapper = mount(Demo36,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-data-source 数组', async () => {
        const wrapper = mount(Demo37,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-data-source 函数', async () => {
        const wrapper = mount(Demo38,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-指定选项字段名', async () => {
        const wrapper = mount(Demo39,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-禁用状态、禁用某一项', async () => {
        const wrapper = mount(Demo40,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-为空禁用', async () => {
        const wrapper = mount(Demo41,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-autofocus', async () => {
        const wrapper = mount(Demo42,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-分隔符', async () => {
        const wrapper = mount(Demo43,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-分组', async () => {
        const wrapper = mount(Demo44,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-可清除', async () => {
        const wrapper = mount(Demo45,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-多项选择', async () => {
        const wrapper = mount(Demo46,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-多项选择', async () => {
        const wrapper = mount(Demo47,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-多项选择', async () => {
        const wrapper = mount(Demo48,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-多项选择', async () => {
        const wrapper = mount(Demo49,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-Tags 风格', async () => {
        const wrapper = mount(Demo50,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-可以重复', async () => {
        const wrapper = mount(Demo51,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-Flag', async () => {
        const wrapper = mount(Demo52,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-Label', async () => {
        const wrapper = mount(Demo53,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-修改尺寸', async () => {
        const wrapper = mount(Demo54,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-前端过滤（搜索）', async () => {
        const wrapper = mount(Demo55,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-匹配方式', async () => {
        const wrapper = mount(Demo56,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-区分大小写', async () => {
        const wrapper = mount(Demo57,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-后端过滤（搜索）', async () => {
        const wrapper = mount(Demo58,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-自动补充', async () => {
        const wrapper = mount(Demo59,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-前端加载更多', async () => {
        const wrapper = mount(Demo60,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-后端加载更多', async () => {
        const wrapper = mount(Demo61,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-前缀方式', async () => {
        const wrapper = mount(Demo62,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });


    it('Demo-自定义可扩展下拉项', async () => {
        const wrapper = mount(Demo63,  { localVue, router });
        await sleep(16);
        expect(wrapper).toMatchSnapshot();
    });

})