From 1082add640d27e07959f3fb29c904ef3f09c9676 Mon Sep 17 00:00:00 2001 From: Robert Date: Wed, 8 Apr 2015 12:48:09 +0200 Subject: [PATCH] Original test cases for TableRegistry moved to TableLocatorTest. TableRegistry cases now test that LocatorInterface methods are called. --- .../TestCase/ORM/Locator/TableLocatorTest.php | 552 ++++++++++++++++++ tests/TestCase/ORM/TableRegistryTest.php | 486 ++------------- 2 files changed, 600 insertions(+), 438 deletions(-) create mode 100644 tests/TestCase/ORM/Locator/TableLocatorTest.php diff --git a/tests/TestCase/ORM/Locator/TableLocatorTest.php b/tests/TestCase/ORM/Locator/TableLocatorTest.php new file mode 100644 index 00000000000..2208ebf0248 --- /dev/null +++ b/tests/TestCase/ORM/Locator/TableLocatorTest.php @@ -0,0 +1,552 @@ +_locator->get(); + */ +class MyUsersTable extends Table +{ + + /** + * Overrides default table name + * + * @var string + */ + protected $_table = 'users'; +} + + +/** + * Test case for TableLocator + */ +class TableLocatorTest extends TestCase +{ + + /** + * TableLocator instance. + * + * @var \Cake\ORM\Locator\TableLocator + */ + protected $_locator; + + + /** + * setup + * + * @return void + */ + public function setUp() + { + parent::setUp(); + Configure::write('App.namespace', 'TestApp'); + + $this->_locator = new TableLocator; + } + + /** + * Test config() method. + * + * @return void + */ + public function testConfig() + { + $this->assertEquals([], $this->_locator->config('Tests')); + + $data = [ + 'connection' => 'testing', + 'entityClass' => 'TestApp\Model\Entity\Article', + ]; + $result = $this->_locator->config('Tests', $data); + $this->assertEquals($data, $result, 'Returns config data.'); + + $result = $this->_locator->config(); + $expected = ['Tests' => $data]; + $this->assertEquals($expected, $result); + } + + /** + * Test config() method with plugin syntax aliases + * + * @return void + */ + public function testConfigPlugin() + { + Plugin::load('TestPlugin'); + + $data = [ + 'connection' => 'testing', + 'entityClass' => 'TestPlugin\Model\Entity\Comment', + ]; + + $result = $this->_locator->config('TestPlugin.TestPluginComments', $data); + $this->assertEquals($data, $result, 'Returns config data.'); + } + + /** + * Test calling config() on existing instances throws an error. + * + * @expectedException \RuntimeException + * @expectedExceptionMessage You cannot configure "Users", it has already been constructed. + * @return void + */ + public function testConfigOnDefinedInstance() + { + $users = $this->_locator->get('Users'); + $this->_locator->config('Users', ['table' => 'my_users']); + } + + /** + * Test the exists() method. + * + * @return void + */ + public function testExists() + { + $this->assertFalse($this->_locator->exists('Articles')); + + $this->_locator->config('Articles', ['table' => 'articles']); + $this->assertFalse($this->_locator->exists('Articles')); + + $this->_locator->get('Articles', ['table' => 'articles']); + $this->assertTrue($this->_locator->exists('Articles')); + } + + /** + * Test the exists() method with plugin-prefixed models. + * + * @return void + */ + public function testExistsPlugin() + { + $this->assertFalse($this->_locator->exists('Comments')); + $this->assertFalse($this->_locator->exists('TestPlugin.Comments')); + + $this->_locator->config('TestPlugin.Comments', ['table' => 'comments']); + $this->assertFalse($this->_locator->exists('Comments'), 'The Comments key should not be populated'); + $this->assertFalse($this->_locator->exists('TestPlugin.Comments'), 'The plugin.alias key should not be populated'); + + $this->_locator->get('TestPlugin.Comments', ['table' => 'comments']); + $this->assertFalse($this->_locator->exists('Comments'), 'The Comments key should not be populated'); + $this->assertTrue($this->_locator->exists('TestPlugin.Comments'), 'The plugin.alias key should now be populated'); + } + + /** + * Test getting instances from the registry. + * + * @return void + */ + public function testGet() + { + $result = $this->_locator->get('Articles', [ + 'table' => 'my_articles', + ]); + $this->assertInstanceOf('Cake\ORM\Table', $result); + $this->assertEquals('my_articles', $result->table()); + + $result2 = $this->_locator->get('Articles'); + $this->assertSame($result, $result2); + $this->assertEquals('my_articles', $result->table()); + } + + /** + * Are auto-models instanciated correctly? How about when they have an alias? + * + * @return void + */ + public function testGetFallbacks() + { + $result = $this->_locator->get('Droids'); + $this->assertInstanceOf('Cake\ORM\Table', $result); + $this->assertEquals('droids', $result->table()); + $this->assertEquals('Droids', $result->alias()); + + $result = $this->_locator->get('R2D2', ['className' => 'Droids']); + $this->assertInstanceOf('Cake\ORM\Table', $result); + $this->assertEquals('droids', $result->table(), 'The table should be derived from the className'); + $this->assertEquals('R2D2', $result->alias()); + + $result = $this->_locator->get('C3P0', ['className' => 'Droids', 'table' => 'rebels']); + $this->assertInstanceOf('Cake\ORM\Table', $result); + $this->assertEquals('rebels', $result->table(), 'The table should be taken from options'); + $this->assertEquals('C3P0', $result->alias()); + + $result = $this->_locator->get('Funky.Chipmunks'); + $this->assertInstanceOf('Cake\ORM\Table', $result); + $this->assertEquals('chipmunks', $result->table(), 'The table should be derived from the alias'); + $this->assertEquals('Chipmunks', $result->alias()); + + $result = $this->_locator->get('Awesome', ['className' => 'Funky.Monkies']); + $this->assertInstanceOf('Cake\ORM\Table', $result); + $this->assertEquals('monkies', $result->table(), 'The table should be derived from the classname'); + $this->assertEquals('Awesome', $result->alias()); + + $result = $this->_locator->get('Stuff', ['className' => 'Cake\ORM\Table']); + $this->assertInstanceOf('Cake\ORM\Table', $result); + $this->assertEquals('stuff', $result->table(), 'The table should be derived from the alias'); + $this->assertEquals('Stuff', $result->alias()); + } + + /** + * Test that get() uses config data set with config() + * + * @return void + */ + public function testGetWithConfig() + { + $this->_locator->config('Articles', [ + 'table' => 'my_articles', + ]); + $result = $this->_locator->get('Articles'); + $this->assertEquals('my_articles', $result->table(), 'Should use config() data.'); + } + + /** + * Test get with config throws an exception if the alias exists already. + * + * @expectedException \RuntimeException + * @expectedExceptionMessage You cannot configure "Users", it already exists in the registry. + * @return void + */ + public function testGetExistingWithConfigData() + { + $users = $this->_locator->get('Users'); + $this->_locator->get('Users', ['table' => 'my_users']); + } + + /** + * Test get() can be called several times with the same option without + * throwing an exception. + * + * @return void + */ + public function testGetWithSameOption() + { + $result = $this->_locator->get('Users', ['className' => 'Cake\Test\TestCase\ORM\MyUsersTable']); + $result2 = $this->_locator->get('Users', ['className' => 'Cake\Test\TestCase\ORM\MyUsersTable']); + $this->assertEquals($result, $result2); + } + + /** + * Tests that tables can be instantiated based on conventions + * and using plugin notation + * + * @return void + */ + public function testGetWithConventions() + { + $table = $this->_locator->get('articles'); + $this->assertInstanceOf('TestApp\Model\Table\ArticlesTable', $table); + $table = $this->_locator->get('Articles'); + $this->assertInstanceOf('TestApp\Model\Table\ArticlesTable', $table); + + $table = $this->_locator->get('authors'); + $this->assertInstanceOf('TestApp\Model\Table\AuthorsTable', $table); + $table = $this->_locator->get('Authors'); + $this->assertInstanceOf('TestApp\Model\Table\AuthorsTable', $table); + } + + /** + * Test get() with plugin syntax aliases + * + * @return void + */ + public function testGetPlugin() + { + Plugin::load('TestPlugin'); + $table = $this->_locator->get('TestPlugin.TestPluginComments', ['connection' => 'test']); + + $this->assertInstanceOf('TestPlugin\Model\Table\TestPluginCommentsTable', $table); + $this->assertFalse( + $this->_locator->exists('TestPluginComments'), + 'Short form should NOT exist' + ); + $this->assertTrue( + $this->_locator->exists('TestPlugin.TestPluginComments'), + 'Long form should exist' + ); + + $second = $this->_locator->get('TestPlugin.TestPluginComments'); + $this->assertSame($table, $second, 'Can fetch long form'); + } + + /** + * Test get() with same-alias models in different plugins + * + * There should be no internal cache-confusion + * + * @return void + */ + public function testGetMultiplePlugins() + { + Plugin::load('TestPlugin'); + Plugin::load('TestPluginTwo'); + + $app = $this->_locator->get('Comments'); + $plugin1 = $this->_locator->get('TestPlugin.Comments'); + $plugin2 = $this->_locator->get('TestPluginTwo.Comments'); + + $this->assertInstanceOf('Cake\ORM\Table', $app, 'Should be an app table instance'); + $this->assertInstanceOf('TestPlugin\Model\Table\CommentsTable', $plugin1, 'Should be a plugin 1 table instance'); + $this->assertInstanceOf('TestPluginTwo\Model\Table\CommentsTable', $plugin2, 'Should be a plugin 2 table instance'); + + $plugin2 = $this->_locator->get('TestPluginTwo.Comments'); + $plugin1 = $this->_locator->get('TestPlugin.Comments'); + $app = $this->_locator->get('Comments'); + + $this->assertInstanceOf('Cake\ORM\Table', $app, 'Should still be an app table instance'); + $this->assertInstanceOf('TestPlugin\Model\Table\CommentsTable', $plugin1, 'Should still be a plugin 1 table instance'); + $this->assertInstanceOf('TestPluginTwo\Model\Table\CommentsTable', $plugin2, 'Should still be a plugin 2 table instance'); + } + + /** + * Test get() with plugin aliases + className option. + * + * @return void + */ + public function testGetPluginWithClassNameOption() + { + Plugin::load('TestPlugin'); + $table = $this->_locator->get('Comments', [ + 'className' => 'TestPlugin.TestPluginComments', + 'connection' => 'test' + ]); + $class = 'TestPlugin\Model\Table\TestPluginCommentsTable'; + $this->assertInstanceOf($class, $table); + $this->assertFalse($this->_locator->exists('TestPluginComments'), 'Class name should not exist'); + $this->assertFalse($this->_locator->exists('TestPlugin.TestPluginComments'), 'Full class alias should not exist'); + $this->assertTrue($this->_locator->exists('Comments'), 'Class name should exist'); + + $second = $this->_locator->get('Comments'); + $this->assertSame($table, $second); + } + + /** + * Test get() with full namespaced classname + * + * @return void + */ + public function testGetPluginWithFullNamespaceName() + { + Plugin::load('TestPlugin'); + $class = 'TestPlugin\Model\Table\TestPluginCommentsTable'; + $table = $this->_locator->get('Comments', [ + 'className' => $class, + 'connection' => 'test' + ]); + $this->assertInstanceOf($class, $table); + $this->assertFalse($this->_locator->exists('TestPluginComments'), 'Class name should not exist'); + $this->assertFalse($this->_locator->exists('TestPlugin.TestPluginComments'), 'Full class alias should not exist'); + $this->assertTrue($this->_locator->exists('Comments'), 'Class name should exist'); + } + + /** + * Tests that table options can be pre-configured for the factory method + * + * @return void + */ + public function testConfigAndBuild() + { + $this->_locator->clear(); + $map = $this->_locator->config(); + $this->assertEquals([], $map); + + $connection = ConnectionManager::get('test', false); + $options = ['connection' => $connection]; + $this->_locator->config('users', $options); + $map = $this->_locator->config(); + $this->assertEquals(['users' => $options], $map); + $this->assertEquals($options, $this->_locator->config('users')); + + $schema = ['id' => ['type' => 'rubbish']]; + $options += ['schema' => $schema]; + $this->_locator->config('users', $options); + + $table = $this->_locator->get('users', ['table' => 'users']); + $this->assertInstanceOf('Cake\ORM\Table', $table); + $this->assertEquals('users', $table->table()); + $this->assertEquals('users', $table->alias()); + $this->assertSame($connection, $table->connection()); + $this->assertEquals(array_keys($schema), $table->schema()->columns()); + $this->assertEquals($schema['id']['type'], $table->schema()->column('id')['type']); + + $this->_locator->clear(); + $this->assertEmpty($this->_locator->config()); + + $this->_locator->config('users', $options); + $table = $this->_locator->get('users', ['className' => __NAMESPACE__ . '\MyUsersTable']); + $this->assertInstanceOf(__NAMESPACE__ . '\MyUsersTable', $table); + $this->assertEquals('users', $table->table()); + $this->assertEquals('users', $table->alias()); + $this->assertSame($connection, $table->connection()); + $this->assertEquals(array_keys($schema), $table->schema()->columns()); + $this->assertEquals($schema['id']['type'], $table->schema()->column('id')['type']); + } + + /** + * Tests that table options can be pre-configured with a single validator + * + * @return void + */ + public function testConfigWithSingleValidator() + { + $validator = new Validator(); + + $this->_locator->config('users', ['validator' => $validator]); + $table = $this->_locator->get('users'); + + $this->assertSame($table->validator('default'), $validator); + } + + /** + * Tests that table options can be pre-configured with multiple validators + * + * @return void + */ + public function testConfigWithMultipleValidators() + { + $validator1 = new Validator(); + $validator2 = new Validator(); + $validator3 = new Validator(); + + $this->_locator->config('users', [ + 'validator' => [ + 'default' => $validator1, + 'secondary' => $validator2, + 'tertiary' => $validator3, + ] + ]); + $table = $this->_locator->get('users'); + + $this->assertSame($table->validator('default'), $validator1); + $this->assertSame($table->validator('secondary'), $validator2); + $this->assertSame($table->validator('tertiary'), $validator3); + } + + /** + * Test setting an instance. + * + * @return void + */ + public function testSet() + { + $mock = $this->getMock('Cake\ORM\Table'); + $this->assertSame($mock, $this->_locator->set('Articles', $mock)); + $this->assertSame($mock, $this->_locator->get('Articles')); + } + + /** + * Test setting an instance with plugin syntax aliases + * + * @return void + */ + public function testSetPlugin() + { + Plugin::load('TestPlugin'); + + $mock = $this->getMock('TestPlugin\Model\Table\CommentsTable'); + + $this->assertSame($mock, $this->_locator->set('TestPlugin.Comments', $mock)); + $this->assertSame($mock, $this->_locator->get('TestPlugin.Comments')); + } + + /** + * Tests genericInstances + * + * @return void + */ + public function testGenericInstances() + { + $foos = $this->_locator->get('Foos'); + $bars = $this->_locator->get('Bars'); + $this->_locator->get('Articles'); + $expected = ['Foos' => $foos, 'Bars' => $bars]; + $this->assertEquals($expected, $this->_locator->genericInstances()); + } + + /** + * Tests remove an instance + * + * @return void + */ + public function testRemove() + { + $first = $this->_locator->get('Comments'); + + $this->assertTrue($this->_locator->exists('Comments')); + + $this->_locator->remove('Comments'); + $this->assertFalse($this->_locator->exists('Comments')); + + $second = $this->_locator->get('Comments'); + + $this->assertNotSame($first, $second, 'Should be different objects, as the reference to the first was destroyed'); + $this->assertTrue($this->_locator->exists('Comments')); + } + + /** + * testRemovePlugin + * + * Removing a plugin-prefixed model should not affect any other + * plugin-prefixed model, or app model. + * Removing an app model should not affect any other + * plugin-prefixed model. + * + * @return void + */ + public function testRemovePlugin() + { + Plugin::load('TestPlugin'); + Plugin::load('TestPluginTwo'); + + $app = $this->_locator->get('Comments'); + $this->_locator->get('TestPlugin.Comments'); + $plugin = $this->_locator->get('TestPluginTwo.Comments'); + + $this->assertTrue($this->_locator->exists('Comments')); + $this->assertTrue($this->_locator->exists('TestPlugin.Comments')); + $this->assertTrue($this->_locator->exists('TestPluginTwo.Comments')); + + $this->_locator->remove('TestPlugin.Comments'); + + $this->assertTrue($this->_locator->exists('Comments')); + $this->assertFalse($this->_locator->exists('TestPlugin.Comments')); + $this->assertTrue($this->_locator->exists('TestPluginTwo.Comments')); + + $app2 = $this->_locator->get('Comments'); + $plugin2 = $this->_locator->get('TestPluginTwo.Comments'); + + $this->assertSame($app, $app2, 'Should be the same Comments object'); + $this->assertSame($plugin, $plugin2, 'Should be the same TestPluginTwo.Comments object'); + + $this->_locator->remove('Comments'); + + $this->assertFalse($this->_locator->exists('Comments')); + $this->assertFalse($this->_locator->exists('TestPlugin.Comments')); + $this->assertTrue($this->_locator->exists('TestPluginTwo.Comments')); + + $plugin3 = $this->_locator->get('TestPluginTwo.Comments'); + + $this->assertSame($plugin, $plugin3, 'Should be the same TestPluginTwo.Comments object'); + } +} diff --git a/tests/TestCase/ORM/TableRegistryTest.php b/tests/TestCase/ORM/TableRegistryTest.php index 2ad367dff5b..537870e909b 100644 --- a/tests/TestCase/ORM/TableRegistryTest.php +++ b/tests/TestCase/ORM/TableRegistryTest.php @@ -14,44 +14,33 @@ */ namespace Cake\Test\TestCase\ORM; -use Cake\Core\Configure; -use Cake\Core\Plugin; -use Cake\Datasource\ConnectionManager; -use Cake\ORM\Table; +use Cake\ORM\Locator\LocatorInterface; use Cake\ORM\TableRegistry; use Cake\TestSuite\TestCase; -use Cake\Validation\Validator; /** - * Used to test correct class is instantiated when using TableRegistry::get(); + * Test case for TableRegistry */ -class MyUsersTable extends Table +class TableRegistryTest extends TestCase { /** - * Overrides default table name + * Original TableLocator. * - * @var string + * @var Cake\ORM\Locator\LocatorInterface */ - protected $_table = 'users'; -} - - -/** - * Test case for TableRegistry - */ -class TableRegistryTest extends TestCase -{ + protected $_originalLocator; /** - * setup + * Remember original instance to set it back on tearDown() just to make sure + * other tests are not broken. * * @return void */ public function setUp() { parent::setUp(); - Configure::write('App.namespace', 'TestApp'); + $this->_originalLocator = TableRegistry::locator(); } /** @@ -62,490 +51,111 @@ public function setUp() public function tearDown() { parent::tearDown(); - TableRegistry::clear(); + TableRegistry::locator($this->_originalLocator); } /** - * Test config() method. + * Sets and returns mock LocatorInterface instance. * - * @return void + * @return Cake\ORM\Locator\LocatorInterface */ - public function testConfig() + protected function _setMockLocator() { - $this->assertEquals([], TableRegistry::config('Tests')); + $locator = $this->getMock('Cake\ORM\Locator\LocatorInterface'); + TableRegistry::locator($locator); - $data = [ - 'connection' => 'testing', - 'entityClass' => 'TestApp\Model\Entity\Article', - ]; - $result = TableRegistry::config('Tests', $data); - $this->assertEquals($data, $result, 'Returns config data.'); - - $result = TableRegistry::config(); - $expected = ['Tests' => $data]; - $this->assertEquals($expected, $result); + return $locator; } /** - * Test config() method with plugin syntax aliases + * Test locator() method. * * @return void */ - public function testConfigPlugin() + public function testLocator() { - Plugin::load('TestPlugin'); + $this->assertInstanceOf('Cake\ORM\Locator\LocatorInterface', TableRegistry::locator()); - $data = [ - 'connection' => 'testing', - 'entityClass' => 'TestPlugin\Model\Entity\Comment', - ]; + $locator = $this->_setMockLocator(); - $result = TableRegistry::config('TestPlugin.TestPluginComments', $data); - $this->assertEquals($data, $result, 'Returns config data.'); + $this->assertSame($locator, TableRegistry::locator()); } /** - * Test calling config() on existing instances throws an error. + * Test that locator() method is returing TableLocator by default. * - * @expectedException \RuntimeException - * @expectedExceptionMessage You cannot configure "Users", it has already been constructed. * @return void */ - public function testConfigOnDefinedInstance() + public function testLocatorDefault() { - $users = TableRegistry::get('Users'); - TableRegistry::config('Users', ['table' => 'my_users']); + $locator = TableRegistry::locator(); + $this->assertInstanceOf('Cake\ORM\Locator\TableLocator', $locator); } /** - * Test the exists() method. - * - * @return void - */ - public function testExists() - { - $this->assertFalse(TableRegistry::exists('Articles')); - - TableRegistry::config('Articles', ['table' => 'articles']); - $this->assertFalse(TableRegistry::exists('Articles')); - - TableRegistry::get('Articles', ['table' => 'articles']); - $this->assertTrue(TableRegistry::exists('Articles')); - } - - /** - * Test the exists() method with plugin-prefixed models. + * Test config() method. * * @return void */ - public function testExistsPlugin() + public function testConfig() { - $this->assertFalse(TableRegistry::exists('Comments')); - $this->assertFalse(TableRegistry::exists('TestPlugin.Comments')); + $locator = $this->_setMockLocator(); + $locator->expects($this->once())->method('config')->with('Test', []); - TableRegistry::config('TestPlugin.Comments', ['table' => 'comments']); - $this->assertFalse(TableRegistry::exists('Comments'), 'The Comments key should not be populated'); - $this->assertFalse(TableRegistry::exists('TestPlugin.Comments'), 'The plugin.alias key should not be populated'); - - TableRegistry::get('TestPlugin.Comments', ['table' => 'comments']); - $this->assertFalse(TableRegistry::exists('Comments'), 'The Comments key should not be populated'); - $this->assertTrue(TableRegistry::exists('TestPlugin.Comments'), 'The plugin.alias key should now be populated'); + TableRegistry::config('Test', []); } /** - * Test getting instances from the registry. + * Test the get() method. * * @return void */ public function testGet() { - $result = TableRegistry::get('Articles', [ - 'table' => 'my_articles', - ]); - $this->assertInstanceOf('Cake\ORM\Table', $result); - $this->assertEquals('my_articles', $result->table()); - - $result2 = TableRegistry::get('Articles'); - $this->assertSame($result, $result2); - $this->assertEquals('my_articles', $result->table()); - } - - /** - * Are auto-models instanciated correctly? How about when they have an alias? - * - * @return void - */ - public function testGetFallbacks() - { - $result = TableRegistry::get('Droids'); - $this->assertInstanceOf('Cake\ORM\Table', $result); - $this->assertEquals('droids', $result->table()); - $this->assertEquals('Droids', $result->alias()); - - $result = TableRegistry::get('R2D2', ['className' => 'Droids']); - $this->assertInstanceOf('Cake\ORM\Table', $result); - $this->assertEquals('droids', $result->table(), 'The table should be derived from the className'); - $this->assertEquals('R2D2', $result->alias()); - - $result = TableRegistry::get('C3P0', ['className' => 'Droids', 'table' => 'rebels']); - $this->assertInstanceOf('Cake\ORM\Table', $result); - $this->assertEquals('rebels', $result->table(), 'The table should be taken from options'); - $this->assertEquals('C3P0', $result->alias()); - - $result = TableRegistry::get('Funky.Chipmunks'); - $this->assertInstanceOf('Cake\ORM\Table', $result); - $this->assertEquals('chipmunks', $result->table(), 'The table should be derived from the alias'); - $this->assertEquals('Chipmunks', $result->alias()); - - $result = TableRegistry::get('Awesome', ['className' => 'Funky.Monkies']); - $this->assertInstanceOf('Cake\ORM\Table', $result); - $this->assertEquals('monkies', $result->table(), 'The table should be derived from the classname'); - $this->assertEquals('Awesome', $result->alias()); - - $result = TableRegistry::get('Stuff', ['className' => 'Cake\ORM\Table']); - $this->assertInstanceOf('Cake\ORM\Table', $result); - $this->assertEquals('stuff', $result->table(), 'The table should be derived from the alias'); - $this->assertEquals('Stuff', $result->alias()); - } - - /** - * Test that get() uses config data set with config() - * - * @return void - */ - public function testGetWithConfig() - { - TableRegistry::config('Articles', [ - 'table' => 'my_articles', - ]); - $result = TableRegistry::get('Articles'); - $this->assertEquals('my_articles', $result->table(), 'Should use config() data.'); - } - - /** - * Test get with config throws an exception if the alias exists already. - * - * @expectedException \RuntimeException - * @expectedExceptionMessage You cannot configure "Users", it already exists in the registry. - * @return void - */ - public function testGetExistingWithConfigData() - { - $users = TableRegistry::get('Users'); - TableRegistry::get('Users', ['table' => 'my_users']); - } - - /** - * Test get() can be called several times with the same option without - * throwing an exception. - * - * @return void - */ - public function testGetWithSameOption() - { - $result = TableRegistry::get('Users', ['className' => 'Cake\Test\TestCase\ORM\MyUsersTable']); - $result2 = TableRegistry::get('Users', ['className' => 'Cake\Test\TestCase\ORM\MyUsersTable']); - $this->assertEquals($result, $result2); - } - - /** - * Tests that tables can be instantiated based on conventions - * and using plugin notation - * - * @return void - */ - public function testGetWithConventions() - { - $table = TableRegistry::get('articles'); - $this->assertInstanceOf('TestApp\Model\Table\ArticlesTable', $table); - $table = TableRegistry::get('Articles'); - $this->assertInstanceOf('TestApp\Model\Table\ArticlesTable', $table); - - $table = TableRegistry::get('authors'); - $this->assertInstanceOf('TestApp\Model\Table\AuthorsTable', $table); - $table = TableRegistry::get('Authors'); - $this->assertInstanceOf('TestApp\Model\Table\AuthorsTable', $table); - } - - /** - * Test get() with plugin syntax aliases - * - * @return void - */ - public function testGetPlugin() - { - Plugin::load('TestPlugin'); - $table = TableRegistry::get('TestPlugin.TestPluginComments'); - - $this->assertInstanceOf('TestPlugin\Model\Table\TestPluginCommentsTable', $table); - $this->assertFalse( - TableRegistry::exists('TestPluginComments'), - 'Short form should NOT exist' - ); - $this->assertTrue( - TableRegistry::exists('TestPlugin.TestPluginComments'), - 'Long form should exist' - ); - - $second = TableRegistry::get('TestPlugin.TestPluginComments'); - $this->assertSame($table, $second, 'Can fetch long form'); - } - - /** - * Test get() with same-alias models in different plugins - * - * There should be no internal cache-confusion - * - * @return void - */ - public function testGetMultiplePlugins() - { - Plugin::load('TestPlugin'); - Plugin::load('TestPluginTwo'); - - $app = TableRegistry::get('Comments'); - $plugin1 = TableRegistry::get('TestPlugin.Comments'); - $plugin2 = TableRegistry::get('TestPluginTwo.Comments'); - - $this->assertInstanceOf('Cake\ORM\Table', $app, 'Should be an app table instance'); - $this->assertInstanceOf('TestPlugin\Model\Table\CommentsTable', $plugin1, 'Should be a plugin 1 table instance'); - $this->assertInstanceOf('TestPluginTwo\Model\Table\CommentsTable', $plugin2, 'Should be a plugin 2 table instance'); - - $plugin2 = TableRegistry::get('TestPluginTwo.Comments'); - $plugin1 = TableRegistry::get('TestPlugin.Comments'); - $app = TableRegistry::get('Comments'); - - $this->assertInstanceOf('Cake\ORM\Table', $app, 'Should still be an app table instance'); - $this->assertInstanceOf('TestPlugin\Model\Table\CommentsTable', $plugin1, 'Should still be a plugin 1 table instance'); - $this->assertInstanceOf('TestPluginTwo\Model\Table\CommentsTable', $plugin2, 'Should still be a plugin 2 table instance'); - } - - /** - * Test get() with plugin aliases + className option. - * - * @return void - */ - public function testGetPluginWithClassNameOption() - { - Plugin::load('TestPlugin'); - $table = TableRegistry::get('Comments', [ - 'className' => 'TestPlugin.TestPluginComments', - ]); - $class = 'TestPlugin\Model\Table\TestPluginCommentsTable'; - $this->assertInstanceOf($class, $table); - $this->assertFalse(TableRegistry::exists('TestPluginComments'), 'Class name should not exist'); - $this->assertFalse(TableRegistry::exists('TestPlugin.TestPluginComments'), 'Full class alias should not exist'); - $this->assertTrue(TableRegistry::exists('Comments'), 'Class name should exist'); - - $second = TableRegistry::get('Comments'); - $this->assertSame($table, $second); - } - - /** - * Test get() with full namespaced classname - * - * @return void - */ - public function testGetPluginWithFullNamespaceName() - { - Plugin::load('TestPlugin'); - $class = 'TestPlugin\Model\Table\TestPluginCommentsTable'; - $table = TableRegistry::get('Comments', [ - 'className' => $class, - ]); - $this->assertInstanceOf($class, $table); - $this->assertFalse(TableRegistry::exists('TestPluginComments'), 'Class name should not exist'); - $this->assertFalse(TableRegistry::exists('TestPlugin.TestPluginComments'), 'Full class alias should not exist'); - $this->assertTrue(TableRegistry::exists('Comments'), 'Class name should exist'); - } - - /** - * Tests that table options can be pre-configured for the factory method - * - * @return void - */ - public function testConfigAndBuild() - { - TableRegistry::clear(); - $map = TableRegistry::config(); - $this->assertEquals([], $map); - - $connection = ConnectionManager::get('test', false); - $options = ['connection' => $connection]; - TableRegistry::config('users', $options); - $map = TableRegistry::config(); - $this->assertEquals(['users' => $options], $map); - $this->assertEquals($options, TableRegistry::config('users')); - - $schema = ['id' => ['type' => 'rubbish']]; - $options += ['schema' => $schema]; - TableRegistry::config('users', $options); - - $table = TableRegistry::get('users', ['table' => 'users']); - $this->assertInstanceOf('Cake\ORM\Table', $table); - $this->assertEquals('users', $table->table()); - $this->assertEquals('users', $table->alias()); - $this->assertSame($connection, $table->connection()); - $this->assertEquals(array_keys($schema), $table->schema()->columns()); - $this->assertEquals($schema['id']['type'], $table->schema()->column('id')['type']); - - TableRegistry::clear(); - $this->assertEmpty(TableRegistry::config()); - - TableRegistry::config('users', $options); - $table = TableRegistry::get('users', ['className' => __NAMESPACE__ . '\MyUsersTable']); - $this->assertInstanceOf(__NAMESPACE__ . '\MyUsersTable', $table); - $this->assertEquals('users', $table->table()); - $this->assertEquals('users', $table->alias()); - $this->assertSame($connection, $table->connection()); - $this->assertEquals(array_keys($schema), $table->schema()->columns()); - $this->assertEquals($schema['id']['type'], $table->schema()->column('id')['type']); - } - - /** - * Tests that table options can be pre-configured with a single validator - * - * @return void - */ - public function testConfigWithSingleValidator() - { - $validator = new Validator(); + $locator = $this->_setMockLocator(); + $locator->expects($this->once())->method('get')->with('Test', []); - TableRegistry::config('users', ['validator' => $validator]); - $table = TableRegistry::get('users'); - - $this->assertSame($table->validator('default'), $validator); + TableRegistry::get('Test', []); } /** - * Tests that table options can be pre-configured with multiple validators - * - * @return void - */ - public function testConfigWithMultipleValidators() - { - $validator1 = new Validator(); - $validator2 = new Validator(); - $validator3 = new Validator(); - - TableRegistry::config('users', [ - 'validator' => [ - 'default' => $validator1, - 'secondary' => $validator2, - 'tertiary' => $validator3, - ] - ]); - $table = TableRegistry::get('users'); - - $this->assertSame($table->validator('default'), $validator1); - $this->assertSame($table->validator('secondary'), $validator2); - $this->assertSame($table->validator('tertiary'), $validator3); - } - - /** - * Test setting an instance. + * Test the get() method. * * @return void */ public function testSet() { - $mock = $this->getMock('Cake\ORM\Table'); - $this->assertSame($mock, TableRegistry::set('Articles', $mock)); - $this->assertSame($mock, TableRegistry::get('Articles')); - } - - /** - * Test setting an instance with plugin syntax aliases - * - * @return void - */ - public function testSetPlugin() - { - Plugin::load('TestPlugin'); + $table = $this->getMock('Cake\ORM\Table'); - $mock = $this->getMock('TestPlugin\Model\Table\CommentsTable'); + $locator = $this->_setMockLocator(); + $locator->expects($this->once())->method('set')->with('Test', $table); - $this->assertSame($mock, TableRegistry::set('TestPlugin.Comments', $mock)); - $this->assertSame($mock, TableRegistry::get('TestPlugin.Comments')); + TableRegistry::set('Test', $table); } /** - * Tests genericInstances - * - * @return void - */ - public function testGenericInstances() - { - $foos = TableRegistry::get('Foos'); - $bars = TableRegistry::get('Bars'); - TableRegistry::get('Articles'); - $expected = ['Foos' => $foos, 'Bars' => $bars]; - $this->assertEquals($expected, TableRegistry::genericInstances()); - } - - /** - * Tests remove an instance + * Test the remove() method. * * @return void */ public function testRemove() { - $first = TableRegistry::get('Comments'); - - $this->assertTrue(TableRegistry::exists('Comments')); - - TableRegistry::remove('Comments'); - $this->assertFalse(TableRegistry::exists('Comments')); + $locator = $this->_setMockLocator(); + $locator->expects($this->once())->method('remove')->with('Test'); - $second = TableRegistry::get('Comments'); - - $this->assertNotSame($first, $second, 'Should be different objects, as the reference to the first was destroyed'); - $this->assertTrue(TableRegistry::exists('Comments')); + TableRegistry::remove('Test'); } /** - * testRemovePlugin - * - * Removing a plugin-prefixed model should not affect any other - * plugin-prefixed model, or app model. - * Removing an app model should not affect any other - * plugin-prefixed model. + * Test the clear() method. * * @return void */ - public function testRemovePlugin() + public function testClear() { - Plugin::load('TestPlugin'); - Plugin::load('TestPluginTwo'); + $locator = $this->_setMockLocator(); + $locator->expects($this->once())->method('clear'); - $app = TableRegistry::get('Comments'); - TableRegistry::get('TestPlugin.Comments'); - $plugin = TableRegistry::get('TestPluginTwo.Comments'); - - $this->assertTrue(TableRegistry::exists('Comments')); - $this->assertTrue(TableRegistry::exists('TestPlugin.Comments')); - $this->assertTrue(TableRegistry::exists('TestPluginTwo.Comments')); - - TableRegistry::remove('TestPlugin.Comments'); - - $this->assertTrue(TableRegistry::exists('Comments')); - $this->assertFalse(TableRegistry::exists('TestPlugin.Comments')); - $this->assertTrue(TableRegistry::exists('TestPluginTwo.Comments')); - - $app2 = TableRegistry::get('Comments'); - $plugin2 = TableRegistry::get('TestPluginTwo.Comments'); - - $this->assertSame($app, $app2, 'Should be the same Comments object'); - $this->assertSame($plugin, $plugin2, 'Should be the same TestPluginTwo.Comments object'); - - TableRegistry::remove('Comments'); - - $this->assertFalse(TableRegistry::exists('Comments')); - $this->assertFalse(TableRegistry::exists('TestPlugin.Comments')); - $this->assertTrue(TableRegistry::exists('TestPluginTwo.Comments')); - - $plugin3 = TableRegistry::get('TestPluginTwo.Comments'); - - $this->assertSame($plugin, $plugin3, 'Should be the same TestPluginTwo.Comments object'); + TableRegistry::clear(); } }