Testing props and events in Vue - Mini Project: Build & Apply

Testing props and events

📖 Scenario: You are building a simple Vue component that shows a message and lets users click a button to notify the parent component.

🎯 Goal: Create a Vue component called MessageButton that accepts a message prop and emits a clicked event when the button is pressed. Then write tests to check the prop and event behavior.

📋 What You'll Learn

Create a Vue component named MessageButton with a message prop of type String

Render the message prop inside a <p> tag

Add a button that emits a clicked event when clicked

Write a test to check the message prop is rendered correctly

Write a test to check the clicked event is emitted on button click

💡 Why This Matters

🌍 Real World

Testing props and events is essential when building interactive Vue components to ensure they behave correctly and communicate with parent components.

💼 Career

Vue developers often write unit tests to verify component inputs (props) and outputs (events), which helps maintain reliable and bug-free applications.

1

Create the MessageButton component with a message prop

Create a Vue component named MessageButton using <script setup>. Define a prop called message of type String. Render the message prop inside a <p> tag.

Vue

// Define the message prop here


   tag -->

Hint

Use defineProps to declare the message prop as a String. Then display it inside a paragraph tag.

2

Add a button that emits a clicked event

Add a button inside the MessageButton component template. When the button is clicked, emit a clicked event using defineEmits.

Vue

const props = defineProps({
  message: String
})

// Define emits here



  {{ message }}
  

Hint

Use defineEmits to declare the clicked event. Add a button with a click handler that calls emit('clicked').

3

Write a test to check the message prop rendering

Write a test using @vue/test-utils to mount the MessageButton component with the message prop set to 'Hello Vue'. Assert that the rendered paragraph contains the text 'Hello Vue'.

Vue

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

describe('MessageButton', () => {
  it('renders the message prop', () => {
    // Mount the component with message prop 'Hello Vue'
    // Assert the paragraph text contains 'Hello Vue'
  })
})

Hint

Use mount to create the component with the message prop. Then check the paragraph text with wrapper.find('p').text().

4

Write a test to check the clicked event emission

Write a test using @vue/test-utils to mount the MessageButton component. Simulate a click on the button and assert that the clicked event was emitted once.

Vue

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

describe('MessageButton', () => {
  it('renders the message prop', () => {
    const wrapper = mount(MessageButton, {
      props: { message: 'Hello Vue' }
    })
    expect(wrapper.find('p').text()).toBe('Hello Vue')
  })

  it('emits clicked event on button click', () => {
    // Mount the component
    // Trigger a click on the button
    // Assert the clicked event was emitted once
  })
})

Hint

Use wrapper.find('button').trigger('click') to simulate the click. Then check wrapper.emitted('clicked') length is 1.

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