Assertions in Software Testing: Key Concepts and Techniques

Anushree Chatterjee

Never argue, repeat your assertion – Robert Owen.

In real life, you may want to repeat your assertions. However, once is enough in software testing if used correctly at the right checkpoints. Assertions are the validations that are executed in the middle or end of the test cases to evaluate that the actual result is as expected. These checkpoints confirm that the application under test (AUT) is behaving as we expect it to.

These assertions are expressions that validate an application’s state or behavior, and the result is binary/boolean: True or False. While writing an automated test, assertions are included in the test script using various conditions to validate the outcome.

Let us learn about them in detail.

What is an Assertion?

The primary purpose of an assertion is to verify that the application is working correctly at the inserted checkpoints and, hence, overall. It is a way of telling the test script, “I expect the value of application state/behavior to be X at this point.“ Does my expectation match the actual result? Tell me in True or False.

When an assertion is executed, it evaluates a condition (usually a comparison between the actual and expected value). If the condition is true, the test continues to run. If the condition is false, the assertion throws an error, marking the test as failed.

Bake a Cake Example

Let us take an example of baking a chocolate cake and how we insert assertions in between and at the end of the process.

Step 1: Measuring Ingredients

Action: You measure 1 cup of sugar.

Assertion: You verify that the amount of sugar is correct.

Step 2: Preheating the Oven

Action: The recipe says to preheat the oven to 350°F.

Assertion: Verify that the oven thermometer has reached 350°F. In software testing, this is like checking that a condition (in this case, the oven temperature) is exactly as expected.

Step 3: Baking Time

Action: The recipe mentions baking the cake for 30 minutes.

Assertion: You set a timer and check the cake for 30 minutes. This is similar to a timeout assertion, ensuring the process (baking) doesn’t take longer than expected.

Step 4: Final Check – The Toothpick Test

Action: Insert a toothpick into the center to check it is baked.

Assertion: The cake is completely baked if the toothpick comes out clean. This is the same as an assertion where you check the final result (in software, this might be checking that a transaction is completed).

Types of Assertions

Below are the two types of assertions and a comparison table:

Hard Asserts are assertions where the test execution is aborted when the assert conditions are not met, and the test case fails. If you want to continue test execution even if one of the assertions fails, use Soft Asserts.

Hard Assert vs. Soft Assert

Assertions in Selenium

A core part of software testing is verifying the behavior of the application. Whether you do it manually or through automation, or whether you’re doing unit testing, integration testing, or end-to-end testing, you will end up verifying different aspects of the application. Thus, you act to make the system behave a certain way, and then you verify it through assertions.

You need to use TestNG with Selenium to set up assertions using org.testng.assert package. By default, the asserts in Selenium are Hard Asserts. To use Soft Asserts (also known as Verify), import the org.testng.asserts.SoftAssert package.

TestNG Assert Methods

Syntax: Assert.Method(actual, expected) or Assert.Method(actual, expected, message)

Where

• actual is the actual value received on the application under test (AUT)
• expected is the expected (correct) value on the AUT
• message is the string error message to display in case of test failure

Below are a few common TestNG assert methods:

Hard Asserts Syntax

• Assert.assertEquals(actual,expected);
• Assert.assertNotEquals(actual,expected,Message);
• Assert.assertTrue(condition);
• Assert.assertFalse(condition);
• Assert.assertNull(object);
• Assert.assertNotNull(object);

Soft Asserts Syntax

• softAssert.assertTrue(false);
• softAssert.assertEquals(1, 2);
• softAssert.assertAll();

Assert Code Examples

Below are TestNG code examples of hard and soft asserts:

Hard Assert Example

import org.testng.Assert;
import org.testng.annotations.Test;

public class HardAssertionExample {

  @Test
  public void testHardAssertion() {
    System.out.println("Test started");
    Assert.assertEquals(2 + 2, 4, "Expected and actual values are not the same!");
    System.out.println("Middle of the test");
    Assert.assertTrue("hello".equals("hello"), "Strings are not equal");
    System.out.println("Test ended");
  }
}

Soft Assert Example

import org.testng.annotations.Test;
import org.testng.asserts.SoftAssert;

public class SoftAssertionExample {

