Yumani's Blog

How to Scroll Down to an Element in Selenium WebDriver with Appium

2023-09-10T10:02:00.002-07:00

Let's say that you're automating a test scenario for a mobile application, and you need to interact with an element that is not initially visible on the screen. You need a way to scroll down until the element becomes visible, allowing you to perform actions on it.

To tackle this problem, you can create a reusable method that scrolls down to a specified element. This method will use the TouchAction class in Appium to simulate a touch-based scroll gesture until the element becomes visible.

Here's a sample method in Java:

public void scrollDownToElement(WebElement element) {
    Dimension size = driver.manage().window().getSize();
    int startX = size.width / 2;
    int startY = (int) (size.height * 0.8);
    int endY = (int) (size.height * 0.2);

    while (!element.isDisplayed()) {
        TouchAction<?> action = new TouchAction<>((PerformsTouchActions) driver);
        action.press(PointOption.point(startX, startY))
                .waitAction(WaitOptions.waitOptions(Duration.ofMillis(500)))
                .moveTo(PointOption.point(startX, endY))
                .release()
                .perform();
    }
}

Let's break down how this method works:

We obtain the screen dimensions to calculate the starting and ending points for the scroll gesture. So we set startX to the middle of the screen, startY to 80% down from the top, and endY to 20% down from the top.
We enter a while loop that continues until the specified element becomes visible.
Inside the loop, we create a TouchAction instance and perform the following steps:

press: We press at the starting point.
waitAction: We introduce a small delay (500 milliseconds) to allow the element to become visible.
moveTo: We move the touch to the ending point.
release: We release the touch action.

The scroll action is performed repeatedly until the element is displayed, indicating that it is now in view.

The scrollDownToElement method presented here provides a reusable solution for ensuring that your target element is within view, allowing you to automate interactions seamlessly. Happy testing!

Android Architectural Pattern - Databinding or 2 way Databinding.

2023-09-09T08:42:00.008-07:00

' We don't use resource Id's for these. They are designed using a different architectural pattern called data binding and in some cases 2 way data binding.'

This is what my friendly app lead told me when I told him I'd like to have 'resource IDs' for some of the elements in the UI. He further said to look 'automated testing using Android dataBinding' and for any hook onto the databindingImpl classes. Very useful hints :).. thanks G

Android DataBinding

Android DataBinding is a library that allows you to bind UI components in your app's layout files directly to data sources (e.g., ViewModel).

It simplifies the process of updating UI elements when data changes and can improve code readability

Steps to identify and interact with elements

Assuming you are using appium/java. Also you have setup necesssary env setup such as mobile capabilties and driver initialisation , server startup, here is how the element capturing happens.

Since DataBinding allows you to bind UI elements directly to data sources, it is a bit different from the traditional method of locating elements using resource IDs or XPath

In Android DataBinding layouts, UI elements are bound to data sources using expressions like @{viewModel.text}.

To locate and interact with these elements in your automated tests, you can use the driver.findElementByAndroidUIAutomator method.

You construct a UiSelector expression that matches the text or other attributes bound to the element.

In this case, I am looking for a TextView with the text matching viewModel.text.

import io.appium.java_client.android.AndroidElement;

// Locate TextView using DataBinding expression
AndroidElement textView = driver.findElementByAndroidUIAutomator(
    "new UiSelector().textMatches(\".*" + viewModel.text + ".*\")"
);

Once I have identified the element using DataBinding expression, I can perform various interactions such as clicking, sending text, or verifying properties.
```
// Click a button
button.click();
```

How to scroll down in ScollView uiElement using Selenium WebDriver with Appium

2023-09-08T15:52:00.008-07:00

A ScrollView is a common UI element in mobile app development, particularly in Android and iOS development. It's used to create a scrollable view that can contain content that doesn't fit entirely on the screen, allowing users to scroll vertically or horizontally to see more content.

Now let's see appium code for scroll ingto an element within a ScrollView in Android.

 public void scrollDownInScrollView(WebElement scrollview) {
        // Calculate screen dimensions
        int screenHeight = driver.manage().window().getSize().getHeight();

        // Define scroll points
        int startX = scrollview.getLocation().getX() + scrollview.getSize().getWidth() / 2;
        int startY = scrollview.getLocation().getY() + scrollview.getSize().getHeight() * 3 / 4;
        int endY = scrollview.getLocation().getY() + scrollview.getSize().getHeight() / 4;

        // Perform the scroll action
        TouchAction<?> action = new TouchAction<>((PerformsTouchActions) driver);
        action.press(PointOption.point(startX, startY))
                .waitAction(WaitOptions.waitOptions(Duration.ofMillis(500)))
                .moveTo(PointOption.point(startX, endY))
                .release()
                .perform();
    }

