Asserting request properties in Cypress - Test Execution Trace

Test Overview

This test checks that a network request is sent with the correct URL and HTTP method when a button is clicked. It verifies the request properties to ensure the app behaves as expected.

Test Code - Cypress

Cypress

describe('Request properties test', () => {
  it('should send a GET request to /api/data when button clicked', () => {
    cy.intercept('GET', '/api/data').as('getData');
    cy.visit('https://example.com');
    cy.get('#load-data-btn').click();
    cy.wait('@getData').its('request').then((req) => {
      expect(req.method).to.equal('GET');
      expect(req.url).to.include('/api/data');
    });
  });
});

Execution Trace - 4 Steps

Step	Action	System State	Assertion	Result
1	cy.intercept sets up a spy for GET requests to /api/data and aliases it as 'getData'	No page loaded yet, intercept ready to capture matching requests	—	PASS
2	cy.visit opens the page at https://example.com	Browser shows the example.com homepage with a button #load-data-btn visible	—	PASS
3	cy.get finds the button with id 'load-data-btn' and clicks it	Button clicked, triggering a network request to /api/data	—	PASS
4	cy.wait waits for the intercepted request '@getData' to complete	Request to /api/data captured by intercept	Verify request method is 'GET' and URL includes '/api/data'	PASS

Failure Scenario

Failing Condition: The request to /api/data is not sent or uses a different HTTP method

Execution Trace Quiz - 3 Questions

What does cy.intercept('GET', '/api/data').as('getData') do in the test?

A It clicks the button with id 'getData'

B It listens for GET requests to /api/data and names this intercept 'getData'

C It sends a GET request to /api/data immediately

D It waits for the page to load

Key Result

Always intercept and alias network requests before triggering actions that send them, so you can wait for and assert on the exact request properties.

Practice

1. What is the primary purpose of using cy.intercept in Cypress tests?

easy

A. To watch and control network requests during test execution

B. To create UI elements dynamically

C. To write CSS styles for the application

D. To generate random test data automatically

Solution

1. Step 1: Understand cy.intercept role

   cy.intercept is used to monitor or stub network requests in Cypress tests.

2. Step 2: Identify correct purpose

   It helps watch and control HTTP requests, not UI or styling tasks.

3. Final Answer:

   To watch and control network requests during test execution -> Option A

4. Quick Check:

   cy.intercept = watch/control requests [OK]

Hint: Remember: intercept = watch network calls [OK]

Common Mistakes:

• Confusing intercept with UI manipulation
• Thinking intercept generates test data
• Mixing intercept with CSS styling

2. Which of the following is the correct syntax to assert that a request method is POST inside a cy.intercept callback?

easy

A. assert(req.method == 'POST')

B. assert.equal(req.method, 'GET')

C. expect(req.method).equals('post')

D. expect(req.method).to.equal('POST')

Solution

1. Step 1: Identify correct assertion syntax

   Cypress uses Chai assertions like expect(value).to.equal(expected).

2. Step 2: Match method and case sensitivity

   HTTP methods are uppercase strings, so 'POST' must be exact.

3. Final Answer:

   expect(req.method).to.equal('POST') -> Option D

4. Quick Check:

   expect().to.equal() with exact case [OK]

Hint: Use expect().to.equal() with exact method case [OK]

Common Mistakes:

• Using lowercase 'post' instead of 'POST'
• Using assert syntax instead of expect
• Checking wrong method like 'GET'

3. Given the following code snippet, what will the assertion check inside the intercept callback?

cy.intercept('POST', '/api/login', (req) => {
  expect(req.body).to.have.property('username', 'admin')
})

medium

A. The request headers must include username 'admin'

B. The request body must include a username property with value 'admin'

C. The response body must have username 'admin'

D. The request URL must contain 'username=admin'

Solution

1. Step 1: Analyze the assertion target

   The assertion checks req.body for a property named 'username' with value 'admin'.

2. Step 2: Understand request vs response and headers

   It does not check URL, response, or headers, only the request body.

3. Final Answer:

   The request body must include a username property with value 'admin' -> Option B

