<?php
/**
 * SocketTest file
 *
 * PHP 5
 *
 * 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);
	}

}