Test tours

2023-08-15T13:36:00.005-07:00

To explain test tours, I will start with exploratory testing.

Explotatory testing is a more creative way of testing, but doesn't mean to say it is a random testing as well. Experts say exploratory can be more effective when we make use of test chrters.

Test tours is one of the methods that we can adopt to write test charters (test purpose) for exploratory testing.

Below are some of the tours that I found in the web. All kudos to this page [1]. I am copying and pasting it here for my notes.

Obsessive-Compulsive tour: This tour aims to repeat the same action as often as possible. This tour can reveal bugs like applying the discount twice.

Bad-Neighborhood tour: Explore the area or feature that has the most errors. In this tour, you spend time on areas known to have issues.

Supermodel tour: This tour focuses only on surface looks and the impressions it makes. Test the UI interface and design elements like layouts, icons, flows, and colors.

Museum tour: Test code that developers didn't change in a while. You can experiment with how the code functions in new environments (Android, iOS, etc.).

UiAutomatorViewer isn't working with higher java versions.

2023-07-30T10:53:00.008-07:00

I was getting this error when tried with my default Java 11;

./uiautomatorviewer -Djava.ext.dirs=/Users/yumani/Library/Android/sdk/tools/lib/x86_64:/Users/yumani/Library/Android/sdk/tools/lib is not supported. Use -classpath instead. Error: Could not create the Java Virtual Machine. Error: A fatal exception has occurred. Program will exit

The problem seems to be caused by the usage of the -Djava.ext.dirs option, which is not supported in newer versions of Java.

Then, I used use -classpath option to set the classpath and got this error

yumani@Yumanis-MacBook-Pro bin % ./uiautomatorviewer -classpath /Users/yumani/Library/Android/sdk/tools/lib/x86_64:/Users/yumani/Library/Android/sdk/tools/lib -Djava.ext.dirs=/Users/yumani/Library/Android/sdk/tools/lib/x86_64:/Users/yumani/Library/Android/sdk/tools/lib is not supported. Use -classpath instead. Error: Could not create the Java Virtual Machine. Error: A fatal exception has occurred. Program will exit.

I am on Java11, tried different options in the net such as upgratig sdk-tools, downloading swt.jar.

Non worked for me in macOS Ventura.

The web advise that worked was downgrading to jdk 1.8.

