Mounting React components in Cypress - Test Execution Trace

Test Overview

This test mounts a simple React component using Cypress. It verifies that the component renders correctly and displays the expected text.

Test Code - Cypress

Cypress

import React from 'react'
import { mount } from 'cypress/react'

function Greeting() {
  return <h1>Hello, Cypress!</h1>
}

describe('Mount React Component', () => {
  it('renders the Greeting component', () => {
    mount(<Greeting />)
    cy.get('h1').should('contain.text', 'Hello, Cypress!')
  })
})

Execution Trace - 4 Steps

Step	Action	System State	Assertion	Result
1	Test starts	Cypress test runner is ready	—	PASS
2	Mounts the Greeting React component using mount()	Browser displays the Greeting component with <h1>Hello, Cypress!</h1>	—	PASS
3	Finds the <h1> element using cy.get('h1')	The <h1> element is present in the DOM	—	PASS
4	Checks that the <h1> contains text 'Hello, Cypress!' using .should('contain.text')	The <h1> text matches 'Hello, Cypress!'	Verify <h1> text content equals 'Hello, Cypress!'	PASS

Failure Scenario

Failing Condition: The Greeting component does not render or the <h1> text is different

Execution Trace Quiz - 3 Questions

What does the mount() function do in this test?

A It waits for the component to load data

B It clicks a button inside the component

C It renders the React component inside the Cypress test browser

D It asserts the component text

Key Result

Always verify that the React component renders the expected content by asserting visible text after mounting it in Cypress.

Practice

1. What is the main purpose of using mount() in Cypress when testing React components?

easy

A. To create mock data for API responses

B. To render the React component inside the Cypress test runner for testing

C. To send HTTP requests to the backend server

D. To compile React components into production code

Solution

1. Step 1: Understand the role of mount() in Cypress

   mount() is used to render React components inside the Cypress test environment so you can interact with and test them.

2. Step 2: Compare other options

   Sending HTTP requests, creating mock data, and compiling code are unrelated to mounting components in Cypress.

3. Final Answer:

   To render the React component inside the Cypress test runner for testing -> Option B

4. Quick Check:

   mount() renders React components for testing [OK]

Hint: mount() renders components in Cypress for testing [OK]

Common Mistakes:

• Confusing mount() with API mocking
• Thinking mount() compiles code
• Using mount() to send HTTP requests

2. Which of the following is the correct syntax to mount a React component named MyButton in Cypress?

easy

A. cy.mount();

B. mount('MyButton');

C. cy.mount('MyButton');

D. mount(<MyButton>);

Solution

1. Step 1: Recall correct mount syntax

   The correct way to mount a React component is to call cy.mount() with the component JSX, like cy.mount(<MyButton />);.

2. Step 2: Identify syntax errors in other options

   mount('MyButton'); uses a string instead of JSX. cy.mount('MyButton'); uses cy.mount but passes a string, which is incorrect. mount(<MyButton>); misses the closing slash in JSX, causing syntax error.

3. Final Answer:

   cy.mount(<MyButton />); -> Option A

4. Quick Check:

   Use cy.mount() with JSX component [OK]

Hint: Use cy.mount() with JSX, not strings [OK]

Common Mistakes:

• Passing component name as string instead of JSX
• Missing closing slash in JSX
• Calling mount() without cy.

3. Given the following test code, what will the assertion check?

import { mount } from 'cypress/react';

function Greeting() {
  return <h1>Hello, Cypress!</h1>;
}

describe('Greeting component', () => {
  it('shows greeting text', () => {
    mount(<Greeting />);
    cy.get('h1').should('contain.text', 'Hello, Cypress!');
  });
});

medium

A. It verifies the component is not rendered

B. It checks if the component has a button element

C. It checks if the h1 element contains the text 'Hello, Cypress!'

D. It tests if the h1 element is empty

Solution

1. Step 1: Understand the test code

   The test mounts the Greeting component, which renders an h1 with text 'Hello, Cypress!'.

2. Step 2: Analyze the assertion

   The assertion uses cy.get('h1').should('contain.text', 'Hello, Cypress!') which checks if the h1 contains that exact text.

3. Final Answer:

   It checks if the h1 element contains the text 'Hello, Cypress!' -> Option C

4. Quick Check:

   Assertion checks h1 text content [OK]

Hint: Look at cy.get selector and should() text check [OK]

Common Mistakes:

• Confusing element types in assertion
• Assuming test checks for buttons
• Thinking assertion checks for absence

4. Identify the error in this Cypress test code for mounting a React component:

import { mount } from 'cypress/react';

function Button() {
  return <button>Click me</button>;
}

describe('Button component', () => {
  it('renders button', () => {
    mount(Button);
    cy.get('button').should('exist');
  });
});

medium

A. The component should be passed as JSX: mount(<Button />)

B. The import statement is missing curly braces

C. The assertion should check for text, not existence

D. The function Button should return a div, not button

Solution

1. Step 1: Check how the component is mounted

   The code calls mount(Button) but it should pass JSX: mount(<Button />) to render the component.

2. Step 2: Verify other parts

   The import is correct with curly braces. Checking existence is valid. Returning a button is fine.

3. Final Answer:

   The component should be passed as JSX: mount(<Button />) -> Option A

4. Quick Check:

   Pass JSX to mount() [OK]

Hint: Always use JSX syntax inside mount() [OK]

Common Mistakes:

• Passing component function instead of JSX
• Changing import syntax unnecessarily
• Confusing assertion purpose

5. You want to test a React component UserCard that receives a name prop and displays it inside a span. Which is the correct way to mount it in Cypress and assert the name is shown?

function UserCard({ name }) {
  return <span>User: {name}</span>;
}

hard

A. cy.mount(<UserCard name="Alice" />); cy.get('span').should('contain.text', 'User: Alice');

B. cy.mount(UserCard, { props: { name: 'Alice' } }); cy.get('span').should('contain.text', 'Alice');

C. mount(<UserCard name='Alice' />); cy.get('span').should('have.text', 'User: Alice');

D. cy.mount(<UserCard name='Alice' />); cy.get('span').should('have.text', 'User: Alice');

Solution

1. Step 1: Mount the component with correct syntax and props

   Use cy.mount(<UserCard name='Alice' />) to mount the component with the prop.

2. Step 2: Assert the exact text inside the span

   Use should('have.text', 'User: Alice') to check the full text content matches exactly.

3. Step 3: Why other options fail

   The option with cy.mount(<UserCard name="Alice" />) and contain.text('User: Alice') uses substring check instead of exact text match.
   The option with cy.mount(UserCard, { props: { name: 'Alice' } }) uses invalid React mount syntax.
   The option with mount(<UserCard name='Alice' />) misses cy. prefix.

4. Final Answer:

   cy.mount(<UserCard name='Alice' />); cy.get('span').should('have.text', 'User: Alice'); -> Option D

5. Quick Check:

   Use cy.mount() with JSX and exact text assertion [OK]

Hint: Use cy.mount() with JSX and exact text check [OK]

Common Mistakes:

• Omitting cy. before mount()
• Using wrong mount() signature
• Using contain.text instead of have.text for exact match