FacetBuilderParserTest::testQueryFieldFacetBuilder() - Code Metrics - Inspection of "EZP-27417: As a Developer I want API to allow remo..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 65ba07...f0ec2b )

by André

created 2017-07-13 09:18 UTC

testQueryFieldFacetBuilder() B

↳ Parent: FacetBuilderParserTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	34
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	21
nc	1
nop	0
dl	0
loc	34
rs	8.8571
c	0
b	0
f	0

<?php

namespace eZ\Publish\Core\REST\Server\Tests\Input\Parser\FacetBuilder;

use eZ\Publish\Core\Repository\Values\Content\Location;
use eZ\Publish\API\Repository\Values\Content\Query;
use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\ContentTypeFacetBuilder;
use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\CriterionFacetBuilder;
use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\FieldFacetBuilder;
use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\LocationFacetBuilder;
use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\SectionFacetBuilder;
use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\TermFacetBuilder;
use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\UserFacetBuilder;
use eZ\Publish\Core\REST\Server\Input\Parser\Criterion\LocationId;

class FacetBuilderParserTest extends FacetBuilderBaseTest
{
    public function testGenericFacetBuilder()
    {
        $inputArray = [
            'Filter' => [],
            'Criteria' => [],
            'Query' => [],
            'FacetBuilders' => [
                'ContentType' => [
                    'name' => 'Generic test',
                    'limit' => 5,
                    'minCount' => 3,
                    'global' => true,
                    'filter' => new LocationId(123),
                ],
            ],
        ];

        $parser = $this->getParser();
        $result = $parser->parse($inputArray, $this->getParsingDispatcher());

        $expectedQuery = new Query([
            'facetBuilders' => [
                new ContentTypeFacetBuilder([
                    'name' => 'Generic test',
                    'limit' => 5,
                    'minCount' => 3,
                    'global' => true,
                    'filter' => new LocationId(123),
                ]),
            ],
        ]);

        $this->assertEquals($expectedQuery, $result);
    }

    public function testQueryContentTypeFacetBuilder()
    {
        $inputArray = [
            'Filter' => [],
            'Criteria' => [],
            'Query' => [],
            'FacetBuilders' => [
                'ContentType' => [],
            ],
        ];

        $parser = $this->getParser();
        $result = $parser->parse($inputArray, $this->getParsingDispatcher());

        $expectedQuery = new Query([
            'facetBuilders' => [
                new ContentTypeFacetBuilder(),
            ],
        ]);

        $this->assertEquals($expectedQuery, $result);
    }

    public function testQueryCriterionFacetBuilder()
    {
        $inputArray = [
            'Filter' => [],
            'Criteria' => [],
            'Query' => [],
            'FacetBuilders' => [
                'Criterion' => [
                    'filter' => new LocationId(123),
                ],
            ],
        ];

        $parser = $this->getParser();
        $result = $parser->parse($inputArray, $this->getParsingDispatcher());

        $expectedQuery = new Query([
            'facetBuilders' => [
                new CriterionFacetBuilder([
                    'filter' => new LocationId(123),
                ]),
            ],
        ]);

        $this->assertEquals($expectedQuery, $result);
    }

    public function testQueryFieldFacetBuilder()
    {
        $inputArray = [
            'Filter' => [],
            'Criteria' => [],
            'Query' => [],
            'FacetBuilders' => [
                'Field' => [
                    'fieldPaths' => [
                        'description',
                    ],
                    'regex' => '/^Description starts with:.*/',
                    'sort' => 'COUNT_DESC',
                ],
            ],
        ];

        $parser = $this->getParser();
        $result = $parser->parse($inputArray, $this->getParsingDispatcher());

        $expectedQuery = new Query([
            'facetBuilders' => [
                new FieldFacetBuilder([
                    'fieldPaths' => [
                        'description',
                    ],
                    'regex' => '/^Description starts with:.*/',
                    'sort' => FieldFacetBuilder::COUNT_DESC,
                ]),
            ],
        ]);

        $this->assertEquals($expectedQuery, $result);
    }