So I installed jdk 1.8, updated in .bash_profile, commented out my older version (because I want to switch back to it when I am not using the UiAutomatorViewer.

source ~/.bash_profile

yumani@Yumanis-MacBook-Pro sdk % tools/bin/uiautomatorviewer -classpath /Users/yumani/Library/Android/sdk/tools/lib/x86_64/swt.jar

How to identify the main actvity from the AndroidManifest.xml

2023-07-30T03:04:00.006-07:00

When you setup applium capacbilities giving the app package and app activity, you have to give the main activity as the app activity.

Here is how you identify the main activity from AndroidManifest.xml when it has multiple activities.

Locate the AndroidManifest.xml:

The AndroidManifest.xml file is located in the app folder of your Android project. The typical path is app/src/main/AndroidManifest.xml.

Open the AndroidManifest.xml:

Use a text editor or an XML editor to open the AndroidManifest.xml file.

Search for <activity> tags:

Inside the AndroidManifest.xml, look for <activity> tags. Each <activity> tag represents an activity (screen) of the Android application.

Find the Main Activity:

The AppActivity is usually the main activity of the app. It is the entry point of the application, and its intent filter is often set to respond to the android.intent.action.MAIN and android.intent.category.LAUNCHER actions.

Look for Intent Filters:

Inside the <activity> tags, check for <intent-filter> tags. The AppActivity should have an <intent-filter> that includes the android.intent.action.MAIN and android.intent.category.LAUNCHER actions.

Extract the AppActivity Name:

Extract the value of the android:name attribute from the <activity> tag that has the <intent-filter> with the android.intent.action.MAIN and android.intent.category.LAUNCHER actions. The value of android:name attribute will be the AppActivity.

<activity

android:name=".ui.MainActivity"

android:label="@string/app_name">

<intent-filter>

</intent-filter>

</activity>

In this example, the AppActivity is .ui.MainActivity.

Hybrid approach to Automation

2023-03-31T06:41:00.007-07:00

What does hybrid approach to test automation mean?

It's a strategic approach that aims to support better maintainability and reduce flakiness in end-to-end (E2E) test automation. This approach involves using a combination of API tests and UI tests.

In scenarios where certain prerequisites must be met before attempting the actual test, we can use endpoint calls/API tests to achieve these prerequisites. Then, we can use webdriver tests for UI-level functional validations/assertions.

By using this approach, we can redice the flakiness that may come from webdriver tests due to delays, object changes, and other issues. This approach is particularly useful for sections of the test case that are outside the main test case.

Let me explain with an example:

In here we are doing a mandatry field validation check; Our featue file is as below;

Scenario: Mandatory fields validation
Given I am a registered user
And I go to the accounts page
And I leave the basic salary field blank
When I try to move to the next page
Then a validation error message is displayed for the basic salary field

My step definition will be like this;

public class MandatoryFieldsValidationStepDefinitions {

    @Given("I am a registered user")
    public void iAmARegisteredUser() {
        // Code to implement the Creat user step using RestAssured API
        
    }

    @And("I go to the accounts page")
    public void iGoToTheAccountsPage() {
        // Code to implement the "And" step using Appium
        // Navigate to the accounts page using Appium
    }

    @And("I leave the basic salary field blank")
    public void iLeaveTheBasicSalaryFieldBlank() {
        // Code to implement the "And" step using Appium
        // Find the basic salary field element and clear its value
    }

    @When("I try to move to the next page")
    public void iTryToMoveToTheNextPage() {
        // Code to implement the "When" step using Appium
        // Find the "Next" button element and click it
    }

    @Then("a validation error message is displayed for the basic salary field")
    public void aValidationErrorMessageIsDisplayedForTheBasicSalaryField() {
        // Code to implement the "Then" step using Appium
        // Find the error message element for the basic salary field and verify it is displayed
    }
}

So how do we support this in our test framework? Since the CucumberRunner takes care of executing the features by mapping them with the correct step definition, all we have to do is ensure that our design is correct and that relevant API testing and webdriver libraries are included in the project.

A sample automation framework structure for a Maven project is shown below;

CT Server?

2023-03-30T06:27:00.005-07:00

What is CT Server?

Recently, I have been reading a lot, or rather more than usual, about Continuous Testing. In fact, I have been trying to design such a process here at BlackArrow. However, today I came across some real details about the CT Server.

So, what is a CT Server? It refers to Continuous Testing server. The blog post that I read advised against using Jenkins for CT. Also, E2E testing is not something that Jenkins deals with in CI builds.

Instead, the author recommends using CT servers, such as BuildWise, which is an open-source software. I am yet to explore how it does things, but I'll be back with another post soon.

CucumberRunner sample

2023-03-21T07:49:00.006-07:00

In this example file, I've added the following options while extending the AbstractTestNGCucumberTests class

import cucumber.api.CucumberOptions;
import cucumber.api.testng.AbstractTestNGCucumberTests;

@CucumberOptions(
        features = "src/test/resources/features",
        glue = {"step_definitions"},
        tags = "@JREQ-BA001-2088 or @smoke or @SE",
        plugin = {
                "pretty",
                "html:target/cucumber-html-report",
                "json:target/cucumber.json",
                "rerun:target/rerun.txt"
        },
        strict = true,
        monochrome = true,
        dryRun = false,
        snippets = cucumber.api.SnippetType.CAMELCASE
)
public class MyTestRunner extends AbstractTestNGCucumberTests {
}

tags: Allows you to run only scenarios with specific tags. In this case, we're running scenarios with any of the three tags specified in the feature file. I have the story ticket, the test inclusion category and the feature tagged.
plugin: This specifies the output formats for the Cucumber report. In addition to the "pretty" format, we're also generating an HTML report, a JSON report, and a rerun file (which lists any scenarios that failed on the first run and need to be rerun).
strict: If set to true, Cucumber will fail if there are any undefined or pending steps. I prefer to have this set to false and user the power of the dryRun option.
monochrome: This makes the output in the console easier to read by removing colour and special characters.
dryRun: If set to true, Cucumber will check that all steps have corresponding step definitions, but won't actually run the scenarios. This can be useful for quickly checking that your step definitions match your feature file.
snippets: This specifies the naming convention for generated step definitions. In this case, we're using CamelCase naming.

Chosen path for using feature files to call my test daa

2023-03-17T09:25:00.003-07:00

This is a summary of the findings from my research past week.

Out of these, I am choosing the method 3 considering the plus points that I could think of..

Using feature files for API test automation - 3

2023-03-14T16:57:00.010-07:00

In here the entire user payload is read from the examples table and stored as a Map in the step definition.

This approach is useful when you have a small number of fields in the request body, and you can easily read them from the feature file's data table.

Scenario Outline: Create User Successfully

    Given the user payload is:
      | first_name    | <first_name> |
      | last_name     | <last_name>  |
      | email         | <email>      |
      | mobile_phone  | <mobile_phone> |
      | date_of_birth | <date_of_birth> |
      | password      | <password>   |
      | username      | <username>   |

    When I send a <method> request to <path>

    Then the response status code should be <status_code>

    Examples:
    | first_name | last_name | email                 | mobile_phone | date_of_birth | password  | username | method | path           | status_code |
    | John       | Doe       | john.doe@example.com  | 1234567890  | 1990-01-01    | password | johndoe  | POST   | /users/create | 201         |

My stpe definition is as below;

public class CreateUserStepDefinitions {

    private RequestSpecification requestSpec;
    private Response response;
    private Map<String, String> userPayload = new HashMap<>();

    @Given("the user payload is:")
    public void the_user_payload_is(Map<String, String> userData) {
        this.userPayload = userData;
    }

    @When("I send a {string} request to {string}")
    public void i_send_a_request_to(String method, String path) {
        requestSpec = RestAssured.given()
                .contentType(ContentType.JSON)
                .body(userPayload);

        response = requestSpec.when()
                .request(method, path);
    }

    @Then("the response status code should be {int}")
    public void the_response_status_code_should_be(int expectedStatusCode) {
        assertEquals(expectedStatusCode, response.getStatusCode());
    }

}

Let me explain the java bits in here -

In the method the_user_payload_is, the Map<String, String> userData parameter contains the data that was provided in the Examples table of the feature file. The data is in key-value pairs where the key represents the column header and the value represents the corresponding cell value.

this.userPayload variable is an instance variable of the class (which means it can be accessed from any method within the class). In the_user_payload_is method, we are assigning the userData map to the userPayload instance variable. This is done so that we can access the userPayload map in other methods within the class, specifically the i_send_a_request_to method.

In the i_send_a_request_to method, we are using the userPayload map as the body of the request.

The RestAssured.given() method is used to start building the request. It is followed by the .contentType(ContentType.JSON) method, which specifies that the request body will be in JSON format. The .body(userPayload) method sets the request body as the userPayload object, which contains the data for creating a new user.

The requestSpec.when().request(method, path) method is then called to send the request to the server with the given method and path. This method returns a response object, which is stored in the response variable for later use in the_response_status_code_should_be method.

Two different flavours of feature files

2023-03-13T10:49:00.000-07:00

Format 1 - Scenario outline with example table

Given I have a valid auth token
When I submit a POST request to create a user with the following details:
| first_name  | last_name    | email    | mobile_phone | date_of_birth | password    | username    |
| <first_name>| <last_name>  | <email>  | <mobile_phone>| <date_of_birth> | <password>  | <username>  |
Then the response status code should be <status_code>

Examples:
| first_name | last_name| email                 | mobile_phone | date_of_birth | password    | username    | status_code |
| John       | Doe      | johndoe@example.com   | 1234567890   | 1990-01-01    | password123 | johndoe123  | 201         |
| Jane       | Smith    | janesmith@example.com | 0987654321   | 1985-02-14    | password456 | janesmith12 | 201         |

This format gives a higher level of abstraction where the same scenario is run multiple times with different sets of data. Yes data including the expected result as well.

This format is useful when you don't want to repeat the same scenario. Also when you have a simpler payload.

Format 2 - Single Scenario with Given\When\Then steps

Feature: Create User API

  Scenario: Create User Successfully
    Given the user payload is:
      | first_name    | John                 |
      | last_name     | Doe                  |
      | email         | john.doe@example.com |
      | mobile_phone  | 1234567890           |
      | date_of_birth | 1990-01-01           |
      | password      | password             |
      | username      | johndoe              |
    When I send a {method} request to {path}
    Then the response status code should be 201
    |method   | path         | status_code |
    | POST    |/users/create"|201          |

This gives more detailed description of the scenario. Each @Given, @When, @Then step is elaborated with relevant data.

In this case you may be having more specific scenarios and conditions.

Using feature files for API test autimation - 2

2023-03-12T16:24:00.008-07:00

Feature file

Similar to the last post, I'm usinng RestAssured for API test automation. Cucumber is used for mapping the feature scenarios. Also extending AbstractTestNGCucmberTests to run the test suite.

Difference is the way the payload is handled. Instead of reading the payload from exmaple tables, I am loading it from a json file.

This way it gives me more flexibility in managing test data/payloads.

I am still using exmaple tables to read other paramaters via <> tags in my featuer file .

Feature: Create User API

  Scenario Outline: Create User Successfully
    Given the user payload file is <data_file>
    When I send a <method> request to <path>
    Then the response status code should be <status_code>

    Examples:
    | data_file                             | method | path                  | status_code |
    |/test/java/resources/user_details.json | POST   | /user_accounts/create | 201         |

Payload file

{
  "first_name": "John",
  "last_name": "Doe",
  "email": "john.doe@example.com",
  "mobile_phone": "1234567890",
  "date_of_birth": "1990-01-01",
  "password": "p@ssword_1",
  "username": "johndoe"
}

CreateUserStep.java

public class CreateUserSteps{
    private RequestSpecification requestSpec;
    private Response response;
    private String requestBody;

    @Given("the user payload file is {string}")
    public void the_user_payload_file_is(String filePath) {
        requestBody = TestDataUtil.getJsonRequestString(filePath);
    }

    @When("I send a {string} request to {string}")
    public void i_send_a_request_to(String method, String path) {
        response = requestSpec.contentType(ContentType.JSON)
                .body(requestBody)
                .when()
                .request(method, path);
    }

    @Then("the response status code should be {int}")
    public void the_response_status_code_should_be(int statusCode) {
        response.then().statusCode(statusCode);
    }
}

Using feature files for API test autimation - 1

2023-03-12T16:18:00.011-07:00

I am usinng RestAssured for API test automation. Cucumber is used for mapping the feature scenarios with the implmentation. In other words we have use of gherkin language in feature files and replication of same in stepdefinitions which has my restAuured/java test implementations.

Since I am a fan of TestNG's capabilities I am extending AbstractTestNGCucmberTests.

Feature file

Feature: Create User API

  Scenario: Create User Successfully
    Given the user payload is:
      | first_name    | John   |
      | last_name     | Doe    |
      | email         | john.doe@example.com |
      | mobile_phone  | 1234567890 |
      | date_of_birth | 1990-01-01 |
      | password      | password |
      | username      | johndoe |
    When I send a {method} request to {path}
    Then the response status code should be 201
    |method  | path         | status_code |
    | POST    |/user_account/create"|201         |

StepDefinitions

To handle the payload, I am using .replace method, where values in an existing jsom template is replaced with the data in exmaple table.

The helper class TestDataUtil, uses its updateJsonRequestString method to get us the payload. This is what is does;

First it reads the content of the json file. Then it replaces all the placeholders in it with the corresponding values in the data table. Also saves it as a String. The modified String is then written back to the json file. This updated json file is assigned to requestBody variable.


public class CreateUserSteps {
        private RequestSpecification requestSpec;
        private Response response;
        private String requestBody;

    @Given("the user payload is:")
    public void the_user_payload_is(Map<String, String> dataTable) {
        String requestBody = TestDataUtil.updateJsonRequestString("create_user.json")
                .replace("{{first_name}}", dataTable.get("first_name"))
                .replace("{{last_name}}", dataTable.get("last_name"))
                .replace("{{email}}", dataTable.get("email"))
                .replace("{{mobile_phone}}", dataTable.get("mobile_phone"))
                .replace("{{date_of_birth}}", dataTable.get("date_of_birth"))
                .replace("{{password}}", dataTable.get("password"))
                .replace("{{username}}", dataTable.get("username"));
    }

    @When("I send a {string} request to {string}")
    public void i_send_a_request_to(String method, String path) {
        response = requestSpec.contentType(ContentType.JSON)
                .body(requestBody)
                .when()
                .request(method, path);
    }

    @Then("the response status code should be {int}")
    public void the_response_status_code_should_b(int expectedStatusCode) {
            response.then().statusCode(expectedStatusCode);
    }
    
}

Selenium - Configure TestNG to your Selenium framework.

2022-12-12T16:00:00.005-08:00

To enable TestNG features in out test framework, as the first step we need to load the TestNG libraries to our test development environment(Eclipse).

Go to mvnreposotory.com and type in "testng"in the search bar.
In the search results, select the latest available for dependency version. At the time of writing this blog I got below 7.6.1 version.
Copy maven syntax for the dependency, so that we can paste it to our pom.xml.
Once copied append it to the pom.xml of your maven project (which the framework was being built.
Accordingly I added below to my pom.xml.

<!-- https://mvnrepository.com/artifact/org.testng/testng -->
<dependency>
    <groupId>org.testng</groupId>
    <artifactId>testng</artifactId>
    <version>7.6.1</version>
    <scope>test</scope>
</dependency>

Also we need to install the testNG plugin to the IDE. Go to Help >> Eclipse Market Place >> search for "TestNG"

Select to install the plugin and you are good.

TestNG - files structure

2022-12-01T04:04:00.002-08:00

Structure of the TesNG.xml file consists elements as below.

<suite>
    <test name = "">
         <classes>
            <class name="" />
         <classes>
    </test>
    <test name = "">
        <classes>
            <class name="" />
        <classes>
     </test>
</suite>

Each testNG xml pockets its content within the parent <suite> tags.
test tags is the next main level and you can have many test tags. These specify the module.
classes comes next. This helps goup the many classes you have under a certain test module
class is the smallest element which carries the class name.

Example of a sample TestNG is as below;

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite parallel="tests" name="ShoppingCart">

  <test thread-count ="5" name="Submit Order Tests">
    <classes>
      <class name="learningspace.tests.SubmitOrderTest"/>
    </classes>
  </test>
  
  <test thread-count ="5" name="Error Validation Tests">
    <classes>
      <class name="learningspace.tests.ErrorValidationTests"/>
    </classes>
  </test>
  
</suite>

Beginners spot - Pushing your work to GitHub

2022-11-20T13:30:00.004-08:00

1. Login to your GitHub account and create the repo

2. Go to command prompt;

git config --global user.name "yumani"

git config --global user.email "yumani@gmail.com"

3. Navigate to the location of the local repo and use the below commands.

It will initialize the repo, add the files and push to the origin with the comments.

git init

git add *

git status

git commit -m "Adding the initial file set"

git remote add origin https://github.com/yumaniranaweera/snuggery.git

git push origin master

4. You can import the files structure to your Eclipse editor from "File >> Import>>

Beginners Spot - Setup Maven in Test Automation environment

2022-11-15T16:18:00.006-08:00

1) Install Maven (Windows)

- Download from maven website and unzip the file.

- Set MAVEN_HOME - <base dire>\apache-maven-3.8.6

- Add to path - <base dire>\apache-maven-3.8.6\bin

2) Test the installation

