Decoupling with Design Patterns and Symfony2 DIC

Decoupling with
Design Patterns
and Symfony DIC

@everzet
· Spent more than 7
years writing so!ware
· Spent more than 4
years learning
businesses
· Now filling the gaps
between the two as a
BDD Practice Manager
@Inviqa

behat 3
promise #1 (of 2):
extensibility

“Extensibility is a so!ware design
principle defined as a system’s ability
to have new functionality extended, in
which the system’s internal structure
and data flow are minimally or not
affected”

“So!ware entities (classes, modules,
functions, etc.) should be open for
extension, but closed for modification”

behat 3
promise #2 (of 2):
backwards compatibility

behat 3
- extensibility as the core concept
- BC through extensibility

Symfony Bundles
Behat extensions

Symfony Bundles & Behat extensions
1. Framework creates a temporary
container
2. Framework asks the bundle to add its
services
3. Framework merges all temporary
containers
4. Framework compiles merged
container

interface CompilerPassInterface
{
/**
* You can modify the container here before it is dumped to PHP code.
*
* @param ContainerBuilder $container
*
* @api
*/
public function process(ContainerBuilder $container);
}

class YourSuperBundle extends Bundle
{
public function build(ContainerBuilder $container)
{
parent::build($container);
$container->addCompilerPass(new YourCompilerPass());
}
}

v3.0 v1.0
(extensibility solution v1)

challenge:
behat as the most extensible
test framework

class HookDispatcher extends DispatchingService implements EventSubscriberInterface
{
public static function getSubscribedEvents()
{
return array(
EventInterface::BEFORE_SUITE => array('dispatchHooks', 10),
EventInterface::AFTER_SUITE => array('dispatchHooks', 10),
EventInterface::BEFORE_FEATURE => array('dispatchHooks', 10),
...
);
}
public function dispatchHooks(LifecycleEventInterface $event)
{
$hooksProvider = new HooksCarrierEvent($event->getSuite(), $event->getContextPool());
$this->dispatch(EventInterface::LOAD_HOOKS, $hooksProvider);
foreach ($hooksProvider->getHooksForEvent($event) as $hook) {
$this->dispatchHook($hook, $event);
}
}
...
}

class HooksCarrierEvent extends Event implements LifecycleEventInterface
{
public function addHook(HookInterface $hook)
{
$this->hooks[] = $hook;
}
public function getHooksForEvent(Event $event)
{
return array_filter(
$this->hooks,
function ($hook) use ($event) {
$eventName = $event->getName();
if ($eventName !== $hook->getEventName()) {
return false;
}
return $hook;
}
);
}
...
}

class DictionaryReader implements EventSubscriberInterface
{
{
return array(
EventInterface::LOAD_HOOKS => array('loadHooks', 0),
...
);
}
public function loadHooks(HooksCarrierEvent $event)
{
foreach ($this->read($event->getSuite(), $event->getContextPool()) as $callback) {
if ($callback instanceof HookInterface) {
$event->addHook($callback);
}
}
}
...
}

class EventSubscribersPass implements CompilerPassInterface
{
public function process(ContainerBuilder $container)
{
$dispatcherDefinition = $container->getDefinition('event_dispatcher');
foreach ($container->findTaggedServiceIds('event_subscriber') as $id => $attributes) {
$dispatcherDefinition->addMethodCall('addSubscriber', array(new Reference($id)));
}
}
}

where event dispatcher /
observer is useful?

pub/sub as an
architectural choice

“Coupling is a degree to which each
program module relies on each one of
the other modules”

“Cohesion is a degree to which the
elements of a module belong together”

“Coupling is a degree to which each
program module relies on each one of
the other modules”
{
}
}

“Cohesion is a degree to which the
elements of a module belong together”
{
}
}

v3.0 v2.0
(extensibility solution v2)

There is no single solution for
extensibility. Because extensibility is
not a single problem

framework extensions
Since v2.5 behat has some very
important extensions:
1. MinkExtension
2. Symfony2Extension

problem:
there are multiple possible
algorithms for a single
responsibility

final class EnvironmentManager
{
private $handlers = array();
public function registerEnvironmentHandler(EnvironmentHandler $handler)
{
$this->handlers[] = $handler;
}
public function buildEnvironment(Suite $suite)
{
foreach ($this->handlers as $handler) {
...
}
}
public function isolateEnvironment(Environment $environment, $testSubject = null)
{
foreach ($this->handlers as $handler) {
...
}
}
}

interface EnvironmentHandler
{
public function supportsSuite(Suite $suite);
public function buildEnvironment(Suite $suite);
public function supportsEnvironmentAndSubject(Environment $environment, $testSubject = null);
public function isolateEnvironment(Environment $environment, $testSubject = null);
}

