AMQPConnectionFactoryTest::testSocketConnection() - Code Metrics - php-amqplib/RabbitMqBundle - Measure and Improve Code Quality continuously with Scrutinizer

AMQPConnectionFactoryTest::testSocketConnection() A
last analyzed 2025-01-08 09:32 UTC

↳ Parent: AMQPConnectionFactoryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	26
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	17
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	26
rs	9.7

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

php-amqplib / RabbitMqBundle

AMQPConnectionFactoryTest::testSocketConnection() A last analyzed 2025-01-08 09:32 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

AMQPConnectionFactoryTest::testSocketConnection() A
last analyzed 2025-01-08 09:32 UTC