    public function testQueryLocationFacetBuilder()
    {
        $inputArray = [
            'Filter' => [],
            'Criteria' => [],
            'Query' => [],
            'FacetBuilders' => [
                'Location' => [
                    'location' => new Location(),
                ],
            ],
        ];

        $parser = $this->getParser();
        $result = $parser->parse($inputArray, $this->getParsingDispatcher());

        $expectedQuery = new Query([
            'facetBuilders' => [
                new LocationFacetBuilder([
                    'location' => new Location(),
                ]),
            ],
        ]);

        $this->assertEquals($expectedQuery, $result);
    }

    public function testQuerySectionFacetBuilder()
    {
        $inputArray = [
            'Filter' => [],
            'Criteria' => [],
            'Query' => [],
            'FacetBuilders' => [
                'Section' => [],
            ],
        ];

        $parser = $this->getParser();
        $result = $parser->parse($inputArray, $this->getParsingDispatcher());

        $expectedQuery = new Query([
            'facetBuilders' => [
                new SectionFacetBuilder(),
            ],
        ]);

        $this->assertEquals($expectedQuery, $result);
    }

    public function testQueryTermFacetBuilder()
    {
        $inputArray = [
            'Filter' => [],
            'Criteria' => [],
            'Query' => [],
            'FacetBuilders' => [
                'Term' => [],
            ],
        ];

        $parser = $this->getParser();
        $result = $parser->parse($inputArray, $this->getParsingDispatcher());

        $expectedQuery = new Query([
            'facetBuilders' => [
                new TermFacetBuilder(),
            ],
        ]);

        $this->assertEquals($expectedQuery, $result);
    }

    public function testQueryUserFacetBuilder()
    {
        $inputArray = [
            'Filter' => [],
            'Criteria' => [],
            'Query' => [],
            'FacetBuilders' => [
                'User' => [
                    'select' => 'MODIFIER',
                ],
            ],
        ];

        $parser = $this->getParser();
        $result = $parser->parse($inputArray, $this->getParsingDispatcher());

        $expectedQuery = new Query([
            'facetBuilders' => [
                new UserFacetBuilder([
                    'type' => UserFacetBuilder::MODIFIER,
                ]),
            ],
        ]);

        $this->assertEquals($expectedQuery, $result);
    }

    public function testQueryNoFacetBuilders()
    {
        $inputArray = [
            'Filter' => [],
            'Criteria' => [],
            'Query' => [],
            'FacetBuilders' => [],
        ];

        $parser = $this->getParser();
        $result = $parser->parse($inputArray, $this->getParsingDispatcher());

        $expectedQuery = new Query([
            'facetBuilders' => [],
        ]);

        $this->assertEquals($expectedQuery, $result);
    }

    public function testQueryMultipleFacetBuilders()
    {
        $inputArray = [
            'Filter' => [],
            'Criteria' => [],
            'Query' => [],
            'FacetBuilders' => [
                'ContentType' => [],
                'User' => [
                    'select' => 'MODIFIER',
                ],
            ],
        ];

        $parser = $this->getParser();
        $result = $parser->parse($inputArray, $this->getParsingDispatcher());

        $expectedQuery = new Query([
            'facetBuilders' => [
                new ContentTypeFacetBuilder(),
                new UserFacetBuilder([
                    'type' => UserFacetBuilder::MODIFIER,
                ]),
            ],
        ]);

        $this->assertEquals($expectedQuery, $result);
    }
}


