Asserting request properties in Cypress - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ assertion

intermediate

Check HTTP method in intercepted request

You intercept a network request in Cypress and want to assert that the HTTP method used is POST. Which assertion correctly checks this property?

Cypress

cy.intercept('/api/data').as('getData');
cy.visit('/page');
cy.wait('@getData').its('request.method').should(/* your assertion here */);

A "contain", "POST"

B "include", "POST"

C "equal", "POST"

D "have.property", "POST"

💡 Hint

Use the assertion that checks exact equality of the HTTP method string.

The request.method property is a string representing the HTTP method. To assert it is exactly 'POST', use should('equal', 'POST'). Other assertions like 'contain' or 'include' are for partial matches or objects, which are not appropriate here.

❓ Predict Output

intermediate

Output of request header assertion

Given the following Cypress test code, what will be the test result if the intercepted request does NOT include the header 'Authorization'?

Cypress

cy.intercept('/api/user').as('getUser');
cy.visit('/profile');
cy.wait('@getUser').its('request.headers').should('have.property', 'authorization');

A Test passes successfully

B Test fails with an assertion error about missing 'authorization' property

C Test fails with a timeout error waiting for the request

D Test throws a syntax error

💡 Hint

Think about what happens when you assert a property that does not exist on an object.

The assertion should('have.property', 'authorization') expects the 'authorization' header to exist. If it is missing, Cypress throws an assertion error indicating the property is not found.

🔧 Debug

advanced

Identify the error in request body assertion

This Cypress code tries to assert that the intercepted request body contains a field 'userId' equal to 123. What is wrong with the assertion?

Cypress

cy.intercept('POST', '/api/orders').as('postOrder');
cy.visit('/order');
cy.wait('@postOrder').its('request.body').should('contain', { userId: 123 });

A The 'request.body' is a string, so object comparison fails

B The 'should' assertion is missing a callback function

C The 'contain' assertion does not work with objects; use 'deep.include' instead

D The alias '@postOrder' is not defined before use

💡 Hint

Check the data type of the request body in intercepted requests.

In Cypress, the request.body is often a JSON string, not an object. Using should('contain', { userId: 123 }) fails because it compares an object to a string. You must parse the body or assert on the string content.

🧠 Conceptual

advanced

Best practice for asserting JSON response properties

When asserting properties in a JSON response intercepted by Cypress, which approach is best to ensure the test is reliable and clear?

A Use 'expect(response.body.key).to.exist' inside a '.then()' callback

B Use 'should("contain", { key: value })' directly on the response body

C Use 'should("have.property", "key")' on the response body object

D Use 'should("include", { key: value })' on the entire response object

💡 Hint

Consider how Cypress handles asynchronous commands and object references.

Using .then() with expect() allows you to work with the fully resolved response object and write clear assertions. Other options may fail if the response body is not directly accessible or if partial matches cause false positives.

❓ framework

expert

Correct Cypress code to assert multiple request properties

You want to assert that an intercepted request has method POST, includes a header 'Content-Type' with value 'application/json', and the JSON body contains a field 'active' set to true. Which Cypress code snippet correctly performs all these assertions?

A

cy.wait('@req').then(({ request }) => {
  expect(request.method).to.equal('POST');
  expect(request.headers['Content-Type']).to.equal('application/json');
  expect(request.body).to.include('active:true');
});

B

cy.wait('@req').its('request').should('have.property', 'method', 'POST')
  .and('have.property', 'headers').and('contain', { 'content-type': 'application/json' })
  .and('have.property', 'body').and('include', { active: true });

C

cy.wait('@req').should(({ request }) => {
  expect(request.method).to.equal('POST');
  expect(request.headers.contentType).to.equal('application/json');
  expect(request.body.active).to.be.true;
});

D

cy.wait('@req').then(({ request }) => {
  expect(request.method).to.equal('POST');
  expect(request.headers['content-type']).to.equal('application/json');
  const body = JSON.parse(request.body);
  expect(body.active).to.be.true;
});

💡 Hint

Remember header keys are case-insensitive but usually lowercase in Cypress. Also, parse JSON body before checking fields.

Option D correctly waits for the request, asserts the method, accesses the header with lowercase key, parses the JSON body string, and asserts the 'active' field is true. Other options fail due to incorrect header key casing, missing JSON parsing, or wrong assertion methods.

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