Subversion Repositories SmartDukaan

<?php
/**
 * SocketTest file
 *
 * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice
 *
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 * @link          http://book.cakephp.org/2.0/en/development/testing.html CakePHP(tm) Tests
 * @package       Cake.Test.Case.Network
 * @since         CakePHP(tm) v 1.2.0.4206
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */

App::uses('CakeSocket', 'Network');

/**
 * SocketTest class
 *
 * @package       Cake.Test.Case.Network
 */
class CakeSocketTest extends CakeTestCase {

/**
 * setUp method
 *
 * @return void
 */
        public function setUp() {
                parent::setUp();
                $this->Socket = new CakeSocket(array('timeout' => 1));
        }

/**
 * tearDown method
 *
 * @return void
 */
        public function tearDown() {
                parent::tearDown();
                unset($this->Socket);
        }

/**
 * testConstruct method
 *
 * @return void
 */
        public function testConstruct() {
                $this->Socket = new CakeSocket();
                $config = $this->Socket->config;
                $this->assertSame($config, array(
                        'persistent'    => false,
                        'host'                  => 'localhost',
                        'protocol'              => getprotobyname('tcp'),
                        'port'                  => 80,
                        'timeout'               => 30
                ));

                $this->Socket->reset();
                $this->Socket->__construct(array('host' => 'foo-bar'));
                $config['host'] = 'foo-bar';
                $this->assertSame($this->Socket->config, $config);

                $this->Socket = new CakeSocket(array('host' => 'www.cakephp.org', 'port' => 23, 'protocol' => 'udp'));
                $config = $this->Socket->config;

                $config['host'] = 'www.cakephp.org';
                $config['port'] = 23;
                $config['protocol'] = 17;

                $this->assertSame($this->Socket->config, $config);
        }

/**
 * testSocketConnection method
 *
 * @return void
 */
        public function testSocketConnection() {
                $this->assertFalse($this->Socket->connected);
                $this->Socket->disconnect();
                $this->assertFalse($this->Socket->connected);
                try {
                        $this->Socket->connect();
                        $this->assertTrue($this->Socket->connected);
                        $this->Socket->connect();
                        $this->assertTrue($this->Socket->connected);

                        $this->Socket->disconnect();
                        $config = array('persistent' => true);
                        $this->Socket = new CakeSocket($config);
                        $this->Socket->connect();
                        $this->assertTrue($this->Socket->connected);
                } catch (SocketException $e) {
                        $this->markTestSkipped('Cannot test network, skipping.');
                }
        }

/**
 * data provider function for testInvalidConnection
 *
 * @return array
 */
        public static function invalidConnections() {
                return array(
                        array(array('host' => 'invalid.host', 'port' => 9999, 'timeout' => 1)),
                        array(array('host' => '127.0.0.1', 'port' => '70000', 'timeout' => 1))
                );
        }

/**
 * testInvalidConnection method
 *
 * @dataProvider invalidConnections
 * @expectedException SocketException
 * @return void
 */
        public function testInvalidConnection($data) {
                $this->Socket->config = array_merge($this->Socket->config, $data);
                $this->Socket->connect();
        }

/**
 * testSocketHost method
 *
 * @return void
 */
        public function testSocketHost() {
                try {
                        $this->Socket = new CakeSocket();
                        $this->Socket->connect();
                        $this->assertEquals('127.0.0.1', $this->Socket->address());
                        $this->assertEquals(gethostbyaddr('127.0.0.1'), $this->Socket->host());
                        $this->assertEquals(null, $this->Socket->lastError());
                        $this->assertTrue(in_array('127.0.0.1', $this->Socket->addresses()));

                        $this->Socket = new CakeSocket(array('host' => '127.0.0.1'));
                        $this->Socket->connect();
                        $this->assertEquals('127.0.0.1', $this->Socket->address());
                        $this->assertEquals(gethostbyaddr('127.0.0.1'), $this->Socket->host());
                        $this->assertEquals(null, $this->Socket->lastError());
                        $this->assertTrue(in_array('127.0.0.1', $this->Socket->addresses()));
                } catch (SocketException $e) {
                        $this->markTestSkipped('Cannot test network, skipping.');
                }
        }

/**
 * testSocketWriting method
 *
 * @return void
 */
        public function testSocketWriting() {
                try {
                        $request = "GET / HTTP/1.1\r\nConnection: close\r\n\r\n";
                        $this->assertTrue((bool)$this->Socket->write($request));
                } catch (SocketException $e) {
                        $this->markTestSkipped('Cannot test network, skipping.');
                }
        }

/**
 * testSocketReading method
 *
 * @return void
 */
        public function testSocketReading() {
                $this->Socket = new CakeSocket(array('timeout' => 5));
                try {
                        $this->Socket->connect();
                        $this->assertEquals(null, $this->Socket->read(26));

                        $config = array('host' => 'google.com', 'port' => 80, 'timeout' => 1);
                        $this->Socket = new CakeSocket($config);
                        $this->assertTrue($this->Socket->connect());
                        $this->assertEquals(null, $this->Socket->read(26));
                        $this->assertEquals('2: ' . __d('cake_dev', 'Connection timed out'), $this->Socket->lastError());
                } catch (SocketException $e) {
                        $this->markTestSkipped('Cannot test network, skipping.');
                }
        }

/**
 * testTimeOutConnection method
 *
 * @return void
 */
        public function testTimeOutConnection() {
                $config = array('host' => '127.0.0.1', 'timeout' => 0.5);
                $this->Socket = new CakeSocket($config);
                try {
                        $this->assertTrue($this->Socket->connect());

                        $config = array('host' => '127.0.0.1', 'timeout' => 0.00001);
                        $this->Socket = new CakeSocket($config);
                        $this->assertFalse($this->Socket->read(1024 * 1024));
                        $this->assertEquals('2: ' . __d('cake_dev', 'Connection timed out'), $this->Socket->lastError());
                } catch (SocketException $e) {
                        $this->markTestSkipped('Cannot test network, skipping.');
                }
        }

/**
 * testLastError method
 *
 * @return void
 */
        public function testLastError() {
                $this->Socket = new CakeSocket();
                $this->Socket->setLastError(4, 'some error here');
                $this->assertEquals('4: some error here', $this->Socket->lastError());
        }

/**
 * testReset method
 *
 * @return void
 */
        public function testReset() {
                $config = array(
                        'persistent' => true,
                        'host' => '127.0.0.1',
                        'protocol' => 'udp',
                        'port' => 80,
                        'timeout' => 20
                );
                $anotherSocket = new CakeSocket($config);
                $anotherSocket->reset();
                $this->assertEquals(array(), $anotherSocket->config);
        }

/**
 * testEncrypt
 *
 * @expectedException SocketException
 * @return void
 */
        public function testEnableCryptoSocketExceptionNoSsl() {
                $this->skipIf(!extension_loaded('openssl'), 'OpenSSL is not enabled cannot test SSL.');
                $configNoSslOrTls = array('host' => 'localhost', 'port' => 80, 'timeout' => 0.1);

                // testing exception on no ssl socket server for ssl and tls methods
                $this->Socket = new CakeSocket($configNoSslOrTls);
                $this->Socket->connect();
                $this->Socket->enableCrypto('sslv3', 'client');
        }

/**
 * testEnableCryptoSocketExceptionNoTls
 *
 * @expectedException SocketException
 * @return void
 */
        public function testEnableCryptoSocketExceptionNoTls() {
                $configNoSslOrTls = array('host' => 'localhost', 'port' => 80, 'timeout' => 0.1);

                // testing exception on no ssl socket server for ssl and tls methods
                $this->Socket = new CakeSocket($configNoSslOrTls);
                $this->Socket->connect();
                $this->Socket->enableCrypto('tls', 'client');
        }

/**
 * _connectSocketToSslTls
 *
 * @return void
 */
        protected function _connectSocketToSslTls() {
                $this->skipIf(!extension_loaded('openssl'), 'OpenSSL is not enabled cannot test SSL.');
                $configSslTls = array('host' => 'smtp.gmail.com', 'port' => 465, 'timeout' => 5);
                $this->Socket = new CakeSocket($configSslTls);
                try {
                        $this->Socket->connect();
                } catch (SocketException $e) {
                        $this->markTestSkipped('Cannot test network, skipping.');
                }
        }

/**
 * testEnableCryptoBadMode
 *
 * @expectedException InvalidArgumentException
 * @return void
 */
        public function testEnableCryptoBadMode() {
                // testing wrong encryption mode
                $this->_connectSocketToSslTls();
                $this->Socket->enableCrypto('doesntExistMode', 'server');
                $this->Socket->disconnect();
        }

/**
 * testEnableCrypto
 *
 * @return void
 */
        public function testEnableCrypto() {
                // testing on ssl server
                $this->_connectSocketToSslTls();
                $this->assertTrue($this->Socket->enableCrypto('sslv3', 'client'));
                $this->Socket->disconnect();

                // testing on tls server
                $this->_connectSocketToSslTls();
                $this->assertTrue($this->Socket->enableCrypto('tls', 'client'));
                $this->Socket->disconnect();
        }

/**
 * testEnableCryptoExceptionEnableTwice
 *
 * @expectedException SocketException
 * @return void
 */
        public function testEnableCryptoExceptionEnableTwice() {
                // testing on tls server
                $this->_connectSocketToSslTls();
                $this->Socket->enableCrypto('tls', 'client');
                $this->Socket->enableCrypto('tls', 'client');
        }

/**
 * testEnableCryptoExceptionDisableTwice
 *
 * @expectedException SocketException
 * @return void
 */
        public function testEnableCryptoExceptionDisableTwice() {
                // testing on tls server
                $this->_connectSocketToSslTls();
                $this->Socket->enableCrypto('tls', 'client', false);
        }

/**
 * testEnableCryptoEnableStatus
 *
 * @return void
 */
        public function testEnableCryptoEnableStatus() {
                // testing on tls server
                $this->_connectSocketToSslTls();
                $this->assertFalse($this->Socket->encrypted);
                $this->Socket->enableCrypto('tls', 'client', true);
                $this->assertTrue($this->Socket->encrypted);
        }

/**
 * test getting the context for a socket.
 *
 * @return void
 */
        public function testGetContext() {
                $this->skipIf(!extension_loaded('openssl'), 'OpenSSL is not enabled cannot test SSL.');
                $config = array(
                        'host' => 'smtp.gmail.com',
                        'port' => 465,
                        'timeout' => 5,
                        'context' => array(
                                'ssl' => array('capture_peer' => true)
                        )
                );
                $this->Socket = new CakeSocket($config);
                $this->Socket->connect();
                $result = $this->Socket->context();
                $this->assertEquals($config['context'], $result);
        }

}