What's in my Bag? EDC of a Tester

 

Responsibilities of a Tester working for a Startup

 

An Introduction to mind maps for testers

Why?

• Similar to identifying test conditions and done as part of the test analysis activity.
• Better medium to convey the test scope to other stakeholders than written test conditions.
• As relationships between branches and a complete picture can be seen, it can be a better guide than test conditions when test design is done.

How?

• Think in terms of categories, where supersets should be closely related than subsets.
• Think in terms of use case actors.
• Think in terms of quality characteristics
• Think in terms of architecture
• In terms of success and failure interactions.
• In terms of design techniques
• Classification tree
• Write in short form
• Level of detail should be decided on project requirements and constraints. If you have broken it down to the level of high-level test cases you have gone too far.

Multi Tab Support in Selenium Web Driver

Selenium Web Driver is capable of handling multiple browser tabs. Though the requirement to automate workflows that span multiple tabs is one that automation engineers don’t come across all the time, it’s always good to know how it can be done. 

	package com.dumiduh.other;
	import com.dumiduh.constants.Constants;
	import com.dumiduh.utils.TestBase;
	import org.openqa.selenium.By;
	import org.testng.annotations.AfterClass;
	import org.testng.annotations.BeforeClass;
	import org.testng.annotations.Test;
	import java.util.List;
	import java.util.stream.Collectors;
	public class MultiTabTest extends TestBase {
	@BeforeClass
	public static void setup() {
	instantiateDriver();
	driver.get(Constants.MULTI_WINDOW);
	}
	@Test
	public static void multiWindowTest() {
	System.out.println("URL:\t" + driver.getCurrentUrl());
	//opening a new tab
	driver.findElement(By.xpath("//*[text()='Click Here']"))
	.click();
	//A new tab has been opened.
	System.out.println("Number of tabs\t" + driver.getWindowHandles()
	.size());
	List<String> windows = driver.getWindowHandles()
	.stream()
	.map(window -> {
	return window;
	})
	.collect(Collectors.toList());
	driver.switchTo()
	.window(windows.get(windows.size() - 1));
	driver.get("https://www.yahoo.com");
	System.out.println("URL:\t" + driver.getCurrentUrl());
	}
	@AfterClass
	public static void cleanUp() {
	driver.quit();
	}
	}

view raw MultiTabTest.java hosted with ❤ by GitHub

Selenium Custom Locators

Selenium Web Driver supports both Xpath and CSS Locators as element locator strategies. As these strategies are comprehensive ideally there is no need to provide other abstract strategies such as ID and Class, but providing such strategies OOTB the designers of Selenium have lowered the entry barrier to automation using their library. So as framework developers you can take this further and provide other custom locator strategies to the users. The snippet below shows how a custom by class can be made to wrap around the XPath contains function.

	package com.dumiduh.utils;
	import org.openqa.selenium.By;
	import org.openqa.selenium.SearchContext;
	import org.openqa.selenium.WebElement;
	import java.util.List;
	public class Text extends By {
	private String searchTerm;
	private final String XPATH = "//*[contains(text(),'%s')]";
	public static By containsText(String searchTerm) {
	return new Text(searchTerm);
	}
	private Text(String value) {
	this.searchTerm = value;
	}
	@Override
	public List<WebElement> findElements(SearchContext context) {
	return context.findElements(By.xpath(String.format(XPATH, searchTerm)));
	}
	}

view raw Text.java hosted with ❤ by GitHub

	package com.dumiduh.other;
	import com.dumiduh.constants.Constants;
	import com.dumiduh.utils.Text;
	import com.dumiduh.utils.TestBase;
	import org.testng.Assert;
	import org.testng.annotations.AfterClass;
	import org.testng.annotations.BeforeClass;
	import org.testng.annotations.Test;
	/***
	* The objective of this test is to demonstrate the use of a custom locator.
	*/
	public class CustomeLocatorTest extends TestBase {
	@BeforeClass
	public static void setup() {
	instantiateDriver();
	driver.get(Constants.DYNAMIC_LOAD);
	}
	@Test
	public static void byContainsText() {
	Assert.assertTrue(driver.findElement(Text.containsText("Powered by")).isDisplayed(), "the expected text value was not found in the html document.");
	}
	@AfterClass
	public static void cleanUp() {
	driver.quit();
	}
	}

