Better Bullshit Driven Development [SeleniumCamp 2017]

@juliaviluhina @yashaka
Better Bullshit Driven Development

automician.com seleniumcourses.com
About

Better Bullshit Driver Development
Preface

Plan
Preface: Classic BDD & xUnit examples
BDD Intro
Better BDD with xUnit + Allure
Q&A

xUnit style
public class DiasporaTest extends BaseTest { 
LoginPage loginPage = new LoginPage(); 
NewPost newPost = new NewPost(); 
Stream stream = new Stream(); 
 
@Test 
public void shareMessage() { 
loginPage.open(); 
loginPage.signIn(Users.Selenide.username, Users.Selenide.password); 
newPost.start(); 
newPost.write("Selenide 4.2 released!"); 
newPost.share(); 
stream.shouldHavePostWithText(0, "Selenide 4.2 released!"); 
} 
}

BDD style (option 1)
@defaults 
Feature: Diaspora 
 
Scenario: Share message 
Given I open login page 
And I do sign in with credentials: 'selenide', 'xxxxxxxx' 
When I start new post 
And write new post message: 'Selenide 4.2 is released!' 
And share new post 
Then stream should have post with index '1' of text 'Selenide 4.2 is
released!'

public class DiasporaStepdefs { 
 
@Given("^I open login page$") 
public void I_open_login_page(){ 
} 
 
 
@And("^I do sign in with credentials: '(.+)', '(.+)'$") 
public void I_do_sign_in_with_credentials_selenide_yagniyagni(String
username, String password) { 
loginPage.signIn(username, password); 
}
...

... 
@When("^I start new post$") 
public void I_start_new_post(){ 
newPost.start(); 
} 
 
@And("^write new post message: '(.+)'$") 
public void write_new_post_message_Selenide_is_released_(String text){ 
newPost.write(text); 
}
...

...
@And("^share new post$") 
public void share_new_post() { 
newPost.share(); 
} 
 
@Then("^stream should have post with index '( d+)' of text '(.+)'$") 
public void
stream_should_have_post_with_index_of_text_Selenide_is_released_(int
index, String text) { 
stream.shouldHavePostWithText(index-1, text); 
} 
}

@defaults 
Feature: Diaspora 
 
Scenario: Share message 
Given I signed in from login page with credentials: 'selenide', 'xxxx' 
When I publish new post: 'Selenide 4.2 is released!' 
Then I should see new post 'Selenide 4.2 is released!' in the top of
stream

public class DiasporaStepdefs { 
 
@Given("^I signed in from login page with credentials: '(.+)', '(.+)'$") 
public void
I_signed_in_from_login_page_with_credentials_selenide_yagniyagni(String
username, String password) { 
loginPage.signIn(username, password); 
}
...

...
@When("^I publish new post: '(.+)'$") 
public void I_publish_new_post_Selenide_is_released_(String text) { 
newPost.start(); 
newPost.write(text); 
newPost.share(); 
} 
 
@Then("^I should see new post '(.+)' in the top of stream$") 
public void
I_should_see_new_post_Selenide_is_released_in_the_top_of_stream(String
text) { 
stream.shouldHavePostWithText(0, text); 
} 
}

= ?
human readable
scenarios
…
BDD

= ?
human readable
scenarios
pretty reports
BDD

= ...
human readable
scenarios
pretty reports
BDD

=BDD Optimised
ATDD
giving as a bonus:
readable scenarios and
reports

= Optimised
ATDD
=
Devs write tests ﬁrst
BDD

= Optimised
ATDD
=
Devs write acceptance
tests ﬁrst
BDD

= Optimised
ATDD
=
tests ﬁrst
based on scenarios
already written by BA/PO
BDD

=BDD Optimised
ATDD
=
tests ﬁrst
based on scenarios
unbiased thinking of end
product
doing things once
(reqs are 2 in 1 - are
already automatable)

Optimised
ATDD
=
tests ﬁrst
based on scenarios
product
doing things once
Behaviour Driven Development

