www.aleph1.co.uk Git - yaffs-website/blob - vendor/behat/behat/src/Behat/Behat/Context/Environment/Handler/ContextEnvironmentHandler.php

   1 <?php
   2
   3 /*
   4  * This file is part of the Behat.
   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\Behat\Context\Environment\Handler;
  12
  13 use Behat\Behat\Context\Argument\SuiteScopedResolverFactory;
  14 use Behat\Behat\Context\Argument\SuiteScopedResolverFactoryAdapter;
  15 use Behat\Behat\Context\Argument\ArgumentResolverFactory;
  16 use Behat\Behat\Context\Argument\NullFactory;
  17 use Behat\Behat\Context\ContextClass\ClassResolver;
  18 use Behat\Behat\Context\ContextFactory;
  19 use Behat\Behat\Context\Environment\InitializedContextEnvironment;
  20 use Behat\Behat\Context\Environment\UninitializedContextEnvironment;
  21 use Behat\Testwork\Environment\Environment;
  22 use Behat\Testwork\Environment\Exception\EnvironmentIsolationException;
  23 use Behat\Testwork\Environment\Handler\EnvironmentHandler;
  24 use Behat\Testwork\Suite\Exception\SuiteConfigurationException;
  25 use Behat\Testwork\Suite\Suite;
  26
  27 /**
  28  * Handles build and initialisation of the context-based environments.
  29  *
  30  * @see ContextFactory
  31  *
  32  * @author Konstantin Kudryashov <ever.zet@gmail.com>
  33  */
  34 final class ContextEnvironmentHandler implements EnvironmentHandler
  35 {
  36     /**
  37      * @var ContextFactory
  38      */
  39     private $contextFactory;
  40     /**
  41      * @var ArgumentResolverFactory
  42      */
  43     private $resolverFactory;
  44     /**
  45      * @var ClassResolver[]
  46      */
  47     private $classResolvers = array();
  48
  49     /**
  50      * Initializes handler.
  51      *
  52      * @param ContextFactory                                     $factory
  53      * @param ArgumentResolverFactory|SuiteScopedResolverFactory $resolverFactory
  54      */
  55     public function __construct(ContextFactory $factory, $resolverFactory = null)
  56     {
  57         $this->contextFactory = $factory;
  58
  59         if ($resolverFactory && !$resolverFactory instanceof ArgumentResolverFactory) {
  60             $resolverFactory = new SuiteScopedResolverFactoryAdapter($resolverFactory);
  61         }
  62
  63         $this->resolverFactory = $resolverFactory ?: new NullFactory();
  64     }
  65
  66     /**
  67      * Registers context class resolver.
  68      *
  69      * @param ClassResolver $resolver
  70      */
  71     public function registerClassResolver(ClassResolver $resolver)
  72     {
  73         $this->classResolvers[] = $resolver;
  74     }
  75
  76     /**
  77      * {@inheritdoc}
  78      */
  79     public function supportsSuite(Suite $suite)
  80     {
  81         return $suite->hasSetting('contexts');
  82     }
  83
  84     /**
  85      * {@inheritdoc}
  86      */
  87     public function buildEnvironment(Suite $suite)
  88     {
  89         $environment = new UninitializedContextEnvironment($suite);
  90         foreach ($this->getNormalizedContextSettings($suite) as $context) {
  91             $environment->registerContextClass($this->resolveClass($context[0]), $context[1]);
  92         }
  93
  94         return $environment;
  95     }
  96
  97     /**
  98      * {@inheritdoc}
  99      */
 100     public function supportsEnvironmentAndSubject(Environment $environment, $testSubject = null)
 101     {
 102         return $environment instanceof UninitializedContextEnvironment;
 103     }
 104
 105     /**
 106      * {@inheritdoc}
 107      */
 108     public function isolateEnvironment(Environment $uninitializedEnvironment, $testSubject = null)
 109     {
 110         if (!$uninitializedEnvironment instanceof UninitializedContextEnvironment) {
 111             throw new EnvironmentIsolationException(sprintf(
 112                 'ContextEnvironmentHandler does not support isolation of `%s` environment.',
 113                 get_class($uninitializedEnvironment)
 114             ), $uninitializedEnvironment);
 115         }
 116
 117         $environment = new InitializedContextEnvironment($uninitializedEnvironment->getSuite());
 118         $resolvers = $this->resolverFactory->createArgumentResolvers($environment);
 119
 120         foreach ($uninitializedEnvironment->getContextClassesWithArguments() as $class => $arguments) {
 121             $context = $this->contextFactory->createContext($class, $arguments, $resolvers);
 122             $environment->registerContext($context);
 123         }
 124
 125         return $environment;
 126     }
 127
 128     /**
 129      * Returns normalized suite context settings.
 130      *
 131      * @param Suite $suite
 132      *
 133      * @return array
 134      */
 135     private function getNormalizedContextSettings(Suite $suite)
 136     {
 137         return array_map(
 138             function ($context) {
 139                 $class = $context;
 140                 $arguments = array();
 141
 142                 if (is_array($context)) {
 143                     $class = current(array_keys($context));
 144                     $arguments = $context[$class];
 145                 }
 146
 147                 return array($class, $arguments);
 148             },
 149             $this->getSuiteContexts($suite)
 150         );
 151     }
 152
 153     /**
 154      * Returns array of context classes configured for the provided suite.
 155      *
 156      * @param Suite $suite
 157      *
 158      * @return string[]
 159      *
 160      * @throws SuiteConfigurationException If `contexts` setting is not an array
 161      */
 162     private function getSuiteContexts(Suite $suite)
 163     {
 164         if (!is_array($suite->getSetting('contexts'))) {
 165             throw new SuiteConfigurationException(
 166                 sprintf('`contexts` setting of the "%s" suite is expected to be an array, %s given.',
 167                     $suite->getName(),
 168                     gettype($suite->getSetting('contexts'))
 169                 ),
 170                 $suite->getName()
 171             );
 172         }
 173
 174         return $suite->getSetting('contexts');
 175     }
 176
 177     /**
 178      * Resolves class using registered class resolvers.
 179      *
 180      * @param string $class
 181      *
 182      * @return string
 183      */
 184     private function resolveClass($class)
 185     {
 186         foreach ($this->classResolvers as $resolver) {
 187             if ($resolver->supportsClass($class)) {
 188                 return $resolver->resolveClass($class);
 189             }
 190         }
 191
 192         return $class;
 193     }
 194 }