AMQPConnectionFactoryTest::testClusterConnectionParametersWithRootConnectionKeys() - Code Metrics - Inspection of "Merge pull request #637 from Torondor27/cluster_us..." - php-amqplib/RabbitMqBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ece95b...9e5e0a )

by Mihai

created 2021-05-18 11:20 UTC

testClusterConnectionParametersWithRootConnectionKeys() A

↳ Parent: AMQPConnectionFactoryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	68
Code Lines	46

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	46
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	68
rs	9.1781

How to fix Long Method

<?php

namespace OldSound\RabbitMqBundle\Tests\RabbitMq;

use OldSound\RabbitMqBundle\Provider\ConnectionParametersProviderInterface;
use OldSound\RabbitMqBundle\RabbitMq\AMQPConnectionFactory;
use OldSound\RabbitMqBundle\Tests\RabbitMq\Fixtures\AMQPConnection;
use OldSound\RabbitMqBundle\Tests\RabbitMq\Fixtures\AMQPSocketConnection;
use OldSound\RabbitMqBundle\Tests\RabbitMq\Fixtures\AMQPSSLConnection;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class AMQPConnectionFactoryTest extends TestCase
{
    public function testDefaultValues()
    {
        $factory = new AMQPConnectionFactory(
            AMQPConnection::class,
            []
        );

        /** @var AMQPConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPConnection::class, $instance);
        $this->assertEquals([
            'localhost', // host
            5672,        // port
            'guest',     // user
            'guest',     // password
            '/',         // vhost
            false,       // insist
            "AMQPLAIN",  // login method
            null,        // login response
            "en_US",     // locale
            3,           // connection timeout
            3,           // read write timeout
            null,        // context
            false,       // keepalive
            0,           // heartbeat
        ], $instance->constructParams);
    }

    public function testSocketConnection()
    {
        $factory = new AMQPConnectionFactory(
            AMQPSocketConnection::class,
            []
        );

        /** @var AMQPSocketConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPSocketConnection::class, $instance);
        $this->assertEquals([
            'localhost', // host
            5672,        // port
            'guest',     // user
            'guest',     // password
            '/',         // vhost
            false,       // insist
            "AMQPLAIN",  // login method
            null,        // login response
            "en_US",     // locale
            3,           // read_timeout
            false,       // keepalive
            3,           // write_timeout
            0,           // heartbeat
        ], $instance->constructParams);
    }

    public function testSocketConnectionWithParams()
    {
        $factory = new AMQPConnectionFactory(
            AMQPSocketConnection::class,
            [
                'read_timeout' => 31,
                'write_timeout' => 32,
            ]
        );

        /** @var AMQPSocketConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPSocketConnection::class, $instance);
        $this->assertEquals([
            'localhost', // host
            5672,        // port
            'guest',     // user
            'guest',     // password
            '/',         // vhost
            false,       // insist
            "AMQPLAIN",  // login method
            null,        // login response
            "en_US",     // locale
            31,           // read_timeout
            false,       // keepalive
            32,           // write_timeout
            0,           // heartbeat
        ], $instance->constructParams);
    }

    public function testStandardConnectionParameters()
    {
        $factory = new AMQPConnectionFactory(
            AMQPConnection::class,
            [
                'host' => 'foo_host',
                'port' => 123,
                'user' => 'foo_user',
                'password' => 'foo_password',
                'vhost' => '/vhost',
            ]
        );

        /** @var AMQPConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPConnection::class, $instance);
        $this->assertEquals([
            'foo_host',  // host
            123,         // port
            'foo_user',  // user
            'foo_password', // password
            '/vhost',    // vhost
            false,       // insist
            "AMQPLAIN",  // login method
            null,        // login response
            "en_US",     // locale
            3,           // connection timeout
            3,           // read write timeout
            null,        // context
            false,       // keepalive
            0,           // heartbeat
        ], $instance->constructParams);
    }

    public function testSetConnectionParametersWithUrl()
    {
        $factory = new AMQPConnectionFactory(
            AMQPConnection::class,
            [
                'url' => 'amqp://bar_user:bar_password@bar_host:321/whost?keepalive=1&connection_timeout=6&read_write_timeout=6',
                'host' => 'foo_host',
                'port' => 123,
                'user' => 'foo_user',
                'password' => 'foo_password',
                'vhost' => '/vhost',
            ]
        );

        /** @var AMQPConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPConnection::class, $instance);
        $this->assertEquals([
            'bar_host',  // host
            321,         // port
            'bar_user',  // user
            'bar_password', // password
            'whost',     // vhost
            false,       // insist
            "AMQPLAIN",  // login method
            null,        // login response
            "en_US",     // locale
            6,           // connection timeout
            6,           // read write timeout
            null,        // context
            true,        // keepalive
            0,           // heartbeat
        ], $instance->constructParams);
    }

    public function testSetConnectionParametersWithUrlEncoded()
    {
        $factory = new AMQPConnectionFactory(
            AMQPConnection::class,
            [
                'url' => 'amqp://user%61:%61pass@ho%61st:10000/v%2fhost?keepalive=1&connection_timeout=6&read_write_timeout=6',
            ]
        );

        /** @var AMQPConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPConnection::class, $instance);
        $this->assertEquals([
            'hoast',     // host
            10000,       // port
            'usera',     // user
            'apass',     // password
            'v/host',    // vhost
            false,       // insist
            "AMQPLAIN",  // login method
            null,        // login response
            "en_US",     // locale
            6,           // connection timeout
            6,           // read write timeout
            null,        // context
            true,        // keepalive
            0,           // heartbeat
        ], $instance->constructParams);
    }

    public function testSetConnectionParametersWithUrlWithoutVhost()
    {
        $factory = new AMQPConnectionFactory(
            AMQPConnection::class,
            [
                'url' => 'amqp://user:pass@host:321/?keepalive=1&connection_timeout=6&read_write_timeout=6',
            ]
        );

        /** @var AMQPConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPConnection::class, $instance);
        $this->assertEquals([
            'host',     // host
            321,        // port
            'user',     // user
            'pass',     // password
            '',         // vhost
            false,      // insist
            "AMQPLAIN", // login method
            null,       // login response
            "en_US",    // locale
            6,          // connection timeout
            6,          // read write timeout
            null,       // context
            true,       // keepalive
            0,          // heartbeat
        ], $instance->constructParams);
    }

    public function testSSLConnectionParameters()
    {
        $factory = new AMQPConnectionFactory(
            AMQPSSLConnection::class,
            [
                'host' => 'ssl_host',
                'port' => 123,
                'user' => 'ssl_user',
                'password' => 'ssl_password',
                'vhost' => '/ssl',
                'ssl_context' => [
                    'verify_peer' => false,
                ],
            ]
        );

        /** @var AMQPSSLConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPSSLConnection::class, $instance);
        $this->assertArrayHasKey(6, $instance->constructParams);
        $options = $instance->constructParams[6];
        $this->assertArrayHasKey('ssl_context', $options);
        $context = $options['ssl_context'];
        // unset to check whole array at once later
        $instance->constructParams[6]['ssl_context'] = null;
        $this->assertIsResource($context);
        $this->assertEquals('stream-context', get_resource_type($context));
        $options = stream_context_get_options($context);
        $this->assertEquals(['ssl' => ['verify_peer' => false]], $options);
        $this->assertEquals([
            'ssl_host',     // host
            123 ,            // port
            'ssl_user',     // user
            'ssl_password', // password
            '/ssl',         // vhost,
            [],             // ssl_options
            [               // options
                'url' => '',
                'host' => 'ssl_host',
                'port' => 123,
                'user' => 'ssl_user',
                'password' => 'ssl_password',
                'vhost' => '/ssl',
                'connection_timeout' => 3,
                'read_write_timeout' => 3,
                'ssl_context' => null, // context checked earlier
                'keepalive' => false,
                'heartbeat' => 0,
            ]
        ], $instance->constructParams);
    }

    public function testClusterConnectionParametersWithoutRootConnectionKeys()
    {
        $factory = new AMQPConnectionFactory(
            AMQPConnection::class,
            [
                'hosts' => [
                    [
                        'host' => 'cluster_host',
                        'port' => 123,
                        'user' => 'cluster_user',
                        'password' => 'cluster_password',
                        'vhost' => '/cluster_vhost',
                    ],
                    [
                        'url' => 'amqp://user:pass@host:321/vhost',
                    ]
                ]
            ]
        );

        /** @var AMQPConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPConnection::class, $instance);
        $this->assertEquals([
            'cluster_host',     // host
            123,                // port
            'cluster_user',     // user
            'cluster_password', // password
            '/cluster_vhost',   // vhost
            false,              // insist
            "AMQPLAIN",         // login method
            null,               // login response
            "en_US",            // locale
            3,                  // connection timeout
            3,                  // read write timeout
            null,               // context
            false,              // keepalive
            0,                  // heartbeat
        ], $instance->constructParams);

        $this->assertEquals(
            [
                [
                    [
                        'host' => 'cluster_host',
                        'port' => 123,
                        'user' => 'cluster_user',
                        'password' => 'cluster_password',
                        'vhost' => '/cluster_vhost',
                    ],
                    [
                        'host' => 'host',
                        'port' => 321,
                        'user' => 'user',
                        'password' => 'pass',
                        'vhost' => 'vhost',
                    ]
                ],
                [
                    'url'                => '',
                    'host'               => 'localhost',
                    'port'               => 5672,
                    'user'               => 'guest',
                    'password'           => 'guest',
                    'vhost'              => '/',
                    'connection_timeout' => 3,
                    'read_write_timeout' => 3,
                    'ssl_context'        => null,
                    'keepalive'          => false,
                    'heartbeat'          => 0
                ]
            ],
            $instance::$createConnectionParams
        );
    }

    public function testClusterConnectionParametersWithRootConnectionKeys()
    {
        $factory = new AMQPConnectionFactory(
            AMQPConnection::class,
            [
                'host' => 'host',
                'port' => 123,
                'user' => 'user',
                'password' => 'password',
                'vhost' => '/vhost',
                'hosts' => [
                    [
                        'host' => 'cluster_host',
                        'port' => 123,
                        'user' => 'cluster_user',
                        'password' => 'cluster_password',
                        'vhost' => '/vhost',
                    ],
                ]
            ]
        );

        /** @var AMQPConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPConnection::class, $instance);
        $this->assertEquals([
            'cluster_host',  // host
            123,         // port
            'cluster_user',  // user
            'cluster_password', // password
            '/vhost',    // vhost
            false,       // insist
            "AMQPLAIN",  // login method
            null,        // login response
            "en_US",     // locale
            3,           // connection timeout
            3,           // read write timeout
            null,        // context
            false,       // keepalive
            0,           // heartbeat
        ], $instance->constructParams);

        $this->assertEquals(
            [
                [
                    [
                        'host' => 'cluster_host',
                        'port' => 123,
                        'user' => 'cluster_user',
                        'password' => 'cluster_password',
                        'vhost' => '/vhost',
                    ]
                ],
                [
                    'url'                => '',
                    'host'               => 'host',
                    'port'               => 123,
                    'user'               => 'user',
                    'password'           => 'password',
                    'vhost'              => '/vhost',
                    'connection_timeout' => 3,
                    'read_write_timeout' => 3,
                    'ssl_context'        => null,
                    'keepalive'          => false,
                    'heartbeat'          => 0
                ]
            ],
            $instance::$createConnectionParams
        );
    }

    public function testSSLClusterConnectionParameters()
    {
        $factory = new AMQPConnectionFactory(
            AMQPSSLConnection::class,
            [
                'hosts' => [
                    [
                        'host' => 'ssl_cluster_host',
                        'port' => 123,
                        'user' => 'ssl_cluster_user',
                        'password' => 'ssl_cluster_password',
                        'vhost' => '/ssl_cluster_vhost',
                    ],
                    [
                        'url' => 'amqp://user:pass@host:321/vhost',
                    ]
                ],
                'ssl_context' => [
                    'verify_peer' => false,
                ],
            ]
        );

        /** @var AMQPSSLConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPSSLConnection::class, $instance);

        $this->assertArrayHasKey(6, $instance->constructParams);
        $options = $instance->constructParams[6];
        $this->assertArrayHasKey('ssl_context', $options);
        $context = $options['ssl_context'];
        // unset to check whole array at once later
        $instance->constructParams[6]['ssl_context'] = null;
        $this->assertIsResource($context);
        $this->assertEquals('stream-context', get_resource_type($context));
        $options = stream_context_get_options($context);
        $this->assertEquals(['ssl' => ['verify_peer' => false]], $options);

        $this->assertArrayHasKey(1, $instance::$createConnectionParams);
        $createConnectionOptions = $instance::$createConnectionParams[1];
        $this->assertArrayHasKey('ssl_context', $createConnectionOptions);
        $createConnectionContext = $createConnectionOptions['ssl_context'];
        // unset to check whole array at once later
        $instance::$createConnectionParams[1]['ssl_context'] = null;
        $this->assertIsResource($createConnectionContext);
        $this->assertEquals('stream-context', get_resource_type($createConnectionContext));
        $createConnectionOptions = stream_context_get_options($createConnectionContext);
        $this->assertEquals(['ssl' => ['verify_peer' => false]], $createConnectionOptions);

        $this->assertEquals([
            'ssl_cluster_host',     // host
            123 ,                   // port
            'ssl_cluster_user',     // user
            'ssl_cluster_password', // password
            '/ssl_cluster_vhost',   // vhost,
            [],                     // ssl_options
            [                       // options
                'url' => '',
                'host' => 'localhost',
                'port' => 5672,
                'user' => 'guest',
                'password' => 'guest',
                'vhost' => '/',
                'connection_timeout' => 3,
                'read_write_timeout' => 3,
                'ssl_context' => null,
                'keepalive' => false,
                'heartbeat' => 0,
            ]
        ], $instance->constructParams);

        $this->assertEquals(
            [
                [
                    [
                        'host' => 'ssl_cluster_host',
                        'port' => 123,
                        'user' => 'ssl_cluster_user',
                        'password' => 'ssl_cluster_password',
                        'vhost' => '/ssl_cluster_vhost',
                    ],
                    [
                        'host' => 'host',
                        'port' => 321,
                        'user' => 'user',
                        'password' => 'pass',
                        'vhost' => 'vhost',
                    ]
                ],
                [
                    'url'                => '',
                    'host'               => 'localhost',
                    'port'               => 5672,
                    'user'               => 'guest',
                    'password'           => 'guest',
                    'vhost'              => '/',
                    'connection_timeout' => 3,
                    'read_write_timeout' => 3,
                    'ssl_context'        => null, // context checked earlier
                    'keepalive'          => false,
                    'heartbeat'          => 0
                ]
            ],
            $instance::$createConnectionParams
        );
    }

    public function testSocketClusterConnectionParameters()
    {
        $factory = new AMQPConnectionFactory(
            AMQPSocketConnection::class,
            [
                'hosts' => [
                    [
                        'host' => 'cluster_host',
                        'port' => 123,
                        'user' => 'cluster_user',
                        'password' => 'cluster_password',
                        'vhost' => '/cluster_vhost',
                    ],
                    [
                        'url' => 'amqp://user:pass@host:321/vhost',
                    ]
                ]
            ]
        );

        /** @var AMQPSocketConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPSocketConnection::class, $instance);
        $this->assertEquals([
            'cluster_host',     // host
            123,                // port
            'cluster_user',     // user
            'cluster_password', // password
            '/cluster_vhost',   // vhost
            false,              // insist
            "AMQPLAIN",         // login method
            null,               // login response
            "en_US",            // locale
            3,                  // read_timeout
            false,              // keepalive
            3,                  // write_timeout
            0,                  // heartbeat
        ], $instance->constructParams);

        $this->assertEquals(
            [
                [
                    [
                        'host' => 'cluster_host',
                        'port' => 123,
                        'user' => 'cluster_user',
                        'password' => 'cluster_password',
                        'vhost' => '/cluster_vhost',
                    ],
                    [
                        'host' => 'host',
                        'port' => 321,
                        'user' => 'user',
                        'password' => 'pass',
                        'vhost' => 'vhost',
                    ]
                ],
                [
                    'url'                => '',
                    'host'               => 'localhost',
                    'port'               => 5672,
                    'user'               => 'guest',
                    'password'           => 'guest',
                    'vhost'              => '/',
                    'ssl_context'        => null,
                    'keepalive'          => false,
                    'heartbeat'          => 0,
                    'connection_timeout' => 3,
                    'read_write_timeout' => 3,
                    'read_timeout'       => 3,
                    'write_timeout'      => 3
                ]
            ],
            $instance::$createConnectionParams
        );
    }

    public function testConnectionsParametersProviderWithConstructorArgs()
    {
        $connectionParametersProvider = $this->prepareConnectionParametersProvider();
        $connectionParametersProvider->expects($this->once())
            ->method('getConnectionParameters')
            ->will($this->returnValue(
                [
                    'constructor_args' => [1,2,3,4]
                ]
            ));
        $factory = new AMQPConnectionFactory(
            AMQPConnection::class,
            [],
            $connectionParametersProvider
        );

        /** @var AMQPConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPConnection::class, $instance);
        $this->assertEquals([1,2,3,4], $instance->constructParams);
    }

    public function testConnectionsParametersProvider()
    {
        $connectionParametersProvider = $this->prepareConnectionParametersProvider();
        $connectionParametersProvider->expects($this->once())
            ->method('getConnectionParameters')
            ->will($this->returnValue(
                [
                    'host' => '1.2.3.4',
                    'port' => 5678,
                    'user' => 'admin',
                    'password' => 'admin',
                    'vhost' => 'foo',
                ]
            ));
        $factory = new AMQPConnectionFactory(
            AMQPConnection::class,
            [],
            $connectionParametersProvider
        );

        /** @var AMQPConnection $instance */
        $instance = $factory->createConnection();
        $this->assertInstanceOf(AMQPConnection::class, $instance);
        $this->assertEquals([
            '1.2.3.4',   // host
            5678,        // port
            'admin',     // user
            'admin',     // password
            'foo',       // vhost
            false,       // insist
            "AMQPLAIN",  // login method
            null,        // login response
            "en_US",     // locale
            3,           // connection timeout
            3,           // read write timeout
            null,        // context
            false,       // keepalive
            0,           // heartbeat
        ], $instance->constructParams);
    }

    /**
     * Preparing ConnectionParametersProviderInterface instance
     *
     * @return ConnectionParametersProviderInterface|MockObject
     */
    private function prepareConnectionParametersProvider()
    {
        return $this->getMockBuilder(ConnectionParametersProviderInterface::class)
            ->getMock();
    }
}


