Elastica\Test\Connection\Strategy\RoundRobinTest

Complexity

Total Complexity

8

Size/Duplication

Total Lines	113
Duplicated Lines	51.33 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	testOldStrategySet()	0	7	1
A	testConnection()	0	10	1
A	testFailConnection()	11	11	1
A	testWithOneFailConnection()	23	23	1
A	testWithNoValidConnection()	23	23	2
A	_checkStrategy()	0	6	1
A	_checkResponse()	0	4	1

<?php

namespace Elastica\Test\Connection\Strategy;

use Elastica\Client;
use Elastica\Connection;
use Elastica\Connection\Strategy\RoundRobin;
use Elastica\Exception\ConnectionException;
use Elastica\Response;
use Elastica\Test\Base;

/**
 * Description of RoundRobinTest.
 *
 * @author chabior
 *
 * @internal
 */
class RoundRobinTest extends Base
{
    /**
     * @var int Number of seconds to wait before timeout is called. Is set low for tests to have fast tests.
     */
    protected $_timeout = 1;

    /**
     * @group functional
     */
    public function testConnection(): void
    {
        $config = ['connectionStrategy' => 'RoundRobin'];
        $client = $this->_getClient($config);
        $response = $client->request('_aliases');

        $this->_checkResponse($response);

        $this->_checkStrategy($client);
    }

    /**
     * @group unit
     */
    public function testOldStrategySet(): void
    {
        $config = ['roundRobin' => true];
        $client = $this->_getClient($config);

        $this->_checkStrategy($client);
    }

    /**
     * @group functional
     */
    public function testFailConnection(): void

This method seems to be duplicated in your project.

    {
        $this->expectException(\Elastica\Exception\ConnectionException::class);

        $config = ['connectionStrategy' => 'RoundRobin', 'host' => '255.255.255.0', 'timeout' => $this->_timeout];
        $client = $this->_getClient($config);

        $this->_checkStrategy($client);

        $client->request('_aliases');
    }

    /**
     * @group functional
     */
    public function testWithOneFailConnection(): void

This method seems to be duplicated in your project.

    {
        $connections = [
            new Connection(['host' => '255.255.255.0', 'timeout' => $this->_timeout]),
            new Connection(['host' => $this->_getHost(), 'timeout' => $this->_timeout]),
        ];

        $count = 0;
        $callback = static function ($connection, $exception, $client) use (&$count): void {

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

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

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

            ++$count;
        };

        $client = $this->_getClient(['connectionStrategy' => 'RoundRobin'], $callback);
        $client->setConnections($connections);

        $response = $client->request('_aliases');

        $this->_checkResponse($response);

        $this->_checkStrategy($client);

        $this->assertLessThan(\count($connections), $count);
    }

    /**
     * @group functional
     */
    public function testWithNoValidConnection(): void

This method seems to be duplicated in your project.

    {
        $connections = [
            new Connection(['host' => '255.255.255.0', 'timeout' => $this->_timeout]),
            new Connection(['host' => '45.45.45.45', 'port' => '80', 'timeout' => $this->_timeout]),
            new Connection(['host' => '10.123.213.123', 'timeout' => $this->_timeout]),
        ];

        $count = 0;
        $client = $this->_getClient(['roundRobin' => true], static function () use (&$count): void {
            ++$count;
        });

        $client->setConnections($connections);

        try {
            $client->request('_aliases');
            $this->fail('Should throw exception as no connection valid');
        } catch (ConnectionException $e) {
            $this->assertEquals(\count($connections), $count);
            $this->_checkStrategy($client);
        }
    }

    protected function _checkStrategy(Client $client): void
    {
        $strategy = $client->getConnectionStrategy();

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

    protected function _checkResponse(Response $response): void
    {
        $this->assertTrue($response->isOk());
    }
}