GherkinTest::testLoaderFiltersFeatures() - Code Metrics - Behat/Gherkin - Measure and Improve Code Quality continuously with Scrutinizer

GherkinTest::testLoaderFiltersFeatures() A
last analyzed 2021-01-14 15:16 UTC

↳ Parent: GherkinTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	33
rs	9.392
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace Tests\Behat\Gherkin;

use Behat\Gherkin\Gherkin;
use Behat\Gherkin\Node\FeatureNode;
use Behat\Gherkin\Node\ScenarioNode;
use PHPUnit\Framework\TestCase;

class GherkinTest extends TestCase
{
    public function testLoader()
    {
        $customFilter1 = $this->getCustomFilterMock();
        $customFilter2 = $this->getCustomFilterMock();

        $gherkin = new Gherkin();
        $gherkin->addLoader($loader = $this->getLoaderMock());
        $gherkin->addFilter($nameFilter = $this->getNameFilterMock());
        $gherkin->addFilter($tagFilter = $this->getTagFilterMock());

        $scenario = new ScenarioNode(null, array(), array(), null, null);
        $feature = new FeatureNode(null, null, array(), null, array($scenario), null, null, null, null);

        $loader
            ->expects($this->once())
            ->method('supports')
            ->with($resource = 'some/feature/resource')
            ->will($this->returnValue(true));
        $loader
            ->expects($this->once())
            ->method('load')
            ->with($resource)
            ->will($this->returnValue(array($feature)));

        $nameFilter
            ->expects($this->once())
            ->method('filterFeature')
            ->with($this->identicalTo($feature))
            ->will($this->returnValue($feature));
        $tagFilter
            ->expects($this->once())
            ->method('filterFeature')
            ->with($this->identicalTo($feature))
            ->will($this->returnValue($feature));
        $customFilter1
            ->expects($this->once())
            ->method('filterFeature')
            ->with($this->identicalTo($feature))
            ->will($this->returnValue($feature));
        $customFilter2
            ->expects($this->once())
            ->method('filterFeature')
            ->with($this->identicalTo($feature))
            ->will($this->returnValue($feature));

        $features = $gherkin->load($resource, array($customFilter1, $customFilter2));
        $this->assertEquals(1, count($features));

        $scenarios = $features[0]->getScenarios();
        $this->assertEquals(1, count($scenarios));
        $this->assertSame($scenario, $scenarios[0]);
    }

    public function testNotFoundLoader()
    {
        $gherkin = new Gherkin();

        $this->assertEquals(array(), $gherkin->load('some/feature/resource'));
    }

    public function testLoaderFiltersFeatures()
    {
        $gherkin = new Gherkin();
        $gherkin->addLoader($loader = $this->getLoaderMock());
        $gherkin->addFilter($nameFilter = $this->getNameFilterMock());

        $feature = new FeatureNode(null, null, array(), null, array(), null, null, null, null);

        $loader
            ->expects($this->once())
            ->method('supports')
            ->with($resource = 'some/feature/resource')
            ->will($this->returnValue(true));
        $loader
            ->expects($this->once())
            ->method('load')
            ->with($resource)
            ->will($this->returnValue(array($feature)));

        $nameFilter
            ->expects($this->once())
            ->method('filterFeature')
            ->with($this->identicalTo($feature))
            ->will($this->returnValue($feature));
        $nameFilter
            ->expects($this->once())
            ->method('isFeatureMatch')
            ->with($this->identicalTo($feature))
            ->will($this->returnValue(false));

        $features = $gherkin->load($resource);
        $this->assertEquals(0, count($features));
    }

