cakephp/tests/TestCase/ORM/AssociationCollectionTest.php

<?php
/**
 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
 * 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://cakephp.org CakePHP(tm) Project
 * @since         3.0.0
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */
namespace Cake\Test\TestCase\ORM;

use Cake\ORM\AssociationCollection;
use Cake\ORM\Association\BelongsTo;
use Cake\ORM\Association\BelongsToMany;
use Cake\ORM\Entity;
use Cake\TestSuite\TestCase;

/**
 * AssociationCollection test case.
 */
class AssociationCollectionTest extends TestCase {

/**
 * setup
 *
 * @return void
 */
	public function setUp() {
		parent::setUp();
		$this->associations = new AssociationCollection();
	}

/**
 * Test the simple add/has and get methods.
 *
 * @return void
 */
	public function testAddHasRemoveAndGet() {
		$this->assertFalse($this->associations->has('users'));
		$this->assertFalse($this->associations->has('Users'));

		$this->assertNull($this->associations->get('users'));
		$this->assertNull($this->associations->get('Users'));

		$belongsTo = new BelongsTo([]);
		$this->assertSame($belongsTo, $this->associations->add('Users', $belongsTo));
		$this->assertTrue($this->associations->has('users'));
		$this->assertTrue($this->associations->has('Users'));

		$this->assertSame($belongsTo, $this->associations->get('users'));
		$this->assertSame($belongsTo, $this->associations->get('Users'));

		$this->assertNull($this->associations->remove('Users'));

		$this->assertFalse($this->associations->has('users'));
		$this->assertFalse($this->associations->has('Users'));
		$this->assertNull($this->associations->get('users'));
		$this->assertNull($this->associations->get('Users'));
	}

/**
 * Test removeAll method
 *
 * @return void
 */
	public function testRemoveAll() {
		$this->assertEmpty($this->associations->keys());

		$belongsTo = new BelongsTo([]);
		$this->assertSame($belongsTo, $this->associations->add('Users', $belongsTo));
		$belongsToMany = new BelongsToMany([]);
		$this->assertSame($belongsToMany, $this->associations->add('Cart', $belongsToMany));

		$this->associations->removeAll();
		$this->assertEmpty($this->associations->keys());
	}

/**
 * Test getting associations by property.
 *
 * @return void
 */
	public function testGetByProperty() {
		$belongsTo = new BelongsTo('Users', []);
		$this->assertEquals('user', $belongsTo->property());
		$this->associations->add('Users', $belongsTo);
		$this->assertNull($this->associations->get('user'));

		$this->assertSame($belongsTo, $this->associations->getByProperty('user'));
	}

/**
 * Test associations with plugin names.
 *
 * @return void
 */
	public function testAddHasRemoveGetWithPlugin() {
		$this->assertFalse($this->associations->has('Photos.Photos'));
		$this->assertFalse($this->associations->has('Photos'));

		$belongsTo = new BelongsTo([]);
		$this->assertSame($belongsTo, $this->associations->add('Photos.Photos', $belongsTo));
		$this->assertTrue($this->associations->has('Photos'));
		$this->assertFalse($this->associations->has('Photos.Photos'));
	}

/**
 * Test keys()
 *
 * @return void
 */
	public function testKeys() {
		$belongsTo = new BelongsTo([]);
		$this->associations->add('Users', $belongsTo);
		$this->associations->add('Categories', $belongsTo);
		$this->assertEquals(['users', 'categories'], $this->associations->keys());

		$this->associations->remove('Categories');
		$this->assertEquals(['users'], $this->associations->keys());
	}

/**
 * Test getting association names by type.
 *
 * @return void
 */
	public function testType() {
		$belongsTo = new BelongsTo([]);
		$this->associations->add('Users', $belongsTo);

		$belongsToMany = new BelongsToMany([]);
		$this->associations->add('Tags', $belongsToMany);

		$this->assertSame([$belongsTo], $this->associations->type('BelongsTo'));
		$this->assertSame([$belongsToMany], $this->associations->type('BelongsToMany'));
		$this->assertSame([], $this->associations->type('HasMany'));
	}

/**
 * test cascading deletes.
 *
 * @return void
 */
	public function testCascadeDelete() {
		$mockOne = $this->getMock('Cake\ORM\Association\BelongsTo', [], [[]]);
		$mockTwo = $this->getMock('Cake\ORM\Association\HasMany', [], [[]]);

		$entity = new Entity();
		$options = ['option' => 'value'];
		$this->associations->add('One', $mockOne);
		$this->associations->add('Two', $mockTwo);

		$mockOne->expects($this->once())
			->method('cascadeDelete')
			->with($entity, $options);

		$mockTwo->expects($this->once())
			->method('cascadeDelete')
			->with($entity, $options);

		$this->assertNull($this->associations->cascadeDelete($entity, $options));
	}

/**
 * Test saving parent associations
 *
 * @return void
 */
	public function testSaveParents() {
		$table = $this->getMock('Cake\ORM\Table', [], [[]]);
		$mockOne = $this->getMock(
			'Cake\ORM\Association\BelongsTo',
			['saveAssociated'],
			['Parent', [
				'sourceTable' => $table,
			]]);
		$mockTwo = $this->getMock(
			'Cake\ORM\Association\HasMany',
			['saveAssociated'],
			['Child', [
				'sourceTable' => $table
			]]);

		$this->associations->add('Parent', $mockOne);
		$this->associations->add('Child', $mockTwo);

		$entity = new Entity();
		$entity->set('parent', ['key' => 'value']);
		$entity->set('child', ['key' => 'value']);

		$options = ['option' => 'value'];

		$mockOne->expects($this->once())
			->method('saveAssociated')
			->with($entity, $options)
			->will($this->returnValue(true));

		$mockTwo->expects($this->never())
			->method('saveAssociated');

		$result = $this->associations->saveParents(
			$table,
			$entity,
			['Parent', 'Child'],
			$options
		);
		$this->assertTrue($result, 'Save should work.');
	}

/**
 * Test saving filtered parent associations.
 *
 * @return void
 */
	public function testSaveParentsFiltered() {
		$table = $this->getMock('Cake\ORM\Table', [], [[]]);
		$mockOne = $this->getMock(
			'Cake\ORM\Association\BelongsTo',
			['saveAssociated'],
			['Parents', [
				'sourceTable' => $table,
			]]);
		$mockTwo = $this->getMock(
			'Cake\ORM\Association\BelongsTo',
			['saveAssociated'],
			['Categories', [
				'sourceTable' => $table
			]]);

		$this->associations->add('Parents', $mockOne);
		$this->associations->add('Categories', $mockTwo);

		$entity = new Entity();
		$entity->set('parent', ['key' => 'value']);
		$entity->set('category', ['key' => 'value']);

		$options = ['atomic' => true];

		$mockOne->expects($this->once())
			->method('saveAssociated')
			->with($entity, ['atomic' => true, 'associated' => ['Others']])
			->will($this->returnValue(true));

		$mockTwo->expects($this->never())
			->method('saveAssociated');

		$result = $this->associations->saveParents(
			$table,
			$entity,
			['Parents' => ['associated' => ['Others']]],
			$options
		);
		$this->assertTrue($result, 'Save should work.');
	}

/**
 * Test saving filtered child associations.
 *
 * @return void
 */
	public function testSaveChildrenFiltered() {
		$table = $this->getMock('Cake\ORM\Table', [], [[]]);
		$mockOne = $this->getMock(
			'Cake\ORM\Association\HasMany',
			['saveAssociated'],
			['Comments', [
				'sourceTable' => $table,
			]]);
		$mockTwo = $this->getMock(
			'Cake\ORM\Association\HasOne',
			['saveAssociated'],
			['Profiles', [
				'sourceTable' => $table
			]]);

		$this->associations->add('Comments', $mockOne);
		$this->associations->add('Profiles', $mockTwo);

		$entity = new Entity();
		$entity->set('comments', ['key' => 'value']);
		$entity->set('profile', ['key' => 'value']);

		$options = ['atomic' => true];

		$mockOne->expects($this->once())
			->method('saveAssociated')
			->with($entity, $options + ['associated' => ['Other']])
			->will($this->returnValue(true));

		$mockTwo->expects($this->never())
			->method('saveAssociated');

		$result = $this->associations->saveChildren(
			$table,
			$entity,
			['Comments' => ['associated' => ['Other']]],
			$options
		);
		$this->assertTrue($result, 'Should succeed.');
	}

/**
 * Test exceptional case.
 *
 * @expectedException \InvalidArgumentException
 * @expectedExceptionMessage Cannot save Profiles, it is not associated to Users
 */
	public function testErrorOnUnknownAlias() {
		$table = $this->getMock(
			'Cake\ORM\Table',
			['save'],
			[['alias' => 'Users']]);

		$entity = new Entity();
		$entity->set('profile', ['key' => 'value']);

		$this->associations->saveChildren(
			$table,
			$entity,
			['Profiles'],
			['atomic' => true]
		);
	}

/**
 * Tests the normalizeKeys method
 *
 * @return void
 */
	public function testNormalizeKeys() {
		$this->assertSame([], $this->associations->normalizeKeys([]));
		$this->assertSame([], $this->associations->normalizeKeys(false));

		$assocs = ['a', 'b', 'd' => ['something']];
		$expected = ['a' => [], 'b' => [], 'd' => ['something']];
		$this->assertSame($expected, $this->associations->normalizeKeys($assocs));

		$belongsTo = new BelongsTo([]);
		$this->associations->add('users', $belongsTo);
		$this->associations->add('categories', $belongsTo);
		$expected = ['users' => [], 'categories' => []];
		$this->assertSame($expected, $this->associations->normalizeKeys(true));
	}

}