- Open cmd and type mvn --version

- Should return maven home, version etc.

3) Create a maven project in Eclipse ( You can use maven-quickstart-archetype)

4) Integrate to Eclipse

- Apply Maven Surefire plugin to Eclipse.

- Go to Maven Surefire plugin page >Usage (https://maven.apache.org/surefire/maven-surefire-plugin/usage.html)

- Copy the plugin management snippet and paste in the pom.xml in your eclipse project.

<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.0.0-M7</version>
</plugin>
</plugins>
</pluginManagement>
</build>

Paste this above your dependencies section in the pom.xml.

- now you can run mvn clean, mvn test commands.

5) Integrate TestNG

- We need to add an additional configuration to the plugins section in the pom.xml

- Go to https://maven.apache.org/surefire/maven-surefire-plugin/examples/testng.html

<configuration>
<suiteXmlFiles>
<suiteXmlFile>testng.xml</suiteXmlFile>
</suiteXmlFiles>
</configuration>

- Also you need to add the TestNG dependency to the pom.xml, if its not already added.

Selenium - Explicit wait

2022-11-12T13:33:00.002-08:00

This post is not about explicit wait concept in Selenium. But about how we could convert standard explicit wait command to an action method.

So our standard command set is like this:

	WebDriverWait wait = new WebDriverWait(driver,Duration.ofSeconds(5));
	wait.until(ExpectedConditions.visibilityOfAllElementsLocatedBy(By.cssSelector(".mb-3")));

