Luke Daley

Presentations

Geb - Very Groovy Browser Automation

Geb is a browser automation solution for Groovy. It brings together the power of WebDriver, the elegance of jQuery content selection, the robustness of Page Object modelling and the expressiveness of the Groovy language. Geb enables more expressive, more concise, and (very importantly) more maintainable web tests.

In this session we'll explore the foundations of Geb and illustrate how it uses the language features of Groovy to make web automation and testing productive and effective. After exploring the basics we'll explore Geb's rich Content DSL and discuss patterns for achieving maintainable tests. We'll also look at how it combines with Spock, the Enterprise ready testing framework, to enable low cost executable specifications that describe user behaviour, not browser details.

Productive Grails Functional Testing

We all know we should be writing functional (i.e. web) tests for our Grails applications, but this can sometimes seem like too much work for not enough gain. In this talk we'll look at the current Grails plugins that are out there that can start to decrease the development and maintenance cost and make getting the coverage you need more achievable.

Firstly we'll explore the powerful combination of Geb, the Groovy browser automation library, with Spock, the Enterprise ready testing framework, as the foundation for our testing stack. From there we'll discuss how to manage test data sets using the combination of the grails-fixtures and grails-build-test-data plugins. We'll then see how to use the grails-remote-control plugin to get inside your application from your functional tests to configure and how to use the grails-develop-functional-tests plugin to decrease the cycle time when writing your tests.

Finally, we'll discuss strategies for partitioning tests into logical groups and using the remote execution facilities of Geb to have your functional test suite run against multiple browsers and architectures.

Next Level Spock

So you already know and love Spock, the Enterprise ready testing framework, but want to know how to make the most of it and take your testing to the next level? Then this talk is for you. Even if you're new to Spock, but are interested in making your testing more effective this talk is for you.

Spock has many hidden gems which we'll be going through in this session. We'll also be looking at some of the upcoming features in Spock 0.7 including; functionality and contract mixins, improved configurability, and several new lumps of syntax sugar.

Functionally Testing Modern Web Applications with Geb

Geb is a browser automation solution for Groovy. It brings together the power of WebDriver, the elegance of jQuery content selection, the robustness of Page Object modelling and the expressiveness of the Groovy language. Geb enables more expressive, more concise, and (very importantly) more maintainable web tests.

In this session we'll go beyond an introduction and explore how to take advantage of Geb's advanced features to functionally test modern rich, dynamic, web applications. We'll also explore some common patterns and best practices for Page Object modelling that lead to robust tests with a high level of reuse. Finally we'll discuss cross browser testing strategies and explore the options for testing mobile device targeted sites. A basic understanding of Geb is required for this session.

Gradle Plugin Best Practices

One of Gradle's attractive features is that plugins are extremely simple to write and can do anything. Gradle plugins can add new functionality, enhance existing functionality or even remove undesired functionality. If you've ever wanted to write a Gradle plugin, or are interested in the deep details of plugins, then this session is for you.

In this session we'll explore some fundamental concepts that can be used as guidelines when developing plugins and new Gradle functionality, and the role of plugins and how they can be used.

We'll look at issues such as; how to implement flexible tasks, how to support convention over configuration while maintaining flexibility, how to structure plugin stacks, building and distributing plugins and testing your plugins. We'll be developing a sample plugin during the session and discussing other real world example plugins.

Gradle: Next Generation Dependency Management

The Java ecosystem has a strong tradition of dependency management. This can range from structuring the use of the jars in the source to automatically fetching dependencies on demand from a remote repository. This practice has enabled new levels of automation and understanding of just what the dependencies are for a given component. However, the limitations of today's most popular tools, platforms and models are proving to be inadequate in dealing with the complex modern world of continuously delivered, polyglot, software.

In this session we'll discuss these issues, their implications and the work happening in the Gradle ecosystem to address them. Topics will include dependency variants, smart consumers, extensibility, new metadata models and bringing the kind of automated dependency management that Java developers are accustomed to to the world of C/C++ and JavaScript.

Standardizing your Enterprise Build Environment with Gradle

The larger and more diverse your technology organization, the greater the value you can realize in standardizing your build and delivery process. Internal build standards make it easier for people to switch between teams, allowing you to more readily adjust your staffing to meet changing business needs. In this session we’ll walk through examples of leveraging Gradle’s extensibility and plugin mechanisms to develop standards, enforce compliance and deliver tailored out of the box functionality. We will also discuss how to provision such customisations throughout your enterprise in a controllable way.