view raw CustomeLocatorTest.java hosted with ❤ by GitHub

A Comparison of Network Interception capabilities between Cypress and Selenium

Both Selenium and Cypress provide network interception capabilities. As the name implies, the capability allows the user to intercept HTTP requests and manipulate the response received for the given response. This is useful when you want to automate UI scenarios where the preconditions and steps required for the expected output can’t be easily produced.

To evaluate this capability I went about automating the 3 scenarios found below,

• Intercepting and waiting for a network resource attached to a web page to be received to the client side.
• Intercepting and simulating 400 and 500 errors.
• Intercepting and changing response payloads.

I found that Cypress provides HTTP level interception while Selenium simulates interception through the Web Driver client. And that interception in general is easier in Cypress. Selenium provides better control over response status code manipulation, but surprisingly selenium doesn’t provide a way to access the HTTP response codes through its client so asserting status code related scenarios may be more troublesome.

Cypress Examples

	/// <reference types='cypress'/>
	describe("Intercepting network resources", ()=>{
	it("Intercepting and waiting for a URL", ()=>{
	cy.intercept({
	method: "GET",
	url: "https://the-internet.herokuapp.com/css/app.css"
	}).as("slowResource")
	cy.visit("https://the-internet.herokuapp.com/dropdown");
	cy.wait("@slowResource").its('response.statusCode').should('eq', 200);
	})
	it("Intercepting and throwing a network error for a resource", ()=> {
	cy.intercept({
	method: "GET",
	url: "https://the-internet.herokuapp.com/dropdown"
	},{
	forceNetworkError: true
	}).as("slowResource")
	cy.visit("https://the-internet.herokuapp.com/dropdown");
	})
	it.skip("Intercepting and loging the request object", ()=>{
	cy.intercept({
	method: "GET",
	url: "https://the-internet.herokuapp.com/dropdown"
	}, (req) => {
	console.log(req);
	}).as("slowResource")
	cy.visit("https://the-internet.herokuapp.com/dropdown");
	cy.wait("@slowResource").its('response.statusCode');
	})
	it("Intercepting and replying with a static response", ()=>{
	cy.intercept('GET','https://the-internet.herokuapp.com/dropdown', {statusCode: 200, body: "<html><body>test</body></html>"}).as("slowResource")
	cy.visit("https://the-internet.herokuapp.com/dropdown");
	cy.wait("@slowResource").its('response.statusCode').should('eq', 200);
	})
	})

view raw NetworkInterception.cy.js hosted with ❤ by GitHub

Selenium Examples

	package com.dumiduh.other;
	import io.github.bonigarcia.wdm.WebDriverManager;
	import org.openqa.selenium.chrome.ChromeDriver;
	import org.openqa.selenium.devtools.NetworkInterceptor;
	import org.openqa.selenium.remote.http.Contents;
	import org.openqa.selenium.remote.http.HttpResponse;
	import org.openqa.selenium.remote.http.Route;
	import org.testng.annotations.AfterClass;
	import org.testng.annotations.BeforeClass;
	import org.testng.annotations.Test;
	import static org.openqa.selenium.remote.http.HttpMethod.GET;
	public class NetworkInterceptorTest {
	ChromeDriver driver;
	@BeforeClass
	public void setup(){
	WebDriverManager.chromedriver().setup();
	}
	@Test
	public void responseInterceptionError() {
	driver = new ChromeDriver();
	Route route = Route.matching(req -> GET == req.getMethod() && req.getUri()
	.endsWith("/dropdown"))
	.to(() -> req -> new HttpResponse().setStatus(500));
	new NetworkInterceptor(driver, route);
	driver.get("https://the-internet.herokuapp.com/dropdown");
	driver.getPageSource()
	.contains("HTTP ERROR 500");
	}
	@Test
	public void responseInterceptionBody() {
	driver = new ChromeDriver();
	Route route = Route.matching(req -> GET == req.getMethod() && req.getUri()
	.endsWith("/dropdown"))
	.to(() -> req -> new HttpResponse().setContent(Contents.utf8String("<html><body>test</body></html>")));
	new NetworkInterceptor(driver, route);
	driver.get("https://the-internet.herokuapp.com/dropdown");
	}
	@AfterClass
	public void cleanup(){
	driver.quit();
	}
	}