4. Quick Check:

   expect(req.body).to.have.property('username', 'admin') [OK]

Hint: Check if property is in req.body, not URL or headers [OK]

Common Mistakes:

• Confusing request body with URL query
• Checking response instead of request
• Looking at headers instead of body

4. Identify the error in this Cypress intercept assertion:

cy.intercept('GET', '/api/data', (req) => {
  expect(req.headers['Content-Type']).to.equal('application/json')
})

medium

A. The assertion syntax is incorrect

B. The method should be POST, not GET

C. Headers keys are case-insensitive; 'Content-Type' should be 'content-type'

D. The intercept callback must use res instead of req

Solution

1. Step 1: Check header key case sensitivity

   HTTP headers are case-insensitive, but Cypress normalizes header keys to lowercase in the req.headers object. The code uses 'Content-Type' which is incorrect; it should be 'content-type'.

2. Step 2: Validate other parts

   Method GET is valid, assertion syntax is correct, and req is proper for request interception.

3. Final Answer:

   Headers keys are case-insensitive; 'Content-Type' should be 'content-type' -> Option C

4. Quick Check:

   Cypress req.headers use lowercase keys [OK]

Hint: Cypress req.headers uses lowercase keys [OK]

Common Mistakes:

• Using wrong HTTP method
• Misusing response object instead of request
• Incorrect assertion syntax

5. You want to assert that a POST request to /api/submit contains a JSON body with a non-empty email property and a header Authorization starting with 'Bearer '. Which is the best way to write this assertion inside cy.intercept?

hard

A. cy.intercept('POST', '/api/submit', (req) => {
expect(req.body.email).to.be.a('string').and.not.be.empty
expect(req.headers.authorization).to.match(/^Bearer /)
})

B. cy.intercept('POST', '/api/submit', (req) => {
expect(req.body.email).to.exist
expect(req.headers.authorization).to.include('Bearer')
})

C. cy.intercept('POST', '/api/submit', (req) => {
assert.isString(req.body.email)
assert.include(req.headers.authorization, 'Bearer')
})

D. cy.intercept('POST', '/api/submit', (req) => {
expect(req.body.email).to.be.empty
expect(req.headers.authorization).to.equal('Bearer')
})

Solution

1. Step 1: Check email property assertion

   cy.intercept('POST', '/api/submit', (req) => { expect(req.body.email).to.be.a('string').and.not.be.empty expect(req.headers.authorization).to.match(/^Bearer /) }) asserts email is a non-empty string using to.be.a('string').and.not.be.empty, which is precise.

2. Step 2: Check Authorization header assertion

   cy.intercept('POST', '/api/submit', (req) => { expect(req.body.email).to.be.a('string').and.not.be.empty expect(req.headers.authorization).to.match(/^Bearer /) }) uses regex to.match(/^Bearer /) to ensure header starts with 'Bearer ', which is exact and case-sensitive.

3. Step 3: Compare other options

   cy.intercept('POST', '/api/submit', (req) => { expect(req.body.email).to.exist expect(req.headers.authorization).to.include('Bearer') }) uses correct lowercase header key, but .to.exist only checks existence (could be empty or falsy), and .to.include checks substring anywhere, not prefix.
   cy.intercept('POST', '/api/submit', (req) => { assert.isString(req.body.email) assert.include(req.headers.authorization, 'Bearer') }) uses non-standard assert style and misses non-empty check; include not prefix.
   cy.intercept('POST', '/api/submit', (req) => { expect(req.body.email).to.be.empty expect(req.headers.authorization).to.equal('Bearer') }) incorrectly expects empty email and exact 'Bearer' match only.

4. Final Answer:

   expect(req.body.email).to.be.a('string').and.not.be.empty
   expect(req.headers.authorization).to.match(/^Bearer /) -> Option A

5. Quick Check:

   Use precise type and regex assertions for properties [OK]

Hint: Use type checks and regex for precise property assertions [OK]

Common Mistakes:

• Ignoring case sensitivity in headers
• Checking only existence, not content
• Using wrong assertion style inconsistently