text: import { mount } from '@vue/test-utils'
  import { setConfig } from './config-set'
  import { copyProps, makeProp, makePropsConfigurable } from './props'
  
  describe('utils/props', () => {
    it('copyProps() works with array props', async () => {
      const props = ['a', 'b', 'c']
  
      expect(copyProps(props)).toEqual(props)
      // Should be a new array reference
      expect(copyProps(props)).not.toBe(props)
    })
  
    it('copyProps() works with object props', async () => {
      const props = {
        a: { type: String, default: 'foobar' },
        b: { type: [Object, Array], default: null },
        c: 'c'
      }
  
      expect(copyProps(props)).toEqual(props)
      // Should be a new object reference
      expect(copyProps(props)).not.toBe(props)
      // Properties should be new object references
      expect(copyProps(props).a).not.toBe(props.a)
      expect(copyProps(props).a).toEqual(props.a)
      expect(copyProps(props).b).not.toBe(props.b)
      expect(copyProps(props).b).toEqual(props.b)
      // Except for primatives
      expect(copyProps(props).c).toBe(props.c)
      expect(copyProps(props).c).toEqual(props.c)
    })
  
    it('makeProp() works', async () => {
      expect(makeProp()).toEqual({})
      expect(makeProp(undefined)).toEqual({})
      expect(makeProp(null)).toEqual({})
      expect(makeProp('')).toEqual({})
  
      expect(makeProp(Array)).toEqual({ type: Array })
      expect(makeProp(Boolean)).toEqual({ type: Boolean })
      expect(makeProp(Function)).toEqual({ type: Function })
      expect(makeProp(Number)).toEqual({ type: Number })
      expect(makeProp(Object)).toEqual({ type: Object })
      expect(makeProp(String)).toEqual({ type: String })
  
      expect(makeProp(Array, null)).toEqual({ type: Array, default: null })
      expect(makeProp(Boolean, false)).toEqual({ type: Boolean, default: false })
      expect(makeProp(Function, null)).toEqual({ type: Function, default: null })
      expect(makeProp(Number, 0)).toEqual({ type: Number, default: 0 })
      expect(makeProp(Object, null)).toEqual({ type: Object, default: null })
      expect(makeProp(String, '')).toEqual({ type: String, default: '' })
  
      expect(typeof makeProp(Array, []).default).toEqual('function')
      expect(makeProp(Array, []).default()).toEqual([])
  
      const fn = () => {}
      expect(typeof makeProp(Function, fn).default).toEqual('function')
      expect(makeProp(Function, fn).default).toEqual(fn)
  
      expect(typeof makeProp(Object, {}).default).toEqual('function')
      expect(makeProp(Object, {}).default()).toEqual({})
  
      expect(makeProp(Array, undefined, true)).toEqual({ type: Array, required: true })
      expect(makeProp(Boolean, undefined, true)).toEqual({ type: Boolean, required: true })
      expect(makeProp(Function, undefined, true)).toEqual({ type: Function, required: true })
      expect(makeProp(Number, undefined, true)).toEqual({ type: Number, required: true })
      expect(makeProp(Object, undefined, true)).toEqual({ type: Object, required: true })
      expect(makeProp(String, undefined, true)).toEqual({ type: String, required: true })
  
      const validator = value => !!value
      expect(makeProp(String, '', undefined)).toEqual({ type: String, default: '' })
      expect(makeProp(String, '', validator)).toEqual({ type: String, default: '', validator })
      expect(makeProp(String, undefined, validator)).toEqual({ type: String, validator })
      expect(makeProp(String, '', true, validator)).toEqual({
        type: String,
        required: true,
        validator
      })
    })
  
    it('makePropsConfigurable() works', async () => {
      const NAME = 'MyComponent'
      const props = {
        text: {
          type: String,
          default: 'foo'
        }
      }
      const config = {
        [NAME]: { text: 'bar' }
      }
      const ConfigurableComponent = {
        name: NAME,
        props: makePropsConfigurable(props, NAME),
        render(h) {
          return h('div', this.text)
        }
      }
  
      setConfig(config)
  
      const wrapper = mount(ConfigurableComponent)
  
      expect(wrapper.vm).toBeDefined()
      expect(wrapper.element.tagName).toBe('DIV')
      expect(wrapper.text()).toBe('bar')
  
      await wrapper.setProps({ text: 'baz' })
      expect(wrapper.text()).toBe('baz')
    })
  })
  