cakephp-tools/tests/TestCase/Model/Table/TableTest.php

<?php

namespace Tools\Model\Table;

use Cake\Auth\DefaultPasswordHasher;
use Cake\Auth\PasswordHasherFactory;
use Cake\Core\Configure;
use Cake\Datasource\ConnectionManager;
use Cake\I18n\Time;
use Cake\Network\Request;
use Cake\ORM\Behavior;
use Cake\ORM\Entity;
use Cake\ORM\Query;
use Cake\ORM\Table;
use Cake\ORM\TableRegistry;
use Cake\Routing\Router;
use Cake\Utility\Security;
use Tools\TestSuite\TestCase;

class TableTest extends TestCase {

	/**
	 * @var array
	 */
	public $fixtures = [
		'core.posts', 'core.authors',
		'plugin.tools.tools_users', 'plugin.tools.roles',
	];

	/**
	 * @var \Tools\Model\Table\Table;
	 */
	public $Users;

	/**
	 * SetUp method
	 *
	 * @return void
	 */
	public function setUp() {
		parent::setUp();

		Configure::write('App.namespace', 'TestApp');

		$this->Users = TableRegistry::get('ToolsUsers');

		$this->Posts = TableRegistry::get('Posts');
		$this->Posts->belongsTo('Authors');
	}

	public function tearDown() {
		TableRegistry::clear();

		parent::tearDown();
	}

	/**
	 * Test truncate
	 *
	 * @return void
	 */
	public function testTruncate() {
		$is = $this->Users->find('count');
		$this->assertEquals(4, $is);

		$config = ConnectionManager::config('test');
		if ((strpos($config['driver'], 'Mysql') !== false)) {
			$is = $this->Users->getNextAutoIncrement();
			$this->assertEquals(5, $is);
		}

		$is = $this->Users->truncate();
		$is = $this->Users->find('count');
		$this->assertEquals(0, $is);

		if ((strpos($config['driver'], 'Mysql') !== false)) {
			$is = $this->Users->getNextAutoIncrement();
			$this->assertEquals(1, $is);
		}
	}

	/**
	 * TableTest::testTimestamp()
	 *
	 * @return void
	 */
	public function testTimestamp() {
		$this->Roles = TableRegistry::get('Roles');
		$entity = $this->Roles->newEntity(['name' => 'Foo', 'alias' => 'foo']);
		$result = $this->Roles->save($entity);
		$this->assertTrue(!empty($result['created']));
		$this->assertTrue(!empty($result['modified']));
	}

	/**
	 * Check shims
	 *
	 * @return void
	 */
	public function testFindFirst() {
		$result = $this->Users->find('first', ['conditions' => ['name LIKE' => 'User %']]);
		$this->assertEquals('User 1', $result['name']);

		$result = $this->Users->find('first', ['conditions' => ['name NOT LIKE' => 'User %']]);
		$this->assertNotEquals('User 1', $result['name']);
	}

	/**
	 * Check shims
	 *
	 * @return void
	 */
	public function testFindCount() {
		$result = $this->Users->find('count');
		$this->assertEquals(4, $result);

		$result = $this->Users->find('count', ['conditions' => ['name' => 'User 1']]);
		$this->assertEquals(1, $result);
	}

	/**
	 * TableTest::testField()
	 *
	 * @return void
	 */
	public function testField() {
		$result = $this->Users->field('name', ['conditions' => ['name' => 'User 1']]);
		$this->assertEquals('User 1', $result);

		$result = $this->Users->field('name', ['conditions' => ['name' => 'User xxx']]);
		$this->assertNull($result);
	}

	/**
	 * TableTest::testField()
	 *
	 * @return void
	 */
	public function testFieldByConditions() {
		$result = $this->Users->fieldByConditions('name', ['name' => 'User 1']);
		$this->assertEquals('User 1', $result);

		$result = $this->Users->fieldByConditions('name', ['name' => 'User xxx']);
		$this->assertNull($result);
	}

