root/trunk/generator/test/classes/propel/GeneratedObjectTest.php

<?php
/*
 *  $Id$
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under version 3 of the LGPL. For more information please see
 * <http://propel.phpdb.org>.
 */

require_once 'bookstore/BookstoreTestBase.php';

/**
 * Tests the generated Object classes.
 *
 * This test uses generated Bookstore classes to test the behavior of various
 * object operations.  The _idea_ here is to test every possible generated method
 * from Object.tpl; if necessary, bookstore will be expanded to accommodate this.
 *
 * The database is relaoded before every test and flushed after every test.  This
 * means that you can always rely on the contents of the databases being the same
 * for each test method in this class.  See the BookstoreDataPopulator::populate()
 * method for the exact contents of the database.
 *
 * @see        BookstoreDataPopulator
 * @author     Hans Lellelid <hans@xmpl.org>
 */
class GeneratedObjectTest extends BookstoreTestBase {

    /**
     * Test saving an object after setting default values for it.
     */
    public function testSaveWithDefaultValues()
    {
        // From the schema.xml, I am relying on the following:
        //  - that 'Penguin' is the default Name for a Publisher
        //  - that 2001-01-01 is the default ReviewDate for a Review

        // 1) check regular values (VARCHAR)
        $pub = new Publisher();
        $pub->setName('Penguin');
        $pub->save();
        $this->assertTrue($pub->getId() !== null, "Expect Publisher to have been saved when default value set.");

        // 2) check date/time values
        $review = new Review();
        // note that this is different from how it's represented in schema, but should resolve to same unix timestamp
        $review->setReviewDate('2001-01-01');
        $this->assertTrue($review->isModified(), "Expect Review to have been marked 'modified' after default date/time value set.");

    }

    /**
     * Test default return values.
     */
    public function testDefaultValues()
    {
        $r = new Review();
        $this->assertEquals('2001-01-01', $r->getReviewDate('Y-m-d'));

        $this->assertFalse($r->isModified(), "expected isModified() to be falseb");

        $acct = new BookstoreEmployeeAccount();
        $this->assertEquals(true, $acct->getEnabled());
        $this->assertFalse($acct->isModified());

        $acct->setLogin("testuser");
        $acct->setPassword("testpass");
        $this->assertTrue($acct->isModified());
    }

    /**
     * Tests the use of default expressions.
     * (Also indirectly tests the reload() method.)
     */
    public function testDefaultExpresions()
    {
        if (Propel::getDb(BookstoreEmployeePeer::DATABASE_NAME) instanceof DBSqlite) {
            $this->markTestSkipped("Cannot test default expressions with SQLite");
        }

        $employee = new BookstoreEmployee();
        $employee->setName("Johnny Walker");

        $acct = new BookstoreEmployeeAccount();
        $acct->setBookstoreEmployee($employee);
        $acct->setLogin("test-login");

        $this->assertNull($acct->getCreated());

        $acct->save();

        // BookstoreEmployeeAccountPeer::removeInstanceFromPool($acct);

        $acct = BookstoreEmployeeAccountPeer::retrieveByPK($acct->getEmployeeId());
        $this->assertNotNull($acct->getCreated(), "Expected a valid date after retrieving saved object.");

        $now = new DateTime("now");
        $this->assertEquals($now->format("Y-m-d"), $acct->getCreated("Y-m-d"));

        $acct->setCreated($now);
        $this->assertEquals($now->format("Y-m-d"), $acct->getCreated("Y-m-d"));

    }

    /**
     * Test the behavior of date/time/values.
     * This requires that the model was built with propel.useDateTimeClass=true.
     */
    public function testTemporalValues_PreEpoch()
    {
        $r = new Review();

        $preEpochDate = new DateTime('1602-02-02');

        $r->setReviewDate($preEpochDate);

        $this->assertEquals('1602-02-02', $r->getReviewDate(null)->format("Y-m-d"));

        $r->setReviewDate('1702-02-02');

        $this->assertTrue($r->isModified());

        $this->assertEquals('1702-02-02', $r->getReviewDate(null)->format("Y-m-d"));

        // Now test for setting null
        $r->setReviewDate(null);
        $this->assertNull($r->getReviewDate());

    }