final class EnvironmentHandlerPass implements CompilerPassInterface
{
{
$references = $this->processor->findAndSortTaggedServices($container, ‘environment.handler’);
$definition = $container->getDefinition(‘environment.manager’);
foreach ($references as $reference) {
$definition->addMethodCall('registerEnvironmentHandler', array($reference));
}
}
}

where delegation loop is
useful?

behat testers
There are 5 testers in behat core:
1. FeatureTester
2. ScenarioTester
3. OutlineTester
4. BackgroundTester
5. StepTester

behat testers
Behat needs to provide you with:
· Hooks
· Events

problem:
we need to dynamically extend
the core testers behaviour

final class RuntimeScenarioTester implements ScenarioTester
{
public function setUp(Environment $env, FeatureNode $feature,
Scenario $example, $skip)
{
return new SuccessfulSetup();
}
public function test(Environment $env, FeatureNode $feature,
Scenario $scenario, $skip = false)
{
...
}
public function tearDown(Environment $env, FeatureNode $feature,
Scenario $scenario, $skip, TestResult $result)
{
return new SuccessfulTeardown();
}
}

interface ScenarioTester
{
Scenario $scenario, $skip);
Scenario $scenario, $skip);
Scenario $scenario, $skip, TestResult $result);
}

final class EventDispatchingScenarioTester implements ScenarioTester
{
public function __construct(ScenarioTester $baseTester, EventDispatcherInterface $eventDispatcher)
{
$this->baseTester = $baseTester;
$this->eventDispatcher = $eventDispatcher;
}
Scenario $scenario, $skip)
{
$event = new BeforeScenarioTested($env, $feature, $scenario);
$this->eventDispatcher->dispatch($this->beforeEventName, $event);
$setup = $this->baseTester->setUp($env, $feature, $scenario, $skip);
return $setup;
}
Scenario $scenario, $skip)
{
return $this->baseTester->test($env, $feature, $scenario, $skip);
}
{
$teardown = $this->baseTester->tearDown($env, $feature, $scenario, $skip, $result);
$event = new AfterScenarioTested($env, $feature, $scenario, $result, $teardown);
$this->eventDispatcher->dispatch($event);
return $teardown;
}
}

final class HookableScenarioTester implements ScenarioTester
{
public function __construct(ScenarioTester $baseTester, HookDispatcher $hookDispatcher)
{
$this->baseTester = $baseTester;
$this->hookDispatcher = $hookDispatcher;
}
Scenario $example, $skip)
{
$setup = $this->baseTester->setUp($env, $feature, $scenario, $skip);
$hookCallResults = $this->hookDispatcher->dispatchScopeHooks($setup);
return new HookedSetup($setup, $hookCallResults);
}
Scenario $scenario, $skip = false)
{
return $this->baseTester->test($env, $feature, $scenario, $skip);
}
{
$teardown = $this->baseTester->tearDown($env, $feature, $scenario, $skip, $result);
$hookCallResults = $this->hookDispatcher->dispatchScopeHooks($teardown);
return new HookedTeardown($teardown, $hookCallResults);
}
}

final class ScenarioTesterWrappersPass implements CompilerPassInterface
{
{
$references = $this->findAndReorderTaggedServices($container, ‘tester.scenario_wrapper’);
$id = (string) $reference;
$renamedId = $id . '.inner';
// This logic is based on SymfonyComponentDependencyInjectionCompilerDecoratorServicePass
$definition = $container->getDefinition(‘tester.scenario’);
$container->setDefinition($renamedId, $definition);
$container->setAlias('tester.scenario', new Alias($id, $public));
$wrappingService = $container->getDefinition($id);
$wrappingService->replaceArgument(0, new Reference($renamedId));
}
}
...
}

behat output
Behat has a very simple output:

behat output
Until you start using backgrounds:

behat output
And throwing exceptions from their
hooks:

problem:
we need to add behaviour to
complex output logic

pattern: chain of responsibility

final class NodeEventListeningFormatter implements Formatter
{
public function __construct(EventListener $listener)
{
$this->listener = $listener;
}
{
return array(TestworkEventDispatcher::BEFORE_ALL_EVENTS => 'listenEvent');
}
public function listenEvent(Event $event, $eventName = null)
{
$eventName = $eventName ?: $event->getName();
$this->listener->listenEvent($this, $event, $eventName);
}
}

final class ChainEventListener implements EventListener, Countable, IteratorAggregate
{
private $listeners;
public function __construct(array $listeners)
{
$this->listeners = $listeners;
}
public function listenEvent(Formatter $formatter, Event $event, $eventName)
{
foreach ($this->listeners as $listener) {
$listener->listenEvent($formatter, $event, $eventName);
}
}
...
}