	/**
	 * Test 2.x shimmed order property
	 *
	 *   $this->order = array('field_name' => 'ASC') etc
	 *
	 * becomes
	 *
	 *   $this->order = array('TableName.field_name' => 'ASC') and a beforeFind addition.
	 *
	 * @return void
	 */
	public function testOrder() {
		$this->Users->truncate();
		$rows = [
			['role_id' => 1, 'name' => 'Gandalf'],
			['role_id' => 2, 'name' => 'Asterix'],
			['role_id' => 1, 'name' => 'Obelix'],
			['role_id' => 3, 'name' => 'Harry Potter']];
		foreach ($rows as $row) {
			$entity = $this->Users->newEntity($row);
			$this->Users->save($entity);
		}

		$result = $this->Users->find('list')->toArray();
		$expected = [
			'Asterix',
			'Gandalf',
			'Harry Potter',
			'Obelix'
		];
		$this->assertSame($expected, array_values($result));
	}

	/**
	 * TableTest::testGetRelatedInUse()
	 *
	 * @return void
	 */
	public function testGetRelatedInUse() {
		$this->skipIf(true, 'TODO');
		$results = $this->Posts->getRelatedInUse('Authors', 'author_id', 'list');
		//die(debug($results->toArray()));
		$expected = [1 => 'mariano', 3 => 'larry'];
		$this->assertEquals($expected, $results->toArray());
	}

	/**
	 * TableTest::testGetFieldInUse()
	 *
	 * @return void
	 */
	public function testGetFieldInUse() {
		$this->skipIf(true, 'TODO');
		$this->db = ConnectionManager::get('test');
		$this->skipIf(!($this->db instanceof Mysql), 'The test is only compatible with Mysql.');

		$results = $this->Posts->getFieldInUse('author_id', 'list');
		$expected = [1 => 'First Post', 2 => 'Second Post'];
		$this->assertEquals($expected, $results);
	}

	/**
	 * TableTest::testValidateDate()
	 *
	 * @return void
	 */
	public function testValidateDate() {
		$date = new Time('2010-01-22');
		$res = $this->Users->validateDate($date);
		//debug($res);
		$this->assertTrue($res);

		// Careful: now becomes 2010-03-01 in Cake3
		// FIXME
		$date = new Time('2010-02-29');
		//debug($date->format(FORMAT_DB_DATETIME));
		$res = $this->Users->validateDate($date);
		//$this->assertFalse($res);
		$this->assertTrue($res);

		$date = new Time('2010-02-23 11:11:11');
		$context = ['data' => ['after' => new Time('2010-02-22')]];
		$res = $this->Users->validateDate($date, ['after' => 'after'], $context);
		//debug($res);
		$this->assertTrue($res);

		$date = new Time('2010-02-23');
		$context = ['data' => ['after' => new Time('2010-02-24 11:11:11')]];
		$res = $this->Users->validateDate($date, ['after' => 'after'], $context);
		//debug($res);
		$this->assertFalse($res);

		$date = new Time('2010-02-25');
		$context = ['data' => ['after' => new Time('2010-02-25')]];
		$res = $this->Users->validateDate($date, ['after' => 'after'], $context);
		//debug($res);
		$this->assertTrue($res);

		$date = new Time('2010-02-25');
		$context = ['data' => ['after' => new Time('2010-02-25')]];
		$res = $this->Users->validateDate($date, ['after' => 'after', 'min' => 1], $context);
		//debug($res);
		$this->assertFalse($res);

		$date = new Time('2010-02-25');
		$context = ['data' => ['after' => new Time('2010-02-24')]];
		$res = $this->Users->validateDate($date, ['after' => 'after', 'min' => 2], $context);
		//debug($res);
		$this->assertFalse($res);

		$date = new Time('2010-02-25');
		$context = ['data' => ['after' => new Time('2010-02-24')]];
		$res = $this->Users->validateDate($date, ['after' => 'after', 'min' => 1], $context);
		//debug($res);
		$this->assertTrue($res);

		$date = new Time('2010-02-25');
		$context = ['data' => ['after' => new Time('2010-02-24')]];
		$res = $this->Users->validateDate($date, ['after' => 'after', 'min' => 2], $context);
		//debug($res);
		$this->assertFalse($res);

		$date = new Time('2010-02-24');
		$context = ['data' => ['before' => new Time('2010-02-24')]];
		$res = $this->Users->validateDate($date, ['before' => 'before', 'min' => 1], $context);
		//debug($res);
		$this->assertFalse($res);

		$date = new Time('2010-02-24');
		$context = ['data' => ['before' => new Time('2010-02-25')]];
		$res = $this->Users->validateDate($date, ['before' => 'before', 'min' => 1], $context);
		//debug($res);
		$this->assertTrue($res);

		$date = new Time('2010-02-24');
		$context = ['data' => ['before' => new Time('2010-02-25')]];
		$res = $this->Users->validateDate($date, ['before' => 'before', 'min' => 2], $context);
		//debug($res);
		$this->assertFalse($res);

		$date = new Time('2010-02-24');
		$context = ['data' => ['before' => new Time('2010-02-26')]];
		$res = $this->Users->validateDate($date, ['before' => 'before', 'min' => 2], $context);
		//debug($res);
		$this->assertTrue($res);
	}

