Issues in Session.php - New Issues - Inspection of "remote controller implementation" - doyolabs/behat-code-coverage - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — develop (#8)

by ANTHONIUS

created 2019-06-07 12:39 UTC

src/Bridge/CodeCoverage/Session/Session.php (3 issues)

Labels

Severity

Major 3

<?php

/*
 * This file is part of the doyo/behat-coverage-extension project.
 *
 * (c) Anthonius Munthi <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Doyo\Behat\Coverage\Bridge\CodeCoverage\Session;

use Doyo\Behat\Coverage\Bridge\CodeCoverage\Processor;
use Doyo\Behat\Coverage\Bridge\CodeCoverage\TestCase;
use Doyo\Behat\Coverage\Bridge\Exception\CacheException;
use SebastianBergmann\CodeCoverage\Filter;
use Symfony\Component\Cache\Adapter\FilesystemAdapter;

abstract class Session implements \Serializable, SessionInterface
{
    const CACHE_KEY = 'session';

    /**
     * @var string|null
     */
    protected $name;

    /**
     * @var TestCase
     */
    protected $testCase;

    /**
     * @var FilesystemAdapter|null
     */
    protected $adapter;

    /**
     * @var array
     */
    protected $data = [];

    /**
     * @var array
     */
    protected $filterOptions = [];

    /**
     * @var Processor
     */
    protected $processor;

    /**
     * @var array
     */
    protected $codeCoverageOptions = [];

    /**
     * @var \Exception[]
     */
    protected $exceptions = [];

    /**
     * @var bool
     */
    protected $hasStarted = false;

    public function __construct($sessionName)
    {
        $dir               = sys_get_temp_dir().'/doyo/behat-coverage-extension';
        $adapter           = new FilesystemAdapter($sessionName, 0, $dir);
        $this->adapter     = $adapter;
        $this->name = $sessionName;

        $this->refresh();
    }

    /**
     * {@inheritdoc}
     */
    public function reset()
    {
        $this->testCase   = null;
        $this->data       = [];
        $this->processor  = null;
        $this->exceptions = [];

        $this->save();
    }

    /**
     * {@inheritdoc}
     */
    public function serialize()
    {
        $data = [
            $this->testCase,
            $this->data,
            $this->codeCoverageOptions,
            $this->filterOptions,
            $this->exceptions,
        ];

        return serialize($data);
    }

    /**
     * {@inheritdoc}
     */
    public function unserialize($serialized)
    {
        list(
            $this->testCase,
            $this->data,
            $this->codeCoverageOptions,
            $this->filterOptions,
            $this->exceptions
        ) = unserialize($serialized);
    }

    /**
     * {@inheritdoc}
     */
    public function refresh()
    {
        $adapter = $this->adapter;
        $cached  = $adapter->getItem(static::CACHE_KEY)->get();

        if ($cached instanceof self) {
            $this->testCase                   = $cached->getTestCase();
            $this->data                       = $cached->getData() ?: [];
            $this->exceptions                 = $cached->getExceptions();
            $this->filterOptions              = $cached->getFilterOptions();
            $this->codeCoverageOptions        = $cached->getCodeCoverageOptions();
        }
    }

    /**
     * @return string|null
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * @return TestCase
     */
    public function getTestCase()
    {
        return $this->testCase;
    }

    /**
     * {@inheritdoc}
     */
    public function setTestCase(TestCase $testCase = null)
    {
        $this->testCase = $testCase;

        return $this;
    }

    /**
     * @return FilesystemAdapter|null
     */
    public function getAdapter(): FilesystemAdapter
    {
        return $this->adapter;
    }

    /**
     * @param FilesystemAdapter|null $adapter
     *
     * @return Cache
filter:
    dependency_paths: ["lib/*"]
     */
    public function setAdapter(FilesystemAdapter $adapter): self
    {
        $this->adapter = $adapter;

        return $this;

    }

    /**
     * {@inheritdoc}
     */
    public function getData()
    {
        return $this->data;
    }

    /**
     * @param array $data
     *
     * @return Cache
     */
    public function setData(array $data)
    {
        $this->data = $data;
    }

    /**
     * @return array
     */
    public function getCodeCoverageOptions(): array
    {
        return $this->codeCoverageOptions;
    }

    /**
     * {@inheritdoc}
     */
    public function setCodeCoverageOptions(array $codeCoverageOptions): self
    {
        $this->codeCoverageOptions = $codeCoverageOptions;

        return $this;
    }

    /**
     * @param Processor $processor
     *
     * @return Cache
     */
    public function setProcessor(Processor $processor = null)
    {
        $this->processor = $processor;

        return $this;

    }

    public function getProcessor()
    {
        return $this->processor;
    }

    public function getFilterOptions(): array
    {
        return $this->filterOptions;
    }

    /**
     * {@inheritdoc}
     */
    public function setFilterOptions(array $filterOptions)
    {
        $this->filterOptions = $filterOptions;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function hasExceptions()
    {
        return \count($this->exceptions) > 0;
    }

    /**
     * {@inheritdoc}
     */
    public function getExceptions()
    {
        return $this->exceptions;
    }

    /**
     * {@inheritdoc}
     */
    final public function start($driver = null)
    {
        if (null === $this->testCase) {
            return;
        }
        try {
            $processor = $this->processor;
            if (null === $processor) {
                $processor = $this->createCodeCoverage($driver);
            }
            $processor->start($this->testCase);
            $this->hasStarted = true;
        } catch (\Exception $e) {
            $message = sprintf(
                "Can not start code coverage in namespace: %s :\n%s",
                $this->name,
                $e->getMessage()
            );
            $this->exceptions[] = $message;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function save()
    {
        $adapter = $this->adapter;
        $item    = $adapter->getItem(static::CACHE_KEY);

        $item->set($this);
        $adapter->save($item);
    }

    /**
     * @return Filter
     */
    protected function createCodeCoverageFilter()
    {
        $config = $this->filterOptions;
        $filter = new Filter();
        foreach ($config as $method => $value) {
            $method = 'set'.ucfirst($method);
            \call_user_func_array([$filter, $method], [$value]);
        }

        return $filter;
    }

    public function shutdown()
    {
        if ($this->hasStarted) {
            try {
                $this->stop();
            } catch (\Exception $e) {
                $this->exceptions[] = new CacheException($e->getMessage());
            }
        }

        $this->processor    = null;
        $this->hasStarted   = false;
        $this->save();
    }

    /**
     * @param mixed|null $driver
     *
     * @return Processor
     */
    protected function createCodeCoverage($driver = null)
    {
        $coverage = $this->processor;
        $filter   = $this->createCodeCoverageFilter();
        $options  = $this->codeCoverageOptions;

        if (null === $coverage) {
            $coverage        = new Processor($driver, $filter);
            $this->processor = $coverage;
        }

        foreach ($options as $method => $option) {
            $method = 'set'.ucfirst($method);
            \call_user_func_array([$coverage, $method], [$option]);
        }

        return $coverage;
    }
}


1		<?php
2
3		/*
4		* This file is part of the doyo/behat-coverage-extension project.
5		*
6		* (c) Anthonius Munthi <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		declare(strict_types=1);
13
14		namespace Doyo\Behat\Coverage\Bridge\CodeCoverage\Session;
15
16		use Doyo\Behat\Coverage\Bridge\CodeCoverage\Processor;
17		use Doyo\Behat\Coverage\Bridge\CodeCoverage\TestCase;
18		use Doyo\Behat\Coverage\Bridge\Exception\CacheException;
19		use SebastianBergmann\CodeCoverage\Filter;
20		use Symfony\Component\Cache\Adapter\FilesystemAdapter;
21
22		abstract class Session implements \Serializable, SessionInterface
23		{
24		const CACHE_KEY = 'session';
25
26		/**
27		* @var string\|null
28		*/
29		protected $name;
30
31		/**
32		* @var TestCase
33		*/
34		protected $testCase;
35
36		/**
37		* @var FilesystemAdapter\|null
38		*/
39		protected $adapter;
40
41		/**
42		* @var array
43		*/
44		protected $data = [];
45
46		/**
47		* @var array
48		*/
49		protected $filterOptions = [];
50
51		/**
52		* @var Processor
53		*/
54		protected $processor;
55
56		/**
57		* @var array
58		*/
59		protected $codeCoverageOptions = [];
60
61		/**
62		* @var \Exception[]
63		*/
64		protected $exceptions = [];
65
66		/**
67		* @var bool
68		*/
69		protected $hasStarted = false;
70
71	25	public function __construct($sessionName)
72		{
73	25	$dir = sys_get_temp_dir().'/doyo/behat-coverage-extension';
74	25	$adapter = new FilesystemAdapter($sessionName, 0, $dir);
75	25	$this->adapter = $adapter;
76	25	$this->name = $sessionName;
77
78	25	$this->refresh();
79		}
80
81		/**
82		* {@inheritdoc}
83		*/
84	23	public function reset()
85		{
86	23	$this->testCase = null;
87	23	$this->data = [];
88	23	$this->processor = null;
89	23	$this->exceptions = [];
90
91	23	$this->save();
92		}
93
94		/**
95		* {@inheritdoc}
96		*/
97	25	public function serialize()
98		{
99		$data = [
100	25	$this->testCase,
101	25	$this->data,
102	25	$this->codeCoverageOptions,
103	25	$this->filterOptions,
104	25	$this->exceptions,
105		];
106
107	25	return serialize($data);
108		}
109
110		/**
111		* {@inheritdoc}
112		*/
113	23	public function unserialize($serialized)
114		{
115		list(
116	23	$this->testCase,
117	23	$this->data,
118	23	$this->codeCoverageOptions,
119	23	$this->filterOptions,
120	23	$this->exceptions
121	23	) = unserialize($serialized);
122		}
123
124		/**
125		* {@inheritdoc}
126		*/
127	25	public function refresh()
128		{
129	25	$adapter = $this->adapter;
130	25	$cached = $adapter->getItem(static::CACHE_KEY)->get();
131
132	25	if ($cached instanceof self) {
133	22	$this->testCase = $cached->getTestCase();
134	22	$this->data = $cached->getData() ?: [];
135	22	$this->exceptions = $cached->getExceptions();
136	22	$this->filterOptions = $cached->getFilterOptions();
137	22	$this->codeCoverageOptions = $cached->getCodeCoverageOptions();
138		}
139		}
140
141		/**
142		* @return string\|null
143		*/
144	7	public function getName()
145		{
146	7	return $this->name;
147		}
148
149		/**
150		* @return TestCase
151		*/
152	23	public function getTestCase()
153		{
154	23	return $this->testCase;
155		}
156
157		/**
158		* {@inheritdoc}
159		*/
160	19	public function setTestCase(TestCase $testCase = null)
161		{
162	19	$this->testCase = $testCase;
163
164	19	return $this;
165		}
166
167		/**
168		* @return FilesystemAdapter\|null
169		*/
170	1	public function getAdapter(): FilesystemAdapter
171		{
172	1	return $this->adapter;
173		}
174
175		/**
176		* @param FilesystemAdapter\|null $adapter
177		*
178		* @return Cache
		0 ignored issues – show Bug introduced 2019-06-07 12:44 UTC by Report Bug Copy Issue Report Show Similar Issues like this The type `Doyo\Behat\Coverage\Brid...eCoverage\Session\Cache` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
179		*/
180	1	public function setAdapter(FilesystemAdapter $adapter): self
181		{
182	1	$this->adapter = $adapter;
183
184	1	return $this;
		0 ignored issues – show Bug Best Practice introduced 2019-06-07 12:44 UTC by Report Bug Copy Issue Report Show Similar Issues like this The expression `return $this` returns the type `Doyo\Behat\Coverage\Brid...overage\Session\Session` which is incompatible with the documented return type `Doyo\Behat\Coverage\Brid...eCoverage\Session\Cache`. Loading history...
185		}
186
187		/**
188		* {@inheritdoc}
189		*/
190	22	public function getData()
191		{
192	22	return $this->data;
193		}
194
195		/**
196		* @param array $data
197		*
198		* @return Cache
199		*/
200	4	public function setData(array $data)
201		{
202	4	$this->data = $data;
203		}
204
205		/**
206		* @return array
207		*/
208	22	public function getCodeCoverageOptions(): array
209		{
210	22	return $this->codeCoverageOptions;
211		}
212
213		/**
214		* {@inheritdoc}
215		*/
216	10	public function setCodeCoverageOptions(array $codeCoverageOptions): self
217		{
218	10	$this->codeCoverageOptions = $codeCoverageOptions;
219
220	10	return $this;
221		}
222
223		/**
224		* @param Processor $processor
225		*
226		* @return Cache
227		*/
228	15	public function setProcessor(Processor $processor = null)
229		{
230	15	$this->processor = $processor;
231
232	15	return $this;
		0 ignored issues – show Bug Best Practice introduced 2019-06-07 12:44 UTC by Report Bug Copy Issue Report Show Similar Issues like this The expression `return $this` returns the type `Doyo\Behat\Coverage\Brid...overage\Session\Session` which is incompatible with the documented return type `Doyo\Behat\Coverage\Brid...eCoverage\Session\Cache`. Loading history...
233		}
234
235	1	public function getProcessor()
236		{
237	1	return $this->processor;
238		}
239
240	22	public function getFilterOptions(): array
241		{
242	22	return $this->filterOptions;
243		}
244
245		/**
246		* {@inheritdoc}
247		*/
248	10	public function setFilterOptions(array $filterOptions)
249		{
250	10	$this->filterOptions = $filterOptions;
251
252	10	return $this;
253		}
254
255		/**
256		* {@inheritdoc}
257		*/
258	7	public function hasExceptions()
259		{
260	7	return \count($this->exceptions) > 0;
261		}
262
263		/**
264		* {@inheritdoc}
265		*/
266	22	public function getExceptions()
267		{
268	22	return $this->exceptions;
269		}
270
271		/**
272		* {@inheritdoc}
273		*/
274	9	final public function start($driver = null)
275		{
276	5	if (null === $this->testCase) {
277	1	return;
278		}
279		try {
280	4	$processor = $this->processor;
281	4	if (null === $processor) {
282	1	$processor = $this->createCodeCoverage($driver);
283		}
284	4	$processor->start($this->testCase);
285	9	$this->hasStarted = true;
286	1	} catch (\Exception $e) {
287	1	$message = sprintf(
288	1	"Can not start code coverage in namespace: %s :\n%s",
289	1	$this->name,
290	1	$e->getMessage()
291		);
292	1	$this->exceptions[] = $message;
293		}
294		}
295
296		/**
297		* {@inheritdoc}
298		*/
299	25	public function save()
300		{
301	25	$adapter = $this->adapter;
302	25	$item = $adapter->getItem(static::CACHE_KEY);
303
304	25	$item->set($this);
305	25	$adapter->save($item);
306		}
307
308		/**
309		* @return Filter
310		*/
311	1	protected function createCodeCoverageFilter()
312		{
313	1	$config = $this->filterOptions;
314	1	$filter = new Filter();
315	1	foreach ($config as $method => $value) {
316	1	$method = 'set'.ucfirst($method);
317	1	\call_user_func_array([$filter, $method], [$value]);
318		}
319
320	1	return $filter;
321		}
322
323	8	public function shutdown()
324		{
325	8	if ($this->hasStarted) {
326		try {
327	8	$this->stop();
328	2	} catch (\Exception $e) {
329	2	$this->exceptions[] = new CacheException($e->getMessage());
330		}
331		}
332
333	3	$this->processor = null;
334	3	$this->hasStarted = false;
335	3	$this->save();
336		}
337
338		/**
339		* @param mixed\|null $driver
340		*
341		* @return Processor
342		*/
343	1	protected function createCodeCoverage($driver = null)
344		{
345	1	$coverage = $this->processor;
346	1	$filter = $this->createCodeCoverageFilter();
347	1	$options = $this->codeCoverageOptions;
348
349	1	if (null === $coverage) {
350	1	$coverage = new Processor($driver, $filter);
351	1	$this->processor = $coverage;
352		}
353
354	1	foreach ($options as $method => $option) {
355	1	$method = 'set'.ucfirst($method);
356	1	\call_user_func_array([$coverage, $method], [$option]);
357		}
358
359	1	return $coverage;
360		}
361		}
362

doyolabs / behat-code-coverage

Pull Request — develop (#8)

src/Bridge/CodeCoverage/Session/Session.php (3 issues)

Labels

Severity

Introduced By

Duplication Side-by-Side

Filter issues like