General

One ReplaceAll Statement to Rule Them All!

Published August 9, 2018 | By Don Pedro

Well, sort of.

In reviewing my code to make it more efficient, I noticed I have several variations on the .replaceAll() statement. In some case I'm trying to remove the $ and , from a value. In others I'm trying to remove the newline and CRLF characters. For another the goal was to remove the ( and ) from a value. And yet another was for the \ in a date. On top of this, I called replace several times in a row in order to remove specific characters or a string.

While those work, there is a way to accomplish this in a single call and return just the number I'm really looking for.

For example, I have the value $5,573,127 and want just the integer value. That can be done with:

tempText=tempText.replaceAll("[^0-9]","").toInteger()

Everything that isn't a number will be removed and I'll have 5573127 as an Integer. This includes ()[]$,. and -.

If the value is -$5,573,127.35 and I need to keep the decimal or the negative, it's a simple change to add them at the end as values to keep.

tempText=tempText.replaceAll("[^0-9.-]","").toDouble()

Now, if there is additional text, such as "Showing 1 to 8 of 2,056 entries", that can be handled by passing the text string to remove to the .replaceAll(). We then use the pipe | delimiter to indicate there is more conversion we wish to make.

tempText="Showing 1 to 8 of 2,056 entries"
removeText="Showing 1 to 8 of"
tempText=tempText.replaceAll(removeText + "|[^0-9]","").toInteger()
or
tempText=tempText.replaceAll("1 to 8|[^0-9]","").toInteger()

We now have 2056 as the number of entries. We specifically need to remove the 1 to 8 text or else the 1 and 8 will be retained giving us 182056 as a result, which is incorrect.

This will save quite a few lines of codes and make the .replaceAll() much more consistent across my projects. It pretty much won't matter what I'm reading, it'll be easy to get back just the number with one command.

Call the same Test Case twice with a Custom Keyword

Published August 6, 2018 | By Don Pedro

I recently had cause to run a series of tests where I needed to call the same Test Case multiple times, something Katalon Studio does not inherently support. For my test, I wanted to enter several pieces of information into a form, then perform the same validation steps to check table data. The validation steps are the same each time, so I wanted to reuse the test case. No such luck, Katalon Studio does not allow you to add the same Test Case name to the Test Suite.

My first thought was to duplicate each Test Case multiple times, putting a number in front. That seemed awkward and wasteful. I then noted I could go into the Test Suite XML file itself and repeatedly add the same Test Case name multiple times.

While interesting, each Test Case is tied to a GUID, so I would need to make a fake one and that's by no means to maintain. And if someone makes a change to the Suite, most likely everything will come apart like a house of cards.

Turns out I can do what I want by creating a Custom Keyword that calls all my Test Cases. My Test Case will prepare all the data by populating the fields, then at the end of Test, there will be a call to the Custom Keyword, which will run all the tests. It sounds a little odd, but this is at least easy to maintain and is far cleaner than hacking together an XML file.

The structure of the Custom Keyword looks like this:

@Keyword
    def verifyData(){
        WebUI.callTestCase(findTestCase('Read Table Values'), [:], FailureHandling.STOP_ON_FAILURE)
        WebUI.callTestCase(findTestCase('Read Savings Totals'), [:], FailureHandling.STOP_ON_FAILURE)
        etc
        etc
        etc
    }

The Test Suite will contain calls to the Test Cases that populate the data. The Test Cases will each call the Keyword to validate the data. It's not the most elegant of solutions, but it certainly works and gets the job done.

Selenium based Custom Keyword to Count Pagination in Katalon Studio

Published August 5, 2018 | By Don Pedro

Another common task when working with web pages is to count the number of page results returned from a table. In most cases this means using the Webdriver to count the number of UL/LI elements in an object. This corresponds to the number of pages. Like counting the rows in a table, this can be set up as a Custom Keyword and called from any Test Case.

For the websites we develop, the pagination also contains extra buttons. There is usually an extra button to jump to the first entry and another for the last. There is also one to move forward by one page, and one to go back. Depending on how the pagination is put together there may be extra “pages” that aren’t actually part of the result set.

This means if there are 10 pages in the pagination area, and there are 4 navigation buttons, the actual number of pages you can get to is 6.

The pagination Custom Keyword Method I put together takes that into account. When checking for the number of pages available and thus determine how many results have been returned, the number of navigation pages is taken into account.

The Method below counts the number of pages available and determines, then counts back the number of navigation pages. This gives the actual number of pages worth of results. In this way you know just how far ahead you can jump. This also gives you a rough idea if the number of pages returned is within reason for the number of results that should be displayed.

    def countPaginationResultsPerPage(String xpath, String paginationObjectName, int navButtons){

        WebDriver driver = DriverFactory.getWebDriver()
        
        //Find the Pagination ribbon on the page
        WebElement Webtable=driver.findElement(By.xpath(xpath));

        //Get the number of Line Item <li> in the table and turn it into a List
        List<WebElement> TotalRowCount=Webtable.findElements(By.xpath(xpath));

        //Get the size of the List, this is the number of buttons
        int totalNumberOfButtons=TotalRowCount.size()
        log.logWarning('Total Number of Buttons in the Pagination Ribbon:= ' + totalNumberOfButtons)

        //Take out the page nav buttons > or >>, go back the passed in number of places to read the actual page number
        int lastPageOfPagination=WebUI.getText(findTestObject(paginationObjectName, [('index') : totalNumberOfButtons-navButtons])).toInteger()
        log.logWarning('Highest Page That Can Be Clicked On:=' + lastPageOfPagination)
        return lastPageOfPagination
    }