view raw NetworkInterceptorTest.java hosted with ❤ by GitHub

Abstracting the Test Layer using TestNG

The library architecture is popular among test automation framework designers. To follow this pattern, engineers decompose and abstract the automation logic at various conceptual levels, such as at the page, the component or at the element level. But usually, the test layer is left out of these decomposition efforts.

Leaving abstraction out of the test layer can in time lead to duplication of the logic as well as having to spend more time than what is required to script new scenarios. This post will discuss how the test layer can be abstracted and decomposed using TestNG.

High-level Steps

1. Start with designing and implementing test cases so that they are atomic
2. Encapsulate the test layer by scripting the test steps and adding assertions required to validate the component. Then put a mechanism in place to read the test data from an object that can be passed from one test class to another as required.
3. Finally, use the Factory feature in TestNG to compose the larger scripts using the test classes.

Let’s take a crude example of validating a web page with a dropdown[1]. For this example, I have identified the two test cases seen below,

1. Validate that the dropdown page loads the dropdown and that the values are as expected.
2. Validate that the dropdown allows the user to select the option he wants to select.

The test layers for the two test cases were scripted as seen below and were joined together using the factory annotation in the DropDrownTest class. Notice how the same test data object is passed between the two test cases.

Test Class 1

	package com.dumiduh.elements;
	import com.dumiduh.constants.Constants;
	import com.dumiduh.function.DropDownPageFunctions;
	import com.dumiduh.models.TestData;
	import com.dumiduh.utils.JSONUtil;
	import com.dumiduh.utils.TestBase;
	import org.testng.Assert;
	import org.testng.annotations.AfterClass;
	import org.testng.annotations.BeforeClass;
	import org.testng.annotations.Test;
	/**
	* The objective of this test class is to demonstrate how a dropdown maybe handled.
	*/
	public class DropDownUsageTest extends TestBase {
	@BeforeClass
	public static void setup() {
	instantiateDriver();
	driver.get(Constants.DROPDOWN_PAGE_URL);
	}
	@Test
	public static void dropDownUsageTest() {
	TestData testData = DropDownTest.data;
	System.out.println("::\t"+ testData.getDropDownSelection());
	DropDownPageFunctions dropDownPageFunctions = new DropDownPageFunctions(driver);
	dropDownPageFunctions.selectValueFromDropDown(testData.getDropDownSelection());
	//Asserts to see if the dropdown selection has been set.
	Assert.assertTrue(dropDownPageFunctions.isTheGivenValueSelected(testData.getDropDownSelection()));
	}
	@AfterClass
	public static void cleanUp(){
	driver.quit();
	}
	}

view raw DropDownUsageTest.java hosted with ❤ by GitHub