    /**
     * Test setting invalid date/time.
     */
    public function _disabled_testSetTemporalValue_Invalid()
    {
        // FIXME - Figure out why this doesn't work (doesn't throw Exception) in the Phing+PHPUnit context
        $r = new Review();
        try {
            $r->setReviewDate("Invalid Date");
            $this->fail("Expected PropelException when setting date column w/ invalid date");
        } catch (PropelException $x) {
            print "Caught expected PropelException: " . $x->__toString();
        }
    }

    /**
     * Test setting TIMESTAMP columns w/ unix int timestamp.
     */
    public function testTemporalValues_Unix()
    {
        $store = new Bookstore();
        $store->setStoreName("test");
        $store->setStoreOpenTime(strtotime('12:55'));
        $store->save();
        $this->assertEquals('12:55', $store->getStoreOpenTime(null)->format('H:i'));
    }

    /**
     * Test setting TIME columns.
     */
    public function testTemporalValues_TimeSetting()
    {
        $store = new Bookstore();
        $store->setStoreName("test");
        $store->setStoreOpenTime("12:55");
        $store->save();

        $store = new Bookstore();
        $store->setStoreName("test2");
        $store->setStoreOpenTime(new DateTime("12:55"));
        $store->save();
    }

    /**
     * Test setting TIME columns.
     */
    public function testTemporalValues_DateSetting()
    {
        $r = new Review();
        $r->setBook(BookPeer::doSelectOne(new Criteria()));
        $r->setReviewDate(new DateTime('1999-12-20'));
        $r->setReviewedBy("Hans");
        $r->setRecommended(false);
        $r->save();
    }

    /**
     * Testing creating & saving new object & instance pool.
     */
    public function testObjectInstances_New()
    {
        $emp = new BookstoreEmployee();
        $emp->setName(md5(microtime()));
        $emp->save();
        $id = $emp->getId();

        $retrieved = BookstoreEmployeePeer::retrieveByPK($id);
        $this->assertSame($emp, $retrieved, "Expected same object (from instance pool)");
    }

    /**
     *
     */
    public function testObjectInstances_Fkeys()
    {
        // Establish a relationship between one employee and account
        // and then change the employee_id and ensure that the account
        // is not pulling the old employee.

        $pub1 = new Publisher();
        $pub1->setName('Publisher 1');
        $pub1->save();

        $pub2 = new Publisher();
        $pub2->setName('Publisher 2');
        $pub2->save();

        $book = new Book();
        $book->setTitle("Book Title");
        $book->setISBN("1234");
        $book->setPublisher($pub1);
        $book->save();

        $this->assertSame($pub1, $book->getPublisher());

        // now change values behind the scenes
        $con = Propel::getConnection(BookstoreEmployeeAccountPeer::DATABASE_NAME);
        $con->exec("UPDATE " . BookPeer::TABLE_NAME . " SET "
        . " publisher_id = " . $pub2->getId()
        . " WHERE id = " . $book->getId());


        $book2 = BookPeer::retrieveByPK($book->getId());
        $this->assertSame($book, $book2, "Expected same book object instance");

        $this->assertEquals($pub2->getId(), $book->getPublisherId(), "Expected book to have new publisher id");
        $this->assertSame($pub2, $book->getPublisher(), "Expected book to have new publisher object associated.");

        // Now let's set it back and also verify that reload() works ...

        $con->exec("UPDATE " . BookPeer::TABLE_NAME . " SET "
        . " publisher_id = " . $pub1->getId()
        . " WHERE id = " . $book->getId());

        $book->reload();

        $this->assertEquals($pub1->getId(), $book->getPublisherId(), "Expected book to have old publisher id (again).");
        $this->assertSame($pub1, $book->getPublisher(), "Expected book to have old publisher object associated (again).");

    }