Lets make the action class;

public void waitExplicity(By findBy) {
	WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
	wait.until(ExpectedConditions.visibilityOfAllElementsLocatedBy(findBy));																									
}

This is a reusable method and therefore we should maintain it within the Abstract Components of our test framework.

(btw, hope you noticed the By locator being sent into wait.until as a parameter. The child class which will be extending the AbstractComponent class should set the value for this.)

Selenium - POM and Action Methods - 2

2022-11-12T08:20:00.007-08:00

Lets check how the below segment can be changed to page object model.

List<WebElement> products = driver.findElements(By.cssSelector(".mb-3"));	

WebElement prod =products.stream().filter(product->
product.findElement(By.cssSelector("b")).getText().equals(productName)).findFirst().orElse(null);

prod.findElement(By.xpath("//div[@class='card-body']/button[2]")).click();

Lets take the web element descriptions first; Here we are locating a products list (findElements by the classname csslocator). Since its a list we make it of the type List<WebElement> (line 1). This is how it is done by using @FindBy (we discussed in part 1)

@FindBy(css = ".mb-3")
List<WebElement> products;

Afterwards we can do an action class to findElements. I have called a wait method from the abstract components. You can ignore that for the moment. -- let's not distract ourselves with that in this post peepsies ..

public List<WebElement> getProductList(){
	waitExplicity(productBy);
	return products;
}

