Issues in FunctionScoreTest.php - All Issues - Inspection of "Add WeightedAvg aggregation (#1771)" - ruflin/Elastica - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 0d45ed...ea3502 )

by Nicolas
created 2020-04-22 07:42 UTC
tests/Query/FunctionScoreTest.php (20 issues)

Labels

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more
<?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 ( 0d45ed...ea3502 )

tests/Query/FunctionScoreTest.php (20 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like
