Cucumber From the Ground Up - Joseph Beale

Cucumber
From the
Ground Up
Joseph E. Beale
02/17/2015

Who am I and why am I here?
Name: Joe Beale
What is essential to know about me:
 I am NOT brilliant.
What I hope to accomplish today:
 Prove that the bullet point above is
correct.
 Put to death any fear you might have
about writing test automation code.

Agenda
 Installation: 10:30 – 10:45
 Environment Set-up: 10:45 – 11:00
 Build and Test: 11:00 – 11:15
 Q&A + Fun Time: 11:15 – 11:30

Installation
Ruby Installer:
http://rubyinstaller.org/downloads/

Installation
MAKE SURE YOU CHECK THE THREE BOXES THAT
ARE RIGHT UNDER THE FOLDER SELECTION FIELD.

Installation
Download DevKit from the RubyInstaller page:
Extract to C:DevKit

Installation
At command prompt, check for correct
Ruby installation by typing:
 ruby –v [Enter]

Installation
To install DevKit, navigate to C:DevKit and
type the following:
 ruby dk.rb init [Enter]
 ruby dk.rb install [Enter]
Go back to the root directory (C:) and
install Cucumber by typing:
 gem install cucumber [Enter]
You now have Ruby and Cucumber fully installed!

Environment
Using Windows Explorer, create a new
folder on your C drive called test_project.

Environment
Inside of test_project, create a folder called
features, then inside of that create two
more: step_definitions and support.

Environment
RubyMine – A Robust IDE for Ruby Coding
RubyMine is also very Cucumber-friendly!

Environment
We will use RubyMine 5.4.3 for today’s
demo:

Environment
Use the Open Directory command to open
up our test_project folder.

Environment
Create a folder called env.rb inside of the
support folder using New –> File from the
right-click menu.

Environment
Need two more gems for this
demonstration:
 watir-webdriver
 rspec
Q: What is a Ruby gem?
A: A pre-built code module that performs
some useful function in Ruby, available for
free from https://rubygems.org/

Environment
Go back to your command prompt and
install the gems using this command:
 gem install <name of gem> [Enter]

Environment
Require statements tell Ruby that you are
going to use some extra code modules.
Q: Why env.rb in the support folder?
A: Cucumber knows to run env.rb before
anything else and looks for it in support.

Build and Test
Create a feature file and a test scenario.
Cucumber scenarios are written in ordinary
business language using Gherkin keywords
(“Feature:”, “Scenario:”, “Given”, “When”,
“Then”, “And”, “But”).

Build and Test
Create step definitions using RubyMine’s
built-in functionality.

Build and Test
RubyMine creates a new file called
my_steps.rb and adds code blocks with
regular expressions to match your Gherkin
steps.

Build and Test
First step:
Given I am on the Bing home page
To satisfy this step, we need to open a
browser and navigate to the Bing home
page.
How do we do this in Ruby?

Build and Test
Watir Webdriver is a gem that is built to drive
web applications. Since the code is
already written, we only need to learn how
to use it.
http://watirwebdriver.com/

Build and Test
Right on the front page is the code to
create a browser object (along with lots of
other stuff):
We will use these exact lines of code and
modify them slightly for our purposes.

Build and Test
The small ‘b’ in their examples stands for
‘browser’, but when we create an object
we will call it ‘browser’ to avoid confusion.
The browser object is created in env.rb so
that it is executed before any of the steps

Build and Test
Q: Why did you put a ‘$’ in front of your
object name?
A: To indicate that it’s a global variable.
We want the browser object to be
accessible to all steps, so we make it global.

Build and Test
In the first step definition, we will put the
next line of code, but modified to reflect
our global browser object and the URL for
Bing.com:
Now when we run our Cucumber scenario,
the first step will give us…

Build and Test
The Bing home page!

Build and Test
A quick word about method calls: the
format for calling a method in Ruby is
(object name) + dot (‘.’) + (method name).
So in the method call below, the object
name is ‘$browser’ and the method name is
‘goto’.

