Testing props and events in Vue

Introduction

We test props and events to make sure components get the right data and communicate correctly.

When you want to check if a component shows the data passed to it.

When you want to verify a component sends the right event after a user action.

When you want to catch bugs early by testing component behavior.

When you want to ensure your app parts work well together.

When you want to keep your code safe during changes.

Syntax

Vue

import { mount } from '@vue/test-utils'

const wrapper = mount(Component, {
  props: { propName: value }
})

wrapper.vm.$emit('eventName', eventData)

expect(wrapper.props('propName')).toBe(value)
expect(wrapper.emitted('eventName')).toBeTruthy()

Use mount to create a test instance of your component.

Check props with wrapper.props() and events with wrapper.emitted().

Examples

This checks if the label prop is passed correctly to the MyButton component.

Vue

const wrapper = mount(MyButton, {
  props: { label: 'Click me' }
})
expect(wrapper.props('label')).toBe('Click me')

This tests if clicking the button triggers the click event.

Vue

await wrapper.find('button').trigger('click')
expect(wrapper.emitted('click')).toBeTruthy()

This verifies the submit event was emitted with the correct data.

Vue

expect(wrapper.emitted('submit')[0]).toEqual([{ name: 'John' }])

Sample Program

This component shows a button with a name prop. When clicked, it emits a greet event with a message. The test checks the prop and event.

Vue

import { mount } from '@vue/test-utils'
import { defineComponent, h } from 'vue'

const Greeting = defineComponent({
  props: { name: String },
  emits: ['greet'],
  setup(props, { emit }) {
    const sayHello = () => emit('greet', `Hello, ${props.name}!`)
    return () => h('button', { onClick: sayHello }, `Greet ${props.name}`)
  }
})

// Test
const wrapper = mount(Greeting, { props: { name: 'Alice' } })

// Check prop
console.log(wrapper.props('name'))

// Trigger event
wrapper.find('button').trigger('click')

// Check event
console.log(wrapper.emitted('greet'))

Important Notes

Always test both props and events to cover input and output of components.

Use await with trigger if your event handler is async.

Check event payloads carefully to ensure correct data is sent.

Summary

Props pass data into components; test them to confirm correct values.

Events send messages out; test them to confirm correct triggers and data.

Use Vue Test Utils mount, props(), and emitted() for easy testing.

Practice

1. What is the main purpose of testing props in a Vue component?

easy

A. To check if the component receives the correct data from its parent

B. To verify the component's internal state changes

C. To ensure the component renders without errors

D. To test the component's CSS styles

Solution

1. Step 1: Understand what props are in Vue

   Props are how a parent component passes data to a child component.

2. Step 2: Identify the goal of testing props

   Testing props ensures the child component receives the right data as expected.

3. Final Answer:

   To check if the component receives the correct data from its parent -> Option A

4. Quick Check:

   Props test data passing = C [OK]

Hint: Props test data input from parent component [OK]

Common Mistakes:

• Confusing props testing with state testing
• Thinking props test styles or rendering only
• Assuming props test event emissions

2. Which Vue Test Utils method is used to check if an event was emitted by a component?

easy

A. trigger()

B. props()

C. emitted()

D. setData()

Solution

1. Step 1: Recall Vue Test Utils methods for events

   The method emitted() returns an object of events emitted by the component.

2. Step 2: Differentiate from other methods

   trigger() simulates DOM events, props() reads props, and setData() changes component data.

3. Final Answer:

   emitted() -> Option C

4. Quick Check:

   Check emitted events = emitted() = B [OK]

Hint: Use emitted() to see events fired by component [OK]

Common Mistakes:

• Using trigger() to check emitted events
• Confusing props() with emitted()
• Trying to use setData() for event checking

3. Given this test code:

const wrapper = mount(MyButton, { props: { label: 'Click' } })
await wrapper.find('button').trigger('click')
const events = wrapper.emitted()

What will events contain if MyButton emits a 'click' event on button click?

medium

A. {}

B. { click: [ 'Click' ] }

C. { click: [ [ 'Click' ] ] }

D. { click: [ [ ] ] }

Solution

1. Step 1: Understand emitted() output format

   emitted() returns an object where keys are event names and values are arrays of argument arrays for each emit.

2. Step 2: Analyze the event emission

   If the component emits 'click' without arguments, emitted().click is an array with empty arrays for each emit.

3. Final Answer:

   { click: [ [ ] ] } -> Option D

4. Quick Check:

   Event emitted without args = empty array inside emitted() = D [OK]

Hint: emitted() returns arrays of argument arrays per event [OK]

Common Mistakes:

• Assuming emitted event has string argument by default
• Confusing emitted() output structure
• Expecting emitted() to return flat arrays

4. What is wrong with this test code snippet?

const wrapper = mount(MyInput, { props: { value: 'test' } })
wrapper.find('input').trigger('input', { target: { value: 'new' } })
expect(wrapper.emitted('input')[0]).toEqual(['new'])

medium

A. trigger() should be awaited because it returns a promise

B. The emitted event name should be 'update:modelValue' instead of 'input'

C. The props should be passed as 'modelValue' not 'value'

D. The event payload should be an event object, not a string

Solution

1. Step 1: Check if trigger() needs awaiting

   In Vue Test Utils, trigger() returns a promise and should be awaited to ensure DOM updates.

2. Step 2: Verify test correctness

   Without await, the emitted event may not be registered before the expect runs, causing test failure.

3. Final Answer:

   trigger() should be awaited because it returns a promise -> Option A

4. Quick Check:

   Always await trigger() for event emission tests [OK]

Hint: Always await trigger() to catch emitted events [OK]

Common Mistakes:

• Not awaiting trigger() causing false negatives
• Mixing up prop names for v-model
• Expecting event payload as object instead of emitted args

5. You want to test a Vue component that emits a 'submit' event only if a prop 'isValid' is true. Which test approach correctly verifies this behavior?

hard

A. Mount component with isValid=true, trigger submit, expect no emitted event; then mount with isValid=false, trigger submit, expect emitted event

B. Mount component with isValid=false, trigger submit, expect no emitted event; then mount with isValid=true, trigger submit, expect emitted event

C. Mount component without props, trigger submit, expect emitted event regardless of isValid

D. Mount component with isValid=true, do not trigger submit, expect emitted event

Solution

1. Step 1: Understand conditional event emission

   The component emits 'submit' only if prop 'isValid' is true, so test must check both true and false cases.

2. Step 2: Design test cases accordingly

   Mount with isValid false and trigger submit to confirm no event; then mount with true and trigger submit to confirm event emitted.

3. Final Answer:

   Mount component with isValid=false, trigger submit, expect no emitted event; then mount with isValid=true, trigger submit, expect emitted event -> Option B

4. Quick Check:

   Test both prop states for conditional event emission [OK]

Hint: Test both true and false prop values for event emission [OK]

Common Mistakes:

• Testing only one prop state
• Expecting event without triggering action
• Ignoring prop effect on event emission