Optimised
ATDD
=
tests ﬁrst
based on scenarios
product
doing things once
Beh?viour Driven Development

Optimised
ATDD
=
tests ﬁrst
based on scenarios
Automation engineers
write tests after.
adding extra “readable
scenarios” layer for “good
reports”
Beh?viour Driven Development
vs
vs

Optimised
ATDD
=
tests ﬁrst
based on scenarios
Automation engineers
write tests after.
adding extra “readable
scenarios” layer for “good
reports”
Bullshit Driven Development
vs
vs

WTF?
adding additional limited
pseudo-programming layer
just to make tests readable
and with good reports?

Better “Bullshit” Driven Development
without additional limited pseudo programming layers ;)

pom.xml with just xUnit + Selenide
<dependencies> 
<dependency> 
<groupId>com.codeborne </groupId> 
<artifactId>selenide </artifactId> 
<version>4.2 </version> 
<scope>test </scope> 
</dependency> 
<dependency> 
<groupId>junit </groupId> 
<artifactId>junit </artifactId> 
</dependency> 
</dependencies>

xUnit + PageObject with readable steps
 
@Test 
newPost.start(); 
newPost.share(); 
} 
}

public class LoginPage { 
 
public void open() { 
Selenide.open("/users/sign_in"); 
} 
 
public void signIn(String username, String password) { 
Form form = new Form($("#new_user")); 
form.set("USERNAME", username); 
form.set("PASSWORD", password); 
form.submit(); 
} 
}

Report :(

Better xUnit reports with Allure

<dependencies>
... 
<dependency> 
<groupId>ru.yandex.qatools.allure </groupId> 
<artifactId>allure-junit-adaptor </artifactId> 
<version>${allure.version} </version> 
</dependency> 
</dependencies>
pom.xml with Allure conﬁguration

<build> 
<plugins> 
<plugin> 
<groupId>org.apache.maven.plugins </groupId> 
<artifactId>maven-surefire-plugin </artifactId> 
<version>2.19.1 </version> 
<configuration> 
<testFailureIgnore>false </testFailureIgnore> 
<argLine> 
-javaagent:"${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar" 
</argLine> 
<properties> 
<property> 
<name>listener </name> 
<value>ru.yandex.qatools.allure.junit.AllureRunListener </value> 
</property> 
</properties> 
</configuration> 
<dependencies> 
<dependency> 
<groupId>org.aspectj </groupId> 
<artifactId>aspectjweaver </artifactId> 
<version>${aspectj.version} </version> 
</dependency> 
</dependencies> 
</plugin> 
... 
</plugins> 
</build>

<build> 
<plugins> 
... 
<plugin> 
<groupId>org.mortbay.jetty </groupId> 
<artifactId>jetty-maven-plugin </artifactId> 
<configuration> 
<webAppSourceDirectory>${project.build.directory}/site/allure-
maven-plugin </webAppSourceDirectory> 
<stopKey /> 
<stopPort /> 
</configuration> 
</plugin> 
</plugins> 
</build>

<reporting> 
<excludeDefaults>true </excludeDefaults> 
<plugins> 
<plugin> 
<groupId>ru.yandex.qatools.allure </groupId> 
<artifactId>allure-maven-plugin </artifactId> 
</plugin> 
</plugins> 
</reporting>

xUnit + PageObject with reportable @Steps :)
 
@Test 
newPost.start(); 
newPost.share(); 
} 
}

public class LoginPage { 
 
@Step 
public void open() { 
Selenide.open("/users/sign_in"); 
} 
 
@Step 
public void signIn(String username, String password) { 
Form form = new Form($("#new_user")); 
form.set("USERNAME", username); 
form.set("PASSWORD", password); 
form.submit(); 
} 
}

Report

Report
qwerty1234

Report
qwerty1234
qwerty1234

Missed “objects info” in reports :(
 
@Test 
newPost.start(); 
newPost.share(); 
} 
}