Next (line 3-4) we go through the list and filter the product which matches the product name that we specify through a String. This is how it is converted to an action method.

public WebElement getProductByName(String productName){
	WebElement prod =getProductList().stream().filter(product->
	product.findElement(By.cssSelector("b")).getText().equals(productName)).findFirst().orElse(null);
	return prod;
}

Let me add bit of details here; If you look at the line 3 of our first code snippet, the stream filter results are assigned to a variable called prod. How is the prod extracted? By traversing though the products, which is the list of products. With me? ook one step ahead-

How do we get the products from our POM & Action Methos approach? via the getProductList action method.

So that's what we have done above. We have getProductList().stream().filter .... instead previous products.stream().filter ....

Now next is the fun part! See what we do when we do addToCart.

public void addToCart(String productName){
		WebElement chosenProduct = getProductByName(productName);
		chosenProduct.findElement(addtoCartBtn).click();
}

We use getProductByName(productName) and assign the returning WebElement to 'chosenProduct' variable. same concept as above. The list web element is replaced by the action method that we created to get the list webelement.

In the next line we do a findElement from within the chosenProduct context, not driver context (noticed!) This is not POM struff. Its about how Selenium facilitate different locator contexts.

However, we cannot use the elements defined in POM to other context. Only driver context could use them. So we have to use the long By.locator methods or we could defined them separately and use here. See.. notice the line 1 below.

