Elastica\Test\Connection\Strategy\StrategyFactoryTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	72
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	testNoCollisionWithGlobalNamespace()	0	9	2
A	testCreateCallbackStrategy()	0	9	1
A	testCreateByName()	0	8	1
A	testCreateByClass()	0	6	1
A	testCreateByClassName()	0	6	1
A	testFailCreate()	0	8	1

<?php

namespace Elastica\Test\Connection\Strategy;

use Elastica\Connection\Strategy\CallbackStrategy;
use Elastica\Connection\Strategy\Simple;
use Elastica\Connection\Strategy\StrategyFactory;
use Elastica\Test\Base;

/**
 * Description of StrategyFactoryTest.
 *
 * @author chabior
 *
 * @internal
 */
class StrategyFactoryTest extends Base
{
    /**
     * @group unit
     */
    public function testCreateCallbackStrategy(): void
    {
        $callback = static function ($connections): void {

The parameter $connections is not used and could be removed.

        };

        $strategy = StrategyFactory::create($callback);

        $this->assertInstanceOf(CallbackStrategy::class, $strategy);
    }

    /**
     * @group unit
     */
    public function testCreateByName(): void
    {
        $strategyName = 'Simple';

        $strategy = StrategyFactory::create($strategyName);

        $this->assertInstanceOf(Simple::class, $strategy);
    }

    /**
     * @group unit
     */
    public function testCreateByClass(): void
    {
        $strategy = new EmptyStrategy();

        $this->assertEquals($strategy, StrategyFactory::create($strategy));
    }

    /**
     * @group unit
     */
    public function testCreateByClassName(): void
    {
        $strategy = StrategyFactory::create(EmptyStrategy::class);

        $this->assertInstanceOf(EmptyStrategy::class, $strategy);
    }

    /**
     * @group unit
     */
    public function testFailCreate(): void
    {
        $this->expectException(\InvalidArgumentException::class);

        $strategy = new \stdClass();

        StrategyFactory::create($strategy);
    }

    /**
     * @group unit
     */
    public function testNoCollisionWithGlobalNamespace(): void
    {
        // create collision
        if (!\class_exists('Simple')) {
            \class_alias('Elastica\Util', 'Simple');
        }
        $strategy = StrategyFactory::create('Simple');
        $this->assertInstanceOf(Simple::class, $strategy);
    }
}