	/**
	 * TableTest::testValidateDatetime()
	 *
	 * @return void
	 */
	public function testValidateDatetime() {

		$date = new Time('2010-01-22 11:11:11');
		$res = $this->Users->validateDatetime($date);
		//debug($res);
		$this->assertTrue($res);

		/*
		$date = new Time('2010-01-22 11:61:11');
		$res = $this->Users->validateDatetime($date);
		//debug($res);
		$this->assertFalse($res);
		*/

		//FIXME
		$date = new Time('2010-02-29 11:11:11');
		$res = $this->Users->validateDatetime($date);
		//debug($res);
		//$this->assertFalse($res);
		$this->assertTrue($res);

		$date = null;
		$res = $this->Users->validateDatetime($date, ['allowEmpty' => true]);
		//debug($res);
		$this->assertTrue($res);

		/*
		$date = new Time => '0000-00-00 00:00:00');
		$res = $this->Users->validateDatetime($date, array('allowEmpty' => true));
		//debug($res);
		$this->assertTrue($res);
		*/

		$date = new Time('2010-02-23 11:11:11');
		$context = ['data' => ['after' => new Time('2010-02-22 11:11:11')]];
		$res = $this->Users->validateDatetime($date, ['after' => 'after'], $context);
		//debug($res);
		$this->assertTrue($res);

		$date = new Time('2010-02-23 11:11:11');
		$context = ['data' => ['after' => new Time('2010-02-24 11:11:11')]];
		$res = $this->Users->validateDatetime($date, ['after' => 'after'], $context);
		//debug($res);
		$this->assertFalse($res);

		$date = new Time('2010-02-23 11:11:11');
		$context = ['data' => ['after' => new Time('2010-02-23 11:11:11')]];
		$res = $this->Users->validateDatetime($date, ['after' => 'after'], $context);
		//debug($res);
		$this->assertFalse($res);

		$date = new Time('2010-02-23 11:11:11');
		$context = ['data' => ['after' => new Time('2010-02-23 11:11:11')]];
		$res = $this->Users->validateDatetime($date, ['after' => 'after', 'min' => 1], $context);
		//debug($res);
		$this->assertFalse($res);

		$date = new Time('2010-02-23 11:11:11');
		$context = ['data' => ['after' => new Time('2010-02-23 11:11:11')]];
		$res = $this->Users->validateDatetime($date, ['after' => 'after', 'min' => 0], $context);
		//debug($res);
		$this->assertTrue($res);

		$date = new Time('2010-02-23 11:11:11');
		$context = ['data' => ['after' => new Time('2010-02-23 11:11:10')]];
		$res = $this->Users->validateDatetime($date, ['after' => 'after'], $context);
		//debug($res);
		$this->assertTrue($res);

		$date = new Time('2010-02-23 11:11:11');
		$context = ['data' => ['after' => new Time('2010-02-23 11:11:12')]];
		$res = $this->Users->validateDatetime($date, ['after' => 'after'], $context);
		//debug($res);
		$this->assertFalse($res);
	}

	/**
	 * TableTest::testValidateTime()
	 *
	 * @return void
	 */
	public function testValidateTime() {

		$date = '11:21:11';
		$res = $this->Users->validateTime($date);
		//debug($res);
		$this->assertTrue($res);

		$date = '11:71:11';
		$res = $this->Users->validateTime($date);
		//debug($res);
		$this->assertFalse($res);

		$date = '2010-02-23 11:11:11';
		$context = ['data' => ['before' => new Time('2010-02-23 11:11:12')]];
		$res = $this->Users->validateTime($date, ['before' => 'before'], $context);
		//debug($res);
		$this->assertTrue($res);

		$date = '2010-02-23 11:11:11';
		$context = ['data' => ['after' => new Time('2010-02-23 11:11:12')]];
		$res = $this->Users->validateTime($date, ['after' => 'after'], $context);
		//debug($res);
		$this->assertFalse($res);
	}

