FunctionScoreTest - Code Metrics - Inspection of "Use AWS SDK package version compatible with PHP 8..." - ruflin/Elastica - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9146c8...39ecb4 )

by Nicolas

created 2020-09-28 08:54 UTC

FunctionScoreTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	570
Duplicated Lines	41.93 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

Metric	Value
wmc	18
lcom	1
cbo	10
dl	239
loc	570
rs	10
c	0
b	0
f	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	testToArray()	0	35	1
A	testGauss()	0	12	1
A	testGaussMultiValue()	0	21	1
A	testAddWeightFunction()	12	12	1
A	testLegacyFilterAddWeightFunction()	12	12	1
A	testWeightWithLegacyFilter()	30	30	1
A	testRandomScore()	34	34	1
A	testRandomScoreWithLegacyFilter()	34	34	1
A	testRandomScoreWeightWithLegacyFilter()	27	27	1
A	testRandomScoreWithoutField()	33	33	1
A	testScriptScore()	0	30	1
B	testDecayWeight()	0	59	1
A	testWeight()	30	30	1
A	testRandomScoreWeight()	27	27	1
A	testSetMinScore()	0	33	1
A	testFieldValueFactor()	0	30	1
A	_getIndexForTest()	0	29	1

How to fix Duplicated Code

<?php

namespace Elastica\Test\Query;

use Elastica\Document;
use Elastica\Mapping;
use Elastica\Query\FunctionScore;
use Elastica\Query\MatchAll;
use Elastica\Query\Term;
use Elastica\Script\Script;
use Elastica\Test\Base as BaseTest;

/**
 * @internal
 */
class FunctionScoreTest extends BaseTest
{
    protected $locationOrigin = '32.804654, -117.242594';

    /**
     * @group unit
     */
    public function testToArray(): void
    {
        $priceOrigin = 0;
        $locationScale = '2mi';
        $priceScale = 9.25;
        $query = new FunctionScore();
        $childQuery = new MatchAll();
        $query->setQuery($childQuery);
        $query->addDecayFunction(FunctionScore::DECAY_GAUSS, 'location', $this->locationOrigin, $locationScale);
        $query->addDecayFunction(FunctionScore::DECAY_GAUSS, 'price', $priceOrigin, $priceScale);
        $expected = [
            'function_score' => [
                'query' => $childQuery->toArray(),
                'functions' => [
                    [
                        'gauss' => [
                            'location' => [
                                'origin' => $this->locationOrigin,
                                'scale' => $locationScale,
                            ],
                        ],
                    ],
                    [
                        'gauss' => [
                            'price' => [
                                'origin' => $priceOrigin,
                                'scale' => $priceScale,
                            ],
                        ],
                    ],
                ],
            ],
        ];
        $this->assertEquals($expected, $query->toArray());
    }

    /**
     * @group unit
     */
    public function testDecayWeight(): void
    {
        $priceOrigin = 0;
        $locationScale = '2mi';
        $priceScale = 9.25;
        $query = new FunctionScore();
        $childQuery = new MatchAll();
        $query->setQuery($childQuery);
        $query->addDecayFunction(
            FunctionScore::DECAY_GAUSS,
            'location',
            $this->locationOrigin,
            $locationScale,
            null,
            null,
            .5,
            null,
            FunctionScore::MULTI_VALUE_MODE_AVG
        );
        $query->addDecayFunction(
            FunctionScore::DECAY_GAUSS,
            'price',
            $priceOrigin,
            $priceScale,
            null,
            null,
            2,
            null,
            FunctionScore::MULTI_VALUE_MODE_MAX
        );
        $expected = [
            'function_score' => [
                'query' => $childQuery->toArray(),
                'functions' => [
                    [
                        'gauss' => [
                            'location' => [
                                'origin' => $this->locationOrigin,
                                'scale' => $locationScale,
                            ],
                            'multi_value_mode' => FunctionScore::MULTI_VALUE_MODE_AVG,
                        ],
                        'weight' => .5,
                    ],
                    [
                        'gauss' => [
                            'price' => [
                                'origin' => $priceOrigin,
                                'scale' => $priceScale,
                            ],
                            'multi_value_mode' => FunctionScore::MULTI_VALUE_MODE_MAX,
                        ],
                        'weight' => 2,
                    ],
                ],
            ],
        ];
        $this->assertEquals($expected, $query->toArray());
    }