Test Class 2

	package com.dumiduh.elements;
	import com.dumiduh.function.DropDownPageFunctions;
	import com.dumiduh.models.TestData;
	import com.dumiduh.utils.JSONUtil;
	import com.dumiduh.utils.TestBase;
	import org.testng.Assert;
	import org.testng.annotations.AfterClass;
	import org.testng.annotations.BeforeClass;
	import org.testng.annotations.Test;
	import static com.dumiduh.constants.Constants.DROPDOWN_PAGE_URL;
	public class DropDownPageElementsTest extends TestBase {
	@BeforeClass
	public static void setup() {
	instantiateDriver();
	}
	@Test
	public static void dropDownPageElementTest() {
	TestData data = DropDownTest.data;
	driver.get(DROPDOWN_PAGE_URL);
	DropDownPageFunctions dropdown = new DropDownPageFunctions(driver);
	Assert.assertTrue(dropdown.isTheDropDownHeadingDisplayed());
	Assert.assertTrue(dropdown.isTheDropDownDisplayed());
	Assert.assertEquals(data.getNumberOfOptions(), dropdown.getTheListOfOptions()
	.size());
	if (dropdown.getTheListOfOptions()
	.containsAll(data.getListOfOptions())) {
	Assert.assertTrue(true);
	}
	}
	@AfterClass
	public void cleanUp() {
	DropDownTest.data.setDropDownSelection("Option 2");
	driver.quit();
	}
	}

view raw DropDownPageElementsTest.java hosted with ❤ by GitHub

Factory Class

	package com.dumiduh.elements;
	import com.dumiduh.models.TestData;
	import com.dumiduh.utils.JSONUtil;
	import org.testng.annotations.Factory;
	public class DropDownTest {
	static TestData data = JSONUtil.readAGivenTestDataItem("dropdownendtoend");
	@Factory
	public static Object[] DropDownTest() {
	return new Object[]{
	new DropDownPageElementsTest(),
	new DropDownUsageTest()};
	}
	}

view raw DropDownTest.java hosted with ❤ by GitHub

[1] - https://the-internet.herokuapp.com/dropdown

[repo] - https://github.com/handakumbura/SeleniumAutomationEmployerProfile/tree/feature/atomic_test_cases

Portability testing a web application UI with Selenium

Portability testing of web application UI can easily be handled with Selenium. To handle cross browser testing you can implement a driver instantiation pattern like the one shown below,

	public class TestBase {
	protected static WebDriver driver;
	public static void instantiateDriver() {
	if (BROWSER.equals("chrome")) {
	WebDriverManager.chromedriver().setup();
	ChromeOptions options = new ChromeOptions();
	driver = new ChromeDriver(options);
	} else if (BROWSER.equals("edge")) {
	WebDriverManager.edgedriver().setup();
	EdgeOptions options = new EdgeOptions();
	options.addArguments("start-maximized");
	driver = new EdgeDriver(options);
	} else{
	Logger.getAnonymousLogger().log(Level.INFO,"An unsupported browser argument was provided at run-time.");
	}
	}
	}

view raw TestBase.java hosted with ❤ by GitHub

For cross mobile agent testing, you can use a TestNG data provider to pass in the device types into your test method and repeat the test for as many emulated devices as you would like.

Find the complete project here, https://github.com/handakumbura/SeleniumAutomationEmployerProfile/tree/feature/cross_browser_cross_agent

	public class CrossMobileAgentTest extends TestBase {
	@AfterMethod
	public static void cleanUp() {
	driver.quit();
	}
	@Test(dataProvider = "userAgentsData")
	public static void testDataProvider(String s) {
	ChromeOptions options = new ChromeOptions();
	options.setExperimentalOption("mobileEmulation", Map.of("deviceName", s));
	driver = new ChromeDriver(options);
	driver.get(Constants.DROPDOWN_PAGE_URL);
	DropDownPageFunctions dropDownPageFunctions = new DropDownPageFunctions(driver);
	TestData testData = JSONUtil.readTestData("002");
	dropDownPageFunctions.selectValueFromDropDown(testData.getStringValue());
	//Asserts to see if the dropdown selection has been set.
	Assert.assertTrue(dropDownPageFunctions.isTheGivenValueSelected(testData.getStringValue()), "The given value was not set as the dropdown selection.");
	}
	@DataProvider(name = "userAgentsData")
	public static Object[][] generateData() {
	return new String[][]{{"iPhone 5"}, {"iPhone 6"}, {"Nexus 6"}};
	}
	}

