Elastica\Test\Aggregation\CompositeTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	183
Duplicated Lines	8.2 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	testSize()	0	13	1
A	testAddSource()	0	20	1
A	testAddAfter()	0	13	1
A	testCompositeNoAfterAggregation()	0	37	1
A	testCompositeWithSizeAggregation()	0	32	1
A	testCompositeWithAfterAggregation()	0	26	1
A	_getIndexForTest()	15	15	1

<?php

namespace Elastica\Test\Aggregation;

use Elastica\Aggregation\Composite;
use Elastica\Aggregation\Terms;
use Elastica\Document;
use Elastica\Index;
use Elastica\Query;

/**
 * @internal
 */
class CompositeTest extends BaseAggregationTest
{
    /**
     * @group unit
     */
    public function testSize(): void
    {
        $composite = new Composite('products');
        $composite->setSize(200);
        $this->assertEquals(200, $composite->getParam('size'));

        $expected = [
            'composite' => [
                'size' => 200,
            ],
        ];
        $this->assertEquals($expected, $composite->toArray());
    }

    /**
     * @group unit
     */
    public function testAddSource(): void
    {
        $expected = [
            'composite' => [
                'sources' => [
                    [
                        'product' => [
                            'terms' => [
                                'field' => 'product_id',
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $composite = new Composite('products');
        $composite->addSource((new Terms('product_id'))->setField('product_id')->setName('product'));
        $this->assertEquals($expected, $composite->toArray());
    }

    /**
     * @group unit
     */
    public function testAddAfter(): void
    {
        $checkpoint = ['checkpointproduct' => 'checkpoint'];
        $expected = [
            'composite' => [
                'after' => $checkpoint,
            ],
        ];

        $composite = new Composite('products');
        $composite->addAfter($checkpoint);
        $this->assertEquals($expected, $composite->toArray());
    }

    /**
     * @group functional
     */
    public function testCompositeNoAfterAggregation(): void
    {
        $composite = new Composite('products');
        $composite->addSource((new Terms('color'))->setField('color.keyword')->setName('color'));

        $query = new Query();
        $query->addAggregation($composite);

        $results = $this->_getIndexForTest()->search($query)->getAggregation('products');
        $expected = [
            'after_key' => [
                'color' => 'red',
            ],
            'buckets' => [
                [
                    'key' => [
                        'color' => 'blue',
                    ],
                    'doc_count' => 2,
                ],
                [
                    'key' => [
                        'color' => 'green',
                    ],
                    'doc_count' => 1,
                ],
                [
                    'key' => [
                        'color' => 'red',
                    ],
                    'doc_count' => 1,
                ],
            ],
        ];

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

    /**
     * @group functional
     */
    public function testCompositeWithSizeAggregation(): void
    {
        $composite = new Composite('products');
        $composite->setSize(2);
        $composite->addSource((new Terms('color'))->setField('color.keyword')->setName('color'));

        $query = new Query();
        $query->addAggregation($composite);

        $results = $this->_getIndexForTest()->search($query)->getAggregation('products');
        $expected = [
            'after_key' => [
                'color' => 'green',
            ],
            'buckets' => [
                [
                    'key' => [
                        'color' => 'blue',
                    ],
                    'doc_count' => 2,
                ],
                [
                    'key' => [
                        'color' => 'green',
                    ],
                    'doc_count' => 1,
                ],
            ],
        ];

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

    /**
     * @group functional
     */
    public function testCompositeWithAfterAggregation(): void
    {
        $composite = new Composite('products');
        $composite->setSize(2);
        $composite->addSource((new Terms('color'))->setField('color.keyword')->setName('color'));
        $composite->addAfter(['color' => 'green']);
        $query = new Query();
        $query->addAggregation($composite);

        $results = $this->_getIndexForTest()->search($query)->getAggregation('products');
        $expected = [
            'after_key' => [
                'color' => 'red',
            ],
            'buckets' => [
                [
                    'key' => [
                        'color' => 'red',
                    ],
                    'doc_count' => 1,
                ],
            ],
        ];

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

    protected function _getIndexForTest(): Index

This method seems to be duplicated in your project.

    {
        $index = $this->_createIndex();

        $index->addDocuments([
            new Document(1, ['price' => 5, 'color' => 'blue']),
            new Document(2, ['price' => 5, 'color' => 'blue']),
            new Document(3, ['price' => 3, 'color' => 'red']),
            new Document(4, ['price' => 3, 'color' => 'green']),
        ]);

        $index->refresh();

        return $index;
    }
}