Specification by Example | Concordion

Concordion | Runners and Drivers

2017-11-18T00:00:00+00:00

This article describes the Runners and Drivers pattern which enables test code to be layered with clean interfaces. This enhances maintainability of the code and leads to effective reuse of the application drivers across test suites. In addition, it opens up the drivers for use in exploratory and maintenance scripting. It also avoids lock-in to any specific test runner or driver, opening up the potential for future migration to new test runners or drivers.

Application Drivers

An Application Driver is responsible for manipulating an application through one of its interfaces (eg. web app, web service, database, desktop application, host, message queue).

The Driver will normally require a 3rd party library to interface with the application, such as Selenium WebDriver. (In some cases, it is also possible to interface directly with the service layer of the application.)

A basic driver may expose its functionality in terms of actions on the interface - eg. enter first name, click OK, get error message.

It is often worthwhile to add functionality to group the actions into workflows that represents the business intent, eg. update payee details, make one-off payment.

A common pattern used for Application Drivers is the Page Object pattern. This encapsulates the logic for driving a page in one place so that it is simple to change, and provides an easy interface for users. Example usage (using Groovy) might be:

def loginPage = gotoLoginPage()
def landingPage = loginPage.loginAs("user123", "password")
def oneOffPaymentPage = landingPage.selectOneOffPayment()
oneOffPaymentPage.pay(230.50, "06-9952-5439870-01")

It is good practice to break the test fixtures into separate Action and Page objects. The Action objects implement user actions, such as “Transfer money between accounts”. The Page objects abstract operations on the web page, for instance “Click on Transfer button”. The acceptance and automated tests should use the Action objects where possible, but may need to use the Page objects for some operations. The Page objects isolate the tester from changes to the web page (for example if the location or name of the Transfer button are changed). The Action objects isolate the tester from higher level changes, such as “Transfer money” being implemented using a different workflow or metaphor (eg drag and drop).

Runners

Once you have implemented Application Drivers, they can be reused for a number of use cases, for example:

running tests,
data setup,
scripting

You can use a wide variety of frameworks for running the tests, including basic xUnit style, Specification by Example (such as Concordion), data-driven, keyword-driven etc. These frameworks run the tests and report test results for the user.

Data setup could be spreadsheet-driven, and could be one-off (eg. data migration) or part of a regular test setup.

Scripting would use a language such as Groovy, VBScript, Python or Ruby to perform custom actions on the application. When performing exploratory testing, you can speed up repetitive actions (eg. logon and navigation) through scripting.

Advantages of using Runners and Drivers

By separating drivers and runners, you achieve a high degree of reuse.

It is important to never include test logic in the Application Drivers, otherwise your Driver becomes tied to the particular test runner framework that you are using. Similarly don’t expose driver specifics to the test layer - for example, you should return Strings or domain objects rather than return WebElements.

With the right level of abstraction, you minimise the changes required to test code when the application changes - with the goal of only needing one change to test code for each application change. As the organisation grows a library of drivers, you are able to capitalise upon the work of others to quickly create new tests.

Concordion | .NET Presentation

2017-08-05T00:00:00+00:00

We’re keen to update Concordion.NET to match the Concordion 2.0 Java features.

Here’s a presentation about Concordion.NET:

2017-07-Concordion.NET

This is released under a Creative Commons Attribution 4.0 International license, so please feel free to adapt and share this for your own presentation. All we ask for is attribution.

For those keen to contribute to Concordion 2.0, please join in the discussion here.

Concordion | Presentations

2017-06-10T00:00:00+00:00

I’ve been presenting Concordion at a few meetup groups and brown bag sessions recently. Here are the slide decks.

2017-04-Concordion-2.0 - mixed audience
2016-05-Concordion-2.0 - technical audience
2016-05-05_Wellington_Test_Automation_Meetup - short, technical test audience

These use the reveal.js presentation format.

These are released under a Creative Commons Attribution 4.0 International license, so please feel free to adapt and share these for your own presentations. All we ask for is attribution.

Concordion | Writing a Blog

2017-06-08T00:00:00+00:00

Welcome!

Welcome to the Concordion community blog. The primary goal of this blog is to deliver interesting content about Concordion. If you have valuable ideas, tips, or experiences, then you are more than welcome to contribute. Sharing practical examples are important. After reading your blog post, your readers should not only have gained new insights and ideas, but also know how to actually implement these in practice. The more practical your tips, techniques and ideas are, the better.

This community blog uses Jekyll to allow blogging using simple static Markdown or HTML web pages, with all of the content hosted on the version control platform of GitHub. The goal was to eliminate the complexity of other blogging platforms by creating a workflow that allows you to blog like a hacker. To create a new blog entry you shold get started with the following steps:

Create your own fork of the blog.
Copy the blog template and rename it according to the topic you want to write about.
Edit the header information and add your article content.
Check your blog post.
Create a pull request to get your article published.

1. Create your own fork of the blog

A fork is a copy of the website repository containing all blog entries. Forking a repository allows you to freely experiment with changes without affecting the original project. You can accomplish this step directly in the browser. Go to the blog repository on github.com and click on fork in the top-right corner of the page. That’s it! Now, you have your private copy of the original blog repository.

2. Rename the template with the title of your post

To write a new blog post, you have to create a new Markdown or HTML file within the directory that contains all existing blog entries, _posts. To achieve this step:

Navigate to the _posts directory of your fork of the blog that you have created in the previous step.
Click on the Create new file button.
Set the file name to include today’s date and the title of your post. The naming convention requires posts to be named yyyy-mm-dd-title.md.
Copy the contents of one of the existing posts for further modification.

3. Write your blog content

Now you can edit the content of your post file. First you should edit the first few lines of the file containing metadata for your article. Please, provide a title that will appear in the title bar, along with a heading that will show at the top of the page, a description for the meta tag and for social media shares, and a unique identifier that will be used for comments to the article. Additionally, provide your name next to the author tag, and optionally a link to your homepage with the homepage tag. This will be displayed at the top of your blog post, similar to the information you see in this blog example.

Please, describe your valuable tips, ideas, or experiences after the --- at the end of the header. You can either type your content using Markdown or HTML syntax directly in the browser or clone the fork of your blog onto your computer and use one of the available editors.

4. Check your blog post

To run Jekyll locally, you will need Ruby bundler installed. Then run:

bundle update
bundle exec jekyll s

Your blog will then be created under http://localhost:4000/blog.html.

5. Publish your blog post

Your blog post is now written and looking good - you have just to publish it. This is done through issuing a pull request on github.com. Open the fork of the blog you have created in step 1 in your web browser. At the bottom of the page, select the Create a new branch for this commit and start a pull request radio button. Give the pull request a descriptive name. Add a short comment about the idea of your blog post and press the Propose new file button. After the pull request has been accepted, you can view your blog on the Concordion webpage.