Elastica\Test\Processor\ForeachProcessorTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	testForeachProcessorDefault()	0	18	1
A	testForeachRawProcessorDefault()	0	22	1
A	testForeachProcessorIgnoreMissing()	0	20	1
A	testForeachProcessor()	0	33	2

<?php

namespace Elastica\Test\Processor;

use Elastica\Bulk;
use Elastica\Document;
use Elastica\Processor\ForeachProcessor;
use Elastica\Processor\Uppercase;
use Elastica\ResultSet;
use Elastica\Test\BasePipeline as BasePipelineTest;

/**
 * @internal
 */
class ForeachProcessorTest extends BasePipelineTest
{
    /**
     * @group unit
     */
    public function testForeachProcessorDefault(): void
    {
        $subprocessor = new Uppercase('field2');
        $processor = new ForeachProcessor('field1', $subprocessor);

        $expected = [
            'foreach' => [
                'field' => 'field1',
                'processor' => [
                    'uppercase' => [
                        'field' => 'field2',
                    ],
                ],
            ],
        ];

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

    /**
     * @group unit
     */
    public function testForeachRawProcessorDefault(): void
    {
        $subprocessor = [
            'uppercase' => [
                'field' => 'field2',
            ],
        ];
        $processor = new ForeachProcessor('field1', $subprocessor);

        $expected = [
            'foreach' => [
                'field' => 'field1',
                'processor' => [
                    'uppercase' => [
                        'field' => 'field2',
                    ],
                ],
            ],
        ];

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

    /**
     * @group unit
     */
    public function testForeachProcessorIgnoreMissing(): void
    {
        $subprocessor = new Uppercase('field2');
        $processor = new ForeachProcessor('field1', $subprocessor);
        $processor->setIgnoreMissing(true);

        $expected = [
            'foreach' => [
                'field' => 'field1',
                'processor' => [
                    'uppercase' => [
                        'field' => 'field2',
                    ],
                ],
                'ignore_missing' => true,
            ],
        ];

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

    /**
     * @group functional
     */
    public function testForeachProcessor(): void
    {
        $subprocessor = new Uppercase('_ingest._value');
        $foreach = new ForeachProcessor('values', $subprocessor);

        $pipeline = $this->_createPipeline('my_custom_pipeline', 'pipeline for Foreach');
        $pipeline->addProcessor($foreach)->create();

        $index = $this->_createIndex();
        $bulk = new Bulk($index->getClient());
        $bulk->setIndex($index);

        $bulk->addDocuments([
            new Document(null, ['name' => 'ruflin', 'type' => 'elastica', 'values' => ['foo', 'bar', 'baz']]),
        ]);
        $bulk->setRequestParam('pipeline', 'my_custom_pipeline');

        $bulk->send();
        $index->refresh();

        /** @var ResultSet $result */
        $result = $index->search('*');

        $this->assertCount(1, $result->getResults());

$result->getResults() is of type array<integer,object<Elastica\Result>>, but the function expects a object<Countable>|object<PHPUnit\Framework\iterable>.

        foreach ($result->getResults() as $rx) {
            $value = $rx->getData();
            $this->assertCount(3, $value['values']);
            $this->assertEquals('FOO', $value['values'][0]);
            $this->assertEquals('BAR', $value['values'][1]);
            $this->assertEquals('BAZ', $value['values'][2]);
        }
    }
}