AmaTeam\ElasticSearch\Test\Suite\Functional\Indexing\NormalizerTest

Complexity

Total Complexity

6

Size/Duplication

Total Lines	92
Duplicated Lines	19.57 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	shouldPreserveUnknownOptions()	0	7	1
A	_before()	0	6	1
A	shouldDeduplicateIndices()	0	12	1
A	shouldPreserveUnknownOption()	9	9	1
A	shouldStripUnknownOption()	7	7	1
A	shouldNormalizeKnownOptionName()	0	19	1

<?php

namespace AmaTeam\ElasticSearch\Test\Suite\Functional\Indexing;

use AmaTeam\ElasticSearch\API\Indexing;
use AmaTeam\ElasticSearch\API\Indexing\Normalization\Context;
use AmaTeam\ElasticSearch\API\Indexing\OptionInterface;
use AmaTeam\ElasticSearch\Indexing\Normalizer;
use AmaTeam\ElasticSearch\Indexing\Operations;
use AmaTeam\ElasticSearch\Indexing\Option\Infrastructure\Registry;
use Codeception\Test\Unit;
use PHPUnit\Framework\Assert;
use PHPUnit_Framework_MockObject_MockObject as Mock;

class NormalizerTest extends Unit
{
    /**
     * @var Indexing
     */
    private $dummy;

    protected function _before()
    {
        $this->dummy = (new Indexing())
            ->setReadIndices([])
            ->setWriteIndices([])
            ->setType('doc');
    }

    /**
     * @test
     */
    public function shouldNormalizeKnownOptionName()
    {
        $id = 'alpha';
        $friendlyId = 'beta';
        /** @var Mock|OptionInterface $option */
        $option = $this->createMock(OptionInterface::class);
        $option
            ->expects($this->any())
            ->method('getId')
            ->willReturn($id);
        $option
            ->expects($this->any())
            ->method('getFriendlyId')
            ->willReturn($friendlyId);
        $registry = (new Registry())->register($option);
        $input = Operations::from($this->dummy)->setOption($friendlyId, 'value');
        $expectation = Operations::from($this->dummy)->setOption($id, 'value');
        $output = (new Normalizer($registry))->normalize($input);
        Assert::assertEquals($expectation, $output);
    }

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

This method seems to be duplicated in your project.

    {
        $option = 'alpha';
        $context = (new Context())->setPreserveUnknownOptions(false);
        $input = Operations::from($this->dummy)->setOption($option, 'value');
        $output = (new Normalizer())->normalize($input, $context);
        Assert::assertEquals($this->dummy, $output);
    }

    /**
     * @test
     */
    public function shouldPreserveUnknownOptions()
    {
        $option = 'alpha';
        $context = (new Context())->setPreserveUnknownOptions(true);
        $input = Operations::from($this->dummy)->setOption($option, 'value');
        $output = (new Normalizer())->normalize($input, $context);
        Assert::assertEquals($input, $output);
    }

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

This method seems to be duplicated in your project.

    {
        $option = 'alpha';
        $context = (new Context())
            ->setPreserveUnknownOptions(false)
            ->setPreservedOptions([$option]);
        $input = Operations::from($this->dummy)->setOption($option, 'value');
        $output = (new Normalizer())->normalize($input, $context);
        Assert::assertEquals($input, $output);
    }

    /**
     * @test
     */
    public function shouldDeduplicateIndices()
    {
        $index = 'curly';
        $indices = [$index, $index, $index];
        $input = Operations::from($this->dummy)
            ->setReadIndices($indices)
            ->setWriteIndices($indices);
        $expectation = Operations::from($this->dummy)
            ->setReadIndices([$index])
            ->setWriteIndices([$index]);
        $output = (new Normalizer())->normalize($input);
        Assert::assertEquals($expectation, $output);
    }
}