Annyce Davis

Davis Technology Consulting

Grails: Functional Testing with Geb and Spock

by

Functional testing allows you to execute HTTP requests against your running application and verify if it’s performing the desired behavior.

Since Grails doesn’t ship with any direct support for functional testing (using Grails 2.2.4) I decided to use a common configuration of Geb with Spock for my testing needs. My configuration files are included below.  I had to modify BuildConfig.groovy and then include a separate configuration file for Geb.


BuildConfig.groovy

    repositories {
       mavenRepo "http://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-support"
    }

    def gebVersion = "0.9.2"
    def seleniumVersion = "2.35.0"

    dependencies {
        test "org.seleniumhq.selenium:selenium-chrome-driver:$seleniumVersion"
        test "org.spockframework:spock-grails-support:0.7-groovy-2.0"
        test "org.gebish:geb-spock:$gebVersion"
        test "org.seleniumhq.selenium:selenium-support:2.40.0"
    }

    plugins {
        test ":geb:$gebVersion"
        test (":spock:0.7") {
            exclude "spock-grails-support"
        }
    }

The tests and config files are stored in the test/functional folder of the main application. In the primary functional folder you can place your GebConfig.groovy file. There are various configuration options available to you. I prefer to use a very simple version, consisting of the following:

GebConfig.groovy

import org.openqa.selenium.chrome.ChromeDriver

reportsDir = "target/geb-reports"
driver = { new ChromeDriver() }

You will also need to install the ChromeDriver.  Info available here.

Once that’s done, you should define some Geb Pages that represent the corresponding gsp pages in your application. I typically define three key components: the url, the at closure, and the content closure. These elements will be used in your Spock Specification to navigate to the desired page in your application, verify that you are at the correct page and then interact with elements on the page that you define in the content closure.

Sample Page

import geb.Page

class LoginPage extends Page {

    static url = "login/auth"

    static at = { title == "Login" }

    static content = {
        loginForm { $("#loginForm") }
        loginButton { $("#loginButton") }
        registerLink { $("a[href*='register/index']") }
    }
}

Sample Spec

import geb.spock.GebReportingSpec
import spock.lang.Stepwise

@Stepwise
class LoginSpec extends GebReportingSpec {

    def "invalid login"() {
        given: "I am at the login page"
        to LoginPage

        when: "I am entering invalid password"
        loginForm.j_username = "me@gmail.com"
        loginForm.j_password = "ioguffwf"
        loginButton.click()

        then: "I am being redirected to the login page"
        at LoginPage
        !loginForm.j_username
        !loginForm.j_password
    }

    def "admin login"() {
        given : "I am at the login page"
        to LoginPage

        when: "I am entering valid username and password"
        loginForm.j_username = "me@gmail.com"
        loginForm.j_password = "me"
        loginButton.click()

        then: "I am being redirected to the homepage"
        at HomePage
    }
}

Spock specifications are very simple to read and should be written in such a way that it’s very clear what you are attempting to test and verify.  In this case, the LoginSpec, the specification has only two methods which are executed in order.  The first makes sure that when a user enters invalid login credentials they are redirected back to the log in page.  The second verifies that they are taken to the HomePage when the login succeeds.

In order to run your functional tests you can use the following commands:

grails test-app functional: -https
grails test-app -clean functional: LoginSpec -https

I add the -https flag because my application has support for https and I want to be able to test that functionality as well.

Happy testing!

Android Annotations: Brief Overview and a Simple Example

by

Android Annotations is a project which allows you to use simple Java Annotations in your Android classes and have the compiler generate some of the “boilerplate code” for you.  I have not noticed any overhead in the application’s performance so far and I really like how neat the code is, when compared to some of the default code that is typical in Android applications.

Here is an example of creating an activity and then performing a simple operation using a bean to load data:

@EActivity(R.layout.main)
@OptionsMenu(R.menu.main_menu)
@Fullscreen
public class MainActivity extends Activity {

    @Bean(MyAPIImpl.class)
    MyAPI mAPI;

    @AfterInject
    void loadData() {
      mAPI.getData();
    }

    @Click(R.id.startButton)
    void startClicked() {
      NextActivity_.intent(this).start();
    }
}

So what you’ll notice in the code is that it’s very clear what this Activity is doing, no need to scroll through lists of Views being initialized and endless availability checks.  Also, the click listeners that are normally splattered throughout the code is contained in a simple method with the @Click annotation. Here you just define the resource id of the item that you would like to associate with the click event and then a method to handle the click.

Furthermore, this Activity references a view in the R.layout.main layout file, without having to define the typical onCreate() method. It also defines which menu file it’s going to use with the @OptionsMenu annotation. Pretty simple, right?  In a future post I will show additional examples of how using AndroidAnnotations makes your code more maintainable. Have you tried this library yet? If so, please let me know what you think. Curious to find out what others think of it.

Android: IntelliJ IDEA/Android Studio Quick Tip

by

I’ve started using IntelliJ as my IDE of choice for developing backend APIs and Android applications.  One really nice feature, which is also available in Android Studio, is the option to create strings.xml values on the fly.  All you need to do is type the name of the desired string resource and then the “bulb” icon will appear asking you if you want to create that resource.  Super simple, but extremely convenient for those times when you are editing a lot of xml files in Android.

 

 

 

Follow Me

  • Bluesky