Katalon Studio

Checking for the presence of an object without throwing an error

One of my goals has to been to make my tests less noisy and not generate errors in the log unless it’s really necessary. For example, if an object is missing from the page, that may or may not be an error. If a tab is missing, the user may not meet the criteria to make it display.

When checking for the existence of an object using the WebUI.verifyElementVisible() keyword, a lot of additional logging that can be misleading. For example, this code block will execute as expected, but generates 2 entries for the Failed log.

    @Keyword
    //Function to determine if an item exists on the page
    boolean verifyObjectVisible(String objectReference) {
        try {
            WebUI.verifyElementPresent(findTestObject(objectReference),5)
            return true;
        } catch (Exception e) {
            log.logWarning("The object with the name, " + objectReference + " was not found. Exiting Test.")
            return false;
        }
    }

There is a cleaner way to check for an object using the WebUiCommonHelper.findWebElement command, which is part of the,

import com.kms.katalon.core.webui.common.WebUiCommonHelper library and performs the same function. I like it better because it allows for better handling of errors and logging.

Below is a Custom Keyword that wraps the use of the findWebElement statement within a Try/Catch block to determine if the object exists. The benefit is suppressing an error if the object doesn’t exit.

    @Keyword
    //Function to determine if an item exists on the page using WebUiCommonHelper.findWebElement
    //This does not throw an exception error to the log so it looks cleaner
    boolean verifyObjectPresent(String objectReference) {
        try {
            WebUiCommonHelper.findWebElement(findTestObject(objectReference),5)
            return true;
        } catch (Exception e) {
            return false;
        }
    }

A call to the Custom Keyword would then look like:

    //Check if there are existing notes on the page and count how many
    boolean elementVisible=CustomKeywords.'tools.commonCode.verifyObjectPresent'(katalonObject)
    if (elementVisible==true){
        originalNumberOfTasks=CustomKeywords.'tools.commonCode.countRowsPerPage'(xpath)
    } else {
        log.logWarning('Customer has no Tasks available at this time')
    }

This gives control within the code whether or not to display an error. In looking at the code above, if no Tasks are displayed on the page, a notification message is display, not an error. The test hasn’t failed and there is no problem with the site, a user may not have created an tasks which is why they don’t exit.

 

The verifyElementPresent or verifyElementVisible will perform the same task, but will log multiple errors if an element isn’t found, even when wrapped in a Try/Catch block.

Other articles of interest:

More Katalon Studio and Automation to come

Although I haven’t posted anything for some time now, I haven’t abandoned automation or Katalon Studio. Quite the opposite. I’ve completed several Udemy courses for Groovy, Java, automation and SQL. Along with that, I’ve used this slower time of the year to review all my code and make improvements so that my tests are more resilient, more modular, more scalable and less “noisy.”

There have also been quite a few changes to Katalon Studio. There is the ability to import and export Custom Keywords, so moving more code to that section of the project seems ideal. The Execution Profiles are a bit easier to work with, so I’ve moved more data out of the tests themselves and set them up as Global Variables. Cucumber BDD is available as well, and while I’m not using it currently, I did take a Udemy course on it so it might be something I try to incorporate into my project in the future.

Of course, after running the tests hundreds of times, I’ve noted areas of improvement such as better handling for transient conditions like an item not being found. And with some new found experience, I see how a test that performs one task can be parameterize, turned into a method and perform the same task multiple times with different input.

I’m quite pleased with the improvements and will share some of my discoveries. To that end, I have created a rather unexciting Github repository where I have shared some code snippets. It’ll get better over time. At least I hope so.

You can access it at: https://github.com/DonPedroQA/qajamboree

Other articles of interest:

One ReplaceAll Statement to Rule Them All!

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.

Other articles of interest:

Call the same Test Case twice with a Custom Keyword

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.

Other articles of interest:

Selenium based Custom Keyword to Count Pagination in Katalon Studio

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)

Other articles of interest:

Recent Comments

  • Create a Dynamic Object at Runtime (1)
    • Jeremy Brien: I appreciate this! I saw this post on LinkedIn this morning and was able to find a use case for it! I found that defining my xpath with an iterable variable allows me to loop through and capture text from tables created...
  • Output status messages and test information by writing to the Log File Viewer in Katalon Studio (2)
    • Don Pedro: That would be things like: log.logWarning(‘The import date listed on the site is: ‘ + importDate) log.logWarning(‘The value from the site is: ‘ + salesFigure) log.logWarning(‘Filter Results for ‘ +...
    • Prashant Pednekar: Thanks for the informative article but can we also put some variable values to make it more exciting.
  • Setting up a repeatable Search Method in Katalon Studio (1)
    • RJ: Thanks a lot! This is very helpful 🙂
  • Filling forms with random numbers in Katalon Studio (3)
    • Patrick Clough: We created a handy random string generator custom keyword. The method takes in a string for the type of string you want, and an integer for the length. Looks like this: static String RANDOM_ALPHANUM =...
    • Don Pedro: randomNumber is the variable that holds the result of generating a new random number. Depending on how things work on your site, you might need to convert the number to a String before it’s recognized correctly....
    • Seth: When you are setting up randomNumber is this a new keyword or a new variable? I am trying to randomly generate unique socials and can’t seem to connect my generator to my Set Text.
  • Working with Dates and Date Formatting in Katalon Studio (5)
    • Ann: THANK YOU ! That worked perfectly !
    • Don Pedro: import groovy.time.TimeCategory currentDate = new Date() println currentDate use( TimeCategory ) { after30Mins = currentDate + 30.minutes } println after30Mins https://stackoverflow.com/ques tions/21166927/incrementing...
    • ricky julianto nugroho: hay can u gave me an example for plus a hour in the time ? example : now is 15 pm i want to print 16 in the text thank you
  • Boostnote for Code Snippets (1)
    • Manual: Hi Don, Regarding the code snippets and examples that you have created. Is there any GitHub repo or something that can be shared? Thanks
  • Using TypeIt4Me with Katalon Studio (3)
    • Manual: That’s great thanks for sharing.
    • Don Pedro: Added a screenshot to show some examples of how I have shortcuts configured for Groovy code. TypeIt4Me supports groups, so you can create shortcuts related to Groovy, Selenium, and other topics to keep them organized. You can...
    • Manual: Hi Don, I like the idea of using the TypeIt4Me for scripting test code. Could you please share how I can create. I also like the idea of creating code templates to use with code editors. Thanks, Manual
  • Another success with Katalon Studio (2)
    • Don Pedro: Since Katalon is free, a very practical demonstration of what it can would be to create the code needed to fill in forms. That was one of my first tasks as Katalon could fill in a lengthy form in seconds versus the minute or...