RuntimeStepTester::__construct() - Code Metrics - Inspection of "Complexity improvements (#2)" - Chekote/BehatRetryExtension - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (46933e)

by Donald

created 2017-11-19 16:44 UTC

RuntimeStepTester::__construct() A

↳ Parent: RuntimeStepTester

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	2
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php namespace Chekote\BehatRetryExtension\Tester;

use Behat\Behat\Definition\Call\DefinitionCall;
use Behat\Behat\Definition\DefinitionFinder;
use Behat\Behat\Definition\Exception\SearchException;
use Behat\Behat\Definition\SearchResult;
use Behat\Behat\Tester\Exception\PendingException;
use Behat\Behat\Tester\Result\ExecutedStepResult;
use Behat\Behat\Tester\Result\FailedStepSearchResult;
use Behat\Behat\Tester\Result\SkippedStepResult;
use Behat\Behat\Tester\Result\StepResult;
use Behat\Behat\Tester\Result\UndefinedStepResult;
use Behat\Behat\Tester\StepTester;
use Behat\Gherkin\Node\FeatureNode;
use Behat\Gherkin\Node\StepNode;
use Behat\Testwork\Call\CallCenter;
use Behat\Testwork\Call\CallResult;
use Behat\Testwork\Environment\Environment;
use Behat\Testwork\Tester\Setup\SuccessfulSetup;
use Behat\Testwork\Tester\Setup\SuccessfulTeardown;

/**
 * Tester executing step tests in the runtime.
 *
 * This class is a copy of \Behat\Behat\Tester\Runtime\RuntimeStepTester by Konstantin Kudryashov <[email protected]>.
 * It has a modified testDefinition() method to implement the retry functionality.
 *
 * I would ideally like to extend or wrap the existing RuntimeStepTester, but neither is possible because the class
 * is final, and the method is private. v_v
 */
final class RuntimeStepTester implements StepTester
{
    /** Number of seconds to attempt "Then" steps before accepting a failure */
    public static $timeout;

    /** @var int number of nanoseconds to wait between each retry of "Then" steps */
    public static $interval;

    /** @var array list of Gherkin keywords */
    protected static $keywords = ['Given', 'When', 'Then'];

    /**
     * @var DefinitionFinder
     */
    private $definitionFinder;

    /**
     * @var CallCenter
     */
    private $callCenter;

    /** @var string The last "Given", "When", or "Then" keyword encountered */
    protected $lastKeyword;

    /**
     * Initialize tester.
     *
     * @param DefinitionFinder $definitionFinder
     * @param CallCenter       $callCenter
     */
    public function __construct(DefinitionFinder $definitionFinder, CallCenter $callCenter)
    {
        $this->definitionFinder = $definitionFinder;
        $this->callCenter = $callCenter;
    }

    /**
     * {@inheritdoc}
     */
    public function setUp(Environment $env, FeatureNode $feature, StepNode $step, $skip)
    {
        return new SuccessfulSetup();
    }