Standards help establish the software development practices developed by your best engineers and communicate them to the rest of the company. Perhaps most importantly, they keep your developers from wasting time endlessly re-creating commodity portions of the build infrastructure that do not create value unique to the project they are building. Standardizing the right parts of the build makes for a lower-friction software development organization full of higher quality builds and happier engineers.

• You have many company-specific standards that you would like to model across your teams.
• You have a large number of projects with different languages, runtime platforms, and build systems. You would like to model a standard across all those projects.
• You have tried imposing too rigid a build standard across your organization and found that it didn't work, but you still want the benefits of standardization for new and established projects alike.

Gradle Core Developer Luke Daley will show you how the Gradle build tool gives you a powerful, developer-friendly, toolkit for defining your enterprise build standards across the organization in a way that they are automatically applied to all developers without the need on their side to configure anything. Gradle adopts Maven's innovation by providing the same out-of-the-box standards for typical project types--but it doesn't stop there. The more you automate the process of software delivery, then more you end up defining your own company-specific build standards. These standards must find expression in the build tool in a native way, not as ad-hoc additions. At its heart, Gradle is not a mere provider of build standards, but a toolkit for defining your own standards as a body of tested, executable code that finds expression in a concise and idiomatic domain-specific language.

Another important aspect of an enterprise build infrastructure is provisioning the build environment. With Gradle you can avoid many scenarios where developers have to read wiki pages how to configure their local build environment. Things will just work. Furthermore the specification of the build environment is version controlled, thus making historical builds much more reproducible.

Gradle - the Innovation continues

The Gradle development team have not been taking it easy since the release of Gradle 1.0. New features and innovations are constantly being added, rough edges are being smoothed and the platform continues to expand. In this session we’ll explore the most notable additions to Gradle since the release of 1.0 and preview some of the new and exciting features just over the horizon with Gradle founder and Gradleware CEO Hans Dockter and Gradle core developer Peter Niederwieser.

Gradle continues to evolve with a high velocity to gain new capabilities, features and increased build performance.

We’ll dig into to some of the features incorporated since the 1.0 release, such as:

• Maven import and archetype support
• Parallel task execution
• Improved Dependency Reporting
• Dependency management improvements that make Grade the best dependency system out there.
• Additions to the task model like soft dependencies and finalizer tasks.
• Gradle Android and C/C++ Support
• Improvements to the Tooling API (i.e. embedded Gradle)
• Better scalability for large scale enterprise builds
• Using Jenkins slaves for distributed test execution.
• Deep integration with Arquillian for deploying to web and JEE servers.

We’ll also take a sneak peak at some of the upcoming features that will soon be available in Gradle.

Implementing a Standardized Build Platform Across the Enterprise with Gradle

The larger and more diverse your technology organization, the greater the value you can realize in standardizing your build and delivery process. Internal build standards make it easier for people to switch between teams, allowing you to more readily adjust your staffing to meet changing business needs. In this session we’ll walk through examples of leveraging Gradle’s extensibility and plugin mechanisms to develop standards, enforce compliance and deliver tailored out of the box functionality. We will also look at how to provision such customisations throughout your enterprise in a controllable way.

Gradle's flexibility combined with its support for conventions, including your conventions, provides the ability to solve your automation challenges effectively in a centralised fashion.

Automated web application testing with Gradle and Selenium

Doing full stack testing (sometimes referred to as "functional" or "acceptance" testing) of web applications is a non trivial business. While such tests are undisputedly more costly to develop, maintain and execute than simple unit tests, that's no excuse to ignore this crucial aspect of a comprehensive testing strategy. Many teams still rely on expensive manual testing for coverage at this level, citing the difficulty in managing a large body of automated functional tests. In this session we'll look at how Gradle can help by orchestrating the necessary components of a Selenium 2 based toolchain.

We'll look at how Gradle's flexibility and extensibility can be used to; provision browsers to be used for testing, parameterizing test execution, grouping tests, executing tests across different browsers, parallelizing test execution in different ways and merging test results. We'll implement a focussed build framework for developing, executing and maintaining automated web tests using Java, Selenium, TestNG and using Jenkins to run our tests for us. Automated web tests have a high cost but an extremely high value, as they can give you confidence that your software actually works when fully assembled. We'll see how Gradle can reduce the cost aspect of this equation without sacrificing on the value.

Finally, we'll briefly look at using some more progressive tooling by using Geb in place of Selenium and the Spock Framework in place of TestNG. The Geb and Spock Framework tools are both side projects of Gradleware core engineers.