Event listeners
Behat has 2 types of listeners:
1. Printers
2. Flow controllers

final class StepListener implements EventListener
{
{
$this->captureScenarioOnScenarioEvent($event);
$this->forgetScenarioOnAfterEvent($eventName);
$this->printStepSetupOnBeforeEvent($formatter, $event);
$this->printStepOnAfterEvent($formatter, $event);
}
...
}

class FirstBackgroundFiresFirstListener implements EventListener
{
public function __construct(EventListener $descendant)
{
$this->descendant = $descendant;
}
{
$this->flushStatesIfBeginningOfTheFeature($eventName);
$this->markFirstBackgroundPrintedAfterBackground($eventName);
if ($this->isEventDelayedUntilFirstBackgroundPrinted($event)) {
$this->delayedUntilBackgroundEnd[] = array($event, $eventName);
return;
}
$this->descendant->listenEvent($formatter, $event, $eventName);
$this->fireDelayedEventsOnAfterBackground($formatter, $eventName);
}
}

where composite and CoR
are useful?

interface StepTester
{
StepNode $step, $skip);
StepNode $step, $skip);
StepNode $step, $skip, StepResult $result);
}

problem:
we need to introduce
backwards incompatible
change into the API

interface ScenarioStepTester
{
ScenarioNode $scenario, StepNode $step, $skip);
ScenarioNode $scenario, StepNode $step, $skip);
ScenarioNode $scenario, StepNode $step, $skip,
StepResult $result);
}

final class StepToScenarioTesterAdapter implements ScenarioStepTester
{
public function __construct(StepTester $stepTester) { ... }
ScenarioNode $scenario, StepNode $step, $skip)
{
return $this->stepTester->setUp($env, $feature, $step, $skip);
}
ScenarioNode $scenario, StepNode $step, $skip)
{
return $this->stepTester->test($env, $feature, $step, $skip);
}
ScenarioNode $scenario, StepNode $step, $skip,
StepResult $result)
{
return $this->stepTester-> tearDown($env, $feature, $step, $skip);
}
}

final class StepTesterAdapterPass implements CompilerPassInterface
{
{
$references = $this->processor->findAndSortTaggedServices($container, ‘tester.step_wrapper’);
$id = (string) $reference;
$renamedId = $id . ‘.adaptee’;
$adapteeDefinition = $container->getDefinition($id);
$reflection = new ReflectionClass($adapteeDefinition->getClass());
if (!$reflection->implementsInterface(‘StepTester’)) {
return;
}
$container->removeDefinition($id);
$container->setDefinition(
$id,
new Definition(‘StepToScenarioTesterAdapter’, array(
$adapteeDefinition
));
);
}
}
}

backwards compatibility
Backwards compatibility in Behat
comes from the extensibility.
1. Everything is extension
2. New features are extensions too
3. New features could be toggled on/off

performance implications
· 2x more objects in v3 than in v2
· Value objects are used instead of
simple types
· A lot of additional concepts
throughout
· It must be slow

Step1: Close the doors
Assume you have no extension points
by default.
1. Private properties
2. Final classes

Step 2: Open doors properly when you need them
1. Identify the need for extension points
2. Make extension points explicit

class BundleFeatureLocator extends FilesystemFeatureLocator
{
public function locateSpecifications(Suite $suite, $locator)
{
if (!$suite instanceof SymfonyBundleSuite) {
return new noSpecificationsIterator($suite);
}
$bundle = $suite->getBundle();
if (0 !== strpos($locator, '@' . $bundle->getName())) {
return new NoSpecificationsIterator($suite);
}
$locatorSuffix = substr($locator, strlen($bundle->getName()) + 1);
return parent::locateSpecifications($suite, $bundle->getPath() . '/Features' . $locatorSuffix);
}
}

final class BundleFeatureLocator implements SpecificationLocator
{
public function __construct(SpecificationLocator $baseLocator) { ... }
public function locateSpecifications(Suite $suite, $locator)
{
if (!$suite instanceof SymfonyBundleSuite) {
return new noSpecificationsIterator($suite);
}
$bundle = $suite->getBundle();
if (0 !== strpos($locator, '@' . $bundle->getName())) {
return new NoSpecificationsIterator($suite);
}
$locatorSuffix = substr($locator, strlen($bundle->getName()) + 1);
return $this->baseLocator->locateSpecifications($suite, $bundle->getPath() . '/Features' . $locatorSuffix);
}
}

the most closed most
extensible testing
framework

ask questions
close Feed! L♻♻ps:
https://joind.in/11559

Decoupling with Design Patterns and Symfony2 DIC

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Decoupling with Design Patterns and Symfony2 DIC (20)

Recently uploaded (20)

Decoupling with Design Patterns and Symfony2 DIC