    /**
     * @group functional
     */
    public function testGauss(): void
    {
        $query = new FunctionScore();
        $query->addDecayFunction(FunctionScore::DECAY_GAUSS, 'location', $this->locationOrigin, '4mi');
        $query->addDecayFunction(FunctionScore::DECAY_GAUSS, 'price', 0, 10);
        $response = $this->_getIndexForTest()->search($query);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $results = $response->getResults();

        // the document with the closest location and lowest price should be scored highest
        $result0 = $results[0]->getData();
        $this->assertEquals("Mr. Frostie's", $result0['name']);
    }

    /**
     * @group functional
     */
    public function testGaussMultiValue(): void
    {
        $query = new FunctionScore();
        $query->addDecayFunction(
            FunctionScore::DECAY_GAUSS,
            'location',
            $this->locationOrigin,
            '4mi',
            null,
            null,
            null,
            null,
            FunctionScore::MULTI_VALUE_MODE_SUM
        );
        $response = $this->_getIndexForTest()->search($query);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $results = $response->getResults();

        // the document with the sum of distances should be scored highest
        $result0 = $results[0]->getData();
        $this->assertEquals("Miller's Field", $result0['name']);
    }

    /**
     * @group unit
     */
    public function testAddWeightFunction(): void

    {
        $filter = new Term(['price' => 4.5]);
        $query = new FunctionScore();
        $query->addWeightFunction(5.0, $filter);

        $sameFilter = new Term(['price' => 4.5]);
        $sameQuery = new FunctionScore();
        $sameQuery->addWeightFunction(5.0, $sameFilter);

        $this->assertEquals($query->toArray(), $sameQuery->toArray());
    }

    /**
     * @group unit
     */
    public function testLegacyFilterAddWeightFunction(): void

    {
        $query = new FunctionScore();
        $filter = new Term(['price' => 4.5]);
        $query->addWeightFunction(5.0, $filter);

        $sameQuery = new FunctionScore();
        $sameFilter = new Term(['price' => 4.5]);
        $sameQuery->addWeightFunction(5.0, $sameFilter);

        $this->assertEquals($query->toArray(), $sameQuery->toArray());
    }

    /**
     * @group functional
     */
    public function testWeight(): void

