{"id":15877,"date":"2022-08-29T07:00:00","date_gmt":"2022-08-29T05:00:00","guid":{"rendered":"https:\/\/sii.pl\/blog\/?p=15877"},"modified":"2023-05-10T15:47:04","modified_gmt":"2023-05-10T13:47:04","slug":"using-kotlin-language-functionalities-to-enrich-the-ui-tests-written-in-java","status":"publish","type":"post","link":"https:\/\/sii.pl\/blog\/en\/using-kotlin-language-functionalities-to-enrich-the-ui-tests-written-in-java\/","title":{"rendered":"Using Kotlin language functionalities to enrich the UI tests written in Java"},"content":{"rendered":"\n

We \u2013 the Java people \u2013 are doomed to the object-oriented paradigm. Don\u2019t take it as a bad feature of the language, though. As the 3 Billion Devices Run Java installer shows (invariably since the beginning of this century), Java has entered into the programming canon and it\u2019s very difficult to find a person in IT who hasn\u2019t heard of this language.<\/p>\n\n\n\n

It\u2019s been over 25 years since the first release of Java, and although it\u2019s still evolving, we can\u2019t change one truth about it \u2013 Java wasn\u2019t created with functional programming in mind. However, this statement has become less bitter after the Java 8 update, which introduced lambda expressions<\/a> and streams into our code. <\/p>\n\n\n\n

Nowadays, the JVM universe isn\u2019t limited to Java only. Many noteworthy programming languages have been created. Some of them are more focused on functional programming, which perfectly complements Java.  <\/p>\n\n\n\n

In this article, I\u2019d like to familiarize you with selected functionalities of the Kotlin language that will enrich and facilitate writing automatic UI tests, based on the example of web testing<\/strong>.<\/p>\n\n\n\n

Kotlin \u2013 first steps<\/strong><\/h2>\n\n\n\n

An introduction to Kotlin has already been described in the article by Rafa\u0142 Ha\u0142asa<\/a>. Also, the Jetbrains company prepared a very interesting introduction to the language<\/a>. Those who are not familiar with Kotlin yet are welcome to have a closer look at both the article and the tutorial.<\/p>\n\n\n\n

Using Kotlin in a project <\/strong><\/h2>\n\n\n\n

IntelliJ environment <\/strong><\/h3>\n\n\n\n

In the case of IntelliJ, most of the work with adding support to Kotlin will be done for us by IDE. The user has to add the Kotlin plugin in IDE and create a new Kotlin file (.kt) in the project structure. Then, IntelliJ will automatically detect the usage of Kotlin and ask if we want to configure the project. The essential changes in dependency (adding kotlin-stdlib) and plugin will be made automatically.  <\/p>\n\n\n\n

Another environment <\/strong><\/h3>\n\n\n\n

If you use an IDE other than IntelliJ, check a guidebook to implementing Kotlin in Gradle<\/a> and Maven<\/a> projects. <\/p>\n\n\n\n

Fun facts <\/strong><\/h2>\n\n\n\n

The Kotlin language was created to be fully cooperative with Java. When searching for a solution for a problem with a code, we can search for sources both in Java and Kotlin languages. If we copy the Java code and paste it into the .kt file, IntelliJ will ask us whether we want to translate the pasted code to Kotlin: <\/p>\n\n\n\n

Sample translation of Java into Kotlin<\/em><\/em><\/figcaption><\/figure>\n\n\n\n

Why does it work? <\/strong><\/h3>\n\n\n\n

Both Java and Kotlin compile to Java bytecode. The code snippet written in Kotlin may serve as an example: <\/p>\n\n\n

\nfun main() {\n        val numbers = listOf(1, 2, 3, 4, 5).map { it * it }\n    }\n<\/pre><\/div>\n\n\n
IntelliJ enables previewing the bytecode which generates this snippet. The option is located under the path:
Tools<\/strong> \u2192 Kotlin<\/strong> \u2192 Show Kotlin Bytecode<\/strong><\/p>\n\n\n\n
A part of the bytecode is presented below <\/p>\n\n\n
\npublic final  static  main()V\n\nL0\n\nLINENUMBER 5 L0\n\nICONST_5\n\nANEWARRAY java\/lang\/Integer\n\nDUP\n\nICONST_0\n\nICONST_1\n\nINVOKESTATIC java\/lang\/Integer.valueOf (I)Ljava\/lang\/Integer;\n\n\u2026\n<\/pre><\/div>\n\n\n
We can now decompile this bytecode back into Java. The result is not satisfying, though. The computer has translated the instructions into Java, but the style of the code leaves much to be desired:  <\/p>\n\n\n
\npublic static  final  void  main() {\n\nIterable $this$map$iv = (Iterable)CollectionsKt.listOf(new  Integer[]{1, 2, 3, 4, 5});\n\nint $i$f$map = false;\n\nCollection destination$iv$iv = (Collection)(new  ArrayList(CollectionsKt.collectionSizeOrDefault($this$map$iv, 10)));\n\nint $i$f$mapTo = false;\n\nIterator var6 = $this$map$iv.iterator();\n\nwhile(var6.hasNext()) {\n\nObject item$iv$iv = var6.next();\n\nint  it = ((Number)item$iv$iv).intValue();\n\nint var9 = false;\n\nInteger var11 = it * it;\n\ndestination$iv$iv.add(var11);\n\n}\n\nList numbers = (List)destination$iv$iv;\n\n}\n<\/pre><\/div>\n\n\n
Nevertheless, it is equivalent (from the JVM point of view) with the code written in Kotlin. <\/p>\n\n\n\n
The IntelliJ environment has a fine-tuned Java \u2192 Kotlin code swap, and a code created in this way is structurally acceptable in most cases. Java classes can be easily used in Kotlin code. This relation works both ways, which means Kotlin code can also be implemented in Java.  <\/p>\n\n\n\n
Let\u2019s take a sample class written in Kotlin: <\/p>\n\n\n
\nclass Person(private val name: String, private val age: Int) {\n    fun greet() = println("My name is $name and I am $age ${if (age > 1) "years" else "year"} old.")\n}\n<\/pre><\/div>\n\n\n
We can now use it in the .java file: <\/p>\n\n\n
\npublic class Foo {\n    public static void main(String[] args) {\n        new Person("Tom", 24).greet();\n    }\n}\n<\/pre><\/div>\n\n\n
Output:<\/p>\n\n\n
\nMy name is Tom and I am 24 years old.\n<\/pre><\/div>\n\n\n
Kotlin language functionalities in practice <\/h2>\n\n\n\n
Let\u2019s move on to the main body of the article. In it, I will present two approaches of the Kotlin language that will make writing and maintaining the code easier. <\/p>\n\n\n\n
Delegate by Locator<\/h3>\n\n\n\n
Wait until the fridge is visible and open it. Wait until you see the eggs and take them out.<\/em><\/em><\/p><\/blockquote>\n\n\n\n
When giving the instructions to be carried out, we often skip the obvious details we are certain that everyone will assume before performing the assigned task. A simple example can be clicking the elements on the screen. We simply expect them to be visible before we click on them. <\/p>\n\n\n\n
By using the \u2018by\u2019 delegators<\/a> and the higher-order functions<\/a>, we can build a nice mechanism for searching web elements and deciding when they should be interactive:  <\/p>\n\n\n
\nprivate val usernameField by Id("username")\nprivate val passwordField by Id("password")\nprivate val loginButton by Xpath(".\/\/button[@type='submit']") {\n    \/\/poczekaj a\u017c pola username i password zostan\u0105 wype\u0142nione\n    it.isDisplayed && usernameField.getAttribute("value").isNotEmpty() && passwordField.getAttribute("value").isNotEmpty()\n}\n(\u2026)\n\nfun pressLoginButton() = loginButton.click()\n<\/pre><\/div>\n\n\n
Such an approach allows hiding the expectation of web elements availability and focusing exclusively on the logic of the test scenario.<\/p>\n\n\n\n
What it looks like from the inside<\/strong> <\/em><\/h4>\n\n\n\n
Preliminary assumptions<\/strong> <\/strong><\/p>\n\n\n\n
The project uses the Selenium<\/a> library. There is a reference to WebDriver in the project, which operates UI tests. We create a FluentWait<\/a> object that we will use to wait for web elements. <\/p>\n\n\n
\nval wait: FluentWait<WebDriver> = FluentWait(driver)\n    .withTimeout(Duration.ofSeconds(System.getProperty("wait.timeout")?.toLong() ?: 10L))\n    .pollingEvery(Duration.ofMillis(200))\n    .ignoring(NoSuchElementException::class.java)\n<\/pre><\/div>\n\n\n
<\/div>\n\n\n\n
\n
\n
\"\"<\/figure>\n<\/div>\n\n\n\n
\n
<\/p>\n\n\n\n

The wait object doesn\u2019t have to be a field of any class. Defining it outside the body of classes means global access to this object.<\/p>\n<\/div>\n<\/div>\n\n\n\n
We create an abstract Locator<\/em> class, which expands the ReadOnlyProperty<\/a> class. The Locator class will contain all the logic concerning operating on web elements. <\/p>\n\n\n\n
Description of class parameters:<\/strong> <\/strong><\/p>\n\n\n\n
locator \u2013 the selected mechanism for finding elements (e.g., Id, Xpath, CssSelector, etc.)  <\/p>\n\n\n\n
path \u2013 the value of the path that points to the searched web element <\/p>\n\n\n\n
accessRule \u2013 a function that takes a web element as a parameter and returns boolean (a condition for interaction with the web element).<\/p>\n\n\n
\nabstract class Locator(\n    private val locator: (String) -> By,\n    private val path: String,\n    private val accessRule: (WebElement) -> Boolean\n) : ReadOnlyProperty<Any?, WebElement> {\n    private val element: WebElement by lazy {\n        wait.until { driver.findElement(locator(path)) }\n    }\n \n    override fun getValue(thisRef: Any?, property: KProperty<*>): WebElement {\n        wait.until { accessRule(webElement) }\n        return webElement\n    }\n}\n<\/pre><\/div>\n\n\n
\n
\n
\"\"<\/figure>\n<\/div>\n\n\n\n
\n
<\/p>\n\n\n\n

The By lazy<\/strong> delegator means lazy evaluation. The element field will not be calculated until it is first used.<\/p>\n<\/div>\n<\/div>\n\n\n\n
\n
\n
\"\"<\/figure>\n<\/div>\n\n\n\n
\n
<\/p>\n\n\n\n

We can freely extend the getValue method with further instructions on accessing the web element. However, there are some cases when we don\u2019t want to wait until the object is visible. Such objects can be marked with any annotation (e.g., @Hidden). We will get access to the delegated object through the property argument.  <\/p>\n<\/div>\n<\/div>\n\n\n\n
All that\u2019s left is creating the classes we need to extend Locator, according to our needs: <\/p>\n\n\n
\nclass Xpath(\n    path: String,\n    \/\/ poczekaj a\u017c b\u0119dzie widoczny\n    accessRule: (WebElement) -> Boolean = { it.isDisplayed }\n) : Locator(By::xpath, path, accessRule)\n\nclass Id(\n    id: String,\n    \/\/zwracaj zawsze\n    accessRule: (WebElement) -> Boolean = { true }\n) : Locator(By::id, id, accessRule)\n<\/pre><\/div>\n\n\n
And using them as in the example above. <\/p>\n\n\n\n
Integration with Java<\/strong> <\/h3>\n\n\n\n
As I\u2019ve already mentioned, we can use Kotlin code in a Java class. However, the Java language doesn\u2019t have the function of expressing \u2018by\u2019 delegators. An idea for integration is defining web elements in the .kt class and expanding the .java class with it: <\/p>\n\n\n
\nclass MyScreenPageObject extends MyScreenKotlinPageObject {\n(\u2026)\n    public void clickLoginButton() {\n        getLoginButton().click();\n    }\n}\n<\/pre><\/div>\n\n\n
Getters for the fields defined by delegators were automatically generated for operating in Java, but all logic for accessing and evaluating elements remained intact. <\/p>\n\n\n\n
\n
\n
\"\"<\/figure>\n<\/div>\n\n\n\n
\n
<\/p>\n\n\n\n

Bear in mind that in this case the access modifier in the .kt class may not be set to private.<\/p>\n<\/div>\n<\/div>\n\n\n\n
\n
\n
\"\"<\/figure>\n<\/div>\n\n\n\n
\n
<\/p>\n\n\n\n

All Kotlin classes (except for the abstract ones) are \u2018final\u2019 by default, meaning that one cannot inherit from them. In this case, it is required to mark the .kt class with the word open<\/em> (the inverse of the meaning of \u2018final\u2019). <\/p>\n<\/div>\n<\/div>\n\n\n\n
For comparison, this is the same code \u2013 Vanilla Java + Selenium (simplified): <\/p>\n\n\n
\nclass MyScreen {\n(\u2026)\n    public void clickLoginButton() {\n        WebElement usernameField = getWait().until(ExpectedConditions.visibilityOfElementLocated(By.id("username")));\n        WebElement passwordField = getWait().until(ExpectedConditions.visibilityOfElementLocated(By.id("password")));\n        getWait().until(driver -> !usernameField.getAttribute("value").isEmpty()\n                &&\n                !passwordField.getAttribute("value").isEmpty());\n        getWait().until(ExpectedConditions.visibilityOfElementLocated(By.xpath(".\/\/button[@type='submit']"))).click();\n    }\n}\n<\/pre><\/div>\n\n\n
Robot pattern<\/h3>\n\n\n\n
On the login page, enter your username.<\/em><\/p>
On the login page, enter your password.<\/em><\/p>
On the login page, click the Login button.<\/em><\/p><\/blockquote>\n\n\n\n
When performing steps within one web app page, we know the context. Referring to the object each time to call a method can be onerous, especially when there are a dozen steps. <\/p>\n\n\n
\nloginPage.fillCredentialsForUser("blogersii001);\nloginPage.pressLoginButton();\nloginPage.verifyUserIsSuccessfullyLoggedIn();\n<\/pre><\/div>\n\n\n
An idea for improvement idea is to use high-order functions again and create a pleasant mechanism for creating scopes where the context is already known. <\/p>\n\n\n
\n@Test\nfun `user can access website and log in`() {\n    mainPage {\n        verifyHeaderTitleIsEqualTo("<bloger_sii\/>")\n        clickOnSignInButton()\n    }\n \n    loginPage {\n        fillCredentialsForUser("blogersii001")\n        pressLoginButton()\n        verifyUserIsSuccessfullyLoggedIn()\n    }\n}\n<\/pre><\/div>\n\n\n
\n
\n
\"\"<\/figure>\n<\/div>\n\n\n\n
\n
<\/p>\n\n\n\n

Functions in Kotlin can be named by standard camelCase or by any other string of characters marked between the \u2018 \u2019 (back quote) characters. <\/p>\n<\/div>\n<\/div>\n\n\n\n
<\/p>\n\n\n\n
What it looks like from the inside<\/strong> <\/h3>\n\n\n\n
Above I showed that the test stages are divided into scopes, called \u2018robots.\u2019 Each robot has a reference to the PageObject object for which a set of functions is executed. The only available functions in each robot are those that are defined in the PageObject<\/a> class that the robot was created for.  <\/p>\n\n\n\n
The secret of this approach is a \u2018robot\u2019 function that takes the methods of one particular page (defined in PageObject) and executes them in the order they are given: <\/p>\n\n\n
\nfun loginPage(func: LoginPage.() -> Unit) {\n    LoginPage().func()\n}\n<\/pre><\/div>\n\n\n
The argument of the loginPage function is a function that exists in the LoginPage class and returns a Unit value <\/strong>(equivalent to void<\/em> in Java). The loginPage function creates a new object of the LoginPage class and applies all the methods given as arguments to it. <\/p>\n\n\n\n
Similarly, a robot for the MainPage class will be created from the example above.  <\/p>\n\n\n\n
\n
\n
\"\"<\/figure>\n<\/div>\n\n\n\n
\n
<\/p>\n\n\n\n

Robots can be accessed globally. Define them in a separate file (e.g., robots.kt) for project cleanliness. <\/p>\n<\/div>\n<\/div>\n\n\n\n
<\/p>\n\n\n\n
Integration with Java<\/strong> <\/h3>\n\n\n\n
Java doesn\u2019t support the robot mechanism as high-order functions. So what we can do in this situation is to create robot-functions for the already existing PageObject classes written in Java. <\/p>\n\n\n
\npublic class AddBlogPage {\n(...)\n\n    public void addBlogTitle(String blogTitle) {\n        (...)\n    }\n\n    public void submitBlogArticle() {\n        (...)\n    }\n}\n<\/pre><\/div>\n\n\n
We create a robot-function for the Java class: <\/p>\n\n\n
\nfun addBlogPage(func: AddBlogPage.() -> Unit) {\n    AddBlogPage().func()\n}\n<\/pre><\/div>\n\n\n
And use it in tests written in Kotlin: <\/p>\n\n\n
\n@Test\nfun `Integrate Java class in Kotlin robot test`() {\n    addBlogPage {\n        addBlogTitle("Blogersii - Kotlin")\n        submitBlogArticle()\n    }\n}\n<\/pre><\/div>\n\n\n
One may ask: <\/p>\n\n\n\n
Ok, but why to do that when we know \u2018Builder design pattern\u2019 and \u2018method chaining\u2019 that are available in regular Java?<\/em><\/p><\/blockquote>\n\n\n\n
Creating a robot-like structure is possible in Java, but may cause problems. <\/p>\n\n\n\n
To chain methods, they must return a reference to the object from which they are called. Each method we want to chain must have the returned type changed from void <\/em>to its own class. In the case of Kotlin, code refactoring is not required. The improvement is added without changes to the body of the PageObject classes. <\/p>\n\n\n\n
An example of chaining methods \u2013 Vanilla Java:<\/strong> <\/strong><\/p>\n\n\n
\npublic class AddBlogPage {\n\t(...)\n\n    public AddBlogPage addBlogTitle(String blogTitle) {\n        (...)\n        return this;\n    }\n\n    public AddBlogPage submitBlogArticle() {\n        (...)\n        return this;\n    }\n}\n<\/pre><\/div>\n\n\n
Usage in tests:<\/strong><\/strong><\/p>\n\n\n
\n@Test\nvoid javaTest(){\n\tnew AddBlogPage()\n\t.addBlogTitle("Blogersii - Kotlin")\n\t.submitBlogArticle();\n}\n<\/pre><\/div>\n\n\n
The second approach, less known and applied to achieve a similar result in Java is initializing objects using double brace initialization. In this case, we don\u2019t have to change the return types in the AddBlogPage class, since the reference to the class inside the braces in executed through the \u2018this\u2019<\/strong> value. <\/p>\n\n\n\n
Usage in tests: <\/strong> <\/strong><\/p>\n\n\n
\n@Test\nvoid javaTest(){\n    new AddBlogPage(){{\n        addBlogTitle("Blogersii - Kotlin");\n        submitBlogArticle();\n    }};\n}\n<\/pre><\/div>\n\n\n
This approach carries risks<\/strong>. This way of initialization generates an additional anonymous class inside each time, which extends after the PageObject class. Although using this type of initialization in trace amounts will not hinder the work of the Garbage Collector, initializing objects repeatedly in this way may lead to memory leaks. <\/p>\n\n\n\n
Summary<\/strong> <\/h2>\n\n\n\n
Kotlin is still developing. Presenting all the fun facts and improvements it offers is surely far beyond the content of one article. <\/p>\n\n\n\n
I hope this article will strengthen the readers\u2019 interest in Kotlin, and the proposed solutions (perhaps after creative modifications) will be useful in your projects. <\/p>\n\n\n\n
The article is based on the UI-testing framework I am developing as my hobby.  <\/p>\n\n\n\n
Source code and examples are located in the public repository<\/a>. <\/p>\n\n\n\n
Also, check play.kotlinlang.org<\/a> to try out Kotlin online without prior installation. <\/p>\n\n\n
\n            \n
\n    \n
\n            
\n            \n\n
<\/div>\n        <\/div>\n            
\n            \n\n
<\/div>\n        <\/div>\n            
\n            \n\n
<\/div>\n        <\/div>\n            
\n            \n\n
<\/div>\n        <\/div>\n            
\n            \n\n
<\/div>\n        <\/div>\n    <\/div>\n    \n
\n            
\n            \n\n
<\/div>\n        <\/div>\n            
\n            \n\n
<\/div>\n        <\/div>\n            
\n            \n\n
<\/div>\n        <\/div>\n            
\n            \n\n
<\/div>\n        <\/div>\n            
\n            \n\n
<\/div>\n        <\/div>\n    <\/div>\n<\/div>\n                \n\n
\n            5\/5 ( votes: 5)    <\/div>\n    <\/div>\n","protected":false},"excerpt":{"rendered":"
We \u2013 the Java people \u2013 are doomed to the object-oriented paradigm. Don\u2019t take it as a bad feature of … Continued<\/a><\/p>\n","protected":false},"author":401,"featured_media":19771,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"_editorskit_title_hidden":false,"_editorskit_reading_time":7,"_editorskit_is_block_options_detached":false,"_editorskit_block_options_position":"{}","inline_featured_image":false,"footnotes":""},"categories":[1321],"tags":[1517,1441,1339],"class_list":["post-15877","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-testing","tag-ui-2","tag-java-en","tag-kotlin-en"],"acf":[],"aioseo_notices":[],"republish_history":[],"featured_media_url":"https:\/\/sii.pl\/blog\/wp-content\/uploads\/2022\/08\/Wykorzystanie-funkcjonalnosci-jezyka-Kotlin-do-urozmaicenia-testow-UI-pisanych-w-jezyku-Java.jpg","category_names":["Testing"],"_links":{"self":[{"href":"https:\/\/sii.pl\/blog\/en\/wp-json\/wp\/v2\/posts\/15877"}],"collection":[{"href":"https:\/\/sii.pl\/blog\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/sii.pl\/blog\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/sii.pl\/blog\/en\/wp-json\/wp\/v2\/users\/401"}],"replies":[{"embeddable":true,"href":"https:\/\/sii.pl\/blog\/en\/wp-json\/wp\/v2\/comments?post=15877"}],"version-history":[{"count":3,"href":"https:\/\/sii.pl\/blog\/en\/wp-json\/wp\/v2\/posts\/15877\/revisions"}],"predecessor-version":[{"id":21582,"href":"https:\/\/sii.pl\/blog\/en\/wp-json\/wp\/v2\/posts\/15877\/revisions\/21582"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/sii.pl\/blog\/en\/wp-json\/wp\/v2\/media\/19771"}],"wp:attachment":[{"href":"https:\/\/sii.pl\/blog\/en\/wp-json\/wp\/v2\/media?parent=15877"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sii.pl\/blog\/en\/wp-json\/wp\/v2\/categories?post=15877"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sii.pl\/blog\/en\/wp-json\/wp\/v2\/tags?post=15877"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}