    public function testSetFiltersOverridesAllFilters()
    {
        $gherkin = new Gherkin();
        $gherkin->addLoader($loader = $this->getLoaderMock());
        $gherkin->addFilter($nameFilter = $this->getNameFilterMock());
        $gherkin->setFilters(array());

        $feature = new FeatureNode(null, null, array(), null, array(), null, null, null, null);

        $loader
            ->expects($this->once())
            ->method('supports')
            ->with($resource = 'some/feature/resource')
            ->will($this->returnValue(true));
        $loader
            ->expects($this->once())
            ->method('load')
            ->with($resource)
            ->will($this->returnValue(array($feature)));

        $nameFilter
            ->expects($this->never())
            ->method('filterFeature');
        $nameFilter
            ->expects($this->never())
            ->method('isFeatureMatch');

        $features = $gherkin->load($resource);
        $this->assertEquals(1, count($features));
    }

    public function testSetBasePath()
    {
        $gherkin = new Gherkin();
        $gherkin->addLoader($loader1 = $this->getLoaderMock());
        $gherkin->addLoader($loader2 = $this->getLoaderMock());

        $loader1
            ->expects($this->once())
            ->method('setBasePath')
            ->with($basePath = '/base/path')
            ->will($this->returnValue(null));

        $loader2
            ->expects($this->once())
            ->method('setBasePath')
            ->with($basePath = '/base/path')
            ->will($this->returnValue(null));

        $gherkin->setBasePath($basePath);
    }

    protected function getLoaderMock()
    {
        return $this->getMockBuilder('Behat\Gherkin\Loader\GherkinFileLoader')
            ->disableOriginalConstructor()
            ->getMock();
    }

    protected function getCustomFilterMock()
    {
        return $this->getMockBuilder('Behat\Gherkin\Filter\FilterInterface')
            ->disableOriginalConstructor()
            ->getMock();
    }

    protected function getNameFilterMock()
    {
        return $this->getMockBuilder('Behat\Gherkin\Filter\NameFilter')
            ->disableOriginalConstructor()
            ->getMock();
    }

    protected function getTagFilterMock()
    {
        return $this->getMockBuilder('Behat\Gherkin\Filter\TagFilter')
            ->disableOriginalConstructor()
            ->getMock();
    }
}