view raw CrossMobileAgentTest.java hosted with ❤ by GitHub

How to read the user selection from a radio button group using Selenium?

SeleniumUtil library has been occupying my free time for the past couple of months. Since I’ve already written at length about what it is I won’t do that again here but if you really want to know you look here [1] [2].

When I implemented the abstraction wrapper for the HTML radio button group I ran into a problem. How would someone go about reading the user selection form a radio button group? Take a look at this HTML block,

According to the HTML5 spec, Radio Buttons belonging to the same group would have the same name attribute value. So toggling a given radio button using Selenium is not too difficult, but unlike Checkbox's the Radio Buttons I've seen in the wild (including this W3C example) doesn't append a checked attribute upon user selection. This complicates things.

I first tried retrieving the selection using the $0 variable that stores the user selection. But it turned out it was a browser specific variable that is not exposed to JavaScript. So how can we get a handle on this element and read its value? I did this,

	// store the value of the radio button that the user selects by attaching event handlers to the radio group members.
	window.radio; document.querySelectorAll('[name="age"]').forEach(elem => {elem.addEventListener('click',function(e){ window.radio = e.target.defaultValue})});
	// read the stored value later when the user has made the selection.
	return window.radio;

view raw RadioButtonSnippet.js hosted with ❤ by GitHub

But you can save all the pain because this snippet and bunch of other JavaScript goodies are available in SeleniumUtil 0.7.5.  

[1] - https://abuginthesystem.blogspot.com/2022/12/i-just-started-open-source-project-to.html

[2] - https://abuginthesystem.blogspot.com/2023/01/seleniumutil-070-is-now-available-with.html

SeleniumUtil 0.7.0 is now available with a few Java Script utility methods

Abstraction helps to promote code reuse and reduce development time among other benefits. When considering Selenium based test automation, you can abstract at many different points such as at dependency, infrastructure, technology, page, component or even at the element or locator level. SeleniumUtil is an open source library that aims to provide generic abstractions and other useful utilities so that you don’t need to worry about them in your Selenium based test automation projects.

Version 0.7.0 is now available in maven central and it provides a few technology level abstractions in the form of a few parameterized Java Script methods.

Usage

	package com.dumiduh.other;
	import com.dumiduh.constants.Constants;
	import com.dumiduh.utils.TestBase;
	import io.github.handakumbura.EventListener;
	import io.github.handakumbura.JavaScriptHelper;
	import org.testng.annotations.AfterClass;
	import org.testng.annotations.BeforeClass;
	import org.testng.annotations.Test;
	public class JavaScriptHelper extends TestBase {
	private static final String OPTIONS_BLOCK = "'<option>papaya</option><option>apple</option>'";
	private static final String DROPDOWN_CSS_SELECTOR = "#dropdown";
	private static final String CALLBACK = "function(){console.log('clicked')}";
	@BeforeClass
	public static void setup() {
	instantiateDriver();
	driver.get(Constants.DROPDOWN_PAGE_URL);
	}
	@Test
	public static void dropDownTest() {
	JavaScriptHelper javaScriptHelper = new JavaScriptHelper(driver);
	//pauses execution up to 2 minutes.
	javaScriptHelper.pauseTheDOMForAGivenDuration(5000);
	//attaches a valid and well-formed HTML block as a child of a given element.
	javaScriptHelper.appendHTMLBlockAsAChild(OPTIONS_BLOCK,DROPDOWN_CSS_SELECTOR);
	//attaches a callback function to a given event in the DOM.
	javaScriptHelper.attachASnippetAsAEventCallBack(DROPDOWN_CSS_SELECTOR, EventListener.CLICK,CALLBACK);
	}
	@AfterClass
	public static void cleanUp() {
	driver.quit();
	}
	}

view raw JavaScriptHelper.java hosted with ❤ by GitHub

[repo] - https://github.com/handakumbura/Seleniumuntil