    /**
     * Test the reload() method.
     */
    public function testReload()
    {
        $a = AuthorPeer::doSelectOne(new Criteria());

        $origName = $a->getFirstName();

        $a->setFirstName(md5(time()));

        $this->assertNotEquals($origName, $a->getFirstName());
        $this->assertTrue($a->isModified());

        $a->reload();

        $this->assertEquals($origName, $a->getFirstName());
        $this->assertFalse($a->isModified());

    }

    /**
     * Test reload(deep=true) method.
     */
    public function testReloadDeep()
    {
        // arbitrary book
        $b = BookPeer::doSelectOne(new Criteria());

        // arbitrary, different author
        $c = new Criteria();
        $c->add(AuthorPeer::ID, $b->getAuthorId(), Criteria::NOT_EQUAL);
        $a = AuthorPeer::doSelectOne($c);

        $origAuthor = $b->getAuthor();

        $b->setAuthor($a);

        $this->assertNotEquals($origAuthor, $b->getAuthor(), "Expected just-set object to be different from obj from DB");
        $this->assertTrue($b->isModified());

        $b->reload($deep=true);

        $this->assertEquals($origAuthor, $b->getAuthor(), "Expected object in DB to be restored");
        $this->assertFalse($a->isModified());
    }

    /**
     * Test saving an object and getting correct number of affected rows from save().
     * This includes tests of cascading saves to fk-related objects.
     */
    public function testSaveReturnValues()
    {

        $author = new Author();
        $author->setFirstName("Mark");
        $author->setLastName("Kurlansky");
        // do not save

        $pub = new Publisher();
        $pub->setName("Penguin Books");
        // do not save

        $book = new Book();
        $book->setTitle("Salt: A World History");
        $book->setISBN("0142001619");
        $book->setAuthor($author);
        $book->setPublisher($pub);

        $affected = $book->save();
        $this->assertEquals(3, $affected, "Expected 3 affected rows when saving book + publisher + author.");

        // change nothing ...
        $affected = $book->save();
        $this->assertEquals(0, $affected, "Expected 0 affected rows when saving already-saved book.");

        // modify the book (UPDATE)
        $book->setTitle("Salt A World History");
        $affected = $book->save();
        $this->assertEquals(1, $affected, "Expected 1 affected row when saving modified book.");

        // modify the related author
        $author->setLastName("Kurlanski");
        $affected = $book->save();
        $this->assertEquals(1, $affected, "Expected 1 affected row when saving book with updated author.");

        // modify both the related author and the book
        $author->setLastName("Kurlansky");
        $book->setTitle("Salt: A World History");
        $affected = $book->save();
        $this->assertEquals(2, $affected, "Expected 2 affected rows when saving updated book with updated author.");

    }

    /**
     * Test deleting an object using the delete() method.
     */
    public function testDelete() {

        // 1) grab an arbitrary object
        $book = BookPeer::doSelectOne(new Criteria());
        $bookId = $book->getId();

        // 2) delete it
        $book->delete();

        // 3) make sure it can't be save()d now that it's deleted
        try {
            $book->setTitle("Will Fail");
            $book->save();
            $this->fail("Expect an exception to be thrown when attempting to save() a deleted object.");
        } catch (PropelException $e) {}

        // 4) make sure that it doesn't exist in db
        $book = BookPeer::retrieveByPK($bookId);
        $this->assertNull($book, "Expect NULL from retrieveByPK on deleted Book.");

    }

    /**
     *
     */
    public function testNoColsModified()
    {
        $e1 = new BookstoreEmployee();
        $e1->setName('Employee 1');

        $e2 = new BookstoreEmployee();
        $e2->setName('Employee 2');

        $super = new BookstoreEmployee();
        // we don't know who the supervisor is yet
        $super->addSubordinate($e1);
        $super->addSubordinate($e2);

        $affected = $super->save();

    }

