Behat Best Practices

Behat Best
Practices
Ciaran McNulty
@ciaranmcnulty | #scotphp17

Behaviour Driven
Development

BDD is the art of using examples in
conversations to illustrate behaviour
— Liz Keogh

BDD is the art of using
examples in
conversations to
illustrate behaviour

Example
2 - Something that serves to illustrate or explain a rule
— Wiktionary

Rule:
We charge our customers sales tax at a rate of 20%

Rule:
Example:
So, if an item is priced at $10, we charge $10
+ $2 tax for a total of $12

Rule:
Example:
No! If an item is priced at £10, we charge £10
and allocate £1.67 of that as sales tax

Capturing Examples
Input -> Rules -> Output

Capturing Examples
Input: When an action is taken
Output: Then an outcome should occur

Capturing Examples
When I buy a pair of Levi 501s
Then I am charged £32.99

Capturing Examples
Context: Given some situation
Input: When an action is taken
Output: Then an outcome should occur

Capturing Examples
Given Levi 501s are listed at £32.99

Context Questioning
“Is there any other context which, when this event happens, will
produce a different outcome?” - Liz Keogh

Context Questioning
“Is there any situation where I could buy these jeans and pay a different
amount?”

Context Questioning
“Is there any situation where I could buy these jeans and pay a different
amount?”
» When they are on sale
» When I get a staff discount
» When they are ex-display

Outcome Questioning
“Given this context, when this event happens, is there another outcome
that’s important? Something we missed, perhaps?” - Liz Keogh

Outcome Questioning
"Aside from me being charged for the jeans, does something else
happen that we need to care about?"

Outcome Questioning
"Aside from me being charged for the jeans, does something else
happen that we need to care about?"
» I get given a pair of jeans!
» Stock control has to be told we sold them

BDD is not about
testing

BDD is also not about
requirement capture

Validating examples
(ok it is a bit about testing,
sometimes)

Behat

Feature: Scheduling a training course
As a trainer
In order to be able to cancel courses or schedule new ones
I should be able to specify a maximum and minimum class size
Rules:
- Course is proposed with size limits
- When enough enrolments happen, course is considered viable
- When maximum class size is reached, further enrolments are not allowed
Background:
Given "BDD for Beginners" was proposed with a class size of 2 to 3 people
Scenario: Course does not get enough enrolments to be viable
When only Alice enrols on this course
Then this course will not be viable
Scenario: Course gets enough enrolments to be viable
Given Alice has already enrolled on this course
When Bob enrols on this course
Then this course will be viable
Scenario: Enrolments are stopped when class size is reached
Given Alice, Bob and Charlie have already enrolled on this course
When Derek tries to enrol on this course
Then he should not be able to enrol

Feature: Scheduling a training course
As a trainer
In order to be able to cancel courses or schedule new ones
I should be able to specify a maximum and minimum class size
Rules:
- Course is proposed with size limits
- When enough enrolments happen, course is considered viable
- When maximum class size is reached, further enrolments are not allowed

Background:
Scenario: Course does not get enough enrolments to be viable

Background:
Scenario: Course gets enough enrolments to be viable

Background:
Scenario: Enrolments are stopped when class size is reached

Gherkin:
Given a thing happens to Ciaran
PHP:
/**
* @Given a thing happens to :person
*/
public function doAThing(string $person)
{
// you have to write this
}

Driving the Domain layer
» Drive PHP objects directly from scenario
» Proves domain supports business actions
» Aligns domain model with business language
» Executes quickly with few dependencies

class FeatureContext implements Context
{
/**
* @Given :courseTitle was proposed with a class size of :min to :max people
*/
public function courseWasProposedWithAClassSizeOfToPeople(string $courseTitle, int $min, int $max)
{
$this->course = Course::propose(
$courseTitle,
ClassSize::between($min, $max)
);
}
}

{
/** @Transform */
public function transformLearner(string $name) : Learner
{
return Learner::called($name);
}
/**
* @When only :learner enrols on this course
*/
public function learnerEnrolsOnCourse(Learner $learner)
{
$this->course->enrol($learner);
}
}

{
/**
* @Then this course will not be viable
*/
public function thisCourseWillNotBeViable()
{
assert($this->course->isViable() == false);
}
}

{
/**
* @Given :learner has already enrolled on this course
*/
{
}
}

{
/**
* @When (only) :learner enrols on this course
* @Given :learner has already enrolled on this course
*/
{
}
}

{
/**
* @Then this course will be viable
*/
public function thisCourseWillBeViable()
{
assert($this->course->isViable() == true);
}
}

class Course
{
//...
public function isViable(): bool
{
return $this->classSize->isViable($this->learners);
}
}
class ClassSize
{
//...
public function isViable(int $size) : bool
{
return $size >= $this->min;
}
}

class Course
{
//...
public function isViable()
{
return $this->classSize->isViable($this->learners);
}
}
class ClassSize
{
//...
public function isViable(int $size)
{
return $size >= $this->min;
}
}

{
/**
* @Given :learner1, :learner2 and :learner3 have already enrolled on this course
*/
public function learnersHaveAlreadyEnrolledOnThisCourse(
Learner $learner1, Learner $learner2, Learner $learner3
)
{
$this->course->enrol($learner1);
}
}

{
/**
* @When :learner tries to enrol on this course
*/
public function learnerTriesToEnrolOnCourse(Learner $learner)
{
try {
}
catch (Exception $e)
{
$this->enrolmentProblem = $e;
}
}
}

