Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

1605 lines (1382 sloc) 54.881 kB
<?php
/**
* Lithium: the most rad php framework
*
* @copyright Copyright 2012, Union of RAD (http://union-of-rad.org)
* @license http://opensource.org/licenses/bsd-license.php The BSD License
*/
namespace lithium\tests\cases\data\source;
use lithium\data\model\Query;
use lithium\data\entity\Record;
use lithium\data\collection\RecordSet;
use lithium\tests\mocks\data\model\MockDatabase;
use lithium\tests\mocks\data\model\MockDatabasePost;
use lithium\tests\mocks\data\model\MockDatabaseComment;
use lithium\tests\mocks\data\model\MockDatabaseTagging;
use lithium\tests\mocks\data\model\MockDatabasePostRevision;
use lithium\tests\mocks\data\model\mock_database\MockResult;
class DatabaseTest extends \lithium\test\Unit {
public $db = null;
protected $_configs = array();
protected $_model = 'lithium\tests\mocks\data\model\MockDatabasePost';
protected $_gallery = 'lithium\tests\mocks\data\model\MockGallery';
protected $_imageTag = 'lithium\tests\mocks\data\model\MockImageTag';
public function setUp() {
MockDatabasePost::config();
MockDatabaseComment::config();
MockDatabaseTagging::config();
MockDatabasePostRevision::config();
$this->db = new MockDatabase();
MockDatabasePost::$connection = $this->db;
MockDatabaseComment::$connection = $this->db;
MockDatabaseTagging::$connection = $this->db;
MockDatabasePostRevision::$connection = $this->db;
}
public function tearDown() {
$this->db->logs = array();
$this->db->return = array();
}
public function testDefaultConfig() {
$expected = array(
'persistent' => true,
'host' => 'localhost',
'login' => 'root',
'password' => '',
'database' => null,
'encoding' => null,
'dsn' => null,
'options' => array(),
'autoConnect' => true,
'init' => true
);
$result = $this->db->testConfig();
$this->assertEqual($expected, $result);
}
public function testModifyConfig() {
$db = new MockDatabase(array('host' => '127.0.0.1', 'login' => 'bob'));
$expected = array(
'persistent' => true,
'host' => '127.0.0.1',
'login' => 'bob',
'password' => '',
'database' => null,
'encoding' => null,
'dsn' => null,
'options' => array(),
'autoConnect' => true,
'init' => true
);
$result = $db->testConfig();
$this->assertEqual($expected, $result);
}
public function testName() {
$result = $this->db->name("name");
$this->assertEqual("{name}", $result);
$result = $this->db->name("Model.name");
$this->assertEqual("{Model}.{name}", $result);
}
public function testValueWithSchema() {
$result = $this->db->value(null);
$this->assertIdentical('NULL', $result);
$result = $this->db->value('string', array('type' => 'string'));
$this->assertEqual("'string'", $result);
$result = $this->db->value('true', array('type' => 'boolean'));
$this->assertIdentical(1, $result);
$result = $this->db->value('1', array('type' => 'integer'));
$this->assertIdentical(1, $result);
$result = $this->db->value('1.1', array('type' => 'float'));
$this->assertIdentical(1.1, $result);
$result = $this->db->value('1', array('type' => 'string'));
$this->assertIdentical("'1'", $result);
$result = $this->db->value((object) 'CURRENT_TIMESTAMP', array('type' => 'timestamp'));
$this->assertIdentical('CURRENT_TIMESTAMP', $result);
$result = $this->db->value((object) 'REGEXP "^fo$"');
$this->assertIdentical('REGEXP "^fo$"', $result);
$date = date_default_timezone_get();
date_default_timezone_set('UTC');
$result = $this->db->value('Hello World', array('type' => 'timestamp'));
$this->assertIdentical("'1970-01-01 00:00:00'", $result);
date_default_timezone_set($date);
$result = $this->db->value('2012-05-25 22:44:00', array('type' => 'timestamp'));
$this->assertIdentical("'2012-05-25 22:44:00'", $result);
$result = $this->db->value('2012-05-25', array('type' => 'date'));
$this->assertIdentical("'2012-05-25'", $result);
$result = $this->db->value('now', array('type' => 'timestamp'));
$this->assertPattern("/^'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'/", $result);
$result = $this->db->value('now', array('type' => 'date'));
$this->assertPattern("/^'\d{4}-\d{2}-\d{2}'/", $result);
$result = $this->db->value('now', array('type' => 'time'));
$this->assertPattern("/^'\d{2}:\d{2}:\d{2}'/", $result);
}
public function testValueByIntrospect() {
$result = $this->db->value("string");
$this->assertIdentical("'string'", $result);
$result = $this->db->value(true);
$this->assertIdentical(1, $result);
$result = $this->db->value('1');
$this->assertIdentical(1, $result);
$result = $this->db->value('1.1');
$this->assertIdentical(1.1, $result);
}
public function testSchema() {
$model = $this->_model;
$model::config();
$modelName = '';
$expected = array($modelName => array('id', 'author_id', 'title', 'created'));
$result = $this->db->schema(new Query(compact('model')));
$this->assertEqual($expected, $result);
$query = new Query(compact('model') + array('fields' => '*'));
$result = $this->db->schema($query);
$this->assertEqual($expected, $result);
$query = new Query(array(
'model' => $this->_model,
'fields' => array('MockDatabaseComment'),
'with' => array('MockDatabaseComment')
));
$expected = array(
'' => array('id'),
'MockDatabaseComment' => array(
'id', 'post_id', 'author_id', 'body', 'created'
)
);
$result = $this->db->schema($query);
$this->assertEqual($expected, $result);
$options = array(
'model' => $this->_model,
'with' => 'MockDatabaseComment'
);
$options['fields'] = array('id', 'title');
$result = $this->db->schema(new Query($options));
$expected = array($modelName => $options['fields']);
$this->assertEqual($expected, $result);
$options['fields'] = array(
'MockDatabasePost.id',
'MockDatabasePost.title',
'MockDatabaseComment.body'
);
$result = $this->db->schema(new Query($options));
$expected = array(
$modelName => array('id', 'title'),
'MockDatabaseComment' => array('body')
);
$this->assertEqual($expected, $result);
$options['fields'] = array(
'MockDatabasePost' => array('id', 'title'),
'MockDatabaseComment' => array('body', 'created')
);
$result = $this->db->schema(new Query($options));
$expected = array(
$modelName => array('id', 'title'),
'MockDatabaseComment' => array('body', 'created')
);
$this->assertEqual($expected, $result);
$options['fields'] = array('MockDatabasePost', 'MockDatabaseComment');
$result = $this->db->schema(new Query($options));
$expected = array(
$modelName => array('id', 'author_id', 'title', 'created'),
'MockDatabaseComment' => array('id', 'post_id', 'author_id', 'body', 'created')
);
$this->assertEqual($expected, $result);
}
public function testSchemaFromManualFieldList() {
$fields = array('id', 'name', 'created');
$result = $this->db->schema(new Query(compact('fields')));
$this->assertEqual(array('' => $fields), $result);
}
public function testSimpleQueryRender() {
$fieldList = '{MockDatabasePost}.{id}, {MockDatabasePost}.{title},'
. ' {MockDatabasePost}.{created}';
$table = '{mock_database_posts} AS {MockDatabasePost}';
$result = $this->db->renderCommand(new Query(array(
'type' => 'read',
'model' => $this->_model,
'fields' => array('id', 'title', 'created')
)));
$this->assertEqual("SELECT {$fieldList} FROM {$table};", $result);
$result = $this->db->renderCommand(new Query(array(
'type' => 'read',
'model' => $this->_model,
'fields' => array('id', 'title', 'created'),
'limit' => 1
)));
$this->assertEqual("SELECT {$fieldList} FROM {$table} LIMIT 1;", $result);
$result = $this->db->renderCommand(new Query(array(
'type' => 'read',
'model' => $this->_model,
'fields' => array('id', 'title', 'created'),
'limit' => 1,
'conditions' => 'Post.id = 2'
)));
$this->assertEqual("SELECT {$fieldList} FROM {$table} WHERE Post.id = 2 LIMIT 1;", $result);
}
public function testNestedQueryConditions() {
$query = new Query(array(
'type' => 'read',
'model' => $this->_model,
'fields' => array('MockDatabasePost.title', 'MockDatabasePost.body'),
'conditions' => array('Post.id' => new Query(array(
'type' => 'read',
'fields' => array('post_id'),
'model' => 'lithium\tests\mocks\data\model\MockDatabaseTagging',
'conditions' => array('MockDatabaseTag.tag' => array('foo', 'bar', 'baz'))
)))
));
$result = $this->db->renderCommand($query);
$expected = "SELECT {MockDatabasePost}.{title}, {MockDatabasePost}.{body} FROM";
$expected .= " {mock_database_posts} AS {MockDatabasePost} WHERE {Post}.{id} IN";
$expected .= " (SELECT {MockDatabaseTagging}.{post_id} FROM {mock_database_taggings} AS ";
$expected .= "{MockDatabaseTagging} WHERE {MockDatabaseTag}.{tag} IN";
$expected .= " ('foo', 'bar', 'baz'));";
$this->assertEqual($expected, $result);
$query = new Query(array(
'type' => 'read',
'model' => $this->_model,
'fields' => array('MockDatabasePost.title', 'MockDatabasePost.body'),
'conditions' => array('Post.id' => array('!=' => new Query(array(
'type' => 'read',
'fields' => array('post_id'),
'model' => 'lithium\tests\mocks\data\model\MockDatabaseTagging',
'conditions' => array('MockDatabaseTag.tag' => array('foo', 'bar', 'baz'))
))))
));
$result = $this->db->renderCommand($query);
$expected = "SELECT {MockDatabasePost}.{title}, {MockDatabasePost}.{body} FROM";
$expected .= " {mock_database_posts} AS {MockDatabasePost} WHERE ({Post}.{id} NOT IN";
$expected .= " (SELECT {MockDatabaseTagging}.{post_id} FROM {mock_database_taggings} AS ";
$expected .= "{MockDatabaseTagging} WHERE {MockDatabaseTag}.{tag} IN ";
$expected .= "('foo', 'bar', 'baz')));";
$this->assertEqual($expected, $result);
$query = new Query(array(
'type' => 'read', 'model' => $this->_model,
'conditions' => array(
'or' => array(
'{MockDatabasePost}.{id}' => 'value1',
'{MockDatabasePost}.{title}' => 'value2'
)
)
));
$sql = "SELECT * FROM {mock_database_posts} AS {MockDatabasePost} WHERE ";
$sql .= "({MockDatabasePost}.{id} = 'value1' OR {MockDatabasePost}.{title} = 'value2');";
$this->assertEqual($sql, $this->db->renderCommand($query));
}
public function testCastingQueryConditionsWithSchemaWithAlias() {
$query = new Query(array(
'type' => 'read',
'model' => $this->_model,
'conditions' => array(
'MockDatabasePost.title' => '007'
)
));
$result = $this->db->renderCommand($query);
$sql = "SELECT * FROM {mock_database_posts} AS {MockDatabasePost} WHERE ";
$sql .= "{MockDatabasePost}.{title} = '007';";
$this->assertEqual($sql, $result);
}
public function testQueryJoin() {
$query = new Query(array(
'type' => 'read',
'model' => $this->_model,
'fields' => array('MockDatabasePost.title', 'MockDatabasePost.body'),
'conditions' => array('MockDatabaseTag.tag' => array('foo', 'bar', 'baz')),
'joins' => array(new Query(array(
'model' => 'lithium\tests\mocks\data\model\MockDatabaseTag',
'constraints' => '{MockDatabaseTagging}.{tag_id} = {MockDatabaseTag}.{id}'
)))
));
$result = $this->db->renderCommand($query);
$expected = "SELECT {MockDatabasePost}.{title}, {MockDatabasePost}.{body} FROM";
$expected .= " {mock_database_posts} AS {MockDatabasePost} JOIN {mock_database_tags} AS";
$expected .= " {MockDatabaseTag} ON ";
$expected .= "{MockDatabaseTagging}.{tag_id} = {MockDatabaseTag}.{id}";
$expected .= " WHERE {MockDatabaseTag}.{tag} IN ('foo', 'bar', 'baz');";
$this->assertEqual($expected, $result);
}
public function testItem() {
$data = array('title' => 'new post', 'content' => 'This is a new post.');
$item = $this->db->item($this->_model, $data);
$result = $item->data();
$this->assertEqual($data, $result);
}
public function testCreate() {
$entity = new Record(array(
'model' => $this->_model,
'data' => array('title' => 'new post', 'body' => 'the body')
));
$query = new Query(compact('entity') + array(
'type' => 'create',
'model' => $this->_model
));
$hash = $query->export($this->db);
ksort($hash);
$expected = sha1(serialize($hash));
$result = $this->db->create($query);
$this->assertTrue($result);
$result = $query->entity()->id;
$this->assertEqual($expected, $result);
$expected = "INSERT INTO {mock_database_posts} ({title}, {body})";
$expected .= " VALUES ('new post', 'the body');";
$result = $this->db->sql;
$this->assertEqual($expected, $result);
}
public function testCreateGenericSyntax() {
$entity = new Record(array(
'model' => $this->_model,
'data' => array('data' => array('title' => 'new post', 'body' => 'the body'))
));
$query = new Query(compact('entity') + array(
'type' => 'create',
'model' => $this->_model
));
$hash = $query->export($this->db);
ksort($hash);
$expected = sha1(serialize($hash));
$result = $this->db->create($query);
$this->assertTrue($result);
$result = $query->entity()->id;
$this->assertEqual($expected, $result);
$expected = "INSERT INTO {mock_database_posts} ({title}, {body})";
$expected .= " VALUES ('new post', 'the body');";
$result = $this->db->sql;
$this->assertEqual($expected, $result);
}
public function testCreateWithValueBySchema() {
$entity = new Record(array(
'model' => $this->_model,
'data' => array('title' => '007', 'body' => 'the body')
));
$query = new Query(compact('entity') + array(
'type' => 'create',
'model' => $this->_model
));
$hash = $query->export($this->db);
ksort($hash);
$expected = sha1(serialize($hash));
$result = $this->db->create($query);
$this->assertTrue($result);
$result = $query->entity()->id;
$this->assertEqual($expected, $result);
$expected = "INSERT INTO {mock_database_posts} ({title}, {body})";
$expected .= " VALUES ('007', 'the body');";
$result = $this->db->sql;
$this->assertEqual($expected, $result);
}
public function testCreateWithKey() {
$entity = new Record(array(
'model' => $this->_model,
'data' => array('id' => 1, 'title' => 'new post', 'body' => 'the body')
));
$query = new Query(compact('entity') + array('type' => 'create'));
$expected = 1;
$result = $this->db->create($query);
$this->assertTrue($result);
$result = $query->entity()->id;
$this->assertEqual($expected, $result);
$expected = "INSERT INTO {mock_database_posts} ({id}, {title}, {body})";
$expected .= " VALUES (1, 'new post', 'the body');";
$this->assertEqual($expected, $this->db->sql);
}
public function testReadWithQueryStringReturnResource() {
$result = $this->db->read('SELECT * from mock_database_posts AS MockDatabasePost;', array(
'return' => 'resource'
));
$this->assertTrue($result);
$expected = "SELECT * from mock_database_posts AS MockDatabasePost;";
$this->assertEqual($expected, $this->db->sql);
}
public function testCalculation() {
$options = array('type' => 'read', 'model' => $this->_model);
$this->expectException('Undefined offset: 0');
$result = $this->db->calculation('count', new Query($options), $options);
$expected = 'SELECT COUNT(*) as count FROM {mock_database_posts} AS {MockDatabasePost};';
$this->assertEqual($expected, $this->db->sql);
}
public function testReadWithQueryStringReturnArrayWithSchema() {
$result = $this->db->read('SELECT * FROM {:table} WHERE user_id = {:uid};', array(
'table' => 'mock_database_posts',
'uid' => '3',
'schema' => array('id', 'title', 'text')
));
$expected = 'SELECT * FROM \'mock_database_posts\' WHERE user_id = 3;';
$this->assertEqual($expected, $this->db->sql);
}
public function testReadWithQueryObjectRecordSet() {
$query = new Query(array('type' => 'read', 'model' => $this->_model));
$result = $this->db->read($query);
$this->assertTrue($result instanceof RecordSet);
$expected = "SELECT * FROM {mock_database_posts} AS {MockDatabasePost};";
$result = $this->db->sql;
$this->assertEqual($expected, $result);
}
public function testReadWithQueryObjectArray() {
$query = new Query(array('type' => 'read', 'model' => $this->_model));
$result = $this->db->read($query, array('return' => 'array'));
$this->assertTrue(is_array($result));
$expected = "SELECT * FROM {mock_database_posts} AS {MockDatabasePost};";
$result = $this->db->sql;
$this->assertEqual($expected, $result);
}
public function testUpdate() {
$entity = new Record(array(
'model' => $this->_model,
'data' => array('id' => 1, 'title' => 'new post', 'body' => 'the body'),
'exists' => true
));
$query = new Query(compact('entity') + array('type' => 'update'));
$result = $this->db->update($query);
$this->assertTrue($result);
$this->assertEqual(1, $query->entity()->id);
$expected = "UPDATE {mock_database_posts} SET";
$expected .= " {id} = 1, {title} = 'new post', {body} = 'the body' WHERE {id} = 1;";
$this->assertEqual($expected, $this->db->sql);
$entity = new Record(array(
'model' => $this->_model,
'data' => array('id' => 2, 'count' => (object) '{count} + 1'),
'exists' => true
));
$query = new Query(compact('entity') + array('type' => 'update'));
$result = $this->db->update($query);
$this->assertTrue($result);
$this->assertEqual(2, $query->entity()->id);
$expected = "UPDATE {mock_database_posts} SET";
$expected .= " {id} = 2, {count} = {count} + 1 WHERE {id} = 2;";
$this->assertEqual($expected, $this->db->sql);
$query = new Query(array(
'type' => 'update',
'data' => array('modified' => (object) 'NOW()'),
'model' => $this->_model
));
$sql = "UPDATE {mock_database_posts} SET {modified} = NOW();";
$this->assertEqual($sql, $this->db->renderCommand($query));
}
public function testUpdateWithValueBySchema() {
$entity = new Record(array(
'model' => $this->_model,
'data' => array('id' => 1, 'title' => '007', 'body' => 'the body'),
'exists' => true
));
$query = new Query(compact('entity') + array('type' => 'update'));
$result = $this->db->update($query);
$this->assertTrue($result);
$this->assertEqual(1, $query->entity()->id);
$expected = "UPDATE {mock_database_posts} SET";
$expected .= " {id} = 1, {title} = '007', {body} = 'the body' WHERE {id} = 1;";
$this->assertEqual($expected, $this->db->sql);
}
public function testDelete() {
$entity = new Record(array(
'model' => $this->_model,
'data' => array('id' => 1, 'title' => 'new post', 'body' => 'the body'),
'exists' => true
));
$query = new Query(compact('entity') + array('type' => 'delete'));
$this->assertTrue($entity->exists());
$this->assertTrue($this->db->delete($query));
$this->assertEqual(1, $query->entity()->id);
$expected = "DELETE FROM {mock_database_posts} WHERE {id} = 1;";
$this->assertEqual($expected, $this->db->sql);
$this->assertFalse($entity->exists());
}
public function testOrder() {
$query = new Query(array('model' => $this->_model));
$result = $this->db->order("foo_bar", $query);
$expected = 'ORDER BY foo_bar ASC';
$this->assertEqual($expected, $result);
$result = $this->db->order("title", $query);
$expected = 'ORDER BY {MockDatabasePost}.{title} ASC';
$this->assertEqual($expected, $result);
$result = $this->db->order("title", $query);
$expected = 'ORDER BY {MockDatabasePost}.{title} ASC';
$this->assertEqual($expected, $result);
$result = $this->db->order(array("title"), $query);
$expected = 'ORDER BY {MockDatabasePost}.{title} ASC';
$this->assertEqual($expected, $result);
$result = $this->db->order(array("title" => "desc"), $query);
$expected = 'ORDER BY {MockDatabasePost}.{title} desc';
$this->assertEqual($expected, $result);
$result = $this->db->order(array("title" => "dasc"), $query);
$expected = 'ORDER BY {MockDatabasePost}.{title} ASC';
$this->assertEqual($expected, $result);
$result = $this->db->order(array("title" => array()), $query);
$expected = 'ORDER BY {MockDatabasePost}.{title} ASC';
$this->assertEqual($expected, $result);
$result = $this->db->order(array('author_id', "title" => "DESC"), $query);
$expected = 'ORDER BY {MockDatabasePost}.{author_id} ASC, {MockDatabasePost}.{title} DESC';
$this->assertEqual($expected, $result);
}
public function testOrderOnRelated() {
$query = new Query(array(
'model' => $this->_model,
'with' => array('MockDatabaseComment')
));
$result = $this->db->order('MockDatabaseComment.created DESC', $query);
$expected = 'ORDER BY MockDatabaseComment.created DESC';
$this->assertEqual($expected, $result);
$result = $this->db->order(array('MockDatabaseComment.created' => 'DESC'), $query);
$expected = 'ORDER BY MockDatabaseComment.created DESC';
$this->assertEqual($expected, $result);
$result = $this->db->order(
array(
'MockDatabasePost.title' => 'ASC',
'MockDatabaseComment.created' => 'DESC'
),
$query
);
$expected = 'ORDER BY MockDatabasePost.title ASC, MockDatabaseComment.created DESC';
$this->assertEqual($expected, $result);
$result = $this->db->order(
array(
'title' => 'ASC',
'MockDatabaseComment.created' => 'DESC'
),
$query
);
$expected = 'ORDER BY {MockDatabasePost}.{title} ASC, MockDatabaseComment.created DESC';
$this->assertEqual($expected, $result);
}
public function testScopedDelete() {
$query = new Query(array(
'type' => 'delete',
'conditions' => array('published' => false),
'model' => $this->_model
));
$sql = 'DELETE FROM {mock_database_posts} WHERE {published} = 0;';
$this->assertEqual($sql, $this->db->renderCommand($query));
}
public function testScopedUpdate() {
$query = new Query(array(
'type' => 'update',
'conditions' => array('expires' => array('>=' => '2010-05-13')),
'data' => array('published' => false, 'comments' => null),
'model' => $this->_model
));
$sql = "UPDATE {mock_database_posts} SET {published} = 0, {comments} = NULL WHERE ";
$sql .= "({expires} >= '2010-05-13');";
$this->assertEqual($sql, $this->db->renderCommand($query));
}
public function testQueryOperators() {
$query = new Query(array('type' => 'read', 'model' => $this->_model, 'conditions' => array(
'score' => array('between' => array(90, 100))
)));
$sql = "SELECT * FROM {mock_database_posts} AS {MockDatabasePost} WHERE ({score} ";
$sql .= "BETWEEN 90 AND 100);";
$this->assertEqual($sql, $this->db->renderCommand($query));
$query = new Query(array('type' => 'read', 'model' => $this->_model, 'conditions' => array(
'score' => array('>' => 90, '<' => 100)
)));
$sql = "SELECT * FROM {mock_database_posts} AS {MockDatabasePost} WHERE ";
$sql .= "({score} > 90 AND {score} < 100);";
$this->assertEqual($sql, $this->db->renderCommand($query));
$query = new Query(array('type' => 'read', 'model' => $this->_model, 'conditions' => array(
'score' => array('!=' => array(98, 99, 100))
)));
$sql = "SELECT * FROM {mock_database_posts} AS {MockDatabasePost} ";
$sql .= "WHERE ({score} NOT IN (98, 99, 100));";
$this->assertEqual($sql, $this->db->renderCommand($query));
$query = new Query(array('type' => 'read', 'model' => $this->_model, 'conditions' => array(
'scorer' => array('like' => '%howard%')
)));
$sql = "SELECT * FROM {mock_database_posts} AS {MockDatabasePost} ";
$sql .= "WHERE ({scorer} like '%howard%');";
$this->assertEqual($sql, $this->db->renderCommand($query));
$conditions = "custom conditions string";
$query = new Query(compact('conditions') + array(
'type' => 'read', 'model' => $this->_model
));
$sql = "SELECT * FROM {mock_database_posts} AS {MockDatabasePost} WHERE {$conditions};";
$this->assertEqual($sql, $this->db->renderCommand($query));
$query = new Query(array(
'type' => 'read', 'model' => $this->_model,
'conditions' => array(
'field' => array('like' => '%value%', 'not like' => '%value2%')
)
));
$sql = "SELECT * FROM {mock_database_posts} AS {MockDatabasePost} WHERE ";
$sql .= "({field} like '%value%' AND {field} not like '%value2%');";
$this->assertEqual($sql, $this->db->renderCommand($query));
}
public function testConditions() {
$query = new Query(array(
'type' => 'read', 'model' => $this->_model,
'conditions' => array(
'or' => array(
'id' => 'value1',
'title' => 'value2',
'and' => array(
'author_id' => '1',
'created' => '2012-05-25 23:41:00'
),
array('title' => 'value2'),
array('title' => null)
),
'id' => '3',
'author_id' => false
)
));
$sql = "SELECT * FROM {mock_database_posts} AS {MockDatabasePost} WHERE ";
$sql .= "({MockDatabasePost}.{id} = 0 OR {MockDatabasePost}.{title} = 'value2' OR ";
$sql .= "({MockDatabasePost}.{author_id} = 1 AND {MockDatabasePost}.{created} = ";
$sql .= "'2012-05-25 23:41:00') OR ({MockDatabasePost}.{title} = 'value2') OR ";
$sql .= "({MockDatabasePost}.{title} IS NULL)) AND {MockDatabasePost}.{id} = 3 AND ";
$sql .= "{MockDatabasePost}.{author_id} = 0;";
$this->assertEqual($sql, $this->db->renderCommand($query));
$query = new Query(array(
'type' => 'read', 'model' => $this->_model,
'conditions' => array('title' => array('0900'))
));
$sql = 'SELECT * FROM {mock_database_posts} AS {MockDatabasePost}';
$sql .= ' WHERE {title} IN (\'0900\');';
$this->assertEqual($sql, $this->db->renderCommand($query));
$sql = 'SELECT * FROM {mock_database_posts} AS {MockDatabasePost} WHERE ';
$sql .= 'lower(title) = \'test\';';
$query = new Query(array(
'type' => 'read', 'model' => $this->_model,
'conditions' => array('lower(title)' => 'test')
));
$this->assertEqual($sql, $this->db->renderCommand($query));
$query = new Query(array(
'type' => 'read', 'model' => $this->_model,
'conditions' => array( (object) 'lower(title) = \'test\'')
));
$this->assertEqual($sql, $this->db->renderCommand($query));
$sql = 'SELECT * FROM {mock_database_posts} AS {MockDatabasePost} WHERE ';
$sql .= 'lower(title) = REGEXP \'^test$\';';
$query = new Query(array(
'type' => 'read', 'model' => $this->_model,
'conditions' => array( (object) 'lower(title) = REGEXP \'^test$\'')
));
$this->assertEqual($sql, $this->db->renderCommand($query));
$query = new Query(array(
'type' => 'read', 'model' => $this->_model,
'conditions' => array( 'lower(title)' => (object) 'REGEXP \'^test$\'')
));
$this->assertEqual($sql, $this->db->renderCommand($query));
}
public function testHaving() {
$query = new Query(array(
'type' => 'read', 'model' => $this->_model,
'having' => array(
'or' => array(
'id' => 'value1',
'title' => 'value2',
'and' => array(
'author_id' => '1',
'created' => '2012-05-25 23:41:00'
),
array('title' => 'value2'),
array('title' => null)
),
'id' => '3',
'author_id' => false
)
));
$sql = "SELECT * FROM {mock_database_posts} AS {MockDatabasePost} HAVING ";
$sql .= "({MockDatabasePost}.{id} = 0 OR {MockDatabasePost}.{title} = 'value2' OR ";
$sql .= "({MockDatabasePost}.{author_id} = 1 AND {MockDatabasePost}.{created} = ";
$sql .= "'2012-05-25 23:41:00') OR ({MockDatabasePost}.{title} = 'value2') OR ";
$sql .= "({MockDatabasePost}.{title} IS NULL)) AND {MockDatabasePost}.{id} = 3 AND ";
$sql .= "{MockDatabasePost}.{author_id} = 0;";
$this->assertEqual($sql, $this->db->renderCommand($query));
$query = new Query(array(
'type' => 'read', 'model' => $this->_model,
'having' => array('title' => array('0900'))
));
$sql = 'SELECT * FROM {mock_database_posts} AS {MockDatabasePost}' .
' HAVING {title} IN (\'0900\');';
$this->assertEqual($sql, $this->db->renderCommand($query));
}
public function testConstraints() {
$model = $this->_model;
$query = new Query(array(
'type' => 'read',
'model' => $this->_model,
'with' => array(
'MockDatabaseComment' => array(
'constraints' => array(
'or' => array(
array('custom_id' => 'MockDatabasePost.value_id'),
array('custom_id' => 'id'),
'and' => array(
'id' => 'MockDatabasePost.id',
'title' => 'MockDatabasePost.title'
),
array('title' => (object) $this->db->value('value2')),
array('title' => null)
),
'id' => 5
)))));
$sql = 'SELECT * FROM {mock_database_posts} AS {MockDatabasePost} LEFT JOIN ';
$sql .= '{mock_database_comments} AS {MockDatabaseComment} ON ';
$sql .= '(({MockDatabasePost}.{custom_id} = {MockDatabasePost}.{value_id}) OR ';
$sql .= '({MockDatabasePost}.{custom_id} = {MockDatabaseComment}.{id}) OR ';
$sql .= '({MockDatabasePost}.{id} = {MockDatabasePost}.{id} AND {MockDatabasePost}.{title} ';
$sql .= '= {MockDatabasePost}.{title}) OR ({MockDatabasePost}.{title} = \'value2\') ';
$sql .= 'OR ({MockDatabasePost}.{title} IS NULL)) AND {MockDatabasePost}.{id} = 5;';
$this->assertEqual($sql, $this->db->renderCommand($query));
}
public function testReadConditionsWithModel() {
$model = $this->_model;
$options = array(
'type' => 'read',
'model' => $this->_model,
'conditions' => array('id' => 1, 'MockDatabaseComment.id' => 2),
'with' => array('MockDatabaseComment')
);
$result = $this->db->read(new Query($options), $options);
$expected = 'SELECT * FROM {mock_database_posts} AS {MockDatabasePost} LEFT JOIN ';
$expected .= '{mock_database_comments} AS {MockDatabaseComment} ON ';
$expected .= '{MockDatabasePost}.{id} = {MockDatabaseComment}.{mock_database_post_id} ';
$expected .= 'WHERE {MockDatabasePost}.{id} = 1 AND {MockDatabaseComment}.{id} = 2;';
$this->assertEqual($expected, $this->db->sql);
}
public function testFields() {
$query = new Query(array(
'model' => $this->_model,
'with' => array('MockDatabaseComment')
));
$fields = array('id', 'title');
$result = $this->db->fields($fields, $query);
$expected = '{MockDatabasePost}.{id}, {MockDatabasePost}.{title}';
$this->assertEqual($expected,$result);
$fields = array(
'MockDatabasePost' => array('id', 'title', 'created'),
'MockDatabaseComment' => array('body')
);
$result = $this->db->fields($fields, $query);
$expected = '{MockDatabasePost}.{id}, {MockDatabasePost}.{title},';
$expected .= ' {MockDatabasePost}.{created}, {MockDatabaseComment}.{body}';
$this->assertEqual($expected,$result);
$fields = array('MockDatabasePost', 'MockDatabaseComment');
$result = $this->db->fields($fields, $query);
$expected = '{MockDatabasePost}.*, {MockDatabaseComment}.*';
$this->assertEqual($expected, $result);
$fields = array('MockDatabasePost.id as idPost', 'MockDatabaseComment.id AS idComment');
$result = $this->db->fields($fields, $query);
$expected = '{MockDatabasePost}.{id} as idPost, {MockDatabaseComment}.{id} as idComment';
$this->assertEqual($expected, $result);
$expected = array('' => array('idPost'), 'MockDatabaseComment' => array('idComment'));
$this->assertEqual($expected, $query->map());
$fields = array(array('count(MockDatabasePost.id)'));
$expected = 'count(MockDatabasePost.id)';
$result = $this->db->fields($fields, $query);
$this->assertEqual($expected, $result);
$fields = array(array((object) 'count(MockDatabasePost.id)'));
$expected = 'count(MockDatabasePost.id)';
$result = $this->db->fields($fields, $query);
$this->assertEqual($expected, $result);
}
public function testFieldsWithEmptyAlias() {
$query = new Query();
$result = $this->db->fields(array('id', 'name', 'created'), $query);
$expected = '{id}, {name}, {created}';
$this->assertEqual($expected, $result);
}
public function testRawConditions() {
$query = new Query(array('type' => 'read', 'model' => $this->_model, 'conditions' => null));
$this->assertFalse($this->db->conditions(5, $query));
$this->assertFalse($this->db->conditions(null, $query));
$this->assertEqual("WHERE CUSTOM", $this->db->conditions("CUSTOM", $query));
}
public function testRawHaving() {
$query = new Query(array('type' => 'read', 'model' => $this->_model, 'having' => null));
$this->assertFalse($this->db->having(5, $query));
$this->assertFalse($this->db->having(null, $query));
$this->assertEqual("HAVING CUSTOM", $this->db->having("CUSTOM", $query));
}
public function testRelationshipGeneration() {
$comment = 'lithium\tests\mocks\data\model\MockDatabaseComment';
$hasMany = $this->db->relationship($this->_model, 'hasMany', 'Comments', array(
'to' => $comment
));
$this->assertEqual(array('id' => 'mock_database_post_id'), $hasMany->key());
$this->assertEqual('comments', $hasMany->fieldName());
$belongsTo = $this->db->relationship($comment, 'belongsTo', 'Posts', array(
'to' => $this->_model
));
$this->assertEqual(array('post_id' => 'id'), $belongsTo->key());
$this->assertEqual('post', $belongsTo->fieldName());
}
public function testRelationshipGenerationWithNullConstraint() {
$postRevision = 'lithium\tests\mocks\data\model\MockDatabasePostRevision';
$hasMany = $this->db->relationship($this->_model, 'hasMany', 'PostRevisions', array(
'to' => $postRevision,
'constraints' => array('MockDatabasePostRevision.deleted' => null)
));
$this->assertEqual(array('id' => 'mock_database_post_id'), $hasMany->key());
$this->assertEqual('post_revisions', $hasMany->fieldName());
$expected = array(
'MockDatabasePostRevision.deleted' => null,
'MockDatabasePost.id' => 'PostRevisions.mock_database_post_id'
);
$result = $this->db->on($hasMany);
$this->assertEqual($expected, $result);
$belongsTo = $this->db->relationship($postRevision, 'belongsTo', 'Posts', array(
'to' => $this->_model
));
$this->assertEqual(array('post_id' => 'id'), $belongsTo->key());
$this->assertEqual('post', $belongsTo->fieldName());
}
public function testInvalidQueryType() {
$this->expectException('Invalid query type `fakeType`.');
$this->db->read(new Query(array('type' => 'fakeType')));
}
public function testReadWithRelationship() {
$options = array(
'type' => 'read',
'model' => $this->_model,
'with' => array('MockDatabaseComment')
);
$result = $this->db->read(new Query($options), $options);
$expected = 'SELECT * FROM {mock_database_posts} AS {MockDatabasePost} LEFT JOIN ';
$expected .= '{mock_database_comments} AS {MockDatabaseComment} ON ';
$expected .= '{MockDatabasePost}.{id} = {MockDatabaseComment}.{mock_database_post_id};';
$this->assertEqual($expected, $this->db->sql);
}
public function testReadWithRelationshipWithNullConstraint() {
$options = array(
'type' => 'read',
'model' => $this->_model,
'with' => array('MockDatabasePostRevision')
);
$result = $this->db->read(new Query($options), $options);
$expected = 'SELECT * FROM {mock_database_posts} AS {MockDatabasePost} LEFT JOIN ';
$expected .= '{mock_database_post_revisions} AS {MockDatabasePostRevision} ON ';
$expected .= '{MockDatabasePostRevision}.{deleted} IS NULL AND ';
$expected .= '{MockDatabasePost}.{id} = {MockDatabasePostRevision}.{mock_database_post_id};';
$this->assertEqual($expected, $this->db->sql);
}
public function testReadWithHasManyAndLimit() {
$options = array(
'type' => 'read',
'model' => $this->_model,
'with' => array('MockDatabaseComment'),
'limit' => 1
);
$result = $this->db->read(new Query($options), $options);
$this->assertFalse($result instanceof RecordSet);
}
public function testGroup() {
$result = $this->db->group(array('id ASC'));
$expected = 'GROUP BY id ASC';
$this->assertEqual($expected, $result);
}
public function testLimit() {
MockDatabasePost::find('all', array('limit' => 15));
$result = $this->db->sql;
$expected = 'SELECT * FROM {mock_database_posts} AS {MockDatabasePost} LIMIT 15;';
$this->assertEqual($expected, $result);
MockDatabasePost::find('all', array('limit' => 10, 'page' => 3));
$result = $this->db->sql;
$expected = 'SELECT * FROM {mock_database_posts} AS {MockDatabasePost} LIMIT 10 OFFSET 20;';
$this->assertEqual($expected, $result);
}
/**
* Tests that various syntaxes for the `'order'` key of the query object produce the correct
* SQL.
*/
public function testQueryOrderSyntaxes() {
$query = new Query(array(
'type' => 'read', 'model' => $this->_model, 'order' => array('created' => 'ASC')
));
$sql = 'SELECT * FROM {mock_database_posts} AS {MockDatabasePost} ';
$sql .= 'ORDER BY {MockDatabasePost}.{created} ASC;';
$this->assertEqual($sql, $this->db->renderCommand($query));
}
/**
* Tests that complex model constraints with custom operators render correct constraint strings.
*/
public function testRenderArrayJoinConstraintComplex() {
$model = 'lithium\tests\mocks\data\model\MockQueryComment';
$query = new Query(compact('model') + array(
'type' => 'read',
'source' => 'comments',
'alias' => 'Comments',
'conditions' => array('Comment.id' => 1),
'joins' => array(array(
'type' => 'INNER',
'source' => 'posts',
'alias' => 'Post',
'constraints' => array('Comment.post_id' => array('<=' => 'Post.id'))
))
));
$expected = "SELECT * FROM {comments} AS {Comments} INNER JOIN {posts} AS {Post} ON ";
$expected .= "({Comment}.{post_id} <= {Post}.{id}) WHERE {Comment}.{id} = 1;";
$result = $this->db->renderCommand($query);
$this->assertEqual($expected, $result);
}
/**
* Tests that complex model constraints with custom operators render correct constraint strings.
*/
public function testRenderArrayJoinConstraintComplexArray() {
$model = 'lithium\tests\mocks\data\model\MockQueryComment';
$query = new Query(compact('model') + array(
'type' => 'read',
'source' => 'comments',
'alias' => 'Comments',
'conditions' => array('Comment.id' => 1),
'joins' => array(array(
'type' => 'LEFT',
'source' => 'posts',
'alias' => 'Post',
'constraints' => array(
"Comment.post_id" => array(
'<=' => 'Post.id',
'>=' => 'Post.id'
)
)
)
)));
$expected = "SELECT * FROM {comments} AS {Comments} LEFT JOIN {posts} AS {Post} ON ";
$expected .= "({Comment}.{post_id} <= {Post}.{id} AND {Comment}.{post_id} >= {Post}.{id}) ";
$expected .= "WHERE {Comment}.{id} = 1;";
$result = $this->db->renderCommand($query);
$this->assertEqual($expected, $result);
$query = new Query(compact('model') + array(
'type' => 'read',
'source' => 'comments',
'alias' => 'Comments',
'joins' => array(array(
'type' => 'LEFT',
'source' => 'posts',
'alias' => 'Post',
'constraints' => array(
'Comment.post_id' => array('=>' => 'Post.id')
)
))
));
$this->expectException("Unsupported operator `=>`.");
$this->db->renderCommand($query);
}
public function testRenderArrayJoin() {
$model = 'lithium\tests\mocks\data\model\MockQueryComment';
$query = new Query(compact('model') + array(
'type' => 'read',
'source' => 'comments',
'alias' => 'Comment',
'conditions' => array('Comment.id' => 1),
'joins' => array(array(
'type' => 'INNER',
'source' => 'posts',
'alias' => 'Post',
'constraints' => array('Comment.post_id' => 'Post.id')
))
));
$expected = "SELECT * FROM {comments} AS {Comment} INNER JOIN {posts} AS {Post} ON ";
$expected .= "{Comment}.{post_id} = {Post}.{id} WHERE {Comment}.{id} = 1;";
$result = $this->db->renderCommand($query);
$this->assertEqual($expected, $result);
}
public function testModelFindBy() {
$this->db->log = true;
MockDatabasePost::findById(5, array('with' => 'MockDatabaseComment'));
$this->db->log = false;
$result = MockDatabasePost::$connection->logs[0];
$expected = "SELECT DISTINCT({MockDatabasePost}.{id}) AS _ID_ FROM {mock_database_posts} AS ";
$expected .= "{MockDatabasePost} LEFT JOIN {mock_database_comments} AS ";
$expected .= "{MockDatabaseComment} ON {MockDatabasePost}.{id} = ";
$expected .= "{MockDatabaseComment}.{mock_database_post_id} WHERE ";
$expected .= "{MockDatabasePost}.{id} = 5 LIMIT 1;";
$this->assertEqual($expected, $result);
}
public function testsplitFieldname() {
$result = $this->db->invokeMethod('_splitFieldname', array('Alias.fieldname'));
$this->assertEqual(array('Alias', 'fieldname'), $result);
$result = $this->db->invokeMethod('_splitFieldname', array('fieldname'));
$this->assertEqual(array(null, 'fieldname'), $result);
$result = $this->db->invokeMethod('_splitFieldname', array('fieldname'));
$this->assertEqual(array(null, 'fieldname'), $result);
$result = $this->db->invokeMethod('_splitFieldname', array('lower(Alias.fieldname)'));
$this->assertEqual(array(null, 'lower(Alias.fieldname)'), $result);
$result = $this->db->invokeMethod('_splitFieldname', array('Alias.*'));
$this->assertEqual(array('Alias', '*'), $result);
}
public function testOn() {
$conn = MockDatabasePost::connection();
$expected = array(
'MockDatabasePost.id' => 'MockDatabaseComment.mock_database_post_id'
);
$this->assertEqual($expected, $conn->on(MockDatabasePost::relations('MockDatabaseComment')));
$expected = array(
'MockDatabaseComment.mock_database_post_id' => 'MockDatabasePost.id'
);
$this->assertEqual($expected, $conn->on(MockDatabaseComment::relations('MockDatabasePost')));
$expected = array(
'MockDatabasePost.id' => 'MockDatabaseComment.mock_database_post_id',
'MockDatabasePost.published' => (object) "'yes'"
);
$rel = MockDatabasePost::relations('MockDatabaseComment');
$result = $conn->on($rel, null, null, array('published' => (object) "'yes'"));
$this->assertEqual($expected, $result);
$expected = array(
'CustomPost.id' => 'CustomComment.mock_database_post_id',
'CustomPost.published' => (object) "'no'"
);
$constraints = array('published' => (object) "'no'");
$result = $conn->on($rel, 'CustomPost', 'CustomComment', $constraints);
$this->assertEqual($expected, $result);
$expected = array(
'CustomPost.id' => 'CustomComment.post_id'
);
$constraints = array('CustomPost.id' => 'CustomComment.post_id');
$result = $conn->on($rel, 'CustomPost', 'CustomComment', $constraints);
$this->assertEqual($expected, $result);
}
public function testWithGeneration() {
$model = $this->_gallery;
$options = array(
'type' => 'read',
'model' => $model,
'with' => array('Image.ImageTag.Tag')
);
$result = $this->db->read(new Query($options));
$expected = 'SELECT * FROM {mock_gallery} AS {Gallery} LEFT JOIN {mock_image} AS {Image} ';
$expected .= 'ON {Gallery}.{id} = {Image}.{gallery_id} LEFT JOIN {mock_image_tag} AS ';
$expected .= '{ImageTag} ON {Image}.{id} = {ImageTag}.{image_id} LEFT JOIN {mock_tag} ';
$expected .= 'AS {Tag} ON {ImageTag}.{tag_id} = {Tag}.{id};';
$this->assertEqual($expected, $this->db->sql);
$model = $this->_imageTag;
$options = array(
'type' => 'read',
'model' => $model,
'with' => array('Image', 'Tag')
);
$result = $this->db->read(new Query($options));
$expected = 'SELECT * FROM {mock_image_tag} AS {ImageTag} LEFT JOIN {mock_image} AS ';
$expected .= '{Image} ON {ImageTag}.{image_id} = {Image}.{id} LEFT JOIN {mock_tag} AS ';
$expected .= '{Tag} ON {ImageTag}.{tag_id} = {Tag}.{id};';
$this->assertEqual($expected, $this->db->sql);
}
public function testWithOptionAndInlineConstraint() {
$model = $this->_gallery;
$options = array(
'type' => 'read',
'model' => $model,
'with' => array(
'Image' => array(
'constraints' => array(
'Image.title' => (object) "'MyImage'"
)),
'Image.ImageTag.Tag' => array(
'constraints' => array(
'Tag.name' => (object) "'MyTag'"
)
)
)
);
$result = $this->db->read(new Query($options));
$expected = 'SELECT * FROM {mock_gallery} AS {Gallery} ';
$expected .= 'LEFT JOIN {mock_image} AS {Image} ON {Image}.{title} = \'MyImage\' ';
$expected .= 'AND {Gallery}.{id} = {Image}.{gallery_id} LEFT JOIN {mock_image_tag} AS {ImageTag} ON ';
$expected .= '{Image}.{id} = {ImageTag}.{image_id} LEFT JOIN {mock_tag} AS {Tag} ON ';
$expected .= '{Tag}.{name} = \'MyTag\' AND {ImageTag}.{tag_id} = {Tag}.{id};';
$this->assertEqual($expected, $this->db->sql);
$to = 'lithium\tests\mocks\data\model\MockImage';
$model::bind('hasMany', 'Image', array('to' => $to));
$to::bind('belongsTo', 'Gallery', array('to' => $model));
$result = $this->db->read(new Query(array(
'type' => 'read',
'model' => $model,
'with' => array(
'Image.Gallery' => array(
'alias' => 'Gallery2',
'constraints' => array(
'Gallery.custom_id' => 'Gallery2.id'
)
)
)
)));
$expected = 'SELECT * FROM {mock_gallery} AS {Gallery} LEFT JOIN {mock_image} AS {Image} ';
$expected .= 'ON {Gallery}.{id} = {Image}.{gallery_id} LEFT JOIN {mock_gallery} AS ';
$expected .= '{Gallery2} ON {Gallery}.{custom_id} = {Gallery2}.{id} AND ';
$expected .= '{Image}.{gallery_id} = {Gallery2}.{id};';
$this->assertEqual($expected, $this->db->sql);
$model::reset();
}
public function testWithOptionAndConstraintInRelation() {
$model = 'lithium\tests\mocks\data\model\MockGallery';
$to = 'lithium\tests\mocks\data\model\MockImage';
$model::bind('hasMany', 'Image', array(
'to' => $to,
'constraints' => array(
'Image.title' => (object) "'MyImage'"
)));
$result = $this->db->read(new Query(array(
'type' => 'read',
'model' => $model,
'with' => array(
'Image.ImageTag.Tag' => array(
'constraints' => array(
'Tag.name' => (object) "'MyTag'"
)
)
)
)));
$expected = 'SELECT * FROM {mock_gallery} AS {Gallery} ';
$expected .= 'LEFT JOIN {mock_image} AS {Image} ON {Image}.{title} = \'MyImage\' AND ';
$expected .= '{Gallery}.{id} = {Image}.{gallery_id} LEFT JOIN {mock_image_tag} AS ';
$expected .= '{ImageTag} ON {Image}.{id} = {ImageTag}.{image_id} LEFT JOIN {mock_tag} AS ';
$expected .= '{Tag} ON {Tag}.{name} = \'MyTag\' AND {ImageTag}.{tag_id} = {Tag}.{id};';
$this->assertEqual($expected, $this->db->sql);
$model::reset();
}
public function testWithOptionWithNullConstraint() {
$options = array(
'type' => 'read',
'model' => $this->_model,
'with' => array('MockDatabasePostRevision')
);
$result = $this->db->read(new Query($options));
$expected = 'SELECT * FROM {mock_database_posts} AS {MockDatabasePost} LEFT JOIN ';
$expected .= '{mock_database_post_revisions} AS {MockDatabasePostRevision} ON ';
$expected .= '{MockDatabasePostRevision}.{deleted} IS NULL AND ';
$expected .= '{MockDatabasePost}.{id} = {MockDatabasePostRevision}.{mock_database_post_id};';
$this->assertEqual($expected, $this->db->sql);
}
public function testWithOptionAndCustomAlias() {
$model = 'lithium\tests\mocks\data\model\MockGallery';
$model::bind('hasMany', 'Image', array(
'to' => 'lithium\tests\mocks\data\model\MockImage',
'constraints' => array(
'Image.title' => (object) "'MyImage'"
)
));
$options = array(
'type' => 'read',
'model' => $model,
'alias' => 'MyGallery',
'with' => array(
'Image' => array('alias' => 'MyImage')
)
);
$result = $this->db->read(new Query($options));
$query = new Query($options);
$expected = 'SELECT * FROM {mock_gallery} AS {MyGallery} LEFT JOIN ';
$expected .= '{mock_image} AS {MyImage} ON {MyImage}.{title} = \'MyImage\' ';
$expected .= 'AND {MyGallery}.{id} = {MyImage}.{gallery_id};';
$this->assertEqual($expected, $this->db->sql);
$model::reset();
}
public function testJoin() {
$model = $this->_model;
$conn = $model::connection();
$query = new Query(array('type' => 'read', 'model' => $model));
$rel = $model::relations('MockDatabaseComment');
$conn->join($query, $rel, null, null, array('published' => (object) "'yes'"));
$joins = $query->joins();
$expected = array(
'MockDatabaseComment' => array(
'constraints' => array(
'MockDatabasePost.id' => 'MockDatabaseComment.mock_database_post_id',
'MockDatabasePost.published' => (object) "'yes'"
),
'model' => 'lithium\tests\mocks\data\model\MockDatabaseComment',
'type' => 'LEFT',
'alias' => 'MockDatabaseComment'
)
);
$this->assertEqual($expected, $joins);
$query = new Query(array('type' => 'read', 'model' => $model));
$rel = $model::relations('MockDatabaseComment');
$conn->join($query, $rel, null, null, (object) array('published' => (object) "'yes'"));
$joins = $query->joins();
$expected = array(
'MockDatabaseComment' => array(
'constraints' => array(
'published' => (object) "'yes'"
),
'model' => 'lithium\tests\mocks\data\model\MockDatabaseComment',
'type' => 'LEFT',
'alias' => 'MockDatabaseComment'
)
);
$this->assertEqual($expected, $joins);
}
public function testExportedFieldsWithJoinedStrategy() {
$query = new Query(array(
'model' => $this->_gallery,
'with' => array('Image.ImageTag.Tag')
));
$result = $query->export($this->db);
$this->assertEqual('*', $result['fields']);
$query = new Query(array(
'model' => $this->_gallery,
'fields' => 'id',
'with' => array('Image.ImageTag.Tag')
));
$result = $query->export($this->db);
$expected = '{Gallery}.{id}';
$this->assertEqual($expected, $result['fields']);
$query = new Query(array(
'model' => $this->_gallery,
'fields' => 'Tag.id',
'with' => array('Image.ImageTag.Tag')
));
$result = $query->export($this->db);
$expected = '{Gallery}.{id}, {Tag}.{id}, {Image}.{id}, {ImageTag}.{id}';
$this->assertEqual($expected, $result['fields']);
$query = new Query(array(
'model' => $this->_gallery,
'fields' => 'Tag',
'with' => array('Image.ImageTag.Tag')
));
$result = $query->export($this->db);
$expected = '{Gallery}.{id}, {Tag}.*, {Image}.{id}, {ImageTag}.{id}';
$this->assertEqual($expected, $result['fields']);
$query = new Query(array(
'model' => $this->_gallery,
'fields' => 'Tag.*',
'with' => array('Image.ImageTag.Tag')
));
$result = $query->export($this->db);
$expected = '{Gallery}.{id}, {Tag}.*, {Image}.{id}, {ImageTag}.{id}';
$this->assertEqual($expected, $result['fields']);
}
public function testExportedFieldsWithJoinedStrategyAndRecursiveRelation() {
$query = new Query(array(
'model' => $this->_gallery,
'with' => array('Parent.Parent')
));
$result = $query->export($this->db);
$expected = '*';
$this->assertEqual($expected, $result['fields']);
$query = new Query(array(
'model' => $this->_gallery,
'fields' => 'Parent.name',
'with' => array('Parent.Parent')
));
$result = $query->export($this->db);
$expected = '{Gallery}.{id}, {Parent}.{name}';
$this->assertEqual($expected, $result['fields']);
$query = new Query(array(
'model' => $this->_gallery,
'fields' => 'ParentOfParent.name',
'with' => array('Parent.Parent' => array('alias' => 'ParentOfParent'))
));
$result = $query->export($this->db);
$expected = '{Gallery}.{id}, {ParentOfParent}.{name}, {Parent}.{id}';
$this->assertEqual($expected, $result['fields']);
}
public function testCustomField() {
$field = "(CASE `title` WHEN 'Lotus Flower' THEN 'Found' ELSE 'Not Found' END) as extra";
$query = new Query(array(
'type' => 'read',
'model' => $this->_gallery,
'fields' => array('*', $field)
));
$result = $this->db->read($query);
$expected = 'SELECT (CASE `title` WHEN \'Lotus Flower\' THEN \'Found\' ELSE \'Not Found\' ';
$expected .= 'END) as extra, {Gallery}.* FROM {mock_gallery} AS {Gallery};';
$this->assertEqual($expected, $this->db->sql);
$map = array('' => array('extra', 'id', 'title'));
$this->assertEqual($map, $query->map());
$query = new Query(array(
'type' => 'read',
'model' => $this->_gallery,
'fields' => array('*', (object) $field)
));
$result = $this->db->read($query);
$this->assertEqual($expected, $this->db->sql);
$this->assertEqual($map, $query->map());
$query = new Query(array(
'type' => 'read',
'model' => $this->_gallery,
'fields' => array('*', array($field))
));
$result = $this->db->read($query);
$this->assertEqual($expected, $this->db->sql);
$this->assertEqual($map, $query->map());
$query = new Query(array(
'type' => 'read',
'model' => $this->_gallery,
'fields' => array('count(Image.id) as count', 'Image'),
'group' => 'Gallery.id',
'with' => array('Image')
));
$result = $this->db->read($query);
$expected = 'SELECT count(Image.id) as count, {Gallery}.{id}, {Image}.* FROM ';
$expected .= '{mock_gallery} AS {Gallery} LEFT JOIN {mock_image} AS {Image} ON ';
$expected .= '{Gallery}.{id} = {Image}.{gallery_id} GROUP BY Gallery.id;';
$this->assertEqual($expected, $this->db->sql);
$map = array(
'' => array('count', 'id'),
'Image' => array('id', 'title', 'image', 'gallery_id')
);
$this->assertEqual($map, $query->map());
}
public function testReturnArrayOnReadWithString() {
$data = new MockResult(array('records' => array(
array ('id', 'int(11)', 'NO', 'PRI', null, 'auto_increment'),
array ('name', 'varchar(256)', 'YES', '', null, '')
)));
$this->db->return = array(
'schema' => array('field', 'type', 'null', 'key', 'default', 'extra'),
'_execute' => $data
);
$result = $this->db->read('DESCRIBE {table};', array('return' => 'array'));
$expected = array(
array(
'field' => 'id',
'type' => 'int(11)',
'null' => 'NO',
'key' => 'PRI',
'default' => null,
'extra' => 'auto_increment',
),
array(
'field' => 'name',
'type' => 'varchar(256)',
'null' => 'YES',
'key' => '',
'default' => null,
'extra' => '',
)
);
$this->assertEqual($expected, $result);
}
public function testReturnArrayOnReadWithQuery() {
$data = new MockResult(array('records' => array(array(
'1',
'2',
'Post title',
'2012-12-17 17:04:00',
'3',
'1',
'2',
'Very good post',
'2012-12-17 17:05:00',
'1',
'2',
'Post title',
'2012-12-17 17:04:00',
))));
$this->db->return = array(
'_execute' => $data
);
$query = new Query(array(
'type' => 'read',
'model' => $this->_model,
'with' => array('MockDatabaseComment.MockDatabasePost')
));
$result = $this->db->read($query, array('return' => 'array'));
$expected = array(array(
'id' => '1',
'author_id' => '2',
'title' => 'Post title',
'created' => '2012-12-17 17:04:00',
'MockDatabaseComment' => array(
'id' => '3',
'post_id' => '1',
'author_id' => '2',
'body' => 'Very good post',
'created' => '2012-12-17 17:05:00',
'MockDatabasePost' => array(
'id' => '1',
'author_id' => '2',
'title' => 'Post title',
'created' => '2012-12-17 17:04:00',
)
)
));
$this->assertEqual($expected, $result);
}
}
?>
Jump to Line
Something went wrong with that request. Please try again.