1			<?php
2
3			namespace OldSound\RabbitMqBundle\Tests\RabbitMq;
4
5			use OldSound\RabbitMqBundle\Provider\ConnectionParametersProviderInterface;
6			use OldSound\RabbitMqBundle\RabbitMq\AMQPConnectionFactory;
7			use OldSound\RabbitMqBundle\Tests\RabbitMq\Fixtures\AMQPConnection;
8			use OldSound\RabbitMqBundle\Tests\RabbitMq\Fixtures\AMQPSocketConnection;
9			use OldSound\RabbitMqBundle\Tests\RabbitMq\Fixtures\AMQPSSLConnection;
10			use PHPUnit\Framework\MockObject\MockObject;
11			use PHPUnit\Framework\TestCase;
12
13			class AMQPConnectionFactoryTest extends TestCase
14			{
15			public function testDefaultValues()
16			{
17			$factory = new AMQPConnectionFactory(
18			AMQPConnection::class,
19			[]
20			);
21
22			/** @var AMQPConnection $instance */
23			$instance = $factory->createConnection();
24			$this->assertInstanceOf(AMQPConnection::class, $instance);
25			$this->assertEquals([
26			'localhost', // host
27			5672, // port
28			'guest', // user
29			'guest', // password
30			'/', // vhost
31			false, // insist
32			"AMQPLAIN", // login method
33			null, // login response
34			"en_US", // locale
35			3, // connection timeout
36			3, // read write timeout
37			null, // context
38			false, // keepalive
39			0, // heartbeat
40			], $instance->constructParams);
41			}
42
43			public function testSocketConnection()
44			{
45			$factory = new AMQPConnectionFactory(
46			AMQPSocketConnection::class,
47			[]
48			);
49
50			/** @var AMQPSocketConnection $instance */
51			$instance = $factory->createConnection();
52			$this->assertInstanceOf(AMQPSocketConnection::class, $instance);
53			$this->assertEquals([
54			'localhost', // host
55			5672, // port
56			'guest', // user
57			'guest', // password
58			'/', // vhost
59			false, // insist
60			"AMQPLAIN", // login method
61			null, // login response
62			"en_US", // locale
63			3, // read_timeout
64			false, // keepalive
65			3, // write_timeout
66			0, // heartbeat
67			], $instance->constructParams);
68			}
69
70			public function testSocketConnectionWithParams()
71			{
72			$factory = new AMQPConnectionFactory(
73			AMQPSocketConnection::class,
74			[
75			'read_timeout' => 31,
76			'write_timeout' => 32,
77			]
78			);
79
80			/** @var AMQPSocketConnection $instance */
81			$instance = $factory->createConnection();
82			$this->assertInstanceOf(AMQPSocketConnection::class, $instance);
83			$this->assertEquals([
84			'localhost', // host
85			5672, // port
86			'guest', // user
87			'guest', // password
88			'/', // vhost
89			false, // insist
90			"AMQPLAIN", // login method
91			null, // login response
92			"en_US", // locale
93			31, // read_timeout
94			false, // keepalive
95			32, // write_timeout
96			0, // heartbeat
97			], $instance->constructParams);
98			}
99
100			public function testStandardConnectionParameters()
101			{
102			$factory = new AMQPConnectionFactory(
103			AMQPConnection::class,
104			[
105			'host' => 'foo_host',
106			'port' => 123,
107			'user' => 'foo_user',
108			'password' => 'foo_password',
109			'vhost' => '/vhost',
110			]
111			);
112
113			/** @var AMQPConnection $instance */
114			$instance = $factory->createConnection();
115			$this->assertInstanceOf(AMQPConnection::class, $instance);
116			$this->assertEquals([
117			'foo_host', // host
118			123, // port
119			'foo_user', // user
120			'foo_password', // password
121			'/vhost', // vhost
122			false, // insist
123			"AMQPLAIN", // login method
124			null, // login response
125			"en_US", // locale
126			3, // connection timeout
127			3, // read write timeout
128			null, // context
129			false, // keepalive
130			0, // heartbeat
131			], $instance->constructParams);
132			}
133
134			public function testSetConnectionParametersWithUrl()
135			{
136			$factory = new AMQPConnectionFactory(
137			AMQPConnection::class,
138			[
139			'url' => 'amqp://bar_user:bar_password@bar_host:321/whost?keepalive=1&connection_timeout=6&read_write_timeout=6',
140			'host' => 'foo_host',
141			'port' => 123,
142			'user' => 'foo_user',
143			'password' => 'foo_password',
144			'vhost' => '/vhost',
145			]
146			);
147
148			/** @var AMQPConnection $instance */
149			$instance = $factory->createConnection();
150			$this->assertInstanceOf(AMQPConnection::class, $instance);
151			$this->assertEquals([
152			'bar_host', // host
153			321, // port
154			'bar_user', // user
155			'bar_password', // password
156			'whost', // vhost
157			false, // insist
158			"AMQPLAIN", // login method
159			null, // login response
160			"en_US", // locale
161			6, // connection timeout
162			6, // read write timeout
163			null, // context
164			true, // keepalive
165			0, // heartbeat
166			], $instance->constructParams);
167			}
168
169			public function testSetConnectionParametersWithUrlEncoded()
170			{
171			$factory = new AMQPConnectionFactory(
172			AMQPConnection::class,
173			[
174			'url' => 'amqp://user%61:%61pass@ho%61st:10000/v%2fhost?keepalive=1&connection_timeout=6&read_write_timeout=6',
175			]
176			);
177
178			/** @var AMQPConnection $instance */
179			$instance = $factory->createConnection();
180			$this->assertInstanceOf(AMQPConnection::class, $instance);
181			$this->assertEquals([
182			'hoast', // host
183			10000, // port
184			'usera', // user
185			'apass', // password
186			'v/host', // vhost
187			false, // insist
188			"AMQPLAIN", // login method
189			null, // login response
190			"en_US", // locale
191			6, // connection timeout
192			6, // read write timeout
193			null, // context
194			true, // keepalive
195			0, // heartbeat
196			], $instance->constructParams);
197			}
198
199			public function testSetConnectionParametersWithUrlWithoutVhost()
200			{
201			$factory = new AMQPConnectionFactory(
202			AMQPConnection::class,
203			[
204			'url' => 'amqp://user:pass@host:321/?keepalive=1&connection_timeout=6&read_write_timeout=6',
205			]
206			);
207
208			/** @var AMQPConnection $instance */
209			$instance = $factory->createConnection();
210			$this->assertInstanceOf(AMQPConnection::class, $instance);
211			$this->assertEquals([
212			'host', // host
213			321, // port
214			'user', // user
215			'pass', // password
216			'', // vhost
217			false, // insist
218			"AMQPLAIN", // login method
219			null, // login response
220			"en_US", // locale
221			6, // connection timeout
222			6, // read write timeout
223			null, // context
224			true, // keepalive
225			0, // heartbeat
226			], $instance->constructParams);
227			}
228
229			public function testSSLConnectionParameters()
230			{
231			$factory = new AMQPConnectionFactory(
232			AMQPSSLConnection::class,
233			[
234			'host' => 'ssl_host',
235			'port' => 123,
236			'user' => 'ssl_user',
237			'password' => 'ssl_password',
238			'vhost' => '/ssl',
239			'ssl_context' => [
240			'verify_peer' => false,
241			],
242			]
243			);
244
245			/** @var AMQPSSLConnection $instance */
246			$instance = $factory->createConnection();
247			$this->assertInstanceOf(AMQPSSLConnection::class, $instance);
248			$this->assertArrayHasKey(6, $instance->constructParams);
249			$options = $instance->constructParams[6];
250			$this->assertArrayHasKey('ssl_context', $options);
251			$context = $options['ssl_context'];
252			// unset to check whole array at once later
253			$instance->constructParams[6]['ssl_context'] = null;
254			$this->assertIsResource($context);
255			$this->assertEquals('stream-context', get_resource_type($context));
256			$options = stream_context_get_options($context);
257			$this->assertEquals(['ssl' => ['verify_peer' => false]], $options);
258			$this->assertEquals([
259			'ssl_host', // host
260			123 , // port
261			'ssl_user', // user
262			'ssl_password', // password
263			'/ssl', // vhost,
264			[], // ssl_options
265			[ // options
266			'url' => '',
267			'host' => 'ssl_host',
268			'port' => 123,
269			'user' => 'ssl_user',
270			'password' => 'ssl_password',
271			'vhost' => '/ssl',
272			'connection_timeout' => 3,
273			'read_write_timeout' => 3,
274			'ssl_context' => null, // context checked earlier
275			'keepalive' => false,
276			'heartbeat' => 0,
277			]
278			], $instance->constructParams);
279			}
280
281			public function testClusterConnectionParametersWithoutRootConnectionKeys()
282			{
283			$factory = new AMQPConnectionFactory(
284			AMQPConnection::class,
285			[
286			'hosts' => [
287			[
288			'host' => 'cluster_host',
289			'port' => 123,
290			'user' => 'cluster_user',
291			'password' => 'cluster_password',
292			'vhost' => '/cluster_vhost',
293			],
294			[
295			'url' => 'amqp://user:pass@host:321/vhost',
296			]
297			]
298			]
299			);
300
301			/** @var AMQPConnection $instance */
302			$instance = $factory->createConnection();
303			$this->assertInstanceOf(AMQPConnection::class, $instance);
304			$this->assertEquals([
305			'cluster_host', // host
306			123, // port
307			'cluster_user', // user
308			'cluster_password', // password
309			'/cluster_vhost', // vhost
310			false, // insist
311			"AMQPLAIN", // login method
312			null, // login response
313			"en_US", // locale
314			3, // connection timeout
315			3, // read write timeout
316			null, // context
317			false, // keepalive
318			0, // heartbeat
319			], $instance->constructParams);
320
321			$this->assertEquals(
322			[
323			[
324			[
325			'host' => 'cluster_host',
326			'port' => 123,
327			'user' => 'cluster_user',
328			'password' => 'cluster_password',
329			'vhost' => '/cluster_vhost',
330			],
331			[
332			'host' => 'host',
333			'port' => 321,
334			'user' => 'user',
335			'password' => 'pass',
336			'vhost' => 'vhost',
337			]
338			],
339			[
340			'url' => '',
341			'host' => 'localhost',
342			'port' => 5672,
343			'user' => 'guest',
344			'password' => 'guest',
345			'vhost' => '/',
346			'connection_timeout' => 3,
347			'read_write_timeout' => 3,
348			'ssl_context' => null,
349			'keepalive' => false,
350			'heartbeat' => 0
351			]
352			],
353			$instance::$createConnectionParams
354			);
355			}
356
357			public function testClusterConnectionParametersWithRootConnectionKeys()
358			{
359			$factory = new AMQPConnectionFactory(
360			AMQPConnection::class,
361			[
362			'host' => 'host',
363			'port' => 123,
364			'user' => 'user',
365			'password' => 'password',
366			'vhost' => '/vhost',
367			'hosts' => [
368			[
369			'host' => 'cluster_host',
370			'port' => 123,
371			'user' => 'cluster_user',
372			'password' => 'cluster_password',
373			'vhost' => '/vhost',
374			],
375			]
376			]
377			);
378
379			/** @var AMQPConnection $instance */
380			$instance = $factory->createConnection();
381			$this->assertInstanceOf(AMQPConnection::class, $instance);
382			$this->assertEquals([
383			'cluster_host', // host
384			123, // port
385			'cluster_user', // user
386			'cluster_password', // password
387			'/vhost', // vhost
388			false, // insist
389			"AMQPLAIN", // login method
390			null, // login response
391			"en_US", // locale
392			3, // connection timeout
393			3, // read write timeout
394			null, // context
395			false, // keepalive
396			0, // heartbeat
397			], $instance->constructParams);
398
399			$this->assertEquals(
400			[
401			[
402			[
403			'host' => 'cluster_host',
404			'port' => 123,
405			'user' => 'cluster_user',
406			'password' => 'cluster_password',
407			'vhost' => '/vhost',
408			]
409			],
410			[
411			'url' => '',
412			'host' => 'host',
413			'port' => 123,
414			'user' => 'user',
415			'password' => 'password',
416			'vhost' => '/vhost',
417			'connection_timeout' => 3,
418			'read_write_timeout' => 3,
419			'ssl_context' => null,
420			'keepalive' => false,
421			'heartbeat' => 0
422			]
423			],
424			$instance::$createConnectionParams
425			);
426			}
427
428			public function testSSLClusterConnectionParameters()
429			{
430			$factory = new AMQPConnectionFactory(
431			AMQPSSLConnection::class,
432			[
433			'hosts' => [
434			[
435			'host' => 'ssl_cluster_host',
436			'port' => 123,
437			'user' => 'ssl_cluster_user',
438			'password' => 'ssl_cluster_password',
439			'vhost' => '/ssl_cluster_vhost',
440			],
441			[
442			'url' => 'amqp://user:pass@host:321/vhost',
443			]
444			],
445			'ssl_context' => [
446			'verify_peer' => false,
447			],
448			]
449			);
450
451			/** @var AMQPSSLConnection $instance */
452			$instance = $factory->createConnection();
453			$this->assertInstanceOf(AMQPSSLConnection::class, $instance);
454
455			$this->assertArrayHasKey(6, $instance->constructParams);
456			$options = $instance->constructParams[6];
457			$this->assertArrayHasKey('ssl_context', $options);
458			$context = $options['ssl_context'];
459			// unset to check whole array at once later
460			$instance->constructParams[6]['ssl_context'] = null;
461			$this->assertIsResource($context);
462			$this->assertEquals('stream-context', get_resource_type($context));
463			$options = stream_context_get_options($context);
464			$this->assertEquals(['ssl' => ['verify_peer' => false]], $options);
465
466			$this->assertArrayHasKey(1, $instance::$createConnectionParams);
467			$createConnectionOptions = $instance::$createConnectionParams[1];
468			$this->assertArrayHasKey('ssl_context', $createConnectionOptions);
469			$createConnectionContext = $createConnectionOptions['ssl_context'];
470			// unset to check whole array at once later
471			$instance::$createConnectionParams[1]['ssl_context'] = null;
472			$this->assertIsResource($createConnectionContext);
473			$this->assertEquals('stream-context', get_resource_type($createConnectionContext));
474			$createConnectionOptions = stream_context_get_options($createConnectionContext);
475			$this->assertEquals(['ssl' => ['verify_peer' => false]], $createConnectionOptions);
476
477			$this->assertEquals([
478			'ssl_cluster_host', // host
479			123 , // port
480			'ssl_cluster_user', // user
481			'ssl_cluster_password', // password
482			'/ssl_cluster_vhost', // vhost,
483			[], // ssl_options
484			[ // options
485			'url' => '',
486			'host' => 'localhost',
487			'port' => 5672,
488			'user' => 'guest',
489			'password' => 'guest',
490			'vhost' => '/',
491			'connection_timeout' => 3,
492			'read_write_timeout' => 3,
493			'ssl_context' => null,
494			'keepalive' => false,
495			'heartbeat' => 0,
496			]
497			], $instance->constructParams);
498
499			$this->assertEquals(
500			[
501			[
502			[
503			'host' => 'ssl_cluster_host',
504			'port' => 123,
505			'user' => 'ssl_cluster_user',
506			'password' => 'ssl_cluster_password',
507			'vhost' => '/ssl_cluster_vhost',
508			],
509			[
510			'host' => 'host',
511			'port' => 321,
512			'user' => 'user',
513			'password' => 'pass',
514			'vhost' => 'vhost',
515			]
516			],
517			[
518			'url' => '',
519			'host' => 'localhost',
520			'port' => 5672,
521			'user' => 'guest',
522			'password' => 'guest',
523			'vhost' => '/',
524			'connection_timeout' => 3,
525			'read_write_timeout' => 3,
526			'ssl_context' => null, // context checked earlier
527			'keepalive' => false,
528			'heartbeat' => 0
529			]
530			],
531			$instance::$createConnectionParams
532			);
533			}
534
535			public function testSocketClusterConnectionParameters()
536			{
537			$factory = new AMQPConnectionFactory(
538			AMQPSocketConnection::class,
539			[
540			'hosts' => [
541			[
542			'host' => 'cluster_host',
543			'port' => 123,
544			'user' => 'cluster_user',
545			'password' => 'cluster_password',
546			'vhost' => '/cluster_vhost',
547			],
548			[
549			'url' => 'amqp://user:pass@host:321/vhost',
550			]
551			]
552			]
553			);
554
555			/** @var AMQPSocketConnection $instance */
556			$instance = $factory->createConnection();
557			$this->assertInstanceOf(AMQPSocketConnection::class, $instance);
558			$this->assertEquals([
559			'cluster_host', // host
560			123, // port
561			'cluster_user', // user
562			'cluster_password', // password
563			'/cluster_vhost', // vhost
564			false, // insist
565			"AMQPLAIN", // login method
566			null, // login response
567			"en_US", // locale
568			3, // read_timeout
569			false, // keepalive
570			3, // write_timeout
571			0, // heartbeat
572			], $instance->constructParams);
573
574			$this->assertEquals(
575			[
576			[
577			[
578			'host' => 'cluster_host',
579			'port' => 123,
580			'user' => 'cluster_user',
581			'password' => 'cluster_password',
582			'vhost' => '/cluster_vhost',
583			],
584			[
585			'host' => 'host',
586			'port' => 321,
587			'user' => 'user',
588			'password' => 'pass',
589			'vhost' => 'vhost',
590			]
591			],
592			[
593			'url' => '',
594			'host' => 'localhost',
595			'port' => 5672,
596			'user' => 'guest',
597			'password' => 'guest',
598			'vhost' => '/',
599			'ssl_context' => null,
600			'keepalive' => false,
601			'heartbeat' => 0,
602			'connection_timeout' => 3,
603			'read_write_timeout' => 3,
604			'read_timeout' => 3,
605			'write_timeout' => 3
606			]
607			],
608			$instance::$createConnectionParams
609			);
610			}
611
612			public function testConnectionsParametersProviderWithConstructorArgs()
613			{
614			$connectionParametersProvider = $this->prepareConnectionParametersProvider();
615			$connectionParametersProvider->expects($this->once())
616			->method('getConnectionParameters')
617			->will($this->returnValue(
618			[
619			'constructor_args' => [1,2,3,4]
620			]
621			));
622			$factory = new AMQPConnectionFactory(
623			AMQPConnection::class,
624			[],
625			$connectionParametersProvider
626			);
627
628			/** @var AMQPConnection $instance */
629			$instance = $factory->createConnection();
630			$this->assertInstanceOf(AMQPConnection::class, $instance);
631			$this->assertEquals([1,2,3,4], $instance->constructParams);
632			}
633
634			public function testConnectionsParametersProvider()
635			{
636			$connectionParametersProvider = $this->prepareConnectionParametersProvider();
637			$connectionParametersProvider->expects($this->once())
638			->method('getConnectionParameters')
639			->will($this->returnValue(
640			[
641			'host' => '1.2.3.4',
642			'port' => 5678,
643			'user' => 'admin',
644			'password' => 'admin',
645			'vhost' => 'foo',
646			]
647			));
648			$factory = new AMQPConnectionFactory(
649			AMQPConnection::class,
650			[],
651			$connectionParametersProvider
652			);
653
654			/** @var AMQPConnection $instance */
655			$instance = $factory->createConnection();
656			$this->assertInstanceOf(AMQPConnection::class, $instance);
657			$this->assertEquals([
658			'1.2.3.4', // host
659			5678, // port
660			'admin', // user
661			'admin', // password
662			'foo', // vhost
663			false, // insist
664			"AMQPLAIN", // login method
665			null, // login response
666			"en_US", // locale
667			3, // connection timeout
668			3, // read write timeout
669			null, // context
670			false, // keepalive
671			0, // heartbeat
672			], $instance->constructParams);
673			}
674
675			/**
676			* Preparing ConnectionParametersProviderInterface instance
677			*
678			* @return ConnectionParametersProviderInterface\|MockObject
679			*/
680			private function prepareConnectionParametersProvider()
681			{
682			return $this->getMockBuilder(ConnectionParametersProviderInterface::class)
683			->getMock();
684			}
685			}
686

php-amqplib / RabbitMqBundle

Push — master ( ece95b...9e5e0a )

testClusterConnectionParametersWithRootConnectionKeys() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like