  @Test
  public void testSoftAssertion() {
    SoftAssert softAssert = new SoftAssert();

    System.out.println("Test started");
    softAssert.assertEquals(2 + 2, 5, "First assertion failed");
    System.out.println("After first assertion");

    softAssert.assertTrue("hello".equals("world"), "Second assertion failed");
    System.out.println("After second assertion");

    softAssert.assertAll(); // This will report all assertions
    System.out.println("Test ended");

  }
}

See here a Selenium test example to understand better.

Simple and Quick Assertions Using AI

You might have an idea about assertions in software testing and how it works. Implementing it flawlessly is a challenging job. Selenium has its own disadvantages. Here are the 11 reasons not to use Selenium for software testing.

Organizations seek intelligent, fast, and simple solutions for implementing test automation. While the whole world is adopting AI, NLP, and the latest technology to advance, Selenium fails to serve its purpose efficiently.

Forget complex Selenium, TestNG, log4j, JUnit integrations, and other myriad of dependencies. Writing, managing, and maintaining all these scripts together so that they stay relevant and correct is a nightmare for engineers.

Intelligent generative AI-powered testing tools such as testRigor can solve your web, mobile, desktop, and API testing needs singlehandedly in plain English. Learning programming languages and all the syntaxes and dependencies is unnecessary. One testing tool is enough to handle everything in plain English test steps. testRigor works and thinks as a human would. It does not work on XPath and CSS locators. Instead, it “sees” the screen and identifies elements, quite like a human tester would. These testRigor locators bring ultra-stability, and the built-in self-healing capabilities incorporate the UI changes in the test steps automatically to a great extent.

testRigor Assertions

When working with testRigor, “How to write an assert statement?” is the least of your worries! Unlike other traditional test automation tools, you don’t need to worry about assert methods and element locators. testRigor’s assertions are very straightforward as the tool doesn’t test your coding acumen but rather lets you use the power of simple English to converse with the AI engine.

Let’s look at a few examples of these ultra-easy assertions.

Example 1: Verifying different attributes of various types of elements seen on the screen

check that page contains “Login”
check that downloaded file contains "Sitemap"
call "+15344297154" and check it was picked up
check that 2nd "peter" color is "ffaabb"
check that page return code is "404"
check that page did not change compared to the previous step
check that checkbox "Keep me signed in" is not checked

Example 2: Testing emails

send email to "[email protected]" with subject "Test message" and body "Hi, this is a test email."
check that email from "[email protected]" is delivered

check that email to "<random-user>@testrigor-mail.com" and "Confirm" in subject was received and show in mobile

login with email OTP

Example 3: Verifying text present within elements using OCR (optical character recognition)

Some web applications heavily rely on images for buttons, icons, or text. Standard Selenium or other locator-based tools struggle to interact with these directly. OCR allows testRigor to “read” the text within the image and interact with it based on that text. This is great for bypassing these unstable locators by identifying elements based on their visible text.

In the screenshot below, if you want to choose from one of the plans (four black tiles) based on snippets of the text written within them, then you can use testRigor’s OCR feature.

Check that page contains "Best value plan" using OCR

Example 4: Context-based validation with AI

check that page "contains a positive message in the chat response" using ai

grab value by description "10-digit phone number" using ai and save it as "phoneNumber"
check that statement is true "page contains testRigor logo"

check that page “contains an image of graph of negatively growing function” using ai

Read more: Graphs Testing Using AI – How To Guide.

With this feature, the sky is the limit for you! As you get more creative and experienced in forming effective prompts, you can test even more scenarios, like checking if there’s a man wearing spectacles in the image. Read more: Images Testing Using AI – How To Guide.

Can it get simpler and more straightforward than this?

No more confusion between soft assert and hard assert and complex test scripts. With this simplicity, anyone in your team can write and execute test cases quickly and easily, irrespective of their technical proficiency. What’s better is that these simplistic test cases are so self-explanatory that interpreting them is easy for all who are upholding the QA process. This helps break down silos, work together, and gain more test coverage with simplicity and stability.

Conclusion

testRigor allows you to write assertions in a natural, human-readable language. This approach is different from typical code-heavy assertion statements. If tools are available to aid you in your testing process, why not use them? testRigor helps you achieve excellent test coverage with minimum effort and test maintenance.

Your team can work together to write simple English test steps that are ultra-stable, unlike Selenium. Try testRigor today to experience its incredible features.

“We spent so much time on maintenance when using Selenium, and we spend nearly zero time with maintenance using testRigor.”

Keith Powe VP Of Engineering - IDT