RescoreTest - Code Metrics - Inspection of "Add export-ignore to a few .gitattributes entries" - ruflin/Elastica - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1911)

by Sam

created 2021-03-08 21:29 UTC

RescoreTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	231
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

Metric	Value
wmc	5
lcom	1
cbo	8
dl	0
loc	231
rs	10
c	0
b	0
f	0

5 Methods

Rating	Name	Size	Complexity
B	testMultipleQueries()	68	1
A	testToArray()	36	1
A	testSetSize()	38	1
A	testSetWeights()	42	1
A	testQuery()	25	1

<?php

namespace Elastica\Test\Query;

use Elastica\Query;
use Elastica\Query\MatchQuery;
use Elastica\Query\Term;
use Elastica\Rescore\Query as QueryRescore;
use Elastica\Test\Base as BaseTest;

/**
 * @internal
 */
class RescoreTest extends BaseTest
{
    /**
     * @group unit
     */
    public function testToArray(): void
    {
        $query = new Query();
        $mainQuery = new MatchQuery();
        $mainQuery = $mainQuery->setFieldQuery('test1', 'foo');
        $secQuery = new Term();
        $secQuery = $secQuery->setTerm('test2', 'bar', 2);
        $queryRescore = new QueryRescore($secQuery);
        $query->setQuery($mainQuery);
        $query->setRescore($queryRescore);
        $data = $query->toArray();

        $expected = [
            'query' => [
                'match' => [
                    'test1' => [
                        'query' => 'foo',
                    ],
                ],
            ],
            'rescore' => [
                'query' => [
                    'rescore_query' => [
                        'term' => [
                            'test2' => [
                                'value' => 'bar',
                                'boost' => 2,
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $this->assertEquals($expected, $data);
    }

    /**
     * @group unit
     */
    public function testSetSize(): void
    {
        $query = new Query();
        $mainQuery = new MatchQuery();
        $mainQuery = $mainQuery->setFieldQuery('test1', 'foo');
        $secQuery = new Term();
        $secQuery = $secQuery->setTerm('test2', 'bar', 2);
        $queryRescore = new QueryRescore($secQuery);
        $queryRescore->setWindowSize(50);
        $query->setQuery($mainQuery);
        $query->setRescore($queryRescore);
        $data = $query->toArray();

        $expected = [
            'query' => [
                'match' => [
                    'test1' => [
                        'query' => 'foo',
                    ],
                ],
            ],
            'rescore' => [
                'window_size' => 50,
                'query' => [
                    'rescore_query' => [
                        'term' => [
                            'test2' => [
                                'value' => 'bar',
                                'boost' => 2,
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $this->assertEquals($expected, $data);
    }

    /**
     * @group unit
     */
    public function testSetWeights(): void
    {
        $query = new Query();
        $mainQuery = new MatchQuery();
        $mainQuery = $mainQuery->setFieldQuery('test1', 'foo');
        $secQuery = new Term();
        $secQuery = $secQuery->setTerm('test2', 'bar', 2);
        $queryRescore = new QueryRescore($secQuery);
        $queryRescore->setWindowSize(50);
        $queryRescore->setQueryWeight(.7);
        $queryRescore->setRescoreQueryWeight(1.2);
        $query->setQuery($mainQuery);
        $query->setRescore($queryRescore);
        $data = $query->toArray();

        $expected = [
            'query' => [
                'match' => [
                    'test1' => [
                        'query' => 'foo',
                    ],
                ],
            ],
            'rescore' => [
                'window_size' => 50,
                'query' => [
                    'rescore_query' => [
                        'term' => [
                            'test2' => [
                                'value' => 'bar',
                                'boost' => 2,
                            ],
                        ],
                    ],
                    'query_weight' => 0.7,
                    'rescore_query_weight' => 1.2,
                ],
            ],
        ];

        $this->assertEquals($expected, $data);
    }

    /**
     * @group functional
     */
    public function testMultipleQueries(): void
    {
        $query = new Query();
        $mainQuery = new MatchQuery();
        $mainQuery = $mainQuery->setFieldQuery('test1', 'foo');

        $secQuery1 = new Term();
        $secQuery1 = $secQuery1->setTerm('test2', 'bar', 1);
        $rescoreQuery1 = new QueryRescore();
        $rescoreQuery1->setRescoreQuery($secQuery1);

        $secQuery2 = new Term();
        $secQuery2 = $secQuery2->setTerm('test2', 'tom', 2);
        $rescoreQuery2 = new QueryRescore();
        $rescoreQuery2->setRescoreQuery($secQuery2);

        $query->setQuery($mainQuery);
        $query->setRescore([$rescoreQuery1, $rescoreQuery2]);
        $data = $query->toArray();

        $expected = [
            'query' => [
                'match' => [
                    'test1' => [
                        'query' => 'foo',
                    ],
                ],
            ],
            'rescore' => [
                [
                    'query' => [
                        'rescore_query' => [
                            'term' => [
                                'test2' => [
                                    'value' => 'bar',
                                    'boost' => 1,
                                ],
                            ],
                        ],
                    ],
                ],
                [
                    'query' => [
                        'rescore_query' => [
                            'term' => [
                                'test2' => [
                                    'value' => 'tom',
                                    'boost' => 2,
                                ],
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $this->assertEquals($expected, $data);

        $index = $this->_createIndex();
        $index->refresh();
        $index->forcemerge();

        $results = $index->search($query);
        $response = $results->getResponse();

        $this->assertEquals(true, $response->isOk());
        $this->assertEquals(0, $results->getTotalHits());
    }

    /**
     * @group functional
     */
    public function testQuery(): void
    {
        $query = new Query();
        $mainQuery = new MatchQuery();
        $mainQuery = $mainQuery->setFieldQuery('test1', 'foo');
        $secQuery = new Term();
        $secQuery = $secQuery->setTerm('test2', 'bar', 2);
        $queryRescore = new QueryRescore($secQuery);
        $queryRescore->setWindowSize(50);
        $queryRescore->setQueryWeight(.7);
        $queryRescore->setRescoreQueryWeight(1.2);
        $query->setQuery($mainQuery);
        $query->setRescore($queryRescore);
        $data = $query->toArray();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        $index = $this->_createIndex();
        $index->refresh();
        $index->forcemerge();

        $results = $index->search($query);
        $response = $results->getResponse();

        $this->assertEquals(true, $response->isOk());
        $this->assertEquals(0, $results->getTotalHits());
    }
}


1			<?php
2
3			namespace Elastica\Test\Query;
4
5			use Elastica\Query;
6			use Elastica\Query\MatchQuery;
7			use Elastica\Query\Term;
8			use Elastica\Rescore\Query as QueryRescore;
9			use Elastica\Test\Base as BaseTest;
10
11			/**
12			* @internal
13			*/
14			class RescoreTest extends BaseTest
15			{
16			/**
17			* @group unit
18			*/
19			public function testToArray(): void
20			{
21			$query = new Query();
22			$mainQuery = new MatchQuery();
23			$mainQuery = $mainQuery->setFieldQuery('test1', 'foo');
24			$secQuery = new Term();
25			$secQuery = $secQuery->setTerm('test2', 'bar', 2);
26			$queryRescore = new QueryRescore($secQuery);
27			$query->setQuery($mainQuery);
28			$query->setRescore($queryRescore);
29			$data = $query->toArray();
30
31			$expected = [
32			'query' => [
33			'match' => [
34			'test1' => [
35			'query' => 'foo',
36			],
37			],
38			],
39			'rescore' => [
40			'query' => [
41			'rescore_query' => [
42			'term' => [
43			'test2' => [
44			'value' => 'bar',
45			'boost' => 2,
46			],
47			],
48			],
49			],
50			],
51			];
52
53			$this->assertEquals($expected, $data);
54			}
55
56			/**
57			* @group unit
58			*/
59			public function testSetSize(): void
60			{
61			$query = new Query();
62			$mainQuery = new MatchQuery();
63			$mainQuery = $mainQuery->setFieldQuery('test1', 'foo');
64			$secQuery = new Term();
65			$secQuery = $secQuery->setTerm('test2', 'bar', 2);
66			$queryRescore = new QueryRescore($secQuery);
67			$queryRescore->setWindowSize(50);
68			$query->setQuery($mainQuery);
69			$query->setRescore($queryRescore);
70			$data = $query->toArray();
71
72			$expected = [
73			'query' => [
74			'match' => [
75			'test1' => [
76			'query' => 'foo',
77			],
78			],
79			],
80			'rescore' => [
81			'window_size' => 50,
82			'query' => [
83			'rescore_query' => [
84			'term' => [
85			'test2' => [
86			'value' => 'bar',
87			'boost' => 2,
88			],
89			],
90			],
91			],
92			],
93			];
94
95			$this->assertEquals($expected, $data);
96			}
97
98			/**
99			* @group unit
100			*/
101			public function testSetWeights(): void
102			{
103			$query = new Query();
104			$mainQuery = new MatchQuery();
105			$mainQuery = $mainQuery->setFieldQuery('test1', 'foo');
106			$secQuery = new Term();
107			$secQuery = $secQuery->setTerm('test2', 'bar', 2);
108			$queryRescore = new QueryRescore($secQuery);
109			$queryRescore->setWindowSize(50);
110			$queryRescore->setQueryWeight(.7);
111			$queryRescore->setRescoreQueryWeight(1.2);
112			$query->setQuery($mainQuery);
113			$query->setRescore($queryRescore);
114			$data = $query->toArray();
115
116			$expected = [
117			'query' => [
118			'match' => [
119			'test1' => [
120			'query' => 'foo',
121			],
122			],
123			],
124			'rescore' => [
125			'window_size' => 50,
126			'query' => [
127			'rescore_query' => [
128			'term' => [
129			'test2' => [
130			'value' => 'bar',
131			'boost' => 2,
132			],
133			],
134			],
135			'query_weight' => 0.7,
136			'rescore_query_weight' => 1.2,
137			],
138			],
139			];
140
141			$this->assertEquals($expected, $data);
142			}
143
144			/**
145			* @group functional
146			*/
147			public function testMultipleQueries(): void
148			{
149			$query = new Query();
150			$mainQuery = new MatchQuery();
151			$mainQuery = $mainQuery->setFieldQuery('test1', 'foo');
152
153			$secQuery1 = new Term();
154			$secQuery1 = $secQuery1->setTerm('test2', 'bar', 1);
155			$rescoreQuery1 = new QueryRescore();
156			$rescoreQuery1->setRescoreQuery($secQuery1);
157
158			$secQuery2 = new Term();
159			$secQuery2 = $secQuery2->setTerm('test2', 'tom', 2);
160			$rescoreQuery2 = new QueryRescore();
161			$rescoreQuery2->setRescoreQuery($secQuery2);
162
163			$query->setQuery($mainQuery);
164			$query->setRescore([$rescoreQuery1, $rescoreQuery2]);
165			$data = $query->toArray();
166
167			$expected = [
168			'query' => [
169			'match' => [
170			'test1' => [
171			'query' => 'foo',
172			],
173			],
174			],
175			'rescore' => [
176			[
177			'query' => [
178			'rescore_query' => [
179			'term' => [
180			'test2' => [
181			'value' => 'bar',
182			'boost' => 1,
183			],
184			],
185			],
186			],
187			],
188			[
189			'query' => [
190			'rescore_query' => [
191			'term' => [
192			'test2' => [
193			'value' => 'tom',
194			'boost' => 2,
195			],
196			],
197			],
198			],
199			],
200			],
201			];
202
203			$this->assertEquals($expected, $data);
204
205			$index = $this->_createIndex();
206			$index->refresh();
207			$index->forcemerge();
208
209			$results = $index->search($query);
210			$response = $results->getResponse();
211
212			$this->assertEquals(true, $response->isOk());
213			$this->assertEquals(0, $results->getTotalHits());
214			}
215
216			/**
217			* @group functional
218			*/
219			public function testQuery(): void
220			{
221			$query = new Query();
222			$mainQuery = new MatchQuery();
223			$mainQuery = $mainQuery->setFieldQuery('test1', 'foo');
224			$secQuery = new Term();
225			$secQuery = $secQuery->setTerm('test2', 'bar', 2);
226			$queryRescore = new QueryRescore($secQuery);
227			$queryRescore->setWindowSize(50);
228			$queryRescore->setQueryWeight(.7);
229			$queryRescore->setRescoreQueryWeight(1.2);
230			$query->setQuery($mainQuery);
231			$query->setRescore($queryRescore);
232			$data = $query->toArray();
			0 ignored issues – show Unused Code introduced 2020-02-11 13:11 UTC by Report Bug Copy Issue Report `$data` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
233
234			$index = $this->_createIndex();
235			$index->refresh();
236			$index->forcemerge();
237
238			$results = $index->search($query);
239			$response = $results->getResponse();
240
241			$this->assertEquals(true, $response->isOk());
242			$this->assertEquals(0, $results->getTotalHits());
243			}
244			}
245

ruflin / Elastica

Pull Request — master (#1911)

RescoreTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

5 Methods

Duplication Side-by-Side

Filter issues like