XQA
Back to Test Automation
2026-05-125 min read

Expectations for Query or Mutation Results (Test Automation)

Learn Expectations for Query or Mutation Results (Test Automation) step by step with clear examples and exercises.

Title: Test Automation - Expectations for Query and Mutation Results (using JavaScript examples)

Why This Matters

In test automation, understanding the expectations for query and mutation results is crucial to ensure that your tests are reliable and effective. By learning how to handle these scenarios correctly, you can save time, reduce errors, and improve the overall quality of your automated tests.

Importance of Proper Expectations Handling

  • Robust Tests: Handling expectations properly helps ensure that your tests are robust and can withstand changes in the application's behavior.
  • Reduced Errors: Proper handling of expectations reduces the likelihood of false positives or negatives, making your test results more accurate.
  • Improved Test Quality: By improving the quality of your tests, you can have more confidence in your automated testing suite and its ability to catch issues early.

Prerequisites

Before diving into the core concept, it's essential to have a solid understanding of:

  1. JavaScript basics (variables, functions, arrays, objects)
  2. Test automation frameworks (Selenium, Cypress, Playwright)
  3. Querying and manipulating DOM elements
  4. Understanding the difference between GET, POST, PUT, DELETE requests
  5. Familiarity with asynchronous JavaScript and promises
  6. Basic understanding of error handling in JavaScript

Core Concept

In test automation, we often need to make HTTP requests to verify the behavior of our application's backend. These requests can be queries (GET) or mutations (POST, PUT, DELETE). To ensure that our tests are robust and reliable, it's essential to handle the expectations for these results properly.

Querying Results

When making a GET request, we expect to receive a response containing data from the server. We can then compare this data with the expected outcome to verify the behavior of our application. Here's an example using Selenium:

const {Builder, By, Key, until} = require('selenium-webdriver');

let driver = await new Builder().forBrowser('chrome').build();
await driver.get('http://example.com/api/data');

let data = await driver.findElements(By.css('.data'));
expect(data.length).toBe(5); // Verify the number of items returned

In this example, we're making a GET request to an API endpoint that returns a list of data. We then use Selenium to find the elements containing the data and verify that there are 5 items in the list.

Mutating Results

When making a mutation (POST, PUT, DELETE), we expect the server to respond with a status code indicating whether the operation was successful or not. Here's an example using Cypress:

cy.request({
method: 'POST',
url: '/api/items',
body: { name: 'New Item' },
}).then((response) => {
expect(response.status).to.equal(201); // Verify the status code for a successful operation
});

In this example, we're making a POST request to an API endpoint that creates a new item. We then use Cypress to check if the response status is 201, which indicates that the operation was successful and a new resource has been created.

Asynchronous Responses and Promises

When dealing with asynchronous responses, it's essential to use await or promises to handle them properly. This ensures that your tests wait for the response before continuing, preventing errors caused by premature execution.

Worked Example

Let's consider a simple e-commerce application where we can add items to the cart. To test this functionality, we need to:

  1. Navigate to the item page
  2. Click the "Add to Cart" button
  3. Verify that the item has been added to the cart
  4. Check the total price of the items in the cart

Here's a worked example using Playwright:

const { chromium } = require('playwright');

(async () => {
const browser = await chromium.launch();
const context = await browser.newContext();
const page = await context.newPage();

// Navigate to the item page
await page.goto('http://example.com/items/1');

// Click the "Add to Cart" button
await page.click('.add-to-cart-button');

// Verify that the item has been added to the cart
const cartItem = await page.$eval('.cart-item', (el) => el.innerText);
expect(cartItem).toContain('Item 1');

// Check the total price of the items in the cart
const totalPrice = await page.$eval('.total-price', (el) => parseFloat(el.innerText));
expect(totalPrice).toBeCloseTo(19.99, 2); // Item 1 costs $9.99, so the total should be $19.99 when only one item is in the cart

await browser.close();
})();

In this example, we're using Playwright to navigate to an item page, click the "Add to Cart" button, and verify that the item has been added to the cart. We also check the total price of the items in the cart to ensure that it matches our expectations.

Common Mistakes

  1. Not handling asynchronous responses: When making HTTP requests, always use await or a promise to handle asynchronous responses properly.
  2. Ignoring error messages: If your tests fail, make sure to inspect the error messages and understand why they occurred. This will help you debug and improve your tests.
  3. Not verifying the correct data: When querying results, always verify that you're checking the correct data. For example, if you expect a list of items but only check the first item, your test might pass even when other items are incorrect.
  4. Ignoring status codes for mutations: When making mutation requests, always verify the status code to ensure that the operation was successful or not.
  5. Not using proper expectations: Always use appropriate assertion functions like toBe, toEqual, toContain, etc., to compare expected and actual results.

Practice Questions

  1. Write a test using Selenium to verify that a user can log in to your application with valid credentials.
  2. Write a test using Cypress to verify that the search functionality on your e-commerce website returns the correct results.
  3. Write a test using Playwright to verify that the checkout process on your e-commerce website works correctly.
  4. Write a test using Selenium to verify that the user can reset their password when they forget it.
  5. Write a test using Cypress to verify that the application's error handling is working correctly by intentionally causing an error and checking if the appropriate error message is displayed.

FAQ

  1. Why is it important to handle expectations for query and mutation results?
  • Handling expectations properly helps ensure that your tests are robust and can withstand changes in the application's behavior.
  • Proper handling of expectations reduces the likelihood of false positives or negatives, making your test results more accurate.
  1. What should I do if my test fails due to an unexpected result?
  • Inspect the error messages and understand why they occurred. This will help you debug and improve your tests.
  1. How can I verify that a mutation was successful or not?
  • Verify the status code of the response. For example, if you made a POST request, expect the status to be 201 for a successful operation.
  1. What is the difference between toBe and toEqual in JavaScript testing?
  • toBe checks if two values are strictly equal (e.g., numbers, strings, booleans), while toEqual checks deep equality (e.g., arrays, objects).
  1. How can I handle asynchronous responses in my tests?
  • Use await or promises to handle asynchronous responses properly. This ensures that your tests wait for the response before continuing, preventing errors caused by premature execution.
Expectations for Query or Mutation Results (Test Automation) | Test Automation | XQA Learn