1		<?php
2
3		namespace eZ\Publish\Core\REST\Server\Tests\Input\Parser\FacetBuilder;
4
5		use eZ\Publish\Core\Repository\Values\Content\Location;
6		use eZ\Publish\API\Repository\Values\Content\Query;
7		use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\ContentTypeFacetBuilder;
8		use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\CriterionFacetBuilder;
9		use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\FieldFacetBuilder;
10		use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\LocationFacetBuilder;
11		use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\SectionFacetBuilder;
12		use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\TermFacetBuilder;
13		use eZ\Publish\API\Repository\Values\Content\Query\FacetBuilder\UserFacetBuilder;
14		use eZ\Publish\Core\REST\Server\Input\Parser\Criterion\LocationId;
15
16		class FacetBuilderParserTest extends FacetBuilderBaseTest
17		{
18		public function testGenericFacetBuilder()
19		{
20		$inputArray = [
21		'Filter' => [],
22		'Criteria' => [],
23		'Query' => [],
24		'FacetBuilders' => [
25		'ContentType' => [
26		'name' => 'Generic test',
27		'limit' => 5,
28		'minCount' => 3,
29		'global' => true,
30		'filter' => new LocationId(123),
31		],
32		],
33		];
34
35		$parser = $this->getParser();
36		$result = $parser->parse($inputArray, $this->getParsingDispatcher());
37
38		$expectedQuery = new Query([
39		'facetBuilders' => [
40		new ContentTypeFacetBuilder([
41		'name' => 'Generic test',
42		'limit' => 5,
43		'minCount' => 3,
44		'global' => true,
45		'filter' => new LocationId(123),
46		]),
47		],
48		]);
49
50		$this->assertEquals($expectedQuery, $result);
51		}
52
53	View Code Duplication	public function testQueryContentTypeFacetBuilder()
54		{
55		$inputArray = [
56		'Filter' => [],
57		'Criteria' => [],
58		'Query' => [],
59		'FacetBuilders' => [
60		'ContentType' => [],
61		],
62		];
63
64		$parser = $this->getParser();
65		$result = $parser->parse($inputArray, $this->getParsingDispatcher());
66
67		$expectedQuery = new Query([
68		'facetBuilders' => [
69		new ContentTypeFacetBuilder(),
70		],
71		]);
72
73		$this->assertEquals($expectedQuery, $result);
74		}
75
76	View Code Duplication	public function testQueryCriterionFacetBuilder()
77		{
78		$inputArray = [
79		'Filter' => [],
80		'Criteria' => [],
81		'Query' => [],
82		'FacetBuilders' => [
83		'Criterion' => [
84		'filter' => new LocationId(123),
85		],
86		],
87		];
88
89		$parser = $this->getParser();
90		$result = $parser->parse($inputArray, $this->getParsingDispatcher());
91
92		$expectedQuery = new Query([
93		'facetBuilders' => [
94		new CriterionFacetBuilder([
95		'filter' => new LocationId(123),
96		]),
97		],
98		]);
99
100		$this->assertEquals($expectedQuery, $result);
101		}
102
103		public function testQueryFieldFacetBuilder()
104		{
105		$inputArray = [
106		'Filter' => [],
107		'Criteria' => [],
108		'Query' => [],
109		'FacetBuilders' => [
110		'Field' => [
111		'fieldPaths' => [
112		'description',
113		],
114		'regex' => '/^Description starts with:.*/',
115		'sort' => 'COUNT_DESC',
116		],
117		],
118		];
119
120		$parser = $this->getParser();
121		$result = $parser->parse($inputArray, $this->getParsingDispatcher());
122
123		$expectedQuery = new Query([
124		'facetBuilders' => [
125		new FieldFacetBuilder([
126		'fieldPaths' => [
127		'description',
128		],
129		'regex' => '/^Description starts with:.*/',
130		'sort' => FieldFacetBuilder::COUNT_DESC,
131		]),
132		],
133		]);
134
135		$this->assertEquals($expectedQuery, $result);
136		}
137
138	View Code Duplication	public function testQueryLocationFacetBuilder()
139		{
140		$inputArray = [
141		'Filter' => [],
142		'Criteria' => [],
143		'Query' => [],
144		'FacetBuilders' => [
145		'Location' => [
146		'location' => new Location(),
147		],
148		],
149		];
150
151		$parser = $this->getParser();
152		$result = $parser->parse($inputArray, $this->getParsingDispatcher());
153
154		$expectedQuery = new Query([
155		'facetBuilders' => [
156		new LocationFacetBuilder([
157		'location' => new Location(),
158		]),
159		],
160		]);
161
162		$this->assertEquals($expectedQuery, $result);
163		}
164
165	View Code Duplication	public function testQuerySectionFacetBuilder()
166		{
167		$inputArray = [
168		'Filter' => [],
169		'Criteria' => [],
170		'Query' => [],
171		'FacetBuilders' => [
172		'Section' => [],
173		],
174		];
175
176		$parser = $this->getParser();
177		$result = $parser->parse($inputArray, $this->getParsingDispatcher());
178
179		$expectedQuery = new Query([
180		'facetBuilders' => [
181		new SectionFacetBuilder(),
182		],
183		]);
184
185		$this->assertEquals($expectedQuery, $result);
186		}
187
188	View Code Duplication	public function testQueryTermFacetBuilder()
189		{
190		$inputArray = [
191		'Filter' => [],
192		'Criteria' => [],
193		'Query' => [],
194		'FacetBuilders' => [
195		'Term' => [],
196		],
197		];
198
199		$parser = $this->getParser();
200		$result = $parser->parse($inputArray, $this->getParsingDispatcher());
201
202		$expectedQuery = new Query([
203		'facetBuilders' => [
204		new TermFacetBuilder(),
205		],
206		]);
207
208		$this->assertEquals($expectedQuery, $result);
209		}
210
211	View Code Duplication	public function testQueryUserFacetBuilder()
212		{
213		$inputArray = [
214		'Filter' => [],
215		'Criteria' => [],
216		'Query' => [],
217		'FacetBuilders' => [
218		'User' => [
219		'select' => 'MODIFIER',
220		],
221		],
222		];
223
224		$parser = $this->getParser();
225		$result = $parser->parse($inputArray, $this->getParsingDispatcher());
226
227		$expectedQuery = new Query([
228		'facetBuilders' => [
229		new UserFacetBuilder([
230		'type' => UserFacetBuilder::MODIFIER,
231		]),
232		],
233		]);
234
235		$this->assertEquals($expectedQuery, $result);
236		}
237
238	View Code Duplication	public function testQueryNoFacetBuilders()
239		{
240		$inputArray = [
241		'Filter' => [],
242		'Criteria' => [],
243		'Query' => [],
244		'FacetBuilders' => [],
245		];
246
247		$parser = $this->getParser();
248		$result = $parser->parse($inputArray, $this->getParsingDispatcher());
249
250		$expectedQuery = new Query([
251		'facetBuilders' => [],
252		]);
253
254		$this->assertEquals($expectedQuery, $result);
255		}
256
257	View Code Duplication	public function testQueryMultipleFacetBuilders()
258		{
259		$inputArray = [
260		'Filter' => [],
261		'Criteria' => [],
262		'Query' => [],
263		'FacetBuilders' => [
264		'ContentType' => [],
265		'User' => [
266		'select' => 'MODIFIER',
267		],
268		],
269		];
270
271		$parser = $this->getParser();
272		$result = $parser->parse($inputArray, $this->getParsingDispatcher());
273
274		$expectedQuery = new Query([
275		'facetBuilders' => [
276		new ContentTypeFacetBuilder(),
277		new UserFacetBuilder([
278		'type' => UserFacetBuilder::MODIFIER,
279		]),
280		],
281		]);
282
283		$this->assertEquals($expectedQuery, $result);
284		}
285		}
286

ezsystems / ezpublish-kernel

Push — master ( 65ba07...f0ec2b )

testQueryFieldFacetBuilder() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like