By addtoCartBtn = By.xpath("//div[@class='card-body']/button[2]");

public void addToCart(String productName){
	WebElement chosenProduct = getProductByName(productName);
	chosenProduct.findElement(addtoCartBtn).click(); //You cannot use Page objects when you are using a WebElement context
}

So that's about what I learnt on this.. See below for the connected code.

        @FindBy(css = ".mb-3")
	List<WebElement> products;

	//WebElements defined under By type to be used in WebElement context. 
	//You can use POs only in driver context
	By productBy = By.cssSelector(".mb-3");
	By addtoCartBtn = By.xpath("//div[@class='card-body']/button[2]");
	
	public List<WebElement> getProductList(){
		waitExplicity(productBy);
		return products;
	}
	
	public WebElement getProductByName(String productName){
		WebElement prod =getProductList().stream().filter(product->
		product.findElement(By.cssSelector("b")).getText().equals(productName)).findFirst().orElse(null);
		return prod;
	}
	
	public void addToCart(String productName){
		WebElement chosenProduct = getProductByName(productName);
		chosenProduct.findElement(addtoCartBtn).click();
	}

Selenium - Page Object Model and Action Methods

2022-11-12T04:53:00.012-08:00

How we change this code to PageObjectModel and action classes.

1
2
3

driver.findElement(By.id("userEmail")).sendKeys("testA1@gmail.com");
driver.findElement(By.id("userPassword")).sendKeys("testA1#");
driver.findElement(By.id("login")).click();

Page Objects

We can convert the locators to Page Objects this way

/*	Page Objects Model*/
	@FindBy(id="userEmail")
	WebElement useremail;
		
	@FindBy(id="userPassword")
	WebElement userpass;
		
	@FindBy (id="login")
	WebElement login;

How do we do it