	/**
	 * TableTest::testValidateUrl()
	 *
	 * @return void
	 */
	public function testValidateUrl() {
		$data = 'www.dereuromark.de';
		$res = $this->Users->validateUrl($data, ['allowEmpty' => true]);
		$this->assertTrue($res);

		$data = 'www.xxxde';
		$res = $this->Users->validateUrl($data, ['allowEmpty' => true]);
		$this->assertFalse($res);

		$data = 'www.dereuromark.de';
		$res = $this->Users->validateUrl($data, ['allowEmpty' => true, 'autoComplete' => false]);
		$this->assertFalse($res);

		$data = 'http://www.dereuromark.de';
		$res = $this->Users->validateUrl($data, ['allowEmpty' => true, 'autoComplete' => false]);
		$this->assertTrue($res);

		$data = 'www.dereuromark.de';
		$res = $this->Users->validateUrl($data, ['strict' => true]);
		$this->assertTrue($res); # aha

		$data = 'http://www.dereuromark.de';
		$res = $this->Users->validateUrl($data, ['strict' => false]);
		$this->assertTrue($res);

		$this->skipIf(empty($_SERVER['HTTP_HOST']), 'No HTTP_HOST');

		$data = 'http://xyz.de/some/link';
		$res = $this->Users->validateUrl($data, ['deep' => false, 'sameDomain' => true]);
		$this->assertFalse($res);

		$data = '/some/link';
		$res = $this->Users->validateUrl($data, ['deep' => false, 'autoComplete' => true]);
		$this->assertTrue($_SERVER['HTTP_HOST'] === 'localhost' ? !$res : $res);

		$data = 'http://' . $_SERVER['HTTP_HOST'] . '/some/link';
		$res = $this->Users->validateUrl($data, ['deep' => false]);
		$this->assertTrue($_SERVER['HTTP_HOST'] === 'localhost' ? !$res : $res);

		$data = '/some/link';
		$res = $this->Users->validateUrl($data, ['deep' => false, 'autoComplete' => false]);
		$this->assertTrue((env('REMOTE_ADDR') !== '127.0.0.1') ? !$res : $res);

		//$this->skipIf(strpos($_SERVER['HTTP_HOST'], '.') === false, 'No online HTTP_HOST');

		$data = '/some/link';
		$res = $this->Users->validateUrl($data, ['deep' => false, 'sameDomain' => true]);
		$this->assertTrue($_SERVER['HTTP_HOST'] === 'localhost' ? !$res : $res);

		$data = 'https://github.com/';
		$res = $this->Users->validateUrl($data, ['deep' => false]);
		$this->assertTrue($res);

		$data = 'https://github.com/';
		$res = $this->Users->validateUrl($data, ['deep' => true]);
		$this->assertTrue($res);
	}

	/**
	 * TableTest::testValidateUnique()
	 *
	 * @return void
	 */
	public function testValidateUnique() {
		$this->Posts->validator()->add('title', [
			'validateUnique' => [
				'rule' => 'validateUniqueExt',
				'message' => 'valErrRecordTitleExists',
				'provider' => 'table'
			],
		]);
		$data = [
			'title' => 'abc',
			'author_id' => 1,
			'published' => 'N'
		];
		$post = $this->Posts->newEntity($data);
		$this->assertEmpty($post->errors());

		$res = $this->Posts->save($post);
		$this->assertTrue((bool)$res);

		$post = $this->Posts->newEntity($data);
		$this->assertNotEmpty($post->errors());

		$this->Posts->validator()->add('title', [
			'validateUnique' => [
				'rule' => ['validateUniqueExt', ['scope' => ['published']]],
				'message' => 'valErrRecordTitleExists',
				'provider' => 'table'
			],
		]);
		$data = [
			'title' => 'abc',
			'author_id' => 1,
			'published' => 'Y'
		];
		$post = $this->Posts->newEntity($data);
		$this->assertEmpty($post->errors());

		$res = $this->Posts->save($post);
		$this->assertTrue((bool)$res);

		$post = $this->Posts->newEntity($data);
		$this->assertNotEmpty($post->errors());
	}

}