    /**
     * Tests new one-to-one functionality.
     *
     * @todo       -cGeneratedObjectTest Add a test for one-to-one when implemented.
     */
    public function testOneToOne()
    {
        $emp = BookstoreEmployeePeer::doSelectOne(new Criteria());

        $acct = new BookstoreEmployeeAccount();
        $acct->setBookstoreEmployee($emp);
        $acct->setLogin("testuser");
        $acct->setPassword("testpass");

        $this->assertSame($emp->getBookstoreEmployeeAccount(), $acct, "Expected same object instance.");
    }

    /**
     * Test the type sensitivity of the resturning columns.
     *
     */
    public function testTypeSensitive()
    {
        $book = BookPeer::doSelectOne(new Criteria());

        $r = new Review();
        $r->setReviewedBy("testTypeSensitive Tester");
        $r->setReviewDate(time());
        $r->setBook($book);
        $r->setRecommended(true);
        $r->save();

        $id = $r->getId();
        unset($r);

        // clear the instance cache to force reload from database.
        ReviewPeer::clearInstancePool();
        BookPeer::clearInstancePool();

        // reload and verify that the types are the same
        $r2 = ReviewPeer::retrieveByPK($id);

        $this->assertType('integer', $r2->getId(), "Expected getId() to return an integer.");
        $this->assertType('string', $r2->getReviewedBy(), "Expected getReviewedBy() to return a string.");
        $this->assertType('boolean', $r2->getRecommended(), "Expected getRecommended() to return a boolean.");
        $this->assertType('Book', $r2->getBook(), "Expected getBook() to return a Book.");
        $this->assertType('float', $r2->getBook()->getPrice(), "Expected Book->getPrice() to return a float.");
        $this->assertType('DateTime', $r2->getReviewDate(null), "Expected Book->getReviewDate() to return a DateTime.");

    }

    /**
     * This is a test for expected exceptions when saving UNIQUE.
     * See http://propel.phpdb.org/trac/ticket/2
     */
    public function testSaveUnique()
    {
        $emp = new BookstoreEmployee();
        $emp->setName(md5(microtime()));

        $acct = new BookstoreEmployeeAccount();
        $acct->setBookstoreEmployee($emp);
        $acct->setLogin("foo");
        $acct->setPassword("bar");
        $acct->save();

        // now attempt to create a new acct
        $acct2 = $acct->copy();

        try {
            $acct2->save();
            $this->fail("Expected PropelException in first attempt to save object with duplicate value for UNIQUE constraint.");
        } catch (Exception $x) {
            try {
                // attempt to save it again
                $acct3 = $acct->copy();
                $acct3->save();
                $this->fail("Expected PropelException in second attempt to save object with duplicate value for UNIQUE constraint.");
            } catch (Exception $x) {
                // this is expected.
            }
            // now let's double check that it can succeed if we're not violating the constraint.
            $acct3->setLogin("foo2");
            $acct3->save();
        }
    }

    /**
     * Test for correct reporting of isModified().
     */
    public function testIsModified()
    {
        // 1) Basic test

        $a = new Author();
        $a->setFirstName("John");
        $a->setLastName("Doe");
        $a->setAge(25);

        $this->assertTrue($a->isModified(), "Expected Author to be modified after setting values.");

        $a->save();

        $this->assertFalse($a->isModified(), "Expected Author to be unmodified after saving set values.");

        // 2) Test behavior with setting vars of different types

        // checking setting int col to string val
        $a->setAge('25');
        $this->assertFalse($a->isModified(), "Expected Author to be unmodified after setting int column to string-cast of same value.");

        $a->setFirstName("John2");
        $this->assertTrue($a->isModified(), "Expected Author to be modified after changing string column value.");

        // checking setting string col to int val