Then to call the Keyword, the xpath used to count the LI elements, the Katalon Object that defines the actual pagination object, and the number of navigation pages are included:

    CustomKeywords.'commonCode.selenium.countPaginationResultsPerPage'(xpath, 1)

Selenium based Custom Keyword to Count Table Rows in Katalon Studio

Published August 4, 2018 | By Don Pedro

When working with tables, one of the most common tasks is to count the number of rows in that table. Even though Katalon has the ability to create a parameterized version of the table object, you still need to know the number of rows or columns available. The most common way is through the Webdriver, get a List of the returned objects and then get the size.

After doing that a couple of times, I’ve switched over to calling that code from a Custom Keyword and simply call it from the Test Case. To make it dynamic, the xpath of the table is passed. This builds on the idea of passing the Katalon Object as a String. In this case, the xpath is passed as a String so it can be used anywhere.

The basic Keyword is quite simple and looks like this:

public class selenium {
KeywordLogger log = new KeywordLogger()
@Keyword
def countRowsPerPage(String xpath){

WebDriver driver = DriverFactory.getWebDriver()

//Find the table element on the page
WebElement Webtable=driver.findElement(By.xpath(xpath));

//Determine the number of elements in the table
List TotalRowCount=Webtable.findElements(By.xpath(xpath));

//Get the size of the List, this is the number of rows
int totalNumberOfRows=TotalRowCount.size()
log.logWarning('Total Number of rows on the page:= ' + totalNumberOfRows)
return totalNumberOfRows

   }
}

Within the Test Case, a variable would be set to the xpath of the table, such as:

xpath="//*/div[@id='search-results']/div/table/tbody/tr"

The Custom Keyword is then called with a variable set to the number of rows returned from the Custom Keyword Method.

rowResults=CustomKeywords.'commonCode.selenium.countRowsPerPage'(xpath)

The variable can now be used within a FOR loop or to verify the number of results.

Creating and Calling Methods for Test Cases in Katalon Studio

Published August 3, 2018 | By Don Pedro

While it’s possible, and encouraged to set up Custom Keywords to perform repeatable code blocks, the same thing can be done within the Test Case itself. Methods can be defined with the Test Case and called as many times as needed.

As an example, let’s say there are 5 filter boxes on the site. Each filter has a value for a certain type of result. A simple test would be to click each filter and confirm the results in the table match the filter type.
Using the brute force method, there would be 5 code blocks with almost identical code. We would want to read the type of filter, perhaps count the results, click the filter, then confirm the values in table of results.

If we built a method within the Test Case, we could pass in the filter object details, then capture the information we need.

To create the Method, we set it up the same way as it would appear for a Custom Keyword. We omit the @Keyword label and define our procedure. Once the Method has been defined, all we need to do is call it and pass any parameters it calls for. In the example below, the index value of the filter and it’s name are passed to the Method.

The Method below reads the number of results available from the filter. If there are more than 3, it only checks the first 3. If there are 0, an entry is logged stating there are no results. From there, it clicks the filter, then reads the status column from the table of results. The status can be Started, In Progress, Complete or Expired. When we click the Complete filter, the status for each result in the table should Complete. If not, there is something wrong and an error is written to the log.

Again, this is a simple example, but it demonstrates that Methods can be written for the Test Case itself and aren’t just for Custom Keywords.

Additionally, when it comes to Groovy, if you want the Method to return a result, adding the “return” statement at the end takes care of that.
Such as:

return totalNumberOfRows

It’s then possible to set a variable to the result of the Method with:

rowResults=CustomKeywords.'commonCode.selenium.countRowsPerPage'(xpath)

    WebUI.navigateToUrl(GlobalVariable.baseurl)

def checkFilterStatus(int buttonIndex, String filterType){
    KeywordLogger log = new KeywordLogger()
    log.logWarning('Checking Filter Type - ' + filterType)
    WebUI.click(findTestObject('Home/filter-Status Filters', [('buttonIndex') : buttonIndex]))
    String tempText=WebUI.getText(findTestObject('Home/filter-Status Filters', [('buttonIndex') : buttonIndex])).replaceAll(filterType+' |\\(|\\)','')
    int filterText=Integer.valueOf(tempText)
    if (filterText>3){
        filterText=3
    }
    if (filterText==0){
        log.logWarning('NOTE: There are no results to verify for the filter')
    }
    for (int loop = 1; loop <=filterText; loop++) {
        tempText=WebUI.getText(findTestObject('Home/label-Status', [('row') : loop, ('column') : 2]))
        log.logWarning('Checking result: ' + loop)
        if (tempText!=(filterType.toLowerCase())){
            log.logError('ERROR: The Status type of ' + filterType + ' does not match the filter type')
            KeywordUtil.markFailed('ERROR: The Status type of ' + filterType + ' does not match the filter type')
        } else {
            log.logWarning('SUCCESS: The Status type of ' + filterType +' matches the filter type')
        }
    }
}

//Check Filter Status - Pass button index and text of the button
checkFilterStatus(2, "Started")
checkFilterStatus(3, "In Progress")
checkFilterStatus(4, "Complete")
checkFilterStatus(5, "Expired")

Sans Pantalones

It's the classic battle between Wall Street and Bourbon Street

Recent Posts

Favorite Games

Search

One ReplaceAll Statement to Rule Them All!

Other articles of interest:

Call the same Test Case twice with a Custom Keyword

Other articles of interest:

Selenium based Custom Keyword to Count Pagination in Katalon Studio

Other articles of interest:

Selenium based Custom Keyword to Count Table Rows in Katalon Studio

Other articles of interest:

Creating and Calling Methods for Test Cases in Katalon Studio

Other articles of interest:

Recent Comments

Meta