Report :(
Missed “objects info” in reports :(
What is opened?
Where do we do signin?
What do we start?
Where?

Fixing “missed objects” with One Entry Point to PageObjects :)
Diaspora diaspora = new Diaspora(); 
 
@Test 
diaspora.loginPage().open(); 
diaspora.loginPage() 
.signIn(Users.Selenide.username, Users.Selenide.password); 
diaspora.newPost().start(); 
diaspora.newPost().write("Selenide 4.2 released!"); 
diaspora.newPost().share(); 
diaspora.stream().shouldHavePostWithText(0, "Selenide 4.2 released!"); 
} 
}

public class Diaspora { 
 
@Step 
public LoginPage loginPage() { 
return new LoginPage(); 
} 
 
@Step 
public NewPost newPost() { 
return new NewPost(); 
} 
 
@Step 
public Stream stream() { 
return new Stream(); 
}
... 
}

 
@Step 
return new LoginPage(); 
} 
 
@Step 
public NewPost newPost() { 
return new NewPost(); 
} 
 
@Step 
public Stream stream() { 
return new Stream(); 
}
... 
}
The simplest impl.
with
redundant objects,
not actually inﬂuencing
performance much

private final LoginPage loginPage; 
private final NewPost newPost; 
private final Stream stream; 
 
public Diaspora() { 
this.loginPage = new LoginPage(); 
this.newPost = new NewPost(); 
this.stream = new Stream(); 
} 
 
@Step 
return this.loginPage; 
} 
... 
}
but in case
you bother…

public class Application { 
private final LoginPage loginPage; 
private final NewPost newPost; 
private final Stream stream; 
 
public Application() { 
this.loginPage = new LoginPage(); 
this.newPost = new NewPost(); 
this.stream = new Stream(); 
} 
 
@Step 
return this.loginPage; 
} 
... 
}
aka Application Manager

Application app = new Application(); 
 
@Test 
app.loginPage().open(); 
app.loginPage() 
.signIn(Users.Selenide.username, Users.Selenide.password); 
app.newPost().start(); 
app.newPost().write("Selenide 4.2 released!"); 
app.newPost().share(); 
app.stream().shouldHavePostWithText(0, "Selenide 4.2 released!"); 
} 
}
aka Application Manager

Report

Report
May be a bit “too long”
while reading to ﬁnd
“logical code sentences”…

Report
But if consider
that “each sentence” is two lines
it becomes to make sense:)

Applying Fluent PageObject for easier scenarios …
 
@Test 
diaspora.loginPage().open().signIn( 
Users.Selenide.username, 
Users.Selenide.password); 
diaspora.newPost().start().write("Selenide 4.2 released!").share(); 
diaspora.stream().post(0).shouldBe("Selenide 4.2 released!"); 
} 
}

public class NewPost { 
... 
@Step 
public NewPost start() { 
this.textArea.click(); 
return this; 
} 
 
@Step 
public NewPost write(String text) { 
this.textArea.setValue(text); 
return this; 
} 
 
@Step 
public void share(){ 
this.container.find("#submit").click(); 
}

public class NewPost { 
... 
@Step 
public NewPost start() { 
this.textArea.click(); 
return this; 
} 
 
@Step 
public NewPost write(String text) { 
this.textArea.setValue(text); 
return this; 
} 
 
@Step 
public void share(){ 
this.container.find("#submit").click(); 
} 
no need to be “ﬂuent” here,
as we do not know,
where user should proceed a ﬂow

… may lead to “missing ﬂow” in reports :(
Report :(
Where does the sentence
start and ﬁnish?

Fixing “missed ﬂow” with “gherkin” pseudo-steps…
 
@Test 
GIVEN("Logged in from login page"); 
WHEN("Posted new message"); 
THEN("Message should appear in the stream"); 
} 
}

public class Gherkin { 
 
@Step 
public static void GIVEN(String step) {} 
 
@Step 
public static void AND(String step) {} 
 
@Step 
public static void WHEN(String step) {} 
 
@Step 
public static void THEN(String step) {} 
}

Report :)

Report :)
Each new “code sentence”
starts with a “gherkin” keyword

