This post follows on from the previous (see part 1 and part 2). Here I’ll close out this series of posts by performing a bit more abstraction and finish up with some thoughts about how and to what extent the Cucumber abstraction fits in.
Using Serenity with Cucumber, Part 2
In the first post of this series, I got us set up with a Serenity repository using Maven as our build tool. I also started us on the path of applying Cucumber-JVM by putting a feature file in place. In this post we’ll start tying Cucumber into Serenity’s runtime operations.
Using Serenity with Cucumber, Part 1
I’ve talked a bit about Serenity in previous posts as well as Cucumber-JVM. Here I’ll combine the two and talk about how to set up a simple Cucumber-style project. Along with this focus, I’ll be concentrating a bit more on the Serenity reporting as part of this.
Modern Testing and Resilient Strategy
In two previous posts (on design pressure and sources of truth) I talked about the context that a modern test team is often fitting in with. Here I’ll get more specific, particularly in regards to some strategic elements.
Screenplay Pattern with Java, Part 3
Screenplay Pattern with Java, Part 2
This post is following on the from the first post in this series. Here I’m going to dig a little further into the screenplay pattern, finishing up the execution of the test started in the first post. I’m focusing on the screenplay pattern itself here. That pattern can be applied in any programming language. I happen to be using Java, and I’m using a tool (Serenity) that already encapsulates this pattern.
Screenplay Pattern with Java, Part 1
In this tutorial post, I’ll begin covering how to apply the screenplay pattern with the Serenity framework. This is a “roll-up your sleeves and code” post. Here I will take a measured approach to demonstrating the screenplay pattern in the context of a working example.
Screenplays and Journeys, Not Page Objects
I wrote about Serenity with Java in a previous post. There I covered just the basics to get you up and running. Here I want to talk about what I think is the primary value-add of Serenity, which is its focus on the screenplay pattern. I think it’s beyond debate that automation engineers should know of this pattern and use it. It’s up for debate whether Serenity’s implementation is a good way to go about it. I leave answering that latter question to the reader. Here I just want to explore the idea as it is implemented.
Modern Testing and Sources of Truth
In a previous post, on testing and design pressure, I closed by saying that certain elements of decisions need to be encoded as artifacts, but that putting appropriate pressure on design meant minimizing those artifacts. Here I’ll talk a bit about that and what this means for test teams.
Java Automation with Serenity
Serenity is a Java-based library for test automation that wraps and extends WebDriver and JUnit functionality. Serenity also wraps around BDD style tools like Cucumber and jBehave. It even has some nice Jira integration. These benefits aside, Serenity can be a little hard to wrap your head around so I’m hoping this in-depth post will aid automaters who want to give it a try.
Modern Testing and Design Pressure
I’ve recently had reason to give some training on my overall philosophy and rationale for the introduction of Quality Assurance and Testing into modern development environments. I’ll put up a few posts as an attempt to gather my own thoughts and check if my own thinking is consistent.
The Danger of the Technocrat Tester
If being completely accurate, I would have to title this post something like “The Danger of the Companies that Frame Testing as a Technocratic Discipline and Hire Testers Who Reinforce This View”. But that’s a really cumbersome title to write! However, I believe that the technocrat tester is a big problem in our industry and many companies are reinforcing this problem. So let’s talk about this.
Why Test Engineers Should Learn Geb and Spock
Awhile back I talked about why test engineers should learn Groovy. Here I’ll focus on two specific tools in this ecosystem: Geb and Spock.
Continue reading Why Test Engineers Should Learn Geb and Spock
Conceptualizing Test Intersections
In my previous post on intersections of testing, I set the stage for how testing is an activity that takes place at various points of intersection. Here I want to conceptualize that idea a bit more and provide some focus on what it means from an operational standpoint.
The Intersections of Testing
A lot of testers I know come across Joe Rainsberger and his declaration that integrated tests are a scam. This always leads to interesting discussions so I figured I would use this post to distill my own thoughts particularly because the opinions of “scam-based testing” are usually predicated upon a profusion of testing terminology.
Along Came a Symbiont, Part 2
I’m going to continue introducing Symbiont in this post. In this post I’ll focus on the various ways that a script can be constructed.
Along Came a Symbiont, Part 1
I’ve talked about my automated testing framework Symbiont in a variety of posts. Because it’s been used in a variety of locations, I’m going to use this post to do a gentle introduction to the framework in a slightly different way than I have previously.
The Art of Attention to Detail in Exploratory Testing
Testers must have the ability to utilize exploratory testing as well as scripted testing. But exploratory testing is actually not the entirely free-form exercise that some people associate it with. So let’s talk about that.
Continue reading The Art of Attention to Detail in Exploratory Testing
WebDriver in JavaScript with Promises
As a tester wanting to write test tools in the JavaScript context, you have to get used to the concepts of callbacks and promises. This is one area that is very different from other programming languages when considering automation. So let’s talk a bit about that.
JavaScript with Selenium WebDriver and Mocha
I talked previously about using Selenium WebDriver in the context of JavaScript. There I used Jasmine as a test runner for Selenium. Here I want to expand on this by using the arguably more popular Mocha as well as get into more depth on automation construction.
Continue reading JavaScript with Selenium WebDriver and Mocha