Build and Test
The ‘goto’ method is just one of the pre-defined
methods inside of the Watir::Browser class. The
method takes one argument: a URL (because it
needs to know where to “go to”).
Arguments can be passed either inside of
parentheses or alongside a method call. So in
the previous example, we could have said:
$browser.goto(‘http://bing.com’)

Build and Test
Second step:
When I search for "Death Star“
To satisfy this step, we need to interact with
two of the elements of the page:
 The search text field
 The search button (indicated by the
magnifying glass icon)

Build and Test
Watir Webdriver has several methods in the
Browser class to interact with the elements
that are common to most web pages. In
fact, the ones we need are also listed on
their front page:

Build and Test
To interact with the two search elements,
we will use the ‘text_field’ and ‘button’
methods. These methods each take one
argument: a location as indicated by the
syntax (:locater => ‘unique_identifier’). The
examples given are these:
b.text_field(:id => 'entry_0').set 'your name'
b.button(:name => 'submit').click

Build and Test
The locators are part of the html code for
the page elements, and this information is
acquired by using Firefox’s “Inspect
Element” tool.
So if you right-click on the search text field
and choose “Inspect Element” from the
drop-down menu, you will see the specific
html code for that element in the shaded
section.

Build and Test
The most common locator to use is ‘id’. So
we will copy the value ‘sb_form_q’ to use in
our argument to the ‘text_field’ method.

Build and Test
One nice feature of Ruby method calls is
the ability to “chain” your methods one
right after another. Ruby will execute them
in the order given, from left to right. That is
what you see in the the ‘text_field’
example:
b.text_field(:id => 'entry_0').set 'your name'
The ‘set’ method is executed right after the
‘text_field’ method.

Build and Test
You can use the ‘set’ method anytime you
have defined a text field element using the
‘text_field’ method. It takes one argument,
the word or phrase you wish to place in that
field. So, putting it all together, the code for
our second step will look like this:
Q: Where did ‘search_phrase’ come from?

Build and Test
As you may recall, our original step
definition looked like this:
I changed the default variable name ‘arg’
to one that reflects what it actually holds:
‘search_phrase’. The capture group with
wildcard grabs the phrase “Star Wars” from
the step and throws it into the variable.

Build and Test
Since the variable ‘search_phrase’ contains
a string, then it can be used as an
argument for the ‘set’ method. And so we
are then able to use that same Ruby code
block no matter what phrase is used in the
Gherkin step.
Step 
Step
Definition

Build and Test
Running the test now gives us…
That’s
No
Moon!!!

Build and Test
For the button element, we’ll do it exactly
like we did the text field, except instead of
the ‘set’ method, we’ll need to find one
that will click the button. The method name
in this case is – surprise! – ‘click’. Here’s the
example from Watir Webdriver’s front page:
b.button(:name => 'submit').click

Build and Test
The locator they are using is ‘name’, but in
our case there is no name, just a magnifying
glass symbol. So we’ll inspect the element
in order to find the ‘id’ for locating it:

Build and Test
Adding that into the step gives us this:
Again, you can see that we “chained” two
methods: first the ‘button’ method to locate
a specific element and then the
‘click’method. The latter method does not
require any arguments, for obvious reasons.

Build and Test
Now let’s run it again. Well, that’s better!

Build and Test
Third step:
Then the search results will
include "Star Wars“
Somehow we have to get our code to
examine the result page and check to see
if our result phrase “Star Wars” is found
anywhere. This is where the Rspec gem
comes into play.

Build and Test
You might recall that in the env.rb file we
told Ruby to require that code:
RSpec gives us the ability to “match” values
and phrases against an expected result.

Build and Test
For our purposes, the most relevant RSpec
method is ‘should’. This method will check
a value from our object against another
value and either pass or fail the step based
on whether or not it matches. Let’s see how
this step might be coded.
Q: What does the ‘text’ method do?

Build and Test
Many of the html elements on a web page will
have text associated with them, and most of
the time it’s displayed on the page.
For any given element, you can request the
associated text using the ‘text’ method. The
code we used, ‘$browser.text’ will give you all
the text on the page.

Build and Test
The ‘should’ method requires a “matcher”
like ‘include’ or ‘==‘ in order to compare
with the expected result. The ‘include’
matcher mimics the behavior of the Ruby
‘include?’ method that is part of the String
class.
If the expression matches the expected
value, then the test passes!

Build and Test
Running one more time gives us this result in
RubyMine:
Congratulations! You have just passed your
first Ruby/Cucumber automated test!

Q&A + Fun Time
You don’t have to be this guy to automate.

Q&A + Fun Time
In fact, even this guy could do it.

Q&A + Fun Time
Questions? Comments? Snark?
You can reach me at:
joseph_beale@att.net
or
joseph.beale92@gmail.com
or
Connect with me on Linked In!

Cucumber From the Ground Up - Joseph Beale

More Related Content

What's hot (18)

Viewers also liked (15)

Similar to Cucumber From the Ground Up - Joseph Beale (20)

More from QA or the Highway (20)

Recently uploaded (20)

Cucumber From the Ground Up - Joseph Beale