1- Use @FindBy from org.openqa.selenium.By in Selenium. Consider this is replacing "driver.findElement(By" in our standard way of locating elements.

2- Next put the locator type; id, css, xpath, classname etc

3- Add the relative value next to the locator type. For an example, if you choose 'id' as the locator type, you should get the 'id' of the element. In my case the id of the element that I chose is 'userEmail'. So I build my line like this; @FindBy(id="userEmail")

4- That's not all; We need to let Selenium know what the web element is. So add this.

WebElement <element>. In my case WebElement username;

5- So it makes up our page objects this way;

@FindBy(id="userEmail")

WebElement userName;

Action Classes

As action we input username, pass and press login button. I will show you how these can be segmented out to an action class;

public void Login(String email, String pass){
	useremail.sendKeys(email);
	userpass.sendKeys(pass);
	login.click();
}

I think you can easily see how we have used each of the above page objects to action.

eeasy ha !! wait for more cool stuffs peeps :)

Selenium - Composite Actions

2022-11-04T14:02:00.012-07:00

Amazing piece that I learnt today; Composite actions. Its a concept in which you carry several action commands within one line of Selenium code.

For an example, un the below syntax I perform these actions;

move to the search bar, press it, hold down shift key and enter a text and then double-clicking on the text.

So how is it done.

We have used the "Actions" class within org.openqa.selenium.interactions.Actions.

Actions a = new Actions(driver);
WebElement caps = driver.findElement(By.xpath("//input[@id=\"twotabsearchtextbox\"]"));
a.moveToElement(caps).clickAndHold().keyDown(Keys.SHIFT).sendKeys("iphoneX").doubleClick().build().perform()

It supports many actions such as below

clickAndHold().

keyDown(Keys).

sendKeys("iphoneX")

doubleClick()

Once you have selected the action classes required for your test, in Selenium Java you need to end the command with .build().perform();

Complete code is as below;

Selenium - Xpath Locators

2022-11-04T14:02:00.011-07:00

1. By Tagname

//tagname[@attribute='value']

driver.findElement(By.xpath("//input[@placeholder='Name']"))

2. By index of the attribute

//tagname[@attribute='value'][index]

driver.findElement(By.xpath("//input[@type='text'][2]"))

Used when your attribute and the value are same for multiple elements

3. By tagnames when there are many instances of the childtag.

//parenttag/childtag[index])

driver.findElement(By.xpath("//form/input[3]"))

Use index when there are many instances of child tag and you have to locate one of them.)

4. By parent to child-tag

//parenttag[@attribute='value']/childtag[index])

driver.findElement(By.xpath(" //div[@class='forgot-pwd-btn-conainer']/button[1]"))

5. With regular expression

//tagname[contains(@class,'value')] driver.findElement(By.xpath("//button[contains(@class,'submit')]"))

Revisiting ESB

2022-06-13T11:31:00.014-07:00

Messaging Architecture

High-level Architecture

Back in WSO2 ..❤️

2022-06-13T10:08:00.002-07:00

It's been more than 5 years since I've last blogged here! Also, that's almost the same length of time that I was away. Away from WSO2.

During the last 5+ years I was working for an organization in the telecommunication domain. With them, I joined to head the Production support to WSO2 based product platform they had and then gradually picked up, Delivery, Product management and finally headed a product department. Not only that I was moved across 3 company logos within the same group!! I guess it explains the dynamics. Entirely a roller-coaster ride which was made okay by certain lead levels and dear teams I engaged with during the journey.

This June, I joined WSO2 again. Much thankful to Sanjiva, Customer Success leadership for accepting me.

Today's post is all to say how grateful it feels to join again.

Onboarding program at WSO2 simply re-confirms how well you would be looked after.

Initial interfacing by the HR teams to collect my data, personalized couriering of the brand new Apple MacBook Pro and broad welcome greet followed by the amazing onboarding orientation. There was so much attention by WSO2 to all the details. Things like EPF form was sent home with an ink pad and filled form to be collected by the company arranged currier. Comprehensive hands-on session with digi-ops to set up the laptop, mail, apps, etc, so you can operate as everyone else from the day 1 itself! Each of the department joined the induction program to tell new employees about what they do how we can engage. I am sure each batch must be feeling very special and totally ready by the time they are through this program.

Induction hands you over to your lead who discusses their planned programs with necessary buddy support etc.

Yeap.. That was my first 4 days after re-joining!

Looking forward to serve at my best and enjoy every min of it!