{
/**
* @Then (s)he should not be able to enrol
*/
public function learnerShouldNotBeAbleToEnrol()
{
assert($this->enrolmentProblem instanceof CjmTrainingEnrolmentProblem);
}
}

ﬁnal class Course
{
public function enrol(Learner $learner)
{
if (!$this->classSize->hasMoreCapacity($this->learners)) {
throw new EnrolmentProblem('Class is already at capacity');
}
$this->learners++;
}
}

Driving the Service layer
» Configure services in test environment
» Inject services into Behat context (using an extension)
» Interact with domain model via the services
» Aligns service layer with business use cases

Suites
# behat.yml
default:
suites:
domain:
contexts: [ DomainContext ]
services:
contexts: [ ServiceContext ]

class ServiceContext implements Context
{
public function __construct(CourseEnrolments $courseEnrolments)
{
$this->courseEnrolments = $courseEnrolments;
}
/**
* @Given :course was proposed with a class size of :min to :max people
*/
public function wasProposedWithAClassSizeOfToPeople(string $course, int $min, int $max)
{
$this->course = $course;
$this->courseEnrolments->propose($course, $min, $max);
}
}

{
public function __construct(CourseEnrolments $courseEnrolments)
{
$this->courseEnrolments = $courseEnrolments;
}
/**
*/
{
$this->courseId = $course;
}
}

Symfony extension
# behat.yml
default:
suites:
domain:
contexts:
- DomainContext
services:
contexts:
- ServiceContext:
courseEnrolments: "@cjm.training.enrolment.course_enrolments"
extensions:
BehatSymfony2Extension: ~

PSR-11 support
» 'Native' support for instantiatable containers
» Extension point to plug in containers using other methods
» e.g. Roave/behat-psr11extension for Zend Expressive

Autowiring
Type hint services and get them automatically injected in:
» Constructors
» Step definitions
» Transformations

class CourseEnrolments
{
public function propose(string $title, int $minimum, int $maximum)
{
$this->courses->add(
Course::propose(
$title,
ClassSize::between($minimum, $maximum)
)
);
}
}

Infrastructure
» Using real infrastructure is slow
» Using fake infrastructure can lower confidence
» Use fake infrastructure but sync via contract tests

ﬁnal class Courses implements CjmTrainingEnrolmentModelCourses
{
public function add(Course $course) : void
{
$this->courses[] = $course;
}
public function ﬁndByTitle(string $title): Course
{
return $this->courses[0];
}
}

{
/**
* @When (only) :learner enrols on this course
*/
public function learnerEnrolsOnThisCourse(string $learner)
{
$this->courseEnrolments->enrol($learner, $this->courseId);
}
}

{
/**
*/
{
assert($this->courseEnrolments->isCourseViable($this->courseId) == false);
}
}

Domain vs Service layer
» Start by driving domain layer
» Refactor to services when confidence grows
» Drop back to domain layer when remodelling

Driving the UI layer
» Simulate a browser with behat/minkextension
» Interact with domain model via the UI
» Ensures UI supports business actions
» Slow, brittle, flakey...
» Does not constrain API

Don't do this
Scenario: Buying a pair of jeans
Given I am on "/products/levi-501"
When I click on "#add-form input[type=submit]"
Then "#basket ul" should contain "jeans"

Mink
» Browser driver abstraction
» Supports Selenium, Goutte, Browserkit

# behat.yml
deafult:
suites:
domain:
contexts:
- DomainContext
services:
contexts:
- ServiceContext:
endtoend:
ﬁlters:
tags: "@endtoend"
contexts:
- EndToEndContext:

Mink with Symfony
# behat.yml
extensions:
BehatSymfony2Extension: ~
BehatMinkExtension:
sessions:
symfony:
symfony2: ~

Mink with PSR-7
# behat.yml
extensions:
CjmBehatPsr7Extension:
app: %paths.base%/path/to/ﬁle.php
BehatMinkExtension:
sessions:
psr:
psr-7: ~

class EndToEndContext implements RawMinkContext
{
/**
*/
{
$this->course = $course;
}
}

{
/**
*/
public function learnerEnrolsOnCourse(string $learner)
{
$this->visitPath('/courses/' . $this->course);
$page = $this->getSession()->getPage();
$page->ﬁllField('Your name', $learner);
$page->pressButton('Enrol');
}
}

{
/**
*/
{
$this->visitPath('/courses/'.$this->course);
$this->assertSession()->elementExists('css', '#not-viable-warning');
}
}

Automating a real browser
» Avoid or minimise
» Orders of magnitude slower
» Required for end-to-end with JS
» Can often be replaced with JS cucumber stack

# behat.yml
extensions:
BehatMinkExtension:
sessions:
symfony:
symfony2: ~
selenium2:
browser: chrome
capabilities:
chrome:
switches:
- "--headless"
- "--disable-gpu"

Things I'm trying out
» dmore/behat-chrome-extension
» aligning end-to-end tests to service APIs
» property-based testing

Summary
» Drive domain objects directly to explore model
» Refactor to services when model is stable
» Add minimal UI coverage

Thanks
» @ciaranmcnulty
» @Inviqa
» @PhpSpec
» @BDDLondon
» @SymfonyUK
github.com/ciaranmcnulty/behat-symfony-demo
joind.in/event/scotlandphp-2017/behat-best-practices

Behat Best Practices

More Related Content

Similar to Behat Best Practices

More from CiaranMcNulty

Recently uploaded

Behat Best Practices