    /**
     * {@inheritdoc}
     */
    public function test(Environment $env, FeatureNode $feature, StepNode $step, $skip = false)
    {
        $this->updateLastKeyword($step);

        try {
            $search = $this->searchDefinition($env, $feature, $step);
            $result = $this->testDefinition($env, $feature, $step, $search, $skip);
        } catch (SearchException $exception) {
            $result = new FailedStepSearchResult($exception);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function tearDown(Environment $env, FeatureNode $feature, StepNode $step, $skip, StepResult $result)
    {
        return new SuccessfulTeardown();
    }

    /**
     * Searches for a definition.
     *
     * @param Environment $env
     * @param FeatureNode $feature
     * @param StepNode    $step
     *
     * @return SearchResult
     */
    private function searchDefinition(Environment $env, FeatureNode $feature, StepNode $step)
    {
        return $this->definitionFinder->findDefinition($env, $feature, $step);
    }

    /**
     * Tests found definition.
     *
     * @param Environment  $env
     * @param FeatureNode  $feature
     * @param StepNode     $step
     * @param SearchResult $search
     * @param bool         $skip
     *
     * @return StepResult
     */
    private function testDefinition(Environment $env, FeatureNode $feature, StepNode $step, SearchResult $search, $skip)
    {
        if (!$search->hasMatch()) {
            return new UndefinedStepResult();
        }

        if ($skip) {
            return new SkippedStepResult($search);
        }

        $call = $this->createDefinitionCall($env, $feature, $search, $step);

        $result = $this->makeCall($call);

        return new ExecutedStepResult($search, $result);
    }

    /**
     * Records the keyword for the step.
     *
     * This allows us to know where we are when processing And or But steps.
     *
     * @param  StepNode $step
     * @return void
     */
    protected function updateLastKeyword(StepNode $step)
    {
        $keyword = $step->getKeyword();
        if (in_array($keyword, self::$keywords)) {
            $this->lastKeyword = $keyword;
        }
    }

    /**
     * Calls the specified definition, either directly, or via spin() if self::$timeout is not 0.
     *
     * @param  DefinitionCall $call the call to make.
     * @return CallResult     the result of the call.
     */
    protected function makeCall(DefinitionCall $call)
    {
        // @todo We can only "spin" if we are interacting with a remote browser. If the browser is
        // running in the same thread as this test (such as with Goutte or Zombie), then spinning
        // will only prevent that process from continuing, and the test will either pass immediately,
        // or not at all. We need to find out how to check what Driver we're using...
        if ($this->lastKeyword == 'Then' && self::$timeout) {
            return $this->spin(function () use ($call) {
                return $this->callCenter->makeCall($call);
            });
        } else {
            return $this->callCenter->makeCall($call);
        }
    }

    /**
     * Continually calls an assertion until it passes or the timeout is reached.
     *
     * @param  callable   $lambda The lambda assertion to call. Must take no arguments and return
     *                            a CallResult.
     * @return CallResult
     */
    protected function spin(callable $lambda)
    {
        $start = microtime(true);

        $result = null;
        while (microtime(true) - $start < self::$timeout) {
            /** @var $result CallResult */
            $result = $lambda();

            if (!$result->hasException() || ($result->getException() instanceof PendingException)) {
                break;
            }

            time_nanosleep(0, self::$interval);
        }

        return $result;
    }

    /**
     * Creates definition call.
     *
     * @param Environment  $env
     * @param FeatureNode  $feature
     * @param SearchResult $search
     * @param StepNode     $step
     *
     * @return DefinitionCall
     */
    private function createDefinitionCall(Environment $env, FeatureNode $feature, SearchResult $search, StepNode $step)
    {
        $definition = $search->getMatchedDefinition();
        $arguments = $search->getMatchedArguments();

        return new DefinitionCall($env, $feature, $step, $definition, $arguments);
    }
}


1			<?php namespace Chekote\BehatRetryExtension\Tester;
2
3			use Behat\Behat\Definition\Call\DefinitionCall;
4			use Behat\Behat\Definition\DefinitionFinder;
5			use Behat\Behat\Definition\Exception\SearchException;
6			use Behat\Behat\Definition\SearchResult;
7			use Behat\Behat\Tester\Exception\PendingException;
8			use Behat\Behat\Tester\Result\ExecutedStepResult;
9			use Behat\Behat\Tester\Result\FailedStepSearchResult;
10			use Behat\Behat\Tester\Result\SkippedStepResult;
11			use Behat\Behat\Tester\Result\StepResult;
12			use Behat\Behat\Tester\Result\UndefinedStepResult;
13			use Behat\Behat\Tester\StepTester;
14			use Behat\Gherkin\Node\FeatureNode;
15			use Behat\Gherkin\Node\StepNode;
16			use Behat\Testwork\Call\CallCenter;
17			use Behat\Testwork\Call\CallResult;
18			use Behat\Testwork\Environment\Environment;
19			use Behat\Testwork\Tester\Setup\SuccessfulSetup;
20			use Behat\Testwork\Tester\Setup\SuccessfulTeardown;
21
22			/**
23			* Tester executing step tests in the runtime.
24			*
25			* This class is a copy of \Behat\Behat\Tester\Runtime\RuntimeStepTester by Konstantin Kudryashov <[email protected]>.
26			* It has a modified testDefinition() method to implement the retry functionality.
27			*
28			* I would ideally like to extend or wrap the existing RuntimeStepTester, but neither is possible because the class
29			* is final, and the method is private. v_v
30			*/
31			final class RuntimeStepTester implements StepTester
32			{
33			/** Number of seconds to attempt "Then" steps before accepting a failure */
34			public static $timeout;
35
36			/** @var int number of nanoseconds to wait between each retry of "Then" steps */
37			public static $interval;
38
39			/** @var array list of Gherkin keywords */
40			protected static $keywords = ['Given', 'When', 'Then'];
41
42			/**
43			* @var DefinitionFinder
44			*/
45			private $definitionFinder;
46
47			/**
48			* @var CallCenter
49			*/
50			private $callCenter;
51
52			/** @var string The last "Given", "When", or "Then" keyword encountered */
53			protected $lastKeyword;
54
55			/**
56			* Initialize tester.
57			*
58			* @param DefinitionFinder $definitionFinder
59			* @param CallCenter $callCenter
60			*/
61			public function __construct(DefinitionFinder $definitionFinder, CallCenter $callCenter)
62			{
63			$this->definitionFinder = $definitionFinder;
64			$this->callCenter = $callCenter;
65			}
66
67			/**
68			* {@inheritdoc}
69			*/
70			public function setUp(Environment $env, FeatureNode $feature, StepNode $step, $skip)
71			{
72			return new SuccessfulSetup();
73			}
74
75			/**
76			* {@inheritdoc}
77			*/
78			public function test(Environment $env, FeatureNode $feature, StepNode $step, $skip = false)
79			{
80			$this->updateLastKeyword($step);
81
82			try {
83			$search = $this->searchDefinition($env, $feature, $step);
84			$result = $this->testDefinition($env, $feature, $step, $search, $skip);
85			} catch (SearchException $exception) {
86			$result = new FailedStepSearchResult($exception);
87			}
88
89			return $result;
90			}
91
92			/**
93			* {@inheritdoc}
94			*/
95			public function tearDown(Environment $env, FeatureNode $feature, StepNode $step, $skip, StepResult $result)
96			{
97			return new SuccessfulTeardown();
98			}
99
100			/**
101			* Searches for a definition.
102			*
103			* @param Environment $env
104			* @param FeatureNode $feature
105			* @param StepNode $step
106			*
107			* @return SearchResult
108			*/
109			private function searchDefinition(Environment $env, FeatureNode $feature, StepNode $step)
110			{
111			return $this->definitionFinder->findDefinition($env, $feature, $step);
112			}
113
114			/**
115			* Tests found definition.
116			*
117			* @param Environment $env
118			* @param FeatureNode $feature
119			* @param StepNode $step
120			* @param SearchResult $search
121			* @param bool $skip
122			*
123			* @return StepResult
124			*/
125			private function testDefinition(Environment $env, FeatureNode $feature, StepNode $step, SearchResult $search, $skip)
126			{
127			if (!$search->hasMatch()) {
128			return new UndefinedStepResult();
129			}
130
131			if ($skip) {
132			return new SkippedStepResult($search);
133			}
134
135			$call = $this->createDefinitionCall($env, $feature, $search, $step);
136
137			$result = $this->makeCall($call);
138
139			return new ExecutedStepResult($search, $result);
140			}
141
142			/**
143			* Records the keyword for the step.
144			*
145			* This allows us to know where we are when processing And or But steps.
146			*
147			* @param StepNode $step
148			* @return void
149			*/
150			protected function updateLastKeyword(StepNode $step)
151			{
152			$keyword = $step->getKeyword();
153			if (in_array($keyword, self::$keywords)) {
154			$this->lastKeyword = $keyword;
155			}
156			}
157
158			/**
159			* Calls the specified definition, either directly, or via spin() if self::$timeout is not 0.
160			*
161			* @param DefinitionCall $call the call to make.
162			* @return CallResult the result of the call.
163			*/
164			protected function makeCall(DefinitionCall $call)
165			{
166			// @todo We can only "spin" if we are interacting with a remote browser. If the browser is
167			// running in the same thread as this test (such as with Goutte or Zombie), then spinning
168			// will only prevent that process from continuing, and the test will either pass immediately,
169			// or not at all. We need to find out how to check what Driver we're using...
170			if ($this->lastKeyword == 'Then' && self::$timeout) {
171			return $this->spin(function () use ($call) {
172			return $this->callCenter->makeCall($call);
173			});
174			} else {
175			return $this->callCenter->makeCall($call);
176			}
177			}
178
179			/**
180			* Continually calls an assertion until it passes or the timeout is reached.
181			*
182			* @param callable $lambda The lambda assertion to call. Must take no arguments and return
183			* a CallResult.
184			* @return CallResult
185			*/
186			protected function spin(callable $lambda)
187			{
188			$start = microtime(true);
189
190			$result = null;
191			while (microtime(true) - $start < self::$timeout) {
192			/** @var $result CallResult */
193			$result = $lambda();
194
195			if (!$result->hasException() \|\| ($result->getException() instanceof PendingException)) {
196			break;
197			}
198
199			time_nanosleep(0, self::$interval);
200			}
201
202			return $result;
203			}
204
205			/**
206			* Creates definition call.
207			*
208			* @param Environment $env
209			* @param FeatureNode $feature
210			* @param SearchResult $search
211			* @param StepNode $step
212			*
213			* @return DefinitionCall
214			*/
215			private function createDefinitionCall(Environment $env, FeatureNode $feature, SearchResult $search, StepNode $step)
216			{
217			$definition = $search->getMatchedDefinition();
218			$arguments = $search->getMatchedArguments();
219
220			return new DefinitionCall($env, $feature, $step, $definition, $arguments);
221			}
222			}
223

Chekote / BehatRetryExtension

Branch — master (46933e)

RuntimeStepTester::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like