Congegni/sintonia
7
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
sintonia/library/propel/test/testsuite/generator/builder/om/QueryBuilderTest.php

912 lines
38 KiB
PHP
Raw Blame History

<?php
/**
* This file is part of the Propel package.
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*
* @license MIT License
*/
require_once 'tools/helpers/bookstore/BookstoreTestBase.php';
require_once 'tools/helpers/bookstore/BookstoreDataPopulator.php';
/**
* Test class for QueryBuilder.
*
* @author François Zaninotto
* @version $Id: QueryBuilderTest.php 1347 2009-12-03 21:06:36Z francois $
* @package generator.builder.om
*/
class QueryBuilderTest extends BookstoreTestBase
{
public function testExtends()
{
$q = new BookQuery();
$this->assertTrue($q instanceof ModelCriteria, 'Model query extends ModelCriteria');
}
public function testConstructor()
{
$query = new BookQuery();
$this->assertEquals($query->getDbName(), 'bookstore', 'Constructor sets dabatase name');
$this->assertEquals($query->getModelName(), 'Book', 'Constructor sets model name');
}
public function testCreate()
{
$query = BookQuery::create();
$this->assertTrue($query instanceof BookQuery, 'create() returns an object of its class');
$this->assertEquals($query->getDbName(), 'bookstore', 'create() sets dabatase name');
$this->assertEquals($query->getModelName(), 'Book', 'create() sets model name');
$query = BookQuery::create('foo');
$this->assertTrue($query instanceof BookQuery, 'create() returns an object of its class');
$this->assertEquals($query->getDbName(), 'bookstore', 'create() sets dabatase name');
$this->assertEquals($query->getModelName(), 'Book', 'create() sets model name');
$this->assertEquals($query->getModelAlias(), 'foo', 'create() can set the model alias');
}
public function testCreateCustom()
{
// see the myBookQuery class definition at the end of this file
$query = myCustomBookQuery::create();
$this->assertTrue($query instanceof myCustomBookQuery, 'create() returns an object of its class');
$this->assertTrue($query instanceof BookQuery, 'create() returns an object of its class');
$this->assertEquals($query->getDbName(), 'bookstore', 'create() sets dabatase name');
$this->assertEquals($query->getModelName(), 'Book', 'create() sets model name');
$query = myCustomBookQuery::create('foo');
$this->assertTrue($query instanceof myCustomBookQuery, 'create() returns an object of its class');
$this->assertEquals($query->getDbName(), 'bookstore', 'create() sets dabatase name');
$this->assertEquals($query->getModelName(), 'Book', 'create() sets model name');
$this->assertEquals($query->getModelAlias(), 'foo', 'create() can set the model alias');
}
public function testBasePreSelect()
{
$method = new ReflectionMethod('Table2Query', 'basePreSelect');
$this->assertEquals('ModelCriteria', $method->getDeclaringClass()->getName(), 'BaseQuery does not override basePreSelect() by default');
$method = new ReflectionMethod('Table3Query', 'basePreSelect');
$this->assertEquals('BaseTable3Query', $method->getDeclaringClass()->getName(), 'BaseQuery overrides basePreSelect() when a behavior is registered');
}
public function testBasePreDelete()
{
$method = new ReflectionMethod('Table2Query', 'basePreDelete');
$this->assertEquals('ModelCriteria', $method->getDeclaringClass()->getName(), 'BaseQuery does not override basePreDelete() by default');
$method = new ReflectionMethod('Table3Query', 'basePreDelete');
$this->assertEquals('BaseTable3Query', $method->getDeclaringClass()->getName(), 'BaseQuery overrides basePreDelete() when a behavior is registered');
}
public function testBasePostDelete()
{
$method = new ReflectionMethod('Table2Query', 'basePostDelete');
$this->assertEquals('ModelCriteria', $method->getDeclaringClass()->getName(), 'BaseQuery does not override basePostDelete() by default');
$method = new ReflectionMethod('Table3Query', 'basePostDelete');
$this->assertEquals('BaseTable3Query', $method->getDeclaringClass()->getName(), 'BaseQuery overrides basePostDelete() when a behavior is registered');
}
public function testBasePreUpdate()
{
$method = new ReflectionMethod('Table2Query', 'basePreUpdate');
$this->assertEquals('ModelCriteria', $method->getDeclaringClass()->getName(), 'BaseQuery does not override basePreUpdate() by default');
$method = new ReflectionMethod('Table3Query', 'basePreUpdate');
$this->assertEquals('BaseTable3Query', $method->getDeclaringClass()->getName(), 'BaseQuery overrides basePreUpdate() when a behavior is registered');
}
public function testBasePostUpdate()
{
$method = new ReflectionMethod('Table2Query', 'basePostUpdate');
$this->assertEquals('ModelCriteria', $method->getDeclaringClass()->getName(), 'BaseQuery does not override basePostUpdate() by default');
$method = new ReflectionMethod('Table3Query', 'basePostUpdate');
$this->assertEquals('BaseTable3Query', $method->getDeclaringClass()->getName(), 'BaseQuery overrides basePostUpdate() when a behavior is registered');
}
public function testQuery()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
$q = new BookQuery();
$book = $q
->setModelAlias('b')
->where('b.Title like ?', 'Don%')
->orderBy('b.ISBN', 'desc')
->findOne();
$this->assertTrue($book instanceof Book);
$this->assertEquals('Don Juan', $book->getTitle());
}
public function testFindPk()
{
$method = new ReflectionMethod('Table4Query', 'findPk');
$this->assertEquals('BaseTable4Query', $method->getDeclaringClass()->getName(), 'BaseQuery overrides findPk()');
}
public function testFindPkSimpleKey()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
BookPeer::clearInstancePool();
$con = Propel::getConnection('bookstore');
// prepare the test data
$c = new ModelCriteria('bookstore', 'Book');
$c->orderBy('Book.Id', 'desc');
$testBook = $c->findOne();
$count = $con->getQueryCount();
BookPeer::clearInstancePool();
$q = new BookQuery();
$book = $q->findPk($testBook->getId());
$this->assertEquals($testBook, $book, 'BaseQuery overrides findPk() to make it faster');
$this->assertEquals($count+1, $con->getQueryCount(), 'findPk() issues a database query when instance pool is empty');
$q = new BookQuery();
$book = $q->findPk($testBook->getId());
$this->assertEquals($testBook, $book, 'BaseQuery overrides findPk() to make it faster');
$this->assertEquals($count+1, $con->getQueryCount(), 'findPk() does not issue a database query when instance is in pool');
}
public function testFindPkCompositeKey()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
// save all books to make sure related objects are also saved - BookstoreDataPopulator keeps some unsaved
$c = new ModelCriteria('bookstore', 'Book');
$books = $c->find();
foreach ($books as $book) {
$book->save();
}
BookPeer::clearInstancePool();
// retrieve the test data
$c = new ModelCriteria('bookstore', 'BookListRel');
$bookListRelTest = $c->findOne();
$pk = $bookListRelTest->getPrimaryKey();
$q = new BookListRelQuery();
$bookListRel = $q->findPk($pk);
$this->assertEquals($bookListRelTest, $bookListRel, 'BaseQuery overrides findPk() for composite primary keysto make it faster');
}
public function testFindPks()
{
$method = new ReflectionMethod('Table4Query', 'findPks');
$this->assertEquals('BaseTable4Query', $method->getDeclaringClass()->getName(), 'BaseQuery overrides findPks()');
}
public function testFindPksSimpleKey()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
BookPeer::clearInstancePool();
// prepare the test data
$c = new ModelCriteria('bookstore', 'Book');
$c->orderBy('Book.Id', 'desc');
$testBooks = $c->find();
$testBook1 = $testBooks->pop();
$testBook2 = $testBooks->pop();
$q = new BookQuery();
$books = $q->findPks(array($testBook1->getId(), $testBook2->getId()));
$this->assertEquals(array($testBook1, $testBook2), $books->getData(), 'BaseQuery overrides findPks() to make it faster');
}
public function testFindPksCompositeKey()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
// save all books to make sure related objects are also saved - BookstoreDataPopulator keeps some unsaved
$c = new ModelCriteria('bookstore', 'Book');
$books = $c->find();
foreach ($books as $book) {
$book->save();
}
BookPeer::clearInstancePool();
// retrieve the test data
$c = new ModelCriteria('bookstore', 'BookListRel');
$bookListRelTest = $c->find();
$search = array();
foreach ($bookListRelTest as $obj) {
$search[]= $obj->getPrimaryKey();
}
$q = new BookListRelQuery();
$objs = $q->findPks($search);
$this->assertEquals($bookListRelTest, $objs, 'BaseQuery overrides findPks() for composite primary keys to make it work');
}
public function testFilterBy()
{
foreach (BookPeer::getFieldNames(BasePeer::TYPE_PHPNAME) as $colName) {
$filterMethod = 'filterBy' . $colName;
$this->assertTrue(method_exists('BookQuery', $filterMethod), 'QueryBuilder adds filterByColumn() methods for every column');
$q = BookQuery::create()->$filterMethod(1);
$this->assertTrue($q instanceof BookQuery, 'filterByColumn() returns the current query instance');
}
}
public function testFilterByPrimaryKeySimpleKey()
{
$q = BookQuery::create()->filterByPrimaryKey(12);
$q1 = BookQuery::create()->add(BookPeer::ID, 12, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByPrimaryKey() translates to a Criteria::EQUAL in the PK column');
$q = BookQuery::create()->setModelAlias('b', true)->filterByPrimaryKey(12);
$q1 = BookQuery::create()->setModelAlias('b', true)->add('b.ID', 12, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByPrimaryKey() uses true table alias if set');
}
public function testFilterByPrimaryKeyCompositeKey()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
// save all books to make sure related objects are also saved - BookstoreDataPopulator keeps some unsaved
$c = new ModelCriteria('bookstore', 'Book');
$books = $c->find();
foreach ($books as $book) {
$book->save();
}
BookPeer::clearInstancePool();
// retrieve the test data
$c = new ModelCriteria('bookstore', 'BookListRel');
$bookListRelTest = $c->findOne();
$pk = $bookListRelTest->getPrimaryKey();
$q = new BookListRelQuery();
$q->filterByPrimaryKey($pk);
$q1 = BookListRelQuery::create()
->add(BookListRelPeer::BOOK_ID, $pk[0], Criteria::EQUAL)
->add(BookListRelPeer::BOOK_CLUB_LIST_ID, $pk[1], Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByPrimaryKey() translates to a Criteria::EQUAL in the PK columns');
}
public function testFilterByPrimaryKeysSimpleKey()
{
$q = BookQuery::create()->filterByPrimaryKeys(array(10, 11, 12));
$q1 = BookQuery::create()->add(BookPeer::ID, array(10, 11, 12), Criteria::IN);
$this->assertEquals($q1, $q, 'filterByPrimaryKeys() translates to a Criteria::IN on the PK column');
$q = BookQuery::create()->setModelAlias('b', true)->filterByPrimaryKeys(array(10, 11, 12));
$q1 = BookQuery::create()->setModelAlias('b', true)->add('b.ID', array(10, 11, 12), Criteria::IN);
$this->assertEquals($q1, $q, 'filterByPrimaryKeys() uses true table alias if set');
}
public function testFilterByPrimaryKeysCompositeKey()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
// save all books to make sure related objects are also saved - BookstoreDataPopulator keeps some unsaved
$c = new ModelCriteria('bookstore', 'Book');
$books = $c->find();
foreach ($books as $book) {
$book->save();
}
BookPeer::clearInstancePool();
// retrieve the test data
$c = new ModelCriteria('bookstore', 'BookListRel');
$bookListRelTest = $c->find();
$search = array();
foreach ($bookListRelTest as $obj) {
$search[]= $obj->getPrimaryKey();
}
$q = new BookListRelQuery();
$q->filterByPrimaryKeys($search);
$q1 = BookListRelQuery::create();
foreach ($search as $key) {
$cton0 = $q1->getNewCriterion(BookListRelPeer::BOOK_ID, $key[0], Criteria::EQUAL);
$cton1 = $q1->getNewCriterion(BookListRelPeer::BOOK_CLUB_LIST_ID, $key[1], Criteria::EQUAL);
$cton0->addAnd($cton1);
$q1->addOr($cton0);
}
$this->assertEquals($q1, $q, 'filterByPrimaryKeys() translates to a series of Criteria::EQUAL in the PK columns');
}
public function testFilterByIntegerPk()
{
$q = BookQuery::create()->filterById(12);
$q1 = BookQuery::create()->add(BookPeer::ID, 12, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByPkColumn() translates to a Criteria::EQUAL by default');
$q = BookQuery::create()->filterById(12, Criteria::NOT_EQUAL);
$q1 = BookQuery::create()->add(BookPeer::ID, 12, Criteria::NOT_EQUAL);
$this->assertEquals($q1, $q, 'filterByPkColumn() accepts an optional comparison operator');
$q = BookQuery::create()->setModelAlias('b', true)->filterById(12);
$q1 = BookQuery::create()->setModelAlias('b', true)->add('b.ID', 12, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByPkColumn() uses true table alias if set');
$q = BookQuery::create()->filterById(array(10, 11, 12));
$q1 = BookQuery::create()->add(BookPeer::ID, array(10, 11, 12), Criteria::IN);
$this->assertEquals($q1, $q, 'filterByPkColumn() translates to a Criteria::IN when passed a simple array key');
$q = BookQuery::create()->filterById(array(10, 11, 12), Criteria::NOT_IN);
$q1 = BookQuery::create()->add(BookPeer::ID, array(10, 11, 12), Criteria::NOT_IN);
$this->assertEquals($q1, $q, 'filterByPkColumn() accepts a comparison when passed a simple array key');
}
public function testFilterByNumber()
{
$q = BookQuery::create()->filterByPrice(12);
$q1 = BookQuery::create()->add(BookPeer::PRICE, 12, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByNumColumn() translates to a Criteria::EQUAL by default');
$q = BookQuery::create()->filterByPrice(12, Criteria::NOT_EQUAL);
$q1 = BookQuery::create()->add(BookPeer::PRICE, 12, Criteria::NOT_EQUAL);
$this->assertEquals($q1, $q, 'filterByNumColumn() accepts an optional comparison operator');
$q = BookQuery::create()->setModelAlias('b', true)->filterByPrice(12);
$q1 = BookQuery::create()->setModelAlias('b', true)->add('b.PRICE', 12, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByNumColumn() uses true table alias if set');
$q = BookQuery::create()->filterByPrice(array(10, 11, 12));
$q1 = BookQuery::create()->add(BookPeer::PRICE, array(10, 11, 12), Criteria::IN);
$this->assertEquals($q1, $q, 'filterByNumColumn() translates to a Criteria::IN when passed a simple array key');
$q = BookQuery::create()->filterByPrice(array(10, 11, 12), Criteria::NOT_IN);
$q1 = BookQuery::create()->add(BookPeer::PRICE, array(10, 11, 12), Criteria::NOT_IN);
$this->assertEquals($q1, $q, 'filterByNumColumn() accepts a comparison when passed a simple array key');
$q = BookQuery::create()->filterByPrice(array('min' => 10));
$q1 = BookQuery::create()->add(BookPeer::PRICE, 10, Criteria::GREATER_EQUAL);
$this->assertEquals($q1, $q, 'filterByNumColumn() translates to a Criteria::GREATER_EQUAL when passed a \'min\' key');
$q = BookQuery::create()->filterByPrice(array('max' => 12));
$q1 = BookQuery::create()->add(BookPeer::PRICE, 12, Criteria::LESS_EQUAL);
$this->assertEquals($q1, $q, 'filterByNumColumn() translates to a Criteria::LESS_EQUAL when passed a \'max\' key');
$q = BookQuery::create()->filterByPrice(array('min' => 10, 'max' => 12));
$q1 = BookQuery::create()
->add(BookPeer::PRICE, 10, Criteria::GREATER_EQUAL)
->addAnd(BookPeer::PRICE, 12, Criteria::LESS_EQUAL);
$this->assertEquals($q1, $q, 'filterByNumColumn() translates to a between when passed both a \'min\' and a \'max\' key');
}
public function testFilterByTimestamp()
{
$q = BookstoreEmployeeAccountQuery::create()->filterByCreated(12);
$q1 = BookstoreEmployeeAccountQuery::create()->add(BookstoreEmployeeAccountPeer::CREATED, 12, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByDateColumn() translates to a Criteria::EQUAL by default');
$q = BookstoreEmployeeAccountQuery::create()->filterByCreated(12, Criteria::NOT_EQUAL);
$q1 = BookstoreEmployeeAccountQuery::create()->add(BookstoreEmployeeAccountPeer::CREATED, 12, Criteria::NOT_EQUAL);
$this->assertEquals($q1, $q, 'filterByDateColumn() accepts an optional comparison operator');
$q = BookstoreEmployeeAccountQuery::create()->setModelAlias('b', true)->filterByCreated(12);
$q1 = BookstoreEmployeeAccountQuery::create()->setModelAlias('b', true)->add('b.CREATED', 12, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByDateColumn() uses true table alias if set');
$q = BookstoreEmployeeAccountQuery::create()->filterByCreated(array('min' => 10));
$q1 = BookstoreEmployeeAccountQuery::create()->add(BookstoreEmployeeAccountPeer::CREATED, 10, Criteria::GREATER_EQUAL);
$this->assertEquals($q1, $q, 'filterByDateColumn() translates to a Criteria::GREATER_EQUAL when passed a \'min\' key');
$q = BookstoreEmployeeAccountQuery::create()->filterByCreated(array('max' => 12));
$q1 = BookstoreEmployeeAccountQuery::create()->add(BookstoreEmployeeAccountPeer::CREATED, 12, Criteria::LESS_EQUAL);
$this->assertEquals($q1, $q, 'filterByDateColumn() translates to a Criteria::LESS_EQUAL when passed a \'max\' key');
$q = BookstoreEmployeeAccountQuery::create()->filterByCreated(array('min' => 10, 'max' => 12));
$q1 = BookstoreEmployeeAccountQuery::create()
->add(BookstoreEmployeeAccountPeer::CREATED, 10, Criteria::GREATER_EQUAL)
->addAnd(BookstoreEmployeeAccountPeer::CREATED, 12, Criteria::LESS_EQUAL);
$this->assertEquals($q1, $q, 'filterByDateColumn() translates to a between when passed both a \'min\' and a \'max\' key');
}
public function testFilterByString()
{
$q = BookQuery::create()->filterByTitle('foo');
$q1 = BookQuery::create()->add(BookPeer::TITLE, 'foo', Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByStringColumn() translates to a Criteria::EQUAL by default');
$q = BookQuery::create()->filterByTitle('foo', Criteria::NOT_EQUAL);
$q1 = BookQuery::create()->add(BookPeer::TITLE, 'foo', Criteria::NOT_EQUAL);
$this->assertEquals($q1, $q, 'filterByStringColumn() accepts an optional comparison operator');
$q = BookQuery::create()->setModelAlias('b', true)->filterByTitle('foo');
$q1 = BookQuery::create()->setModelAlias('b', true)->add('b.TITLE', 'foo', Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByStringColumn() uses true table alias if set');
$q = BookQuery::create()->filterByTitle(array('foo', 'bar'));
$q1 = BookQuery::create()->add(BookPeer::TITLE, array('foo', 'bar'), Criteria::IN);
$this->assertEquals($q1, $q, 'filterByStringColumn() translates to a Criteria::IN when passed an array');
$q = BookQuery::create()->filterByTitle(array('foo', 'bar'), Criteria::NOT_IN);
$q1 = BookQuery::create()->add(BookPeer::TITLE, array('foo', 'bar'), Criteria::NOT_IN);
$this->assertEquals($q1, $q, 'filterByStringColumn() accepts a comparison when passed an array');
$q = BookQuery::create()->filterByTitle('foo%');
$q1 = BookQuery::create()->add(BookPeer::TITLE, 'foo%', Criteria::LIKE);
$this->assertEquals($q1, $q, 'filterByStringColumn() translates to a Criteria::LIKE when passed a string with a % wildcard');
$q = BookQuery::create()->filterByTitle('foo%', Criteria::NOT_LIKE);
$q1 = BookQuery::create()->add(BookPeer::TITLE, 'foo%', Criteria::NOT_LIKE);
$this->assertEquals($q1, $q, 'filterByStringColumn() accepts a comparison when passed a string with a % wildcard');
$q = BookQuery::create()->filterByTitle('foo%', Criteria::EQUAL);
$q1 = BookQuery::create()->add(BookPeer::TITLE, 'foo%', Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByStringColumn() accepts a comparison when passed a string with a % wildcard');
$q = BookQuery::create()->filterByTitle('*foo');
$q1 = BookQuery::create()->add(BookPeer::TITLE, '%foo', Criteria::LIKE);
$this->assertEquals($q1, $q, 'filterByStringColumn() translates to a Criteria::LIKE when passed a string with a * wildcard, and turns * into %');
$q = BookQuery::create()->filterByTitle('*f%o*o%');
$q1 = BookQuery::create()->add(BookPeer::TITLE, '%f%o%o%', Criteria::LIKE);
$this->assertEquals($q1, $q, 'filterByStringColumn() translates to a Criteria::LIKE when passed a string with mixed wildcards, and turns *s into %s');
}
public function testFilterByBoolean()
{
$q = ReviewQuery::create()->filterByRecommended(true);
$q1 = ReviewQuery::create()->add(ReviewPeer::RECOMMENDED, true, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByBooleanColumn() translates to a Criteria::EQUAL by default');
$q = ReviewQuery::create()->filterByRecommended(true, Criteria::NOT_EQUAL);
$q1 = ReviewQuery::create()->add(ReviewPeer::RECOMMENDED, true, Criteria::NOT_EQUAL);
$this->assertEquals($q1, $q, 'filterByBooleanColumn() accepts an optional comparison operator');
$q = ReviewQuery::create()->filterByRecommended(false);
$q1 = ReviewQuery::create()->add(ReviewPeer::RECOMMENDED, false, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByBooleanColumn() translates to a Criteria::EQUAL by default');
$q = ReviewQuery::create()->setModelAlias('b', true)->filterByRecommended(true);
$q1 = ReviewQuery::create()->setModelAlias('b', true)->add('b.RECOMMENDED', true, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByBooleanColumn() uses true table alias if set');
$q = ReviewQuery::create()->filterByRecommended('true');
$q1 = ReviewQuery::create()->add(ReviewPeer::RECOMMENDED, true, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByBooleanColumn() translates to a = true when passed a true string');
$q = ReviewQuery::create()->filterByRecommended('yes');
$q1 = ReviewQuery::create()->add(ReviewPeer::RECOMMENDED, true, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByBooleanColumn() translates to a = true when passed a true string');
$q = ReviewQuery::create()->filterByRecommended('1');
$q1 = ReviewQuery::create()->add(ReviewPeer::RECOMMENDED, true, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByBooleanColumn() translates to a = true when passed a true string');
$q = ReviewQuery::create()->filterByRecommended('false');
$q1 = ReviewQuery::create()->add(ReviewPeer::RECOMMENDED, false, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByBooleanColumn() translates to a = false when passed a false string');
$q = ReviewQuery::create()->filterByRecommended('no');
$q1 = ReviewQuery::create()->add(ReviewPeer::RECOMMENDED, false, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByBooleanColumn() translates to a = false when passed a false string');
$q = ReviewQuery::create()->filterByRecommended('0');
$q1 = ReviewQuery::create()->add(ReviewPeer::RECOMMENDED, false, Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByBooleanColumn() translates to a = false when passed a false string');
}
public function testFilterByFk()
{
$this->assertTrue(method_exists('BookQuery', 'filterByAuthor'), 'QueryBuilder adds filterByFk() methods');
$this->assertTrue(method_exists('BookQuery', 'filterByPublisher'), 'QueryBuilder adds filterByFk() methods for all fkeys');
$this->assertTrue(method_exists('EssayQuery', 'filterByAuthorRelatedByFirstAuthor'), 'QueryBuilder adds filterByFk() methods for several fkeys on the same table');
$this->assertTrue(method_exists('EssayQuery', 'filterByAuthorRelatedBySecondAuthor'), 'QueryBuilder adds filterByFk() methods for several fkeys on the same table');
}
public function testFilterByFkSimpleKey()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
// prepare the test data
$testBook = BookQuery::create()
->innerJoin('Book.Author') // just in case there are books with no author
->findOne();
$testAuthor = $testBook->getAuthor();
$book = BookQuery::create()
->filterByAuthor($testAuthor)
->findOne();
$this->assertEquals($testBook, $book, 'Generated query handles filterByFk() methods correctly for simple fkeys');
$q = BookQuery::create()->filterByAuthor($testAuthor);
$q1 = BookQuery::create()->add(BookPeer::AUTHOR_ID, $testAuthor->getId(), Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByFk() translates to a Criteria::EQUAL by default');
$q = BookQuery::create()->filterByAuthor($testAuthor, Criteria::NOT_EQUAL);
$q1 = BookQuery::create()->add(BookPeer::AUTHOR_ID, $testAuthor->getId(), Criteria::NOT_EQUAL);
$this->assertEquals($q1, $q, 'filterByFk() accepts an optional comparison operator');
}
public function testFilterByFkCompositeKey()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
BookstoreDataPopulator::populateOpinionFavorite();
// prepare the test data
$testOpinion = BookOpinionQuery::create()
->innerJoin('BookOpinion.ReaderFavorite') // just in case there are books with no author
->findOne();
$testFavorite = $testOpinion->getReaderFavorite();
$favorite = ReaderFavoriteQuery::create()
->filterByBookOpinion($testOpinion)
->findOne();
$this->assertEquals($testFavorite, $favorite, 'Generated query handles filterByFk() methods correctly for composite fkeys');
}
public function testFilterByRefFk()
{
$this->assertTrue(method_exists('BookQuery', 'filterByReview'), 'QueryBuilder adds filterByRefFk() methods');
$this->assertTrue(method_exists('BookQuery', 'filterByMedia'), 'QueryBuilder adds filterByRefFk() methods for all fkeys');
$this->assertTrue(method_exists('AuthorQuery', 'filterByEssayRelatedByFirstAuthor'), 'QueryBuilder adds filterByRefFk() methods for several fkeys on the same table');
$this->assertTrue(method_exists('AuthorQuery', 'filterByEssayRelatedBySecondAuthor'), 'QueryBuilder adds filterByRefFk() methods for several fkeys on the same table');
}
public function testFilterByRefFkSimpleKey()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
// prepare the test data
$testBook = BookQuery::create()
->innerJoin('Book.Author') // just in case there are books with no author
->findOne();
$testAuthor = $testBook->getAuthor();
$author = AuthorQuery::create()
->filterByBook($testBook)
->findOne();
$this->assertEquals($testAuthor, $author, 'Generated query handles filterByRefFk() methods correctly for simple fkeys');
$q = AuthorQuery::create()->filterByBook($testBook);
$q1 = AuthorQuery::create()->add(AuthorPeer::ID, $testBook->getAuthorId(), Criteria::EQUAL);
$this->assertEquals($q1, $q, 'filterByRefFk() translates to a Criteria::EQUAL by default');
$q = AuthorQuery::create()->filterByBook($testBook, Criteria::NOT_EQUAL);
$q1 = AuthorQuery::create()->add(AuthorPeer::ID, $testBook->getAuthorId(), Criteria::NOT_EQUAL);
$this->assertEquals($q1, $q, 'filterByRefFk() accepts an optional comparison operator');
}
public function testFilterByRefFkCompositeKey()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
BookstoreDataPopulator::populateOpinionFavorite();
// prepare the test data
$testOpinion = BookOpinionQuery::create()
->innerJoin('BookOpinion.ReaderFavorite') // just in case there are books with no author
->findOne();
$testFavorite = $testOpinion->getReaderFavorite();
$opinion = BookOpinionQuery::create()
->filterByReaderFavorite($testFavorite)
->findOne();
$this->assertEquals($testOpinion, $opinion, 'Generated query handles filterByRefFk() methods correctly for composite fkeys');
}
public function testFilterByCrossFK()
{
$this->assertTrue(method_exists('BookQuery', 'filterByBookClubList'), 'Generated query handles filterByCrossRefFK() for many-to-many relationships');
$this->assertFalse(method_exists('BookQuery', 'filterByBook'), 'Generated query handles filterByCrossRefFK() for many-to-many relationships');
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
$blc1 = BookClubListQuery::create()->findOneByGroupLeader('Crazyleggs');
$nbBooks = BookQuery::create()
->filterByBookClubList($blc1)
->count();
$this->assertEquals(2, $nbBooks, 'Generated query handles filterByCrossRefFK() methods correctly');
}
public function testJoinFk()
{
$q = BookQuery::create()
->joinAuthor();
$q1 = BookQuery::create()
->join('Book.Author', Criteria::LEFT_JOIN);
$this->assertTrue($q->equals($q1), 'joinFk() translates to a left join on non-required columns');
$q = ReviewQuery::create()
->joinBook();
$q1 = ReviewQuery::create()
->join('Review.Book', Criteria::INNER_JOIN);
$this->assertTrue($q->equals($q1), 'joinFk() translates to an inner join on required columns');
$q = BookQuery::create()
->joinAuthor('a');
$q1 = BookQuery::create()
->join('Book.Author a', Criteria::LEFT_JOIN);
$this->assertTrue($q->equals($q1), 'joinFk() accepts a relation alias as first parameter');
$q = BookQuery::create()
->joinAuthor('', Criteria::INNER_JOIN);
$q1 = BookQuery::create()
->join('Book.Author', Criteria::INNER_JOIN);
$this->assertTrue($q->equals($q1), 'joinFk() accepts a join type as second parameter');
$q = EssayQuery::create()
->joinAuthorRelatedBySecondAuthor();
$q1 = EssayQuery::create()
->join('Essay.AuthorRelatedBySecondAuthor', "INNER JOIN");
$this->assertTrue($q->equals($q1), 'joinFk() translates to a "INNER JOIN" when this is defined as defaultJoin in the schema');
}
public function testJoinFkAlias()
{
$q = BookQuery::create('b')
->joinAuthor('a');
$q1 = BookQuery::create('b')
->join('b.Author a', Criteria::LEFT_JOIN);
$this->assertTrue($q->equals($q1), 'joinFk() works fine with table aliases');
$q = BookQuery::create()
->setModelAlias('b', true)
->joinAuthor('a');
$q1 = BookQuery::create()
->setModelAlias('b', true)
->join('b.Author a', Criteria::LEFT_JOIN);
$this->assertTrue($q->equals($q1), 'joinFk() works fine with true table aliases');
}
public function testJoinRefFk()
{
$q = AuthorQuery::create()
->joinBook();
$q1 = AuthorQuery::create()
->join('Author.Book', Criteria::LEFT_JOIN);
$this->assertTrue($q->equals($q1), 'joinRefFk() translates to a left join on non-required columns');
$q = BookQuery::create()
->joinreview();
$q1 = BookQuery::create()
->join('Book.Review', Criteria::INNER_JOIN);
$this->assertTrue($q->equals($q1), 'joinRefFk() translates to an inner join on required columns');
$q = AuthorQuery::create()
->joinBook('b');
$q1 = AuthorQuery::create()
->join('Author.Book b', Criteria::LEFT_JOIN);
$this->assertTrue($q->equals($q1), 'joinRefFk() accepts a relation alias as first parameter');
$q = AuthorQuery::create()
->joinBook('', Criteria::INNER_JOIN);
$q1 = AuthorQuery::create()
->join('Author.Book', Criteria::INNER_JOIN);
$this->assertTrue($q->equals($q1), 'joinRefFk() accepts a join type as second parameter');
$q = AuthorQuery::create()
->joinEssayRelatedBySecondAuthor();
$q1 = AuthorQuery::create()
->join('Author.EssayRelatedBySecondAuthor', Criteria::INNER_JOIN);
$this->assertTrue($q->equals($q1), 'joinRefFk() translates to a "INNER JOIN" when this is defined as defaultJoin in the schema');
}
public function testUseFkQuerySimple()
{
$q = BookQuery::create()
->useAuthorQuery()
->filterByFirstName('Leo')
->endUse();
$q1 = BookQuery::create()
->join('Book.Author', Criteria::LEFT_JOIN)
->add(AuthorPeer::FIRST_NAME, 'Leo', Criteria::EQUAL);
$this->assertTrue($q->equals($q1), 'useFkQuery() translates to a condition on a left join on non-required columns');
$q = ReviewQuery::create()
->useBookQuery()
->filterByTitle('War And Peace')
->endUse();
$q1 = ReviewQuery::create()
->join('Review.Book', Criteria::INNER_JOIN)
->add(BookPeer::TITLE, 'War And Peace', Criteria::EQUAL);
$this->assertTrue($q->equals($q1), 'useFkQuery() translates to a condition on aninner join on required columns');
}
public function testUseFkQueryJoinType()
{
$q = BookQuery::create()
->useAuthorQuery(null, Criteria::LEFT_JOIN)
->filterByFirstName('Leo')
->endUse();
$q1 = BookQuery::create()
->join('Book.Author', Criteria::LEFT_JOIN)
->add(AuthorPeer::FIRST_NAME, 'Leo', Criteria::EQUAL);
$this->assertTrue($q->equals($q1), 'useFkQuery() accepts a join type as second parameter');
}
public function testUseFkQueryAlias()
{
$q = BookQuery::create()
->useAuthorQuery('a')
->filterByFirstName('Leo')
->endUse();
$join = new ModelJoin();
$join->setJoinType(Criteria::LEFT_JOIN);
$join->setTableMap(AuthorPeer::getTableMap());
$join->setRelationMap(BookPeer::getTableMap()->getRelation('Author'), null, 'a');
$join->setRelationAlias('a');
$q1 = BookQuery::create()
->addAlias('a', AuthorPeer::TABLE_NAME)
->addJoinObject($join, 'a')
->add('a.FIRST_NAME', 'Leo', Criteria::EQUAL);
$this->assertTrue($q->equals($q1), 'useFkQuery() uses the first argument as a table alias');
}
public function testUseFkQueryMixed()
{
$q = BookQuery::create()
->useAuthorQuery()
->filterByFirstName('Leo')
->endUse()
->filterByTitle('War And Peace');
$q1 = BookQuery::create()
->join('Book.Author', Criteria::LEFT_JOIN)
->add(AuthorPeer::FIRST_NAME, 'Leo', Criteria::EQUAL)
->add(BookPeer::TITLE, 'War And Peace', Criteria::EQUAL);
$this->assertTrue($q->equals($q1), 'useFkQuery() allows combining conditions on main and related query');
}
public function testUseFkQueryTwice()
{
$q = BookQuery::create()
->useAuthorQuery()
->filterByFirstName('Leo')
->endUse()
->useAuthorQuery()
->filterByLastName('Tolstoi')
->endUse();
$q1 = BookQuery::create()
->join('Book.Author', Criteria::LEFT_JOIN)
->add(AuthorPeer::FIRST_NAME, 'Leo', Criteria::EQUAL)
->add(AuthorPeer::LAST_NAME, 'Tolstoi', Criteria::EQUAL);
$this->assertTrue($q->equals($q1), 'useFkQuery() called twice on the same relation does not create two joins');
}
public function testUseFkQueryTwiceTwoAliases()
{
$q = BookQuery::create()
->useAuthorQuery('a')
->filterByFirstName('Leo')
->endUse()
->useAuthorQuery('b')
->filterByLastName('Tolstoi')
->endUse();
$join1 = new ModelJoin();
$join1->setJoinType(Criteria::LEFT_JOIN);
$join1->setTableMap(AuthorPeer::getTableMap());
$join1->setRelationMap(BookPeer::getTableMap()->getRelation('Author'), null, 'a');
$join1->setRelationAlias('a');
$join2 = new ModelJoin();
$join2->setJoinType(Criteria::LEFT_JOIN);
$join2->setTableMap(AuthorPeer::getTableMap());
$join2->setRelationMap(BookPeer::getTableMap()->getRelation('Author'), null, 'b');
$join2->setRelationAlias('b');
$q1 = BookQuery::create()
->addAlias('a', AuthorPeer::TABLE_NAME)
->addJoinObject($join1, 'a')
->add('a.FIRST_NAME', 'Leo', Criteria::EQUAL)
->addAlias('b', AuthorPeer::TABLE_NAME)
->addJoinObject($join2, 'b')
->add('b.LAST_NAME', 'Tolstoi', Criteria::EQUAL);
$this->assertTrue($q->equals($q1), 'useFkQuery() called twice on the same relation with two aliases creates two joins');
}
public function testUseFkQueryNested()
{
$q = ReviewQuery::create()
->useBookQuery()
->useAuthorQuery()
->filterByFirstName('Leo')
->endUse()
->endUse();
$q1 = ReviewQuery::create()
->join('Review.Book', Criteria::INNER_JOIN)
->join('Book.Author', Criteria::LEFT_JOIN)
->add(AuthorPeer::FIRST_NAME, 'Leo', Criteria::EQUAL);
// embedded queries create joins that keep a relation to the parent
// as this is not testable, we need to use another testing technique
$params = array();
$result = BasePeer::createSelectSql($q, $params);
$expectedParams = array();
$expectedResult = BasePeer::createSelectSql($q1, $expectedParams);
$this->assertEquals($expectedParams, $params, 'useFkQuery() called nested creates two joins');
$this->assertEquals($expectedResult, $result, 'useFkQuery() called nested creates two joins');
}
public function testUseFkQueryTwoRelations()
{
$q = BookQuery::create()
->useAuthorQuery()
->filterByFirstName('Leo')
->endUse()
->usePublisherQuery()
->filterByName('Penguin')
->endUse();
$q1 = BookQuery::create()
->join('Book.Author', Criteria::LEFT_JOIN)
->add(AuthorPeer::FIRST_NAME, 'Leo', Criteria::EQUAL)
->join('Book.Publisher', Criteria::LEFT_JOIN)
->add(PublisherPeer::NAME, 'Penguin', Criteria::EQUAL);
$this->assertTrue($q->equals($q1), 'useFkQuery() called twice on two relations creates two joins');
}
public function testPrune()
{
$q = BookQuery::create()->prune();
$this->assertTrue($q instanceof BookQuery, 'prune() returns the current Query object');
}
public function testPruneSimpleKey()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
$nbBooks = BookQuery::create()->prune()->count();
$this->assertEquals(4, $nbBooks, 'prune() does nothing when passed a null object');
$testBook = BookQuery::create()->findOne();
$nbBooks = BookQuery::create()->prune($testBook)->count();
$this->assertEquals(3, $nbBooks, 'prune() removes an object from the result');
}
public function testPruneCompositeKey()
{
BookstoreDataPopulator::depopulate();
BookstoreDataPopulator::populate();
// save all books to make sure related objects are also saved - BookstoreDataPopulator keeps some unsaved
$c = new ModelCriteria('bookstore', 'Book');
$books = $c->find();
foreach ($books as $book) {
$book->save();
}
BookPeer::clearInstancePool();
$nbBookListRel = BookListRelQuery::create()->prune()->count();
$this->assertEquals(2, $nbBookListRel, 'prune() does nothing when passed a null object');
$testBookListRel = BookListRelQuery::create()->findOne();
$nbBookListRel = BookListRelQuery::create()->prune($testBookListRel)->count();
$this->assertEquals(1, $nbBookListRel, 'prune() removes an object from the result');
}
}
class myCustomBookQuery extends BookQuery
{
public static function create($modelAlias = null, $criteria = null)
{
if ($criteria instanceof myCustomBookQuery) {
return $criteria;
}
$query = new myCustomBookQuery();
if (null !== $modelAlias) {
$query->setModelAlias($modelAlias);
}
if ($criteria instanceof Criteria) {
$query->mergeWith($criteria);
}
return $query;
}
}
Reference in a new issue View git blame Copy permalink