www.aleph1.co.uk Git - yaffs-website/blob - vendor/behat/behat/src/Behat/Testwork/Suite/ServiceContainer/SuiteExtension.php

   1 <?php
   2
   3 /*
   4  * This file is part of the Behat Testwork.
   5  * (c) Konstantin Kudryashov <ever.zet@gmail.com>
   6  *
   7  * For the full copyright and license information, please view the LICENSE
   8  * file that was distributed with this source code.
   9  */
  10
  11 namespace Behat\Testwork\Suite\ServiceContainer;
  12
  13 use Behat\Testwork\Cli\ServiceContainer\CliExtension;
  14 use Behat\Testwork\ServiceContainer\Extension;
  15 use Behat\Testwork\ServiceContainer\ExtensionManager;
  16 use Behat\Testwork\ServiceContainer\ServiceProcessor;
  17 use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
  18 use Symfony\Component\DependencyInjection\ContainerBuilder;
  19 use Symfony\Component\DependencyInjection\Definition;
  20 use Symfony\Component\DependencyInjection\Reference;
  21
  22 /**
  23  * Extends testwork with suite-related services.
  24  *
  25  * @author Konstantin Kudryashov <ever.zet@gmail.com>
  26  */
  27 final class SuiteExtension implements Extension
  28 {
  29     /*
  30      * Available services
  31      */
  32     const REGISTRY_ID = 'suite.registry';
  33     const BOOTSTRAPPER_ID = 'suite.bootstrapper';
  34
  35     /*
  36      * Available extension points
  37      */
  38     const GENERATOR_TAG = 'suite.generator';
  39     const SETUP_TAG = 'suite.setup';
  40
  41     /**
  42      * @var ServiceProcessor
  43      */
  44     private $processor;
  45
  46     /**
  47      * Initializes extension.
  48      *
  49      * @param null|ServiceProcessor $processor
  50      */
  51     public function __construct(ServiceProcessor $processor = null)
  52     {
  53         $this->processor = $processor ? : new ServiceProcessor();
  54     }
  55
  56     /**
  57      * {@inheritdoc}
  58      */
  59     public function getConfigKey()
  60     {
  61         return 'suites';
  62     }
  63
  64     /**
  65      * {@inheritdoc}
  66      */
  67     public function initialize(ExtensionManager $extensionManager)
  68     {
  69     }
  70
  71     /**
  72      * {@inheritdoc}
  73      */
  74     public function configure(ArrayNodeDefinition $builder)
  75     {
  76         $builder
  77             ->defaultValue(array('default' => array(
  78                 'enabled'    => true,
  79                 'type'       => null,
  80                 'settings'   => array()
  81             )))
  82             ->treatNullLike(array())
  83             ->treatFalseLike(array())
  84             ->useAttributeAsKey('name')
  85             ->normalizeKeys(false)
  86             ->prototype('array')
  87                 ->beforeNormalization()
  88                     ->ifTrue(function ($suite) {
  89                         return is_array($suite) && count($suite);
  90                     })
  91                     ->then(function ($suite) {
  92                         $suite['settings'] = isset($suite['settings'])
  93                             ? $suite['settings']
  94                             : array();
  95
  96                         foreach ($suite as $key => $val) {
  97                             $suiteKeys = array('enabled', 'type', 'settings');
  98                             if (!in_array($key, $suiteKeys)) {
  99                                 $suite['settings'][$key] = $val;
 100                                 unset($suite[$key]);
 101                             }
 102                         }
 103
 104                         return $suite;
 105                     })
 106                 ->end()
 107                 ->normalizeKeys(false)
 108                 ->addDefaultsIfNotSet()
 109                 ->treatTrueLike(array('enabled' => true))
 110                 ->treatNullLike(array('enabled' => true))
 111                 ->treatFalseLike(array('enabled' => false))
 112                 ->children()
 113                     ->booleanNode('enabled')
 114                         ->info('Enables/disables suite')
 115                         ->defaultTrue()
 116                     ->end()
 117                     ->scalarNode('type')
 118                         ->info('Specifies suite type')
 119                         ->defaultValue(null)
 120                     ->end()
 121                     ->arrayNode('settings')
 122                         ->info('Specifies suite extra settings')
 123                         ->defaultValue(array())
 124                         ->useAttributeAsKey('name')
 125                         ->prototype('variable')->end()
 126                     ->end()
 127                 ->end()
 128             ->end()
 129         ;
 130     }
 131
 132     /**
 133      * {@inheritdoc}
 134      */
 135     public function load(ContainerBuilder $container, array $config)
 136     {
 137         $this->setSuiteConfigurations($container, $config);
 138         $this->loadRegistryController($container);
 139         $this->loadBootstrapController($container);
 140         $this->loadRegistry($container);
 141         $this->loadBootstrapper($container);
 142         $this->loadGenericSuiteGenerator($container);
 143     }
 144
 145     /**
 146      * {@inheritdoc}
 147      */
 148     public function process(ContainerBuilder $container)
 149     {
 150         $this->processGenerators($container);
 151         $this->processSetups($container);
 152     }
 153
 154     /**
 155      * Generates and sets suites parameter to container.
 156      *
 157      * @param ContainerBuilder $container
 158      * @param array            $suites
 159      */
 160     private function setSuiteConfigurations(ContainerBuilder $container, array $suites)
 161     {
 162         $configuredSuites = array();
 163         foreach ($suites as $name => $config) {
 164             if (!$config['enabled']) {
 165                 continue;
 166             }
 167
 168             $configuredSuites[$name] = array(
 169                 'type'     => $config['type'],
 170                 'settings' => $config['settings'],
 171             );
 172         }
 173
 174         $container->setParameter('suite.configurations', $configuredSuites);
 175     }
 176
 177     /**
 178      * Loads suite registry controller.
 179      *
 180      * @param ContainerBuilder $container
 181      */
 182     private function loadRegistryController(ContainerBuilder $container)
 183     {
 184         $definition = new Definition('Behat\Testwork\Suite\Cli\SuiteController', array(
 185             new Reference(self::REGISTRY_ID),
 186             '%suite.configurations%'
 187         ));
 188         $definition->addTag(CliExtension::CONTROLLER_TAG, array('priority' => 1100));
 189         $container->setDefinition(CliExtension::CONTROLLER_TAG . '.suite', $definition);
 190     }
 191
 192     /**
 193      * Loads suite bootstrap controller.
 194      *
 195      * @param ContainerBuilder $container
 196      */
 197     private function loadBootstrapController(ContainerBuilder $container)
 198     {
 199         $definition = new Definition('Behat\Testwork\Suite\Cli\InitializationController', array(
 200             new Reference(self::REGISTRY_ID),
 201             new Reference(self::BOOTSTRAPPER_ID)
 202         ));
 203         $definition->addTag(CliExtension::CONTROLLER_TAG, array('priority' => 900));
 204         $container->setDefinition(CliExtension::CONTROLLER_TAG . '.initialization', $definition);
 205     }
 206
 207     /**
 208      * Loads suite registry.
 209      *
 210      * @param ContainerBuilder $container
 211      */
 212     private function loadRegistry(ContainerBuilder $container)
 213     {
 214         $definition = new Definition('Behat\Testwork\Suite\SuiteRegistry');
 215         $container->setDefinition(self::REGISTRY_ID, $definition);
 216     }
 217
 218     /**
 219      * Loads suite bootstrapper.
 220      *
 221      * @param ContainerBuilder $container
 222      */
 223     private function loadBootstrapper(ContainerBuilder $container)
 224     {
 225         $definition = new Definition('Behat\Testwork\Suite\SuiteBootstrapper');
 226         $container->setDefinition(self::BOOTSTRAPPER_ID, $definition);
 227     }
 228
 229     /**
 230      * Loads generic suite generator.
 231      *
 232      * @param ContainerBuilder $container
 233      */
 234     private function loadGenericSuiteGenerator(ContainerBuilder $container)
 235     {
 236         $container->setParameter('suite.generic.default_settings', array());
 237
 238         $definition = new Definition('Behat\Testwork\Suite\Generator\GenericSuiteGenerator', array(
 239             '%suite.generic.default_settings%'
 240         ));
 241         $definition->addTag(SuiteExtension::GENERATOR_TAG, array('priority' => 50));
 242         $container->setDefinition(SuiteExtension::GENERATOR_TAG . '.generic', $definition);
 243     }
 244
 245     /**
 246      * Processes suite generators.
 247      *
 248      * @param ContainerBuilder $container
 249      */
 250     private function processGenerators(ContainerBuilder $container)
 251     {
 252         $references = $this->processor->findAndSortTaggedServices($container, self::GENERATOR_TAG);
 253         $definition = $container->getDefinition(self::REGISTRY_ID);
 254
 255         foreach ($references as $reference) {
 256             $definition->addMethodCall('registerSuiteGenerator', array($reference));
 257         }
 258     }
 259
 260     /**
 261      * Processes suite setups.
 262      *
 263      * @param ContainerBuilder $container
 264      */
 265     private function processSetups(ContainerBuilder $container)
 266     {
 267         $references = $this->processor->findAndSortTaggedServices($container, self::SETUP_TAG);
 268         $definition = $container->getDefinition(self::BOOTSTRAPPER_ID);
 269
 270         foreach ($references as $reference) {
 271             $definition->addMethodCall('registerSuiteSetup', array($reference));
 272         }
 273     }
 274 }