Context Class Requirements¶

In order to be used by Behat, your context class should follow these rules:

1. The context class should implement theBehat\Behat\Context\Context interface.

2. The context class should be calledFeatureContext. It’s a simple conventioninside the Behat infrastructure.FeatureContext is the name of thecontext class for the default suite. This can easily be changed throughsuite configuration insidebehat.php.

3. The context class should be discoverable and loadable by Behat. That means youshould somehow tell Behat about your class file. Behat comes with a PSR-0autoloader out of the box and the default autoloading directory isfeatures/bootstrap. That’s why the defaultFeatureContext is loaded soeasily by Behat. You can place your own classes underfeatures/bootstrapby following the PSR-0 convention or you can even define your own customautoloading folder viabehat.php.

Contexts Lifetime¶

Your context class is initialized before each scenario is run, and every scenariohas its very own context instance. This means 2 things:

1. Every scenario is isolated from each other scenario’s context. You can doalmost anything inside your scenario context instance without the fear ofaffecting other scenarios - every scenario gets its own context instance.

2. Every step in a single scenario is executed inside a common contextinstance. This means you can setprivate instance variables insideyourGiven steps and you’ll be able to read their new values insideyourWhen andThen steps.

Multiple Contexts¶

At some point, it could become very hard to maintain all yourstep definitionsandHooksinside a single class. You could use class inheritance and split definitionsinto multiple classes, but doing so could cause your code to become moredifficult to follow and use.

In light of these issues, Behat provides a more flexible way of helping makeyour code more structured by allowing you to use multiple contexts in a single testsuite.

In order to customise the list of contexts your test suite requires, you needto fine-tune the suite configuration insidebehat.php:

<?php// behat.phpuseFeatureContext;useSecondContext;useThirdContext;useBehat\Config\Config;useBehat\Config\Profile;useBehat\Config\Suite;$profile=newProfile('default')->withSuite(newSuite('default')->withContexts(FeatureContext::class,SecondContext::class,ThirdContext::class,));returnnewConfig()->withProfile($profile);

The firstdefault in this configuration is a name of the profile. Wewill discuss profiles a little bit later. Underthe specific profile, we have a specialsuites section, whichconfigures suites inside this profile. We will talk about test suites in moredetail in thenext chapter, for now just keep in mindthat a suite is a way to tell Behat where to find your features andhow to test them. The interesting part for us now is thecontextssection - this is an array of context class names. Behat will use the classesspecified there as your feature contexts. This means that every timeBehat sees a scenario in your test suite, it will:

1. Get list of all context classes from thiscontexts option.

2. Will try to initialize all these context classes into objects.

3. Will search forstep definitions andHooks in all of them.

Basically, all contexts under thecontexts section of yourbehat.phpare the same for Behat. It will find and use the methods in them the same wayit does in the defaultFeatureContext. And if you’re happy with a singlecontext class, but you don’t like the nameFeatureContext, here’show you change it:

<?php// behat.phpuseMyAwesomeContext;useBehat\Config\Config;useBehat\Config\Profile;useBehat\Config\Suite;$profile=newProfile('default')->withSuite(newSuite('default')->withContexts(MyAwesomeContext::class,));returnnewConfig()->withProfile($profile);

This configuration will tell Behat to look forMyAwesomeContextinstead of the defaultFeatureContext.

<?php// behat.phpuseMyAwesomeContext;useMyWickedContext;useBehat\Config\Config;useBehat\Config\Profile;useBehat\Config\Suite;$profile=newProfile('default')->withSuite(newSuite('default')->withContexts(MyAwesomeContext::class,MyWickedContext::class,))->withSuite(newSuite('suite_a')->withContexts(MyAwesomeContext::class,MyWickedContext::class,))->withSuite(newSuite('suite_b')->withContexts(MyAwesomeContext::class,MyWickedContext::class,));returnnewConfig()->withProfile($profile);

Context Parameters¶

Context classes can be very flexible depending on how far you wantto go in making them dynamic. Most of us will want to make our contextsenvironment-independent; where should we put temporary files, which URLswill be used to access the application? These arecontext configuration options highly dependent on the environment youwill test your features in.

We already said that context classes are just plain old PHP classes.How would you incorporate environment-dependent parameters into yourPHP classes? Useconstructor arguments:

// features/bootstrap/MyAwesomeContext.phpuseBehat\Behat\Context\Context;classMyAwesomeContextimplementsContext{publicfunction__construct($baseUrl,$tempPath){$this->baseUrl=$baseUrl;$this->tempPath=$tempPath;}}

As a matter of fact, Behat gives you ability to do just that. You canspecify arguments required to instantiate your context classes throughsamecontexts setting inside yourbehat.php:

<?php// behat.phpuseMyAwesomeContext;useBehat\Config\Config;useBehat\Config\Profile;useBehat\Config\Suite;$profile=newProfile('default')->withSuite(newSuite('default')->addContext(MyAwesomeContext::class,['http://localhost:8080','/var/tmp',]));returnnewConfig()->withProfile($profile);

Arguments would be passed to theMyAwesomeContext constructor inthe order they were specified here. If you are not happy with the ideaof keeping an order of arguments in your head, you can use argumentnames instead:

<?php// behat.phpuseMyAwesomeContext;useBehat\Config\Config;useBehat\Config\Profile;useBehat\Config\Suite;$profile=newProfile('default')->withSuite(newSuite('default')->addContext(MyAwesomeContext::class,['baseUrl'=>'http://localhost:8080','tempPath'=>'/var/tmp',]));returnnewConfig()->withProfile($profile);

As a matter of fact, if you do, the order in which you specify thesearguments becomes irrelevant:

<?php// behat.phpuseMyAwesomeContext;useBehat\Config\Config;useBehat\Config\Profile;useBehat\Config\Suite;$profile=newProfile('default')->withSuite(newSuite('default')->addContext(MyAwesomeContext::class,['tempPath'=>'/var/tmp','baseUrl'=>'http://localhost:8080',]));returnnewConfig()->withProfile($profile);

Taking this a step further, if your context constructor arguments areoptional:

publicfunction__construct($baseUrl='http://localhost',$tempPath='/var/tmp'){$this->baseUrl=$baseUrl;$this->tempPath=$tempPath;}

You then can specify only the parameter that you actually need to change:

<?php// behat.phpuseMyAwesomeContext;useBehat\Config\Config;useBehat\Config\Profile;useBehat\Config\Suite;$profile=newProfile('default')->withSuite(newSuite('default')->addContext(MyAwesomeContext::class,['tempPath'=>'/var/tmp',]));returnnewConfig()->withProfile($profile);

In this case, the default values would be used for other parameters.

Context Traits¶

PHP 5.4 have brought an interesting feature to the language - traits.Traits are a mechanism for code reuse in single inheritance languageslike PHP. Traits are implemented as a compile-time copy-paste in PHP.That means if you put some step definitions or hooks inside a trait:

// features/bootstrap/ProductsDictionary.phptraitProductsDictionary{#[Given('there is a(n) :product, which costs £:price')]publicfunctionthereIsAWhichCostsPs($product,$price){thrownewPendingException();}}

And then use it in your context:

// features/bootstrap/MyAwesomeContext.phpuseBehat\Behat\Context\Context;classMyAwesomeContextimplementsContext{useProductsDictionary;}

It will just work as you expect it to.

Context traits come in handy if you’d like to have separate contexts,but still need to use the very same step definition in both of them. Instead ofhaving the same code in both context classes – and having to maintain itin both – you should create a single Trait that you would thenuse inboth context classes.