Spatie\SearchIndex\Test\Query\Algolia\SearchQueryTest

Complexity

Total Complexity

14

Size/Duplication

Total Lines	232
Duplicated Lines	12.07 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	10	1
A	it_can_handle_an_empty_query()	0	4	1
A	it_can_handle_a_query_string()	0	7	1
A	it_can_handle_a_location_aware_query()	0	14	1
A	it_can_handle_a_location_aware_query_around_a_radius()	0	15	1
A	it_can_handle_date_restrictions()	0	14	1
A	it_can_handle_multiple_date_restrictions()	0	19	1
A	it_can_handle_numeric_filters()	14	14	1
A	it_can_handle_numeric_filters_with_an_and_relation()	14	14	1
A	it_can_handle_a_search_facet()	0	14	1
A	it_allows_hits_per_page_to_be_set()	0	8	1
A	it_allows_hits_page_to_be_set()	0	10	1
A	it_allows_method_chaining_for_multiple_filters()	0	23	1
A	expectedResult()	0	4	1

<?php

namespace Spatie\SearchIndex\Test\Query\Algolia;

use DateTime;
use PHPUnit\Framework\TestCase;
use Spatie\SearchIndex\Query\Algolia\SearchQuery;

class SearchQueryTest extends TestCase
{
    /**
     * @var SearchQuery
     */
    protected $query;

    /**
     * @var array
     */
    protected $defaultResult;

    public function setUp()
    {
        $this->query = new SearchQuery();
        $this->defaultResult = [
            'numericFilters' => '',
            'facetFilters'   => '',
            'hitsPerPage'    => 10000,
            'page'           => 0,
        ];
    }

    /**
     * @test
     */
    public function it_can_handle_an_empty_query()
    {
        $this->assertEquals($this->defaultResult, $this->query->toArray());
    }

    /**
     * @test
     */
    public function it_can_handle_a_query_string()
    {
        $this->query
            ->searchFor('hello');

        $this->assertEquals($this->expectedResult(['query' => 'hello']), $this->query->toArray());
    }

    /**
     * @test
     */
    public function it_can_handle_a_location_aware_query()
    {
        $lat = 1.234567890;
        $lng = 7.891012345;

        $this->query->aroundLocation($lat, $lng);

        $this->assertEquals($this->expectedResult(
            [
                'aroundLatLng' => $lat.','.$lng,
                'aroundRadius' => 30000,
            ]
        ), $this->query->toArray());
    }

    /**
     * @test
     */
    public function it_can_handle_a_location_aware_query_around_a_radius()
    {
        $lat = 1.234567890;
        $lng = 7.891012345;
        $radius = 12345;

        $this->query->aroundLocation($lat, $lng, $radius);

        $this->assertEquals($this->expectedResult(
            [
                'aroundLatLng' => $lat.','.$lng,
                'aroundRadius' => $radius,
            ]
        ), $this->query->toArray());
    }

    /**
     * @test
     */
    public function it_can_handle_date_restrictions()
    {
        $dateFieldName = 'myDate';
        $operation = '>';
        $date = new DateTime();

        $this->query->withDateRestriction($dateFieldName, $operation, $date);

        $this->assertEquals($this->expectedResult(
            [
                'numericFilters' => ",{$dateFieldName}{$operation}{$date->getTimestamp()}",
            ]
        ), $this->query->toArray());
    }

    /**
     * @test
     */
    public function it_can_handle_multiple_date_restrictions()
    {
        $dateFieldName = 'myDate';
        $operation = '>';
        $date = new DateTime();

        $otherDateFieldName = 'otherDate';
        $otherOperation = '<';
        $otherDate = new DateTime();

        $this->query->withDateRestriction($dateFieldName, $operation, $date);
        $this->query->withDateRestriction($otherDateFieldName, $otherOperation, $otherDate);

        $this->assertEquals($this->expectedResult(
            [
                'numericFilters' => ",{$dateFieldName}{$operation}{$date->getTimestamp()},{$otherDateFieldName}{$otherOperation}{$otherDate->getTimestamp()}",
            ]
        ), $this->query->toArray());
    }

    /**
     * @test
     */
    public function it_can_handle_numeric_filters()

This method seems to be duplicated in your project.

    {
        $name = 'myFilter';
        $myValues = [1, 2, 3];
        $logicalOperator = SearchQuery::LOGICAL_OPERATOR_OR;

        $this->query->withNumericFilter($name, $myValues, $logicalOperator);

        $this->assertEquals($this->expectedResult(
            [
                'numericFilters' => ",({$name}={$myValues[0]},{$name}={$myValues[1]},{$name}={$myValues[2]})",
            ]
        ), $this->query->toArray());
    }

    /**
     * @test
     */
    public function it_can_handle_numeric_filters_with_an_and_relation()

This method seems to be duplicated in your project.

    {
        $name = 'myFilter';
        $myValues = [1, 2, 3];
        $logicalOperator = SearchQuery::LOGICAL_OPERATOR_AND;

        $this->query->withNumericFilter($name, $myValues, $logicalOperator);

        $this->assertEquals($this->expectedResult(
            [
                'numericFilters' => ",{$name}={$myValues[0]},{$name}={$myValues[1]},{$name}={$myValues[2]}",
            ]
        ), $this->query->toArray());
    }

    /**
     * @test
     */
    public function it_can_handle_a_search_facet()
    {
        $names = ['facet1', 'facet2'];
        $values = ['value1', 'value2'];

        $this->query->withFacet($names[0], $values[0]);
        $this->query->withFacet($names[1], $values[1]);

        $this->assertEquals($this->expectedResult(
            [
                'facetFilters' => ",{$names[0]}:{$values[0]},{$names[1]}:{$values[1]}",
            ]
        ), $this->query->toArray());
    }

    /**
     * @test
     */
    public function it_allows_hits_per_page_to_be_set()
    {
        $hitsPerPage = 12345;

        $this->query->setHitsPerPage($hitsPerPage);

        $this->assertEquals($this->expectedResult(['hitsPerPage' => $hitsPerPage]), $this->query->toArray());
    }

    /**
     * @test
     */
    public function it_allows_hits_page_to_be_set()
    {
        $hitsPerPage = 8;
        $page = 2;

        $this->query->setHitsPerPage($hitsPerPage);
        $this->query->setPage($page);

        $this->assertEquals($this->expectedResult(['hitsPerPage' => $hitsPerPage, 'page' => $page]), $this->query->toArray());
    }

    /**
     * @test
     */
    public function it_allows_method_chaining_for_multiple_filters()
    {
        $facetFilter = ['name', 'value'];

        $numericFilterName = 'myFilter';
        $numericFilterValues = [1, 2, 3];
        $logicalOperator = SearchQuery::LOGICAL_OPERATOR_OR;

        $dateFieldName = 'myDate';
        $operation = '>';
        $date = new DateTime();

        $this->query->withFacet('name', 'value')
                    ->withDateRestriction($dateFieldName, $operation, $date)
                    ->withNumericFilter($numericFilterName, $numericFilterValues, $logicalOperator);

        $this->assertEquals($this->expectedResult(
            [
                'facetFilters'   => ",{$facetFilter[0]}:{$facetFilter[1]}",
                'numericFilters' => ",{$dateFieldName}{$operation}{$date->getTimestamp()},({$numericFilterName}={$numericFilterValues[0]},{$numericFilterName}={$numericFilterValues[1]},{$numericFilterName}={$numericFilterValues[2]})",
            ]
        ), $this->query->toArray());
    }

    protected function expectedResult(array $expectedResult)
    {
        return array_merge($this->defaultResult, $expectedResult);
    }
}