1			<?php
2
3			namespace Tests\Behat\Gherkin;
4
5			use Behat\Gherkin\Gherkin;
6			use Behat\Gherkin\Node\FeatureNode;
7			use Behat\Gherkin\Node\ScenarioNode;
8			use PHPUnit\Framework\TestCase;
9
10			class GherkinTest extends TestCase
11			{
12			public function testLoader()
13			{
14			$customFilter1 = $this->getCustomFilterMock();
15			$customFilter2 = $this->getCustomFilterMock();
16
17			$gherkin = new Gherkin();
18			$gherkin->addLoader($loader = $this->getLoaderMock());
19			$gherkin->addFilter($nameFilter = $this->getNameFilterMock());
20			$gherkin->addFilter($tagFilter = $this->getTagFilterMock());
21
22			$scenario = new ScenarioNode(null, array(), array(), null, null);
23			$feature = new FeatureNode(null, null, array(), null, array($scenario), null, null, null, null);
24
25			$loader
26			->expects($this->once())
27			->method('supports')
28			->with($resource = 'some/feature/resource')
29			->will($this->returnValue(true));
30			$loader
31			->expects($this->once())
32			->method('load')
33			->with($resource)
34			->will($this->returnValue(array($feature)));
35
36			$nameFilter
37			->expects($this->once())
38			->method('filterFeature')
39			->with($this->identicalTo($feature))
40			->will($this->returnValue($feature));
41			$tagFilter
42			->expects($this->once())
43			->method('filterFeature')
44			->with($this->identicalTo($feature))
45			->will($this->returnValue($feature));
46			$customFilter1
47			->expects($this->once())
48			->method('filterFeature')
49			->with($this->identicalTo($feature))
50			->will($this->returnValue($feature));
51			$customFilter2
52			->expects($this->once())
53			->method('filterFeature')
54			->with($this->identicalTo($feature))
55			->will($this->returnValue($feature));
56
57			$features = $gherkin->load($resource, array($customFilter1, $customFilter2));
58			$this->assertEquals(1, count($features));
59
60			$scenarios = $features[0]->getScenarios();
61			$this->assertEquals(1, count($scenarios));
62			$this->assertSame($scenario, $scenarios[0]);
63			}
64
65			public function testNotFoundLoader()
66			{
67			$gherkin = new Gherkin();
68
69			$this->assertEquals(array(), $gherkin->load('some/feature/resource'));
70			}
71
72			public function testLoaderFiltersFeatures()
73			{
74			$gherkin = new Gherkin();
75			$gherkin->addLoader($loader = $this->getLoaderMock());
76			$gherkin->addFilter($nameFilter = $this->getNameFilterMock());
77
78			$feature = new FeatureNode(null, null, array(), null, array(), null, null, null, null);
79
80			$loader
81			->expects($this->once())
82			->method('supports')
83			->with($resource = 'some/feature/resource')
84			->will($this->returnValue(true));
85			$loader
86			->expects($this->once())
87			->method('load')
88			->with($resource)
89			->will($this->returnValue(array($feature)));
90
91			$nameFilter
92			->expects($this->once())
93			->method('filterFeature')
94			->with($this->identicalTo($feature))
95			->will($this->returnValue($feature));
96			$nameFilter
97			->expects($this->once())
98			->method('isFeatureMatch')
99			->with($this->identicalTo($feature))
100			->will($this->returnValue(false));
101
102			$features = $gherkin->load($resource);
103			$this->assertEquals(0, count($features));
104			}
105
106			public function testSetFiltersOverridesAllFilters()
107			{
108			$gherkin = new Gherkin();
109			$gherkin->addLoader($loader = $this->getLoaderMock());
110			$gherkin->addFilter($nameFilter = $this->getNameFilterMock());
111			$gherkin->setFilters(array());
112
113			$feature = new FeatureNode(null, null, array(), null, array(), null, null, null, null);
114
115			$loader
116			->expects($this->once())
117			->method('supports')
118			->with($resource = 'some/feature/resource')
119			->will($this->returnValue(true));
120			$loader
121			->expects($this->once())
122			->method('load')
123			->with($resource)
124			->will($this->returnValue(array($feature)));
125
126			$nameFilter
127			->expects($this->never())
128			->method('filterFeature');
129			$nameFilter
130			->expects($this->never())
131			->method('isFeatureMatch');
132
133			$features = $gherkin->load($resource);
134			$this->assertEquals(1, count($features));
135			}
136
137			public function testSetBasePath()
138			{
139			$gherkin = new Gherkin();
140			$gherkin->addLoader($loader1 = $this->getLoaderMock());
141			$gherkin->addLoader($loader2 = $this->getLoaderMock());
142
143			$loader1
144			->expects($this->once())
145			->method('setBasePath')
146			->with($basePath = '/base/path')
147			->will($this->returnValue(null));
148
149			$loader2
150			->expects($this->once())
151			->method('setBasePath')
152			->with($basePath = '/base/path')
153			->will($this->returnValue(null));
154
155			$gherkin->setBasePath($basePath);
156			}
157
158			protected function getLoaderMock()
159			{
160			return $this->getMockBuilder('Behat\Gherkin\Loader\GherkinFileLoader')
161			->disableOriginalConstructor()
162			->getMock();
163			}
164
165			protected function getCustomFilterMock()
166			{
167			return $this->getMockBuilder('Behat\Gherkin\Filter\FilterInterface')
168			->disableOriginalConstructor()
169			->getMock();
170			}
171
172			protected function getNameFilterMock()
173			{
174			return $this->getMockBuilder('Behat\Gherkin\Filter\NameFilter')
175			->disableOriginalConstructor()
176			->getMock();
177			}
178
179			protected function getTagFilterMock()
180			{
181			return $this->getMockBuilder('Behat\Gherkin\Filter\TagFilter')
182			->disableOriginalConstructor()
183			->getMock();
184			}
185			}
186

Behat / Gherkin

GherkinTest::testLoaderFiltersFeatures() A last analyzed 2021-01-14 15:16 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

GherkinTest::testLoaderFiltersFeatures() A
last analyzed 2021-01-14 15:16 UTC