Report
(more complicated example)

Illustration

… leads sometimes to even more to readable code
THEN("Connect first cell of this column to first row from data storage"); 
app.testTable().row(0).cell(0).fill("1").hover(); 
 
EXPECT("Connection works by showing connected data in a cell tooltip (on
hover)"); 
app.testTable().toolTip() 
.shouldHaveKeyRowCells("", "user", "password") 
.shouldHaveValueRowCells("1", "vasya", "pupkin1234");
Implementation

… leads sometimes to not much more readable
 
@Test 
} 
}

… and often redundant code :|
 
@Test 
} 
}
just repeats already
readable “code”

Fixing everything:) with “gherkin” style of One Entry Point
public class DiasporaTest extends GherkinTest { 
 
@Test 
GIVEN().loginPage().open().signIn( 
WHEN().newPost().start().write("Selenide 4.2 released!").share(); 
THEN().stream().post(0).shouldBe("Selenide 4.2 released!"); 
} 
}

public class GherkinTest { 
... 
 
@Step 
public Diaspora GIVEN(String ... comments) { return this.diaspora; } 
 
@Step 
public Diaspora AND(String ... comments) { return this.diaspora; } 
 
@Step 
public Diaspora WHEN(String ... comments) { return this.diaspora; } 
 
@Step 
public Diaspora THEN(String ... comments) { return this.diaspora; } 
}

Report :D
Each new “code sentence”
starts with a “gherkin” keyword

THEN("Connect first cell of this column to first row from data storage") 
.testTable().row(0).cell(0).fill("1").hover(); 
 
EXPECT("Connection works by showing connected data in a cell tooltip (on
hover)") 
.testTable().toolTip() 
.shouldHaveKeyRowCells("", "user", "password") 
.shouldHaveValueRowCells("1", "vasya", "pupkin1234");
Implementation
with additional step comments when needed

Report

Summary
GIVEN
no BA writing Gherkin
AND automation engineers writing tests after
WHEN
xUnit
AND Fluent PageObjects with Allure readable @Steps
AND Gherkin style of One Entry Point (aka Application Manager)
THEN
Bullshit Driven Development is Better

Better Bullshit Driven Development with
xUnit, Fluent PageObjects, Allure @Steps, “Gherkined" One Entry Point
• all-powerful programming language over textual-pseudo-language
• full IDE support (autocompletion, auto-generate, etc.)
• 1 abstraction layer less => simpler and faster in implementation
• still fully readable and with pretty good reports
• newcomers friendly
• Just One Entry Point to all Application Model
• structured with granular Fluent PageObjects => easier to
learn&use via autocompletion

Better Bullshit Driven Development ;)
public class DiasporaTest extends GherkinTest { 
 
@Test 
GIVEN().loginPage().open().signIn( 
WHEN().newPost().start().write("Selenide 4.2 released!").share(); 
THEN().stream().post(0).shouldBe("Selenide 4.2 released!"); 
} 
}

Better Bullshit Driven Development ;)

More ideas
• tune Allure to report objects (via calling their toString() method)
• already possible?
• contribute?
• new Allure Feature: log object classes
• contribute?

Afterwords
There are good practices in context,
but there are no best practices.
(c) Cem Kaner, James Bach

Thank you!
github.com/automician
automician.com
seleniumcourses.com
juliaviluhina @

You are welcome;)
Selene in Python
NSelene in C#
Selenide snippets in Java
Yashaka talks src code
Selenide User Guide

Better Bullshit Driven Development [SeleniumCamp 2017]

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Better Bullshit Driven Development [SeleniumCamp 2017]

Similar to Better Bullshit Driven Development [SeleniumCamp 2017] (20)

Recently uploaded

Recently uploaded (20)

Better Bullshit Driven Development [SeleniumCamp 2017]