    {
        $filter = new Term(['price' => 4.5]);
        $query = new FunctionScore();
        $query->addWeightFunction(5.0, $filter);

        $expected = [
            'function_score' => [
                'functions' => [
                    [
                        'weight' => 5.0,
                        'filter' => [
                            'term' => [
                                'price' => 4.5,
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $this->assertEquals($expected, $query->toArray());

        $response = $this->_getIndexForTest()->search($query);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $results = $response->getResults();

        // the document with price = 4.5 should be scored highest
        $result0 = $results[0]->getData();
        $this->assertEquals("Mr. Frostie's", $result0['name']);
    }

    /**
     * @group functional
     */
    public function testWeightWithLegacyFilter(): void

    {
        $filter = new Term(['price' => 4.5]);
        $query = new FunctionScore();
        $query->addWeightFunction(5.0, $filter);

        $expected = [
            'function_score' => [
                'functions' => [
                    [
                        'weight' => 5.0,
                        'filter' => [
                            'term' => [
                                'price' => 4.5,
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $this->assertEquals($expected, $query->toArray());

        $response = $this->_getIndexForTest()->search($query);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $results = $response->getResults();

        // the document with price = 4.5 should be scored highest
        $result0 = $results[0]->getData();
        $this->assertEquals("Mr. Frostie's", $result0['name']);
    }

    /**
     * @group functional
     */
    public function testRandomScore(): void

    {
        $filter = new Term(['price' => 4.5]);
        $query = new FunctionScore();
        $query->addRandomScoreFunction(2, $filter, null, '_id');

        $expected = [
            'function_score' => [
                'functions' => [
                    [
                        'random_score' => [
                            'seed' => 2,
                            'field' => '_id',
                        ],
                        'filter' => [
                            'term' => [
                                'price' => 4.5,
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $this->assertEquals($expected, $query->toArray());

        $response = $this->_getIndexForTest()->search($query);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $results = $response->getResults();

        // the document with the random score should have a score > 1, means it is the first result
        $result0 = $results[0]->getData();

        $this->assertEquals("Miller's Field", $result0['name']);
    }

    /**
     * @group functional
     */
    public function testRandomScoreWithLegacyFilter(): void

    {
        $filter = new Term(['price' => 4.5]);
        $query = new FunctionScore();
        $query->addRandomScoreFunction(2, $filter, null, '_id');

        $expected = [
            'function_score' => [
                'functions' => [
                    [
                        'random_score' => [
                            'seed' => 2,
                            'field' => '_id',
                        ],
                        'filter' => [
                            'term' => [
                                'price' => 4.5,
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $this->assertEquals($expected, $query->toArray());

        $response = $this->_getIndexForTest()->search($query);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $results = $response->getResults();

        // the document with the random score should have a score > 1, means it is the first result
        $result0 = $results[0]->getData();

        $this->assertEquals("Miller's Field", $result0['name']);
    }

    /**
     * @group unit
     */
    public function testRandomScoreWeight(): void

    {
        $filter = new Term(['price' => 4.5]);
        $query = new FunctionScore();
        $query->addRandomScoreFunction(2, $filter, 2, '_id');

        $expected = [
            'function_score' => [
                'functions' => [
                    [
                        'random_score' => [
                            'seed' => 2,
                            'field' => '_id',
                        ],
                        'filter' => [
                            'term' => [
                                'price' => 4.5,
                            ],
                        ],
                        'weight' => 2,
                    ],
                ],
            ],
        ];

        $this->assertEquals($expected, $query->toArray());
    }

    /**
     * @group unit
     */
    public function testRandomScoreWeightWithLegacyFilter(): void

    {
        $filter = new Term(['price' => 4.5]);
        $query = new FunctionScore();
        $query->addRandomScoreFunction(2, $filter, 2, '_id');

        $expected = [
            'function_score' => [
                'functions' => [
                    [
                        'random_score' => [
                            'seed' => 2,
                            'field' => '_id',
                        ],
                        'filter' => [
                            'term' => [
                                'price' => 4.5,
                            ],
                        ],
                        'weight' => 2,
                    ],
                ],
            ],
        ];

        $this->assertEquals($expected, $query->toArray());
    }

    /**
     * @group functional
     */
    public function testRandomScoreWithoutSeed(): void
    {
        $query = new FunctionScore();
        $query->setRandomScore();

        $response = $this->_getIndexForTest()->search($query);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertEquals(2, $response->count());
    }

    /**
     * @group functional
     */
    public function testRandomScoreWithoutField(): void

    {
        $filter = new Term(['price' => 4.5]);
        $query = new FunctionScore();
        $query->addRandomScoreFunction(2, $filter);

        $expected = [
            'function_score' => [
                'functions' => [
                    [
                        'random_score' => [
                            'seed' => 2,
                        ],
                        'filter' => [
                            'term' => [
                                'price' => 4.5,
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $this->assertEquals($expected, $query->toArray());

        $response = $this->_getIndexForTest()->search($query);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $results = $response->getResults();

        // the document with the random score should have a score > 1, means it is the first result
        $result0 = $results[0]->getData();

        $this->assertEquals("Miller's Field", $result0['name']);
    }

    /**
     * @group functional
     */
    public function testScriptScore(): void
    {
        $scriptString = "_score * doc['price'].value";
        $script = new Script($scriptString, null, Script::LANG_PAINLESS);
        $query = new FunctionScore();
        $query->addScriptScoreFunction($script);
        $expected = [
            'function_score' => [
                'functions' => [
                    [
                        'script_score' => [
                            'script' => [
                                'source' => $scriptString,
                                'lang' => Script::LANG_PAINLESS,
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $this->assertEquals($expected, $query->toArray());

        $response = $this->_getIndexForTest()->search($query);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $results = $response->getResults();

        // the document the highest price should be scored highest
        $result0 = $results[0]->getData();
        $this->assertEquals("Miller's Field", $result0['name']);
    }

    /**
     * @group functional
     */
    public function testSetMinScore(): void
    {
        $this->_checkVersion('1.5');

        $expected = [
            'function_score' => [
                'min_score' => 0.8,
                'functions' => [
                    [
                        'gauss' => [
                            'price' => [
                                'origin' => 0,
                                'scale' => 10,
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $query = new FunctionScore();
        $query->addDecayFunction(FunctionScore::DECAY_GAUSS, 'price', 0, 10);
        $returnedValue = $query->setMinScore(0.8);

        $this->assertEquals($expected, $query->toArray());
        $this->assertInstanceOf(FunctionScore::class, $returnedValue);

        $response = $this->_getIndexForTest()->search($query);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $results = $response->getResults();

        $this->assertCount(1, $results);
        $this->assertEquals(1, $results[0]->getId());
    }

    /**
     * @group functional
     */
    public function testFieldValueFactor(): void
    {
        $this->_checkVersion('1.6');

        $expected = [
            'function_score' => [
                'functions' => [
                    [
                        'field_value_factor' => [
                            'field' => 'popularity',
                            'factor' => 1.2,
                            'modifier' => 'sqrt',
                            'missing' => 0.1,    // available from >=1.6
                        ],
                    ],
                ],
            ],
        ];

        $query = new FunctionScore();
        $query->addFieldValueFactorFunction('popularity', 1.2, FunctionScore::FIELD_VALUE_FACTOR_MODIFIER_SQRT, 0.1);

        $this->assertEquals($expected, $query->toArray());

        $response = $this->_getIndexForTest()->search($query);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $results = $response->getResults();

        $this->assertCount(2, $results);
        $this->assertEquals(2, $results[0]->getId());
    }

    protected function _getIndexForTest()
    {
        $index = $this->_createIndex();
        $index->setMapping(new Mapping([
            'name' => ['type' => 'text', 'index' => 'false'],
            'location' => ['type' => 'geo_point'],
            'price' => ['type' => 'float'],
            'popularity' => ['type' => 'integer'],
        ]));

        $index->addDocuments([
            new Document(1, [
                'name' => "Mr. Frostie's",
                'location' => [['lat' => 32.799605, 'lon' => -117.243027], ['lat' => 32.792744, 'lon' => -117.2387341]],
                'price' => 4.5,
                'popularity' => null,
            ]),
            new Document(2, [
                'name' => "Miller's Field",
                'location' => ['lat' => 32.795964, 'lon' => -117.255028],
                'price' => 9.5,
                'popularity' => 1,
            ]),
        ]);

        $index->refresh();

        return $index;
    }
}


1			<?php
2
3			namespace Elastica\Test\Query;
4
5			use Elastica\Document;
6			use Elastica\Mapping;
7			use Elastica\Query\FunctionScore;
8			use Elastica\Query\MatchAll;
9			use Elastica\Query\Term;
10			use Elastica\Script\Script;
11			use Elastica\Test\Base as BaseTest;
12
13			/**
14			* @internal
15			*/
16			class FunctionScoreTest extends BaseTest
17			{
18			protected $locationOrigin = '32.804654, -117.242594';
19
20			/**
21			* @group unit
22			*/
23			public function testToArray(): void
24			{
25			$priceOrigin = 0;
26			$locationScale = '2mi';
27			$priceScale = 9.25;
28			$query = new FunctionScore();
29			$childQuery = new MatchAll();
30			$query->setQuery($childQuery);
31			$query->addDecayFunction(FunctionScore::DECAY_GAUSS, 'location', $this->locationOrigin, $locationScale);
32			$query->addDecayFunction(FunctionScore::DECAY_GAUSS, 'price', $priceOrigin, $priceScale);
33			$expected = [
34			'function_score' => [
35			'query' => $childQuery->toArray(),
36			'functions' => [
37			[
38			'gauss' => [
39			'location' => [
40			'origin' => $this->locationOrigin,

ruflin / Elastica

Push — master ( 9146c8...39ecb4 )

FunctionScoreTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

17 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like