public function testSavedObjectsWithCriteria()
{
$a = new Author();
$a->setFirstName("Douglas");
$a->setLastName("Adams");
$b1 = new Book();
$b1->setTitle("The Hitchhikers Guide To The Galaxy");
$b1->setISBN('123');
$a->addBook($b1);
$b2 = new Book();
$b2->setTitle("The Restaurant At The End Of The Universe");
$b2->setISBN('123');
$a->addBook($b2);
$c = new Criteria();
$c->add(BookPeer::TITLE, "%Hitchhiker%", Criteria::LIKE);
/* This is the same as testNewObjectsWithCriteria EXCEPT we're now going
to save(). Now the $author and related objects are no longer new
and thus the criteria will be applied in the database.
Apart from that the fix is for sure not trivial, observable behaviour
of the $author should not depend on having called save() or not... */
$booksBeforeSave = $a->getBooks($c);
$a->save();
$booksAfterSave = $a->getBooks($c);
// As of revision 851, this passes...
$this->assertEquals(1, count($booksAfterSave));
foreach ($booksAfterSave as $book) {
$this->assertEquals($b1, $book);
}
/* ... but this would fail. Commented out because it's covered
by testNewObjectsWithCriteria(). */
//$this->assertEquals($booksBeforeSave, $booksAfterSave);
}
function bookInsertion($title, $ISBN, $author)
{
$book = new \Book();
$book->setTitle($title);
$book->setISBN($ISBN);
$book->setAuthor($author);
$book->save();
return $book;
}
function runBookInsertion($i)
{
$book = new Book();
$book->setTitle('Hello' . $i);
$book->setAuthorId($this->authors[array_rand($this->authors)]);
$book->setISBN('1234');
$book->setPrice($i);
$book->save($this->con);
$this->books[] = $book->getId();
}
function runBookInsertion($i)
{
$rand = array_rand($this->authors);
$book = new Book();
$book->setTitle('Hello' . $i);
$book->setAuthor($this->authors[$rand]);
$book->setISBN('1234');
$book->setPrice($i);
$this->session->persist($book);
$this->session->persist($this->authors[$rand]);
$this->books[] = $book;
$this->i++;
if ($this->i >= 500) {
$this->commit();
$this->beginTransaction();
}
}
/**
* Primary key should differ
*/
public function testSavedObjectCreatesDifferentHashForIdenticalObjects()
{
$book1 = new Book();
$book1->setTitle('Foo5');
$book1->setISBN('1234');
$author1 = new Author();
$author1->setFirstName('JAne');
$author1->setLastName('JAne');
$author1->addBook($book1);
$author1->save();
$author2 = new Author();
$author2->setFirstName('JAne');
$author2->setLastName('JAne');
$author2->addBook($book1);
$author2->save();
$this->assertNotEquals($author1->hashCode(), $author2->hashCode());
}
protected function setUp()
{
parent::setUp();
BookstoreDataPopulator::populate();
$cr = new Criteria();
$cr->add(AuthorPeer::LAST_NAME, "Rowling");
$cr->add(AuthorPeer::FIRST_NAME, "J.K.");
$rowling = AuthorPeer::doSelectOne($cr);
$this->authorId = $rowling->getId();
$book = new Book();
$book->setTitle("Harry Potter and the Philosopher's Stone");
$book->setISBN("1234");
$book->setAuthor($rowling);
$book->save();
$this->books[] = $book->getId();
$book = new Book();
$book->setTitle("Harry Potter and the Chamber of Secrets");
$book->setISBN("1234");
$book->setAuthor($rowling);
$book->save();
$this->books[] = $book->getId();
$book = new Book();
$book->setTitle("Harry Potter and the Prisoner of Azkaban");
$book->setISBN("1234");
$book->setAuthor($rowling);
$book->save();
$this->books[] = $book->getId();
$book = new Book();
$book->setTitle("Harry Potter and the Goblet of Fire");
$book->setISBN("1234");
$book->setAuthor($rowling);
$book->save();
$this->books[] = $book->getId();
$book = new Book();
$book->setTitle("Harry Potter and the Half-Blood Prince");
$book->setISBN("1234");
$book->setAuthor($rowling);
$book->save();
$this->books[] = $book->getId();
$book = new Book();
$book->setTitle("Harry Potter and the Deathly Hallows");
$book->setISBN("1234");
$book->setAuthor($rowling);
$book->save();
$this->books[] = $book->getId();
}
public function testSerializeObjectWithCollections()
{
$book1 = new Book();
$book1->setTitle('Foo5');
$book1->setISBN('1234');
$book2 = new Book();
$book2->setTitle('Foo6');
$book2->setISBN('1234');
$author = new Author();
$author->setFirstName('JAne');
$author->addBook($book1);
$author->addBook($book2);
$author->save();
$a = clone $author;
$sa = serialize($a);
$author->clearAllReferences();
$this->assertEquals($author, unserialize($sa));
}
public function testCloneContainingObjects()
{
$a = new Author();
$b = new Book();
$b->setAuthor($a);
$b->setISBN('ISBN1');
$b1 = new Book();
$b1->setPrice(5.55);
$col = new PropelCollection(array($b, $b1));
$clone = clone $col;
$orgCount = $col->getIterator()->count();
$cloneCount = $clone->getIterator()->count();
$this->assertEquals($orgCount, $cloneCount, 'cloned collections have the same size');
$this->assertEquals($b, $clone[0], 'cloned objects are equal');
$this->assertEquals($b1, $clone[1], 'cloned objects are equal');
$this->assertNotSame($b, $clone[0], 'cloned objects are copies, not identical');
$this->assertNotSame($b1, $clone[1], 'cloned objects are copies, not identical');
}
protected function setUp()
{
parent::setUp();
$publisher = new Publisher();
$publisher->setId(1234);
$publisher->setName('Penguin');
$author = new Author();
$author->setId(5678);
$author->setFirstName('George');
$author->setLastName('Byron');
$book = new Book();
$book->setId(9012);
$book->setTitle('Don Juan');
$book->setISBN('0140422161');
$book->setPrice(12.99);
$book->setAuthor($author);
$book->setPublisher($publisher);
$this->book = $book;
}
public function testUtf8()
{
$db = Propel::getDB(BookPeer::DATABASE_NAME);
$title = "Смерть на брудершафт. Младенец и черт";
// 1234567890123456789012345678901234567
// 1 2 3
$a = new Author();
$a->setFirstName("Б.");
$a->setLastName("АКУНИН");
$p = new Publisher();
$p->setName("Детектив российский, остросюжетная проза");
$b = new Book();
$b->setTitle($title);
$b->setISBN("B-59246");
$b->setAuthor($a);
$b->setPublisher($p);
$b->save();
$b->reload();
$this->assertEquals(37, iconv_strlen($b->getTitle(), 'utf-8'), "Expected 37 characters (not bytes) in title.");
$this->assertTrue(strlen($b->getTitle()) > iconv_strlen($b->getTitle(), 'utf-8'), "Expected more bytes than characters in title.");
}
protected function setUp()
{
parent::setUp();
$book1 = new Book();
$book1->setId(9012);
$book1->setTitle('Don Juan');
$book1->setISBN('0140422161');
$book1->setPrice(12.99);
$book1->setAuthorId(5678);
$book1->setPublisherId(1234);
$book1->resetModified();
$book2 = new Book();
$book2->setId(58);
$book2->setTitle('Harry Potter and the Order of the Phoenix');
$book2->setISBN('043935806X');
$book2->setPrice(10.99);
$book2->resetModified();
$this->coll = new PropelObjectCollection();
$this->coll->setModel('Book');
$this->coll[] = $book1;
$this->coll[] = $book2;
}
/**
* Testing foreign keys with multiple referrer columns.
* @link http://propel.phpdb.org/trac/ticket/606
*/
public function testMultiColFk()
{
$con = Propel::getConnection(BookPeer::DATABASE_NAME);
ReaderFavoritePeer::doDeleteAll();
$b1 = new Book();
$b1->setTitle("Book1");
$b1->setISBN("ISBN-1");
$b1->save();
$r1 = new BookReader();
$r1->setName("Me");
$r1->save();
$bo1 = new BookOpinion();
$bo1->setBookId($b1->getId());
$bo1->setReaderId($r1->getId());
$bo1->setRating(9);
$bo1->setRecommendToFriend(true);
$bo1->save();
$rf1 = new ReaderFavorite();
$rf1->setReaderId($r1->getId());
$rf1->setBookId($b1->getId());
$rf1->save();
$c = new Criteria(ReaderFavoritePeer::DATABASE_NAME);
$c->add(ReaderFavoritePeer::BOOK_ID, $b1->getId());
$c->add(ReaderFavoritePeer::READER_ID, $r1->getId());
$results = ReaderFavoritePeer::doSelectJoinBookOpinion($c);
$this->assertEquals(1, count($results), "Expected 1 result");
}
public function testToKeyValue()
{
$author = new Author();
$author->setId(5678);
$author->setFirstName('George');
$author->setLastName('Byron');
$book = new Book();
$book->setId(9012);
$book->setTitle('Don Juan');
$book->setISBN('0140422161');
$book->setPrice(12.99);
$book->setAuthor($author);
$coll = new PropelObjectCollection();
$coll->setModel('Book');
$coll->append($book);
$this->assertCount(1, $coll);
// This will call $book->getId()
$this->assertEquals(array(9012 => 'Don Juan'), $coll->toKeyValue('Id', 'Title'));
// This will call: $book->getAuthor()->getBooks()->getFirst()->getId()
$this->assertEquals(array(9012 => 'Don Juan'), $coll->toKeyValue(array('Author', 'Books', 'First', 'Id'), 'Title'));
}
public function testDoValidate_CustomValidator()
{
$book = new Book();
$book->setTitle("testDoValidate_CustomValidator");
// (valid)
$book->setISBN("Foo.Bar.Baz");
// (invalid)
$res = $book->validate();
$this->assertFalse($res, "Expected validation to fail.");
$failures = $book->getValidationFailures();
$this->assertEquals(1, count($failures), "Expected 1 column to fail validation.");
$this->assertEquals(array(BookPeer::ISBN), array_keys($failures), "Expected EMAIL to fail validation.");
$validator = $failures[BookPeer::ISBN]->getValidator();
$this->assertType('ISBNValidator', $validator, "Expected validator that failed to be ISBNValidator");
}
/**
* Test doCountJoin*() methods.
*/
public function testDoCountJoin()
{
BookPeer::doDeleteAll();
for ($i = 0; $i < 25; $i++) {
$b = new Book();
$b->setTitle("Book {$i}");
$b->setISBN("ISBN {$i}");
$b->save();
}
$c = new Criteria();
$totalCount = BookPeer::doCount($c);
$this->assertEquals($totalCount, BookPeer::doCountJoinAuthor($c));
$this->assertEquals($totalCount, BookPeer::doCountJoinPublisher($c));
}
/**
* This tests to see whether modified objects are being silently overwritten by calls to fk accessor methods.
* @link http://propel.phpdb.org/trac/ticket/509#comment:5
*/
public function testModifiedObjectOverwrite()
{
BookstoreDataPopulator::populate();
$author = new Author();
$author->setFirstName("John");
$author->setLastName("Public");
$books = $author->getBooks();
// empty, of course
$this->assertEquals(0, count($books), "Expected empty collection.");
$book = new Book();
$book->setTitle("A sample book");
$book->setISBN("INITIAL ISBN");
$author->addBook($book);
$author->save();
$book->setISBN("MODIFIED ISBN");
$books = $author->getBooks();
$this->assertEquals(1, count($books), "Expected 1 book.");
$this->assertSame($book, $books[0], "Expected the same object to be returned by fk accessor.");
$this->assertEquals("MODIFIED ISBN", $books[0]->getISBN(), "Expected the modified value NOT to have been overwritten.");
}
/**
* Test removing object when FK is part of the composite PK
*/
public function testRemove_CompositePK()
{
BookReaderQuery::create()->deleteAll();
BookQuery::create()->deleteAll();
BookOpinionQuery::create()->deleteAll();
$br = new BookReader();
$br->setName("TestReader");
$br->save();
$b = new Book();
$b->setTitle("TestBook");
$b->setISBN("XX-XX-XX-XX");
$b->save();
$op = new BookOpinion();
$op->setBookReader($br);
$op->setBook($b);
$op->setRating(10);
$op->setRecommendToFriend(true);
$op->save();
$this->assertEquals(1, BookReaderQuery::create()->count(), '1 BookReader');
$this->assertEquals(1, BookQuery::create()->count(), '1 Book');
$this->assertEquals(1, BookOpinionQuery::create()->count(), '1 BookOpinion');
// make sure everything is loaded correctly (and their relation too)
$br->reload(true);
$b->reload(true);
$op->reload(true);
$br->getBookOpinions();
// load the relation
$b->removeBookOpinion($op);
$b->save();
// the Book knows that there is no longer an opinion
$this->assertEquals(0, count($b->getBookOpinions()), 'Book knows there is no opinion');
// but not the BookReader
$this->assertEquals(1, count($br->getBookOpinions()), 'BookReader still thinks it has 1 opinion');
$br->reload(true);
// with relations
$this->assertEquals(0, count($br->getBookOpinions()), 'BookReader now knows the opinion is gone');
$this->assertEquals(1, BookReaderQuery::create()->count(), '1 BookReader');
$this->assertEquals(1, BookQuery::create()->count(), '1 Book');
$this->assertEquals(0, BookOpinionQuery::create()->count(), '0 BookOpinion');
}
public function testRemoveObjectStoredInDBFromCollection()
{
BookQuery::create()->deleteAll();
BookClubListQuery::create()->deleteAll();
$list = new BookClubList();
$list->setGroupLeader('Archimedes Q. Porter');
$list2 = new BookClubList();
$list2->setGroupLeader('FooBar group');
// No save ...
$book = new Book();
$book->setTitle("Jungle Expedition Handbook");
$book->setISBN('TEST');
$book->addBookClubList($list);
$book->addBookClubList($list2);
$book->save();
$this->assertEquals(2, BookClubListQuery::create()->count(), 'Two BookClubList');
$this->assertEquals(2, BookListRelQuery::create()->count(), 'Two BookClubList');
$book->removeBookClubList($list);
$this->assertEquals(2, BookListRelQuery::create()->count(), 'still Two BookClubList in db before save()');
$this->assertCount(1, $book->getBookClubLists(), 'One BookClubList has been remove');
$book->save();
$this->assertCount(1, $book->getBookClubLists(), 'One BookClubList has been remove');
$this->assertEquals(1, BookListRelQuery::create()->count(), 'One BookClubList has been remove');
}
public function testSpeed()
{
// Add publisher records
// ---------------------
$scholastic = new Publisher();
$scholastic->setName("Scholastic");
// do not save, will do later to test cascade
$morrow = new Publisher();
$morrow->setName("William Morrow");
$morrow->save();
$morrow_id = $morrow->getId();
$penguin = new Publisher();
$penguin->setName("Penguin");
$penguin->save();
$penguin_id = $penguin->getId();
$vintage = new Publisher();
$vintage->setName("Vintage");
$vintage->save();
$vintage_id = $vintage->getId();
// Add author records
// ------------------
$rowling = new Author();
$rowling->setFirstName("J.K.");
$rowling->setLastName("Rowling");
// no save()
$stephenson = new Author();
$stephenson->setFirstName("Neal");
$stephenson->setLastName("Stephenson");
$stephenson->save();
$stephenson_id = $stephenson->getId();
$byron = new Author();
$byron->setFirstName("George");
$byron->setLastName("Byron");
$byron->save();
$byron_id = $byron->getId();
$grass = new Author();
$grass->setFirstName("Gunter");
$grass->setLastName("Grass");
$grass->save();
$grass_id = $grass->getId();
// Add book records
// ----------------
$phoenix = new Book();
$phoenix->setTitle("Harry Potter and the Order of the Phoenix");
$phoenix->setISBN("043935806X");
// cascading save (Harry Potter)
$phoenix->setAuthor($rowling);
$phoenix->setPublisher($scholastic);
$phoenix->save();
$phoenix_id = $phoenix->getId();
$qs = new Book();
$qs->setISBN("0380977427");
$qs->setTitle("Quicksilver");
$qs->setAuthor($stephenson);
$qs->setPublisher($morrow);
$qs->save();
$qs_id = $qs->getId();
$dj = new Book();
$dj->setISBN("0140422161");
$dj->setTitle("Don Juan");
$dj->setAuthor($byron);
$dj->setPublisher($penguin);
$dj->save();
$dj_id = $qs->getId();
$td = new Book();
$td->setISBN("067972575X");
$td->setTitle("The Tin Drum");
$td->setAuthor($grass);
$td->setPublisher($vintage);
$td->save();
$td_id = $td->getId();
// Add review records
// ------------------
$r1 = new Review();
$r1->setBook($phoenix);
$r1->setReviewedBy("Washington Post");
$r1->setRecommended(true);
$r1->setReviewDate(time());
$r1->save();
$r1_id = $r1->getId();
$r2 = new Review();
$r2->setBook($phoenix);
$r2->setReviewedBy("New York Times");
$r2->setRecommended(false);
$r2->setReviewDate(time());
$r2->save();
$r2_id = $r2->getId();
// Perform a "complex" search
// --------------------------
$crit = new Criteria();
$crit->add(BookPeer::TITLE, 'Harry%', Criteria::LIKE);
$results = BookPeer::doSelect($crit);
$crit2 = new Criteria();
$crit2->add(BookPeer::ISBN, array("0380977427", "0140422161"), Criteria::IN);
$results = BookPeer::doSelect($crit2);
// Perform a "limit" search
// ------------------------
$crit = new Criteria();
$crit->setLimit(2);
$crit->setOffset(1);
$crit->addAscendingOrderByColumn(BookPeer::TITLE);
$results = BookPeer::doSelect($crit);
// Perform a lookup & update!
// --------------------------
$qs_lookup = BookPeer::retrieveByPk($qs_id);
$new_title = "Quicksilver (" . crc32(uniqid(rand())) . ")";
$qs_lookup->setTitle($new_title);
$qs_lookup->save();
$qs_lookup2 = BookPeer::retrieveByPk($qs_id);
// Test some basic DATE / TIME stuff
// ---------------------------------
// that's the control timestamp.
$control = strtotime('2004-02-29 00:00:00');
// should be two in the db
$r = ReviewPeer::doSelectOne(new Criteria());
$r_id = $r->getId();
$r->setReviewDate($control);
$r->save();
$r2 = ReviewPeer::retrieveByPk($r_id);
// Testing the DATE/TIME columns
// -----------------------------
// that's the control timestamp.
$control = strtotime('2004-02-29 00:00:00');
// should be two in the db
$r = ReviewPeer::doSelectOne(new Criteria());
$r_id = $r->getId();
$r->setReviewDate($control);
$r->save();
$r2 = ReviewPeer::retrieveByPk($r_id);
// Testing the column validators
// -----------------------------
$bk1 = new Book();
$bk1->setTitle("12345");
// min length is 10
$ret = $bk1->validate();
// Unique validator
$bk2 = new Book();
$bk2->setTitle("Don Juan");
$ret = $bk2->validate();
// Now trying some more complex validation.
$auth1 = new Author();
$auth1->setFirstName("Hans");
// last name required; will fail
$bk1->setAuthor($auth1);
$rev1 = new Review();
$rev1->setReviewDate("08/09/2001");
// will fail: reviewed_by column required
$bk1->addReview($rev1);
$ret2 = $bk1->validate();
$bk2 = new Book();
$bk2->setTitle("12345678901");
// passes
$auth2 = new Author();
$auth2->setLastName("Blah");
//passes
$auth2->setEmail("*****@*****.**");
//passes
$auth2->setAge(50);
//passes
$bk2->setAuthor($auth2);
$rev2 = new Review();
$rev2->setReviewedBy("Me!");
// passes
$rev2->setStatus("new");
// passes
$bk2->addReview($rev2);
$ret3 = $bk2->validate();
// Testing doCount() functionality
// -------------------------------
$c = new Criteria();
$count = BookPeer::doCount($c);
// Testing many-to-many relationships
// ----------------------------------
// init book club list 1 with 2 books
$blc1 = new BookClubList();
$blc1->setGroupLeader("Crazyleggs");
$blc1->setTheme("Happiness");
$brel1 = new BookListRel();
$brel1->setBook($phoenix);
$brel2 = new BookListRel();
$brel2->setBook($dj);
$blc1->addBookListRel($brel1);
$blc1->addBookListRel($brel2);
$blc1->save();
// init book club list 2 with 1 book
$blc2 = new BookClubList();
$blc2->setGroupLeader("John Foo");
$blc2->setTheme("Default");
$brel3 = new BookListRel();
$brel3->setBook($phoenix);
$blc2->addBookListRel($brel3);
$blc2->save();
// re-fetch books and lists from db to be sure that nothing is cached
$crit = new Criteria();
$crit->add(BookPeer::ID, $phoenix->getId());
$phoenix = BookPeer::doSelectOne($crit);
$crit = new Criteria();
$crit->add(BookClubListPeer::ID, $blc1->getId());
$blc1 = BookClubListPeer::doSelectOne($crit);
$crit = new Criteria();
$crit->add(BookClubListPeer::ID, $blc2->getId());
$blc2 = BookClubListPeer::doSelectOne($crit);
$relCount = $phoenix->countBookListRels();
$relCount = $blc1->countBookListRels();
$relCount = $blc2->countBookListRels();
// Removing books that were just created
// -------------------------------------
$hp = BookPeer::retrieveByPk($phoenix_id);
$c = new Criteria();
$c->add(BookPeer::ID, $hp->getId());
// The only way for cascading to work currently
// is to specify the author_id and publisher_id (i.e. the fkeys
// have to be in the criteria).
$c->add(AuthorPeer::ID, $hp->getId());
$c->add(PublisherPeer::ID, $hp->getId());
$c->setSingleRecord(true);
BookPeer::doDelete($c);
// Attempting to delete books by complex criteria
$c = new Criteria();
$cn = $c->getNewCriterion(BookPeer::ISBN, "043935806X");
$cn->addOr($c->getNewCriterion(BookPeer::ISBN, "0380977427"));
$cn->addOr($c->getNewCriterion(BookPeer::ISBN, "0140422161"));
$c->add($cn);
BookPeer::doDelete($c);
$td->delete();
AuthorPeer::doDelete($stephenson_id);
AuthorPeer::doDelete($byron_id);
$grass->delete();
PublisherPeer::doDelete($morrow_id);
PublisherPeer::doDelete($penguin_id);
$vintage->delete();
// These have to be deleted manually also since we have onDelete
// set to SETNULL in the foreign keys in book. Is this correct?
$rowling->delete();
$scholastic->delete();
$blc1->delete();
$blc2->delete();
}
public static function populate($con = null)
{
if ($con === null) {
$con = Propel::getConnection(BookPeer::DATABASE_NAME);
}
$con->beginTransaction();
// Add publisher records
// ---------------------
$scholastic = new Publisher();
$scholastic->setName("Scholastic");
// do not save, will do later to test cascade
$morrow = new Publisher();
$morrow->setName("William Morrow");
$morrow->save($con);
$morrow_id = $morrow->getId();
$penguin = new Publisher();
$penguin->setName("Penguin");
$penguin->save();
$penguin_id = $penguin->getId();
$vintage = new Publisher();
$vintage->setName("Vintage");
$vintage->save($con);
$vintage_id = $vintage->getId();
$rowling = new Author();
$rowling->setFirstName("J.K.");
$rowling->setLastName("Rowling");
// no save()
$stephenson = new Author();
$stephenson->setFirstName("Neal");
$stephenson->setLastName("Stephenson");
$stephenson->save($con);
$stephenson_id = $stephenson->getId();
$byron = new Author();
$byron->setFirstName("George");
$byron->setLastName("Byron");
$byron->save($con);
$byron_id = $byron->getId();
$grass = new Author();
$grass->setFirstName("Gunter");
$grass->setLastName("Grass");
$grass->save($con);
$grass_id = $grass->getId();
$phoenix = new Book();
$phoenix->setTitle("Harry Potter and the Order of the Phoenix");
$phoenix->setISBN("043935806X");
$phoenix->setAuthor($rowling);
$phoenix->setPublisher($scholastic);
$phoenix->setPrice(10.99);
$phoenix->save($con);
$phoenix_id = $phoenix->getId();
$qs = new Book();
$qs->setISBN("0380977427");
$qs->setTitle("Quicksilver");
$qs->setPrice(11.99);
$qs->setAuthor($stephenson);
$qs->setPublisher($morrow);
$qs->save($con);
$qs_id = $qs->getId();
$dj = new Book();
$dj->setISBN("0140422161");
$dj->setTitle("Don Juan");
$dj->setPrice(12.99);
$dj->setAuthor($byron);
$dj->setPublisher($penguin);
$dj->save($con);
$dj_id = $dj->getId();
$td = new Book();
$td->setISBN("067972575X");
$td->setTitle("The Tin Drum");
$td->setPrice(13.99);
$td->setAuthor($grass);
$td->setPublisher($vintage);
$td->save($con);
$td_id = $td->getId();
$r1 = new Review();
$r1->setBook($phoenix);
$r1->setReviewedBy("Washington Post");
$r1->setRecommended(true);
$r1->setReviewDate(time());
$r1->save($con);
$r1_id = $r1->getId();
$r2 = new Review();
$r2->setBook($phoenix);
$r2->setReviewedBy("New York Times");
$r2->setRecommended(false);
$r2->setReviewDate(time());
$r2->save($con);
$r2_id = $r2->getId();
$blob_path = _LOB_SAMPLE_FILE_PATH . '/tin_drum.gif';
$clob_path = _LOB_SAMPLE_FILE_PATH . '/tin_drum.txt';
$m1 = new Media();
$m1->setBook($td);
$m1->setCoverImage(file_get_contents($blob_path));
// CLOB is broken in PDO OCI, see http://pecl.php.net/bugs/bug.php?id=7943
if (get_class(Propel::getDB()) != "DBOracle") {
$m1->setExcerpt(file_get_contents($clob_path));
}
$m1->save($con);
// Add book list records
// ---------------------
// (this is for many-to-many tests)
$blc1 = new BookClubList();
$blc1->setGroupLeader("Crazyleggs");
$blc1->setTheme("Happiness");
$brel1 = new BookListRel();
$brel1->setBook($phoenix);
$brel2 = new BookListRel();
$brel2->setBook($dj);
$blc1->addBookListRel($brel1);
$blc1->addBookListRel($brel2);
$blc1->save();
$bemp1 = new BookstoreEmployee();
$bemp1->setName("John");
$bemp1->setJobTitle("Manager");
$bemp2 = new BookstoreEmployee();
$bemp2->setName("Pieter");
$bemp2->setJobTitle("Clerk");
$bemp2->setSupervisor($bemp1);
$bemp2->save($con);
$bemp3 = new BookstoreCashier();
$bemp3->setName("Tim");
$bemp3->setJobTitle("Cashier");
$bemp3->save($con);
$role = new AcctAccessRole();
$role->setName("Admin");
$bempacct = new BookstoreEmployeeAccount();
$bempacct->setBookstoreEmployee($bemp1);
$bempacct->setAcctAccessRole($role);
$bempacct->setLogin("john");
$bempacct->setPassword("johnp4ss");
$bempacct->save($con);
// Add bookstores
$store = new Bookstore();
$store->setStoreName("Amazon");
$store->setPopulationServed(5000000000);
// world population
$store->setTotalBooks(300);
$store->save($con);
$store = new Bookstore();
$store->setStoreName("Local Store");
$store->setPopulationServed(20);
$store->setTotalBooks(500000);
$store->save($con);
$summary = new BookSummary();
$summary->setSummarizedBook($phoenix);
$summary->setSummary("Harry Potter does some amazing magic!");
$summary->save();
$con->commit();
}
$qs->setTitle("Quicksilver");
$qs->setAuthor($stephenson);
$qs->setPublisher($morrow);
$qs->save();
$qs_id = $qs->getId();
print "Added book \"Quicksilver\" [id = {$qs_id}].\n";
$dj = new Book();
$dj->setISBN("0140422161");
$dj->setTitle("Don Juan");
$dj->setAuthor($byron);
$dj->setPublisher($penguin);
$dj->save();
$dj_id = $qs->getId();
print "Added book \"Don Juan\" [id = {$dj_id}].\n";
$td = new Book();
$td->setISBN("067972575X");
$td->setTitle("The Tin Drum");
$td->setAuthor($grass);
$td->setPublisher($vintage);
$td->save();
$td_id = $td->getId();
print "Added book \"The Tin Drum\" [id = {$dj_id}].\n";
} catch (Exception $e) {
die("Error saving book: " . $e->__toString());
}
// Add review records
// ------------------
try {
print "\nAdding some book reviews to the list\n";
print "------------------------------------\n\n";
$r1 = new Review();
/**
* Test copying when an object has composite primary key.
* @link http://propel.phpdb.org/trac/ticket/618
*/
public function testCopy_CompositePK()
{
$br = new BookReader();
$br->setName("TestReader");
$br->save();
$br->copy();
$b = new Book();
$b->setTitle("TestBook");
$b->setISBN("XX-XX-XX-XX");
$b->save();
$op = new BookOpinion();
$op->setBookReader($br);
$op->setBook($b);
$op->setRating(10);
$op->setRecommendToFriend(true);
$op->save();
$br2 = $br->copy(true);
$this->assertNull($br2->getId());
$opinions = $br2->getBookOpinions();
$this->assertEquals(1, count($opinions), "Expected to have a related BookOpinion after copy()");
// We DO expect the reader_id to be null
$this->assertNull($opinions[0]->getReaderId());
// but we DO NOT expect the book_id to be null
$this->assertEquals($op->getBookId(), $opinions[0]->getBookId());
}
public function testToArrayDeep()
{
$author = new Author();
$author->setId(5678);
$author->setFirstName('George');
$author->setLastName('Byron');
$book = new Book();
$book->setId(9012);
$book->setTitle('Don Juan');
$book->setISBN('0140422161');
$book->setPrice(12.99);
$book->setAuthor($author);
$coll = new PropelArrayCollection();
$coll->setModel('Book');
$coll[] = $book->toArray(BasePeer::TYPE_PHPNAME, true, array(), true);
$expected = array(array('Id' => 9012, 'Title' => 'Don Juan', 'ISBN' => '0140422161', 'Price' => 12.99, 'PublisherId' => null, 'AuthorId' => 5678, 'Author' => array('Id' => 5678, 'FirstName' => 'George', 'LastName' => 'Byron', 'Email' => null, 'Age' => null, 'Books' => array('Book_0' => '*RECURSION*'))));
$this->assertEquals($expected, $coll->toArray());
}
public function testScenarioUsingQuery()
{
// Add publisher records
// ---------------------
try {
$scholastic = new Publisher();
$scholastic->setName("Scholastic");
// do not save, will do later to test cascade
$morrow = new Publisher();
$morrow->setName("William Morrow");
$morrow->save();
$morrow_id = $morrow->getId();
$penguin = new Publisher();
$penguin->setName("Penguin");
$penguin->save();
$penguin_id = $penguin->getId();
$vintage = new Publisher();
$vintage->setName("Vintage");
$vintage->save();
$vintage_id = $vintage->getId();
$this->assertTrue(true, 'Save Publisher records');
} catch (Exception $e) {
$this->fail('Save publisher records');
}
// Add author records
// ------------------
try {
$rowling = new Author();
$rowling->setFirstName("J.K.");
$rowling->setLastName("Rowling");
// do not save, will do later to test cascade
$stephenson = new Author();
$stephenson->setFirstName("Neal");
$stephenson->setLastName("Stephenson");
$stephenson->save();
$stephenson_id = $stephenson->getId();
$byron = new Author();
$byron->setFirstName("George");
$byron->setLastName("Byron");
$byron->save();
$byron_id = $byron->getId();
$grass = new Author();
$grass->setFirstName("Gunter");
$grass->setLastName("Grass");
$grass->save();
$grass_id = $grass->getId();
$this->assertTrue(true, 'Save Author records');
} catch (Exception $e) {
$this->fail('Save Author records');
}
// Add book records
// ----------------
try {
$phoenix = new Book();
$phoenix->setTitle("Harry Potter and the Order of the Phoenix");
$phoenix->setISBN("043935806X");
$phoenix->setAuthor($rowling);
$phoenix->setPublisher($scholastic);
$phoenix->save();
$phoenix_id = $phoenix->getId();
$this->assertFalse($rowling->isNew(), 'saving book also saves related author');
$this->assertFalse($scholastic->isNew(), 'saving book also saves related publisher');
$qs = new Book();
$qs->setISBN("0380977427");
$qs->setTitle("Quicksilver");
$qs->setAuthor($stephenson);
$qs->setPublisher($morrow);
$qs->save();
$qs_id = $qs->getId();
$dj = new Book();
$dj->setISBN("0140422161");
$dj->setTitle("Don Juan");
$dj->setAuthor($byron);
$dj->setPublisher($penguin);
$dj->save();
$dj_id = $qs->getId();
$td = new Book();
$td->setISBN("067972575X");
$td->setTitle("The Tin Drum");
$td->setAuthor($grass);
$td->setPublisher($vintage);
$td->save();
$td_id = $td->getId();
$this->assertTrue(true, 'Save Book records');
} catch (Exception $e) {
$this->fail('Save Author records');
}
// Add review records
// ------------------
try {
$r1 = new Review();
$r1->setBook($phoenix);
$r1->setReviewedBy("Washington Post");
$r1->setRecommended(true);
$r1->setReviewDate(time());
$r1->save();
$r1_id = $r1->getId();
$r2 = new Review();
$r2->setBook($phoenix);
$r2->setReviewedBy("New York Times");
$r2->setRecommended(false);
$r2->setReviewDate(time());
$r2->save();
$r2_id = $r2->getId();
$this->assertTrue(true, 'Save Review records');
} catch (Exception $e) {
$this->fail('Save Review records');
}
// Perform a "complex" search
// --------------------------
$results = BookQuery::create()->filterByTitle('Harry%')->find();
$this->assertEquals(1, count($results));
$results = BookQuery::create()->where('Book.ISBN IN ?', array("0380977427", "0140422161"))->find();
$this->assertEquals(2, count($results));
// Perform a "limit" search
// ------------------------
$results = BookQuery::create()->limit(2)->offset(1)->orderByTitle()->find();
$this->assertEquals(2, count($results));
// we ordered on book title, so we expect to get
$this->assertEquals("Harry Potter and the Order of the Phoenix", $results[0]->getTitle());
$this->assertEquals("Quicksilver", $results[1]->getTitle());
// Perform a lookup & update!
// --------------------------
// Updating just-created book title
// First finding book by PK (=$qs_id) ....
$qs_lookup = BookQuery::create()->findPk($qs_id);
$this->assertNotNull($qs_lookup, 'just-created book can be found by pk');
$new_title = "Quicksilver (" . crc32(uniqid(rand())) . ")";
// Attempting to update found object
$qs_lookup->setTitle($new_title);
$qs_lookup->save();
// Making sure object was correctly updated: ";
$qs_lookup2 = BookQuery::create()->findPk($qs_id);
$this->assertEquals($new_title, $qs_lookup2->getTitle());
// Test some basic DATE / TIME stuff
// ---------------------------------
// that's the control timestamp.
$control = strtotime('2004-02-29 00:00:00');
// should be two in the db
$r = ReviewQuery::create()->findOne();
$r_id = $r->getId();
$r->setReviewDate($control);
$r->save();
$r2 = ReviewQuery::create()->findPk($r_id);
$this->assertEquals(new Datetime('2004-02-29 00:00:00'), $r2->getReviewDate(null), 'ability to fetch DateTime');
$this->assertEquals($control, $r2->getReviewDate('U'), 'ability to fetch native unix timestamp');
$this->assertEquals('2-29-2004', $r2->getReviewDate('n-j-Y'), 'ability to use date() formatter');
// Handle BLOB/CLOB Columns
// ------------------------
$blob_path = dirname(__FILE__) . '/../../etc/lob/tin_drum.gif';
$blob2_path = dirname(__FILE__) . '/../../etc/lob/propel.gif';
$clob_path = dirname(__FILE__) . '/../../etc/lob/tin_drum.txt';
$m1 = new Media();
$m1->setBook($phoenix);
$m1->setCoverImage(file_get_contents($blob_path));
$m1->setExcerpt(file_get_contents($clob_path));
$m1->save();
$m1_id = $m1->getId();
$m1_lookup = MediaQuery::create()->findPk($m1_id);
$this->assertNotNull($m1_lookup, 'Can find just-created media item');
$this->assertEquals(md5(file_get_contents($blob_path)), md5(stream_get_contents($m1_lookup->getCoverImage())), 'BLOB was correctly updated');
$this->assertEquals(file_get_contents($clob_path), (string) $m1_lookup->getExcerpt(), 'CLOB was correctly updated');
// now update the BLOB column and save it & check the results
$m1_lookup->setCoverImage(file_get_contents($blob2_path));
$m1_lookup->save();
$m2_lookup = MediaQuery::create()->findPk($m1_id);
$this->assertNotNull($m2_lookup, 'Can find just-created media item');
$this->assertEquals(md5(file_get_contents($blob2_path)), md5(stream_get_contents($m2_lookup->getCoverImage())), 'BLOB was correctly overwritten');
// Test Validators
// ---------------
require_once 'tools/helpers/bookstore/validator/ISBNValidator.php';
$bk1 = new Book();
$bk1->setTitle("12345");
// min length is 10
$ret = $bk1->validate();
$this->assertFalse($ret, 'validation failed');
$failures = $bk1->getValidationFailures();
$this->assertEquals(1, count($failures), '1 validation message was returned');
$el = array_shift($failures);
$this->assertContains("must be more than", $el->getMessage(), 'Expected validation message was returned');
$bk2 = new Book();
$bk2->setTitle("Don Juan");
$ret = $bk2->validate();
$this->assertFalse($ret, 'validation failed');
$failures = $bk2->getValidationFailures();
$this->assertEquals(1, count($failures), '1 validation message was returned');
$el = array_shift($failures);
$this->assertContains("Book title already in database.", $el->getMessage(), 'Expected validation message was returned');
//Now trying some more complex validation.
$auth1 = new Author();
$auth1->setFirstName("Hans");
// last name required; will fail
$bk1->setAuthor($auth1);
$rev1 = new Review();
$rev1->setReviewDate("08/09/2001");
// will fail: reviewed_by column required
$bk1->addReview($rev1);
$ret2 = $bk1->validate();
$this->assertFalse($ret2, 'validation failed');
$failures2 = $bk1->getValidationFailures();
$this->assertEquals(3, count($failures2), '3 validation messages were returned');
$expectedKeys = array(AuthorPeer::LAST_NAME, BookPeer::TITLE, ReviewPeer::REVIEWED_BY);
$this->assertEquals($expectedKeys, array_keys($failures2), 'correct columns failed');
$bk2 = new Book();
$bk2->setTitle("12345678901");
// passes
$auth2 = new Author();
$auth2->setLastName("Blah");
//passes
$auth2->setEmail("*****@*****.**");
//passes
$auth2->setAge(50);
//passes
$bk2->setAuthor($auth2);
$rev2 = new Review();
$rev2->setReviewedBy("Me!");
// passes
$rev2->setStatus("new");
// passes
$bk2->addReview($rev2);
$ret3 = $bk2->validate();
$this->assertTrue($ret3, 'complex validation can pass');
// Testing doCount() functionality
// -------------------------------
// old way
$c = new Criteria();
$records = BookPeer::doSelect($c);
$count = BookPeer::doCount($c);
$this->assertEquals($count, count($records), 'correct number of results');
// new way
$count = BookQuery::create()->count();
$this->assertEquals($count, count($records), 'correct number of results');
// Test many-to-many relationships
// ---------------
// init book club list 1 with 2 books
$blc1 = new BookClubList();
$blc1->setGroupLeader("Crazyleggs");
$blc1->setTheme("Happiness");
$brel1 = new BookListRel();
$brel1->setBook($phoenix);
$brel2 = new BookListRel();
$brel2->setBook($dj);
$blc1->addBookListRel($brel1);
$blc1->addBookListRel($brel2);
$blc1->save();
$this->assertNotNull($blc1->getId(), 'BookClubList 1 was saved');
// init book club list 2 with 1 book
$blc2 = new BookClubList();
$blc2->setGroupLeader("John Foo");
$blc2->setTheme("Default");
$brel3 = new BookListRel();
$brel3->setBook($phoenix);
$blc2->addBookListRel($brel3);
$blc2->save();
$this->assertNotNull($blc2->getId(), 'BookClubList 2 was saved');
// re-fetch books and lists from db to be sure that nothing is cached
$crit = new Criteria();
$crit->add(BookPeer::ID, $phoenix->getId());
$phoenix = BookPeer::doSelectOne($crit);
$this->assertNotNull($phoenix, "book 'phoenix' has been re-fetched from db");
$crit = new Criteria();
$crit->add(BookClubListPeer::ID, $blc1->getId());
$blc1 = BookClubListPeer::doSelectOne($crit);
$this->assertNotNull($blc1, 'BookClubList 1 has been re-fetched from db');
$crit = new Criteria();
$crit->add(BookClubListPeer::ID, $blc2->getId());
$blc2 = BookClubListPeer::doSelectOne($crit);
$this->assertNotNull($blc2, 'BookClubList 2 has been re-fetched from db');
$relCount = $phoenix->countBookListRels();
$this->assertEquals(2, $relCount, "book 'phoenix' has 2 BookListRels");
$relCount = $blc1->countBookListRels();
$this->assertEquals(2, $relCount, 'BookClubList 1 has 2 BookListRels');
$relCount = $blc2->countBookListRels();
$this->assertEquals(1, $relCount, 'BookClubList 2 has 1 BookListRel');
// Cleanup (tests DELETE)
// ----------------------
// Removing books that were just created
// First finding book by PK (=$phoenix_id) ....
$hp = BookQuery::create()->findPk($phoenix_id);
$this->assertNotNull($hp, 'Could find just-created book');
// Attempting to delete [multi-table] by found pk
$c = new Criteria();
$c->add(BookPeer::ID, $hp->getId());
// The only way for cascading to work currently
// is to specify the author_id and publisher_id (i.e. the fkeys
// have to be in the criteria).
$c->add(AuthorPeer::ID, $hp->getAuthor()->getId());
$c->add(PublisherPeer::ID, $hp->getPublisher()->getId());
$c->setSingleRecord(true);
BookPeer::doDelete($c);
// Checking to make sure correct records were removed.
$this->assertEquals(3, AuthorPeer::doCount(new Criteria()), 'Correct records were removed from author table');
$this->assertEquals(3, PublisherPeer::doCount(new Criteria()), 'Correct records were removed from publisher table');
$this->assertEquals(3, BookPeer::doCount(new Criteria()), 'Correct records were removed from book table');
// Attempting to delete books by complex criteria
BookQuery::create()->filterByISBN("043935806X")->orWhere('Book.ISBN = ?', "0380977427")->orWhere('Book.ISBN = ?', "0140422161")->delete();
// Attempting to delete book [id = $td_id]
$td->delete();
// Attempting to delete authors
AuthorQuery::create()->filterById($stephenson_id)->delete();
AuthorQuery::create()->filterById($byron_id)->delete();
$grass->delete();
// Attempting to delete publishers
PublisherQuery::create()->filterById($morrow_id)->delete();
PublisherQuery::create()->filterById($penguin_id)->delete();
$vintage->delete();
// These have to be deleted manually also since we have onDelete
// set to SETNULL in the foreign keys in book. Is this correct?
$rowling->delete();
$scholastic->delete();
$blc1->delete();
$blc2->delete();
$this->assertEquals(array(), AuthorPeer::doSelect(new Criteria()), 'no records in [author] table');
$this->assertEquals(array(), PublisherPeer::doSelect(new Criteria()), 'no records in [publisher] table');
$this->assertEquals(array(), BookPeer::doSelect(new Criteria()), 'no records in [book] table');
$this->assertEquals(array(), ReviewPeer::doSelect(new Criteria()), 'no records in [review] table');
$this->assertEquals(array(), MediaPeer::doSelect(new Criteria()), 'no records in [media] table');
$this->assertEquals(array(), BookClubListPeer::doSelect(new Criteria()), 'no records in [book_club_list] table');
$this->assertEquals(array(), BookListRelPeer::doSelect(new Criteria()), 'no records in [book_x_list] table');
}
public function testRefIsOnlySavedWhenRequired()
{
BookQuery::create()->deleteAll();
$book = new Book();
$book->setTitle('Propel Book');
$book->setISBN('TEST');
$book->save();
$bookId = $book->getId();
BookPeer::clearInstancePool();
$summary = $this->getMock('BookSummary');
$summary->expects($this->once())->method('isDeleted')->will($this->returnValue(false));
$summary->expects($this->once())->method('isNew')->will($this->returnValue(false));
$summary->expects($this->once())->method('isModified')->will($this->returnValue(false));
$summary->expects($this->never())->method('save');
$coll = new PropelObjectCollection();
$coll->append($summary);
$book = BookQuery::create()->findOneById($bookId);
// In conjunction with the mock above, this simulates loading those entries prior saving the book.
$book->setBookSummarys($coll);
$book->setTitle('Propel2 Book');
$book->save();
}
