--- /dev/null
+<?php
+
+namespace RedUNIT\Base;
+
+use RedUNIT\Base as Base;
+use RedBeanPHP\Facade as R;
+use RedBeanPHP\RedException as RedException;
+use RedBeanPHP\OODBBean as OODBBean;
+
+/**
+ * Relations
+ *
+ * Tests whether RedBeanPHP handles relational data properly.
+ * This test suite is quite large because it tests various types
+ * of relations as well as simple and complex usage scenarios.
+ *
+ * @file RedUNIT/Base/Relations.php
+ * @desc Tests N:1 relations, nested beans.
+ * @author Gabor de Mooij and the RedBeanPHP Community
+ * @license New BSD/GPLv2
+ *
+ * (c) G.J.G.T. (Gabor) de Mooij and the RedBeanPHP Community.
+ * This source file is subject to the New BSD/GPLv2 License that is bundled
+ * with this source code in the file license.txt.
+ */
+class Relations extends Base
+{
+ /**
+ * Test whether untainted parent bean dont
+ * get saved.
+ *
+ * @return void
+ */
+ public function testDontSaveParentIfNotTainted()
+ {
+ R::nuke();
+ $author = R::dispense( 'author' );
+ R::store( $author );
+ $book = R::dispense( 'book' );
+ $book->author = $author;
+ $book->author->name = 'x';
+ $book->author->setMeta( 'tainted', false );
+ R::store( $book );
+ $author = $author->fresh();
+ asrt( isset( $author->name ), false );
+ }
+
+ /**
+ * Tests whether via() applies camelcase-to-snakecase
+ * conversion. Although most of the time you do not need
+ * this since via() is meant to remap typical link tables
+ * to bean - but alas.
+ *
+ * @return void
+ */
+ public function testCamelCasingVia()
+ {
+ R::nuke();
+ $book = R::dispense('book');
+ $book->sharedPage[] = R::dispense('page');
+ R::store( $book );
+ $book = $book->fresh();
+ asrt( count( $book->via('bookPage')->sharedPage ), 1 );
+ $book = $book->fresh();
+ asrt( count( $book->via('book_page')->sharedPage ), 1 );
+ }
+
+ /**
+ * Test whether we can't add more than one FK.
+ */
+ public function testDuplicateFK()
+ {
+ R::nuke();
+ list( $book, $page ) = R::dispenseAll( 'book,page' );
+ $book->sharedPage[] = $page;
+ R::store( $page );
+ R::store( $book );
+ $writer = R::getWriter();
+ $added1 = $writer->addFK( 'book_page', 'book', 'book_id', 'id', TRUE );
+ $added2 = $writer->addFK( 'book_page', 'page', 'page_id', 'id', TRUE );
+ $added = ( $added1 && $added2 );
+ asrt( $added, FALSE );
+ }
+
+ /**
+ * Test whether ->all() reloads a list.
+ *
+ * @return void
+ */
+ public function testAllPrefix()
+ {
+ R::nuke();
+ $book = R::dispense( 'book' );
+ $book->ownPage = R::dispense( 'page', 10 );
+ $book->sharedTag = R::dispense( 'tag', 2 );
+ $i = 0;
+ foreach( $book->ownPage as $page ) {
+ $page->pageno = $i++;
+ }
+ R::store( $book );
+ $book = $book->fresh();
+ asrt( count( $book->ownPage ), 10 );
+ asrt( count( $book->withCondition(' pageno < 5 ')->ownPage ), 5 );
+ asrt( count( $book->ownPage ), 5 );
+ asrt( count( $book->all()->ownPage ), 10 );
+ asrt( count( $book->with(' LIMIT 3 ')->ownPage ), 3 );
+ asrt( count( $book->ownPage ), 3 );
+ asrt( count( $book->all()->ownPage ), 10 );
+ asrt( count( $book->sharedTag ), 2 );
+ asrt( count( $book->with( ' LIMIT 1 ' )->sharedTag ), 1 );
+ asrt( count( $book->sharedTag ), 1 );
+ asrt( count( $book->all()->sharedTag ), 2 );
+ }
+
+ /**
+ * Test Relations and conditions.
+ *
+ * @return void
+ */
+ public function testRelationsAndConditions()
+ {
+ list( $book1, $book2 ) = R::dispense( 'book', 2 );
+ list( $page1, $page2, $page3, $page4 ) = R::dispense( 'page', 4 );
+ list( $author1, $author2 ) = R::dispense( 'author', 2 );
+ $book1->title = 'a';
+ $book2->title = 'b';
+ $page1->thename = '1';
+ $page2->thename = '2';
+ $page3->thename = '3';
+ $page3->thename = '4';
+ $book1->ownPage = array( $page1, $page2 );
+ $book2->ownPage = array( $page3, $page4 );
+ $author1->sharedBook = array( $book1, $book2 );
+ $author2->sharedBook = array( $book2 );
+ R::storeAll( array( $author1, $author2 ) );
+ asrt( count( $author1->sharedBook ), 2 );
+ asrt( count( $author1->withCondition( ' title = ? ', array( 'a' ) )->sharedBook ), 1 );
+ R::store( $author1 );
+ asrt( count( $author1->sharedBook ), 2 );
+ asrt( count( $author1->withCondition( ' xtitle = ? ', array( 'a' ) )->sharedBook ), 0 );
+ R::store( $author1 );
+ asrt( count( $author1->sharedBook ), 2 );
+ $book1 = R::load( 'book', $book1->id );
+ $book2 = $book2->fresh();
+ asrt( count( $book1->ownPage ), 2 );
+ asrt( count( $book1->with( ' LIMIT 1 ' )->ownPage ), 1 );
+ $book1 = $book1->fresh();
+ asrt( count( $book1->ownPage ), 2 );
+ asrt( count( $book1->withCondition( ' thename = ? ', array( '1' ) )->ownPage ), 1 );
+ }
+
+ /**
+ * Test filtering relations on links (using columns in the link table).
+ *
+ * @return void
+ */
+ public function testSharedLinkCond()
+ {
+ testpack( 'Test new shared relations with link conditions' );
+ $w = R::getWriter();
+ list( $b1, $b2 ) = R::dispense( 'book', 2 );
+ $b1->name = 'book1';
+ $b2->name = 'book2';
+ list( $p1, $p2, $p3 ) = R::dispense( 'page', 3 );
+ $p1->text = 'page1';
+ $p1->number = 3;
+ $p2->text = 'page2';
+ $p3->text = 'page3';
+ $b1->link( 'book_page', array( 'order' => 1 ) )->page = $p1;
+ $b1->link( 'bookPage', array( 'order' => 2 ) )->page = $p2;
+ $b2->link( 'book_page', array( 'order' => 1 ) )->page = $p3;
+ $b2->link( 'bookPage', array( 'order' => 2 ) )->page = $p2;
+ $b2->link( 'book_page', array( 'order' => 3 ) )->page = $p1;
+ R::storeAll( array( $b1, $b2 ) );
+ $b1 = R::load( 'book', $b1->id );
+ $b2 = R::load( 'book', $b2->id );
+ $pages = $b1->withCondition( ' book_page.' . $w->esc( 'order' ) . ' = 2 ' )->sharedPage;
+ $page = reset( $pages );
+ asrt( $page->text, 'page2' );
+ $pages = $b2->withCondition( ' ' . $w->esc( 'order' ) . ' = 3 ' )->sharedPage;
+ $page = reset( $pages );
+ asrt( $page->text, 'page1' );
+ $b1 = R::load( 'book', $b1->id );
+ $b2 = R::load( 'book', $b2->id );
+ $pages = $b1->withCondition( ' book_page.' . $w->esc( 'order' ) . ' < 3 AND page.number = 3' )->sharedPage;
+ $page = reset( $pages );
+ asrt( $page->text, 'page1' );
+ $pages = $b2->withCondition( ' ' . $w->esc( 'order' ) . ' > 1 ORDER BY book_page.' . $w->esc( 'order' ) . ' ASC ' )->sharedPage;
+ $page = array_shift( $pages );
+ asrt( $page->text, 'page2' );
+ $page = array_shift( $pages );
+ asrt( $page->text, 'page1' );
+ testpack( 'Test new shared relations and cache' );
+
+ /**
+ * why does this not destroy cache in psql?
+ * ah: An error occurred: SQLSTATE[42703]: Undefined column: 7
+ * ERROR: column "page" of relation "page" does not exist
+ */
+ R::exec( 'UPDATE page SET ' . $w->esc( 'number' ) . ' = 1 ' );
+ R::getWriter()->setUseCache( TRUE );
+ $p1 = R::load( 'page', (int) $p1->id );
+ // Someone else changes the records. Cache remains.
+ R::exec( ' UPDATE page SET ' . $w->esc( 'number' ) . ' = 9 -- keep-cache' );
+ $b1 = R::load( 'book', $b1->id );
+ $p1 = R::load( 'page', (int) $p1->id );
+ // Yupz a stale cache, phantom read!
+ asrt( (int) $p1->number, 1 );
+ $pages = $b1->withCondition( ' book_page.' . $w->esc( 'order' ) . ' = 1 ' )->sharedPage;
+ $page = reset( $pages );
+ // Inconsistent, sad but TRUE, different query -> cache key is different
+ asrt( (int) $page->number, 9 );
+ // However, cache must have been invalidated by this query
+ $p1 = R::load( 'page', (int) $p1->id );
+ // Yes! we're consistent again! -- as if the change just happened later!
+ asrt( (int) $page->number, 9 );
+ // By doing this we keep getting 9 instead of 8
+ $b1->fresh()->withCondition( ' book_page.' . $w->esc( 'order' ) . ' = 1 ' )->sharedPage;
+ // Someone else is busy again...
+ R::exec( ' UPDATE page SET ' . $w->esc( 'number' ) . ' = 8 -- keep-cache' );
+ $b1 = R::load( 'book', $b1->id );
+ $pages = $b1->withCondition( ' book_page.' . $w->esc( 'order' ) . ' = 1 ' )->sharedPage;
+ $page = reset( $pages );
+
+ /**
+ * yes! we get 9 instead of 8, why because the cache key has not changed,
+ * our last query was PAGE-BOOK-RELATION and now we ask for
+ * PAGE-BOOK-RELATION again. if we would have used just a load page
+ * query we would have gotten the new value (8).... let's test that!
+ */
+ asrt( (int) $page->number, 9 );
+ R::exec( ' UPDATE page SET ' . $w->esc( 'number' ) . ' = 9' );
+ $p1 = R::load( 'page', (int) $p1->id );
+ asrt( (int) $page->number, 9 );
+ // Someone else is busy again...
+ R::exec( ' UPDATE page SET ' . $w->esc( 'number' ) . ' = 8 -- keep-cache' );
+ $b1 = R::load( 'book', $b1->id );
+ $pages = $b1->withCondition( ' book_page.' . $w->esc( 'order' ) . ' = 1 ' )->sharedPage;
+ $page = reset( $pages );
+ // Yes, keep-cache wont help, cache key changed!
+ asrt( (int) $page->number, 8 );
+ R::getWriter()->setUseCache( FALSE );
+ }
+
+ /**
+ * Test related count using via().
+ *
+ * @return void
+ */
+ public function testRelatedCountVia()
+ {
+ testpack( 'Test relatedCount with via()' );
+ $shop = R::dispense( 'shop' );
+ $shop->ownRelation = R::dispense( 'relation', 13 );
+ foreach ( $shop->ownRelation as $relation ) {
+ $relation->shop = $shop;
+ $relation->customer = R::dispense( 'customer' );
+ }
+ R::store( $shop );
+ $shop = $shop->fresh();
+ asrt( $shop->via( 'relation' )->countShared( 'customer' ), 13 );
+ }
+
+ /**
+ * Test counting and aliasing.
+ *
+ * @return void
+ */
+ public function testCountingAndAliasing()
+ {
+ $book = R::dispense( 'book' );
+ $book->ownPage = R::dispense( 'page', 10 );
+ $book2 = R::dispense( 'book' );
+ $book2->ownPage = R::dispense( 'page', 4 );
+ list( $Bill, $James, $Andy ) = R::dispense( 'person', 3 );
+ $book->author = $Bill;
+ $book->coAuthor = $James;
+ $book2->author = $Bill;
+ $book2->coAuthor = $Andy;
+ $book->price = 25;
+ $book2->price = 50;
+ $notes = R::dispense( 'note', 10 );
+ $book->sharedNote = array( $notes[0], $notes[1], $notes[2] );
+ $book2->sharedNote = array( $notes[3], $notes[4], $notes[1], $notes[0] );
+ $books = R::dispense( 'book', 5 );
+ $books[2]->title = 'boe';
+ $book->sharedBook = array( $books[0], $books[1] );
+ $book2->sharedBook = array( $books[0], $books[2], $books[4] );
+ R::storeAll( array( $book, $book2 ) );
+ asrt( $book->countOwn( 'page' ), 10 );
+ asrt( $book->withCondition( ' id < 5 ' )->countOwn( 'page' ), 4 );
+ asrt( $Bill->alias( 'author' )->countOwn( 'book' ), 2 );
+ asrt( $Andy->alias( 'coAuthor' )->countOwn( 'book' ), 1 );
+ asrt( $James->alias( 'coAuthor' )->countOwn( 'book' ), 1 );
+ asrt( $Bill->alias( 'author' )->countOwn( 'book' ), 2 );
+ asrt( $book->countShared( 'note' ), 3 );
+ asrt( $book2->countShared( 'note' ), 4 );
+ asrt( $book2->countShared( 'book' ), 3 );
+ $book2 = $book2->fresh();
+ asrt( $book2->withCondition( ' title = ? ', array( 'boe' ) )->countShared( 'book' ), 1 );
+ }
+
+ /**
+ * Test via.
+ *
+ * @return void
+ */
+ public function testVia()
+ {
+ testpack( 'Test via()' );
+ $d = R::dispense( 'doctor' )->setAttr( 'name', 'd1' );
+ $p = R::dispense( 'patient' )->setAttr( 'name', 'p1' );
+ $d->via( 'consult' )->sharedPatient[] = $p;
+ R::store( $d );
+ $d = R::load( 'doctor', $d->id );
+ asrt( count( $d->sharedPatient ), 1 );
+ asrt( in_array( 'consult', R::getWriter()->getTables() ), TRUE );
+ }
+
+ /**
+ * Issue #348 via() should reload shared list
+ *
+ * @return void
+ */
+ public function testIssue348()
+ {
+ $product = R::dispense( 'product' );
+ $product->name = 'test';
+ $color = R::dispense( 'color' );
+ $color->name = 'cname';
+ $color->code = 'ccode';
+ R::store( $product );
+ R::store( $color );
+ $product->link( 'productColor', array(
+ 'stock' => 1,
+ 'position' => 0
+ ) )->color = $color;
+ R::store( $product );
+ asrt( count( $product->sharedColor ), 0 );
+ asrt( count( $product->via( 'product_color' )->sharedColor ), 1 );
+ asrt( count( $product->sharedColor ), 1 );
+ R::renameAssociation( 'color_product', NULL );
+ }
+
+ /**
+ * Test creation of link table.
+ *
+ * @return void
+ */
+ public function testCreationOfLinkTable()
+ {
+ asrt( in_array( 'consult', R::getWriter()->getTables() ), FALSE );
+ $d = R::dispense( 'doctor' )->setAttr( 'name', 'd1' );
+ $p = R::dispense( 'patient' )->setAttr( 'name', 'p1' );
+ $d->sharedPatient[] = $p;
+ R::store($d);
+ asrt( in_array( 'consult', R::getWriter()->getTables() ), TRUE );
+ }
+
+ /**
+ * Fast track link block code should not affect self-referential N-M relations.
+ *
+ * @return void
+ */
+ public function testFastTrackRelations()
+ {
+ testpack( 'Test fast-track linkBlock exceptions' );
+ list( $donald, $mickey, $goofy, $pluto ) = R::dispense( 'friend', 4 );
+ $donald->name = 'D';
+ $mickey->name = 'M';
+ $goofy->name = 'G';
+ $pluto->name = 'P';
+ $donald->sharedFriend = array( $mickey, $goofy );
+ $mickey->sharedFriend = array( $pluto, $goofy );
+ $mickey->sharedBook = array( R::dispense( 'book' ) );
+ R::storeAll( array( $mickey, $donald, $goofy, $pluto ) );
+ $donald = R::load( 'friend', $donald->id );
+ $mickey = R::load( 'friend', $mickey->id );
+ $goofy = R::load( 'friend', $goofy->id );
+ $pluto = R::load( 'friend', $pluto->id );
+ $names = implode( ',', R::gatherLabels( $donald->sharedFriend ) );
+ asrt( $names, 'G,M' );
+ $names = implode( ',', R::gatherLabels( $goofy->sharedFriend ) );
+ asrt( $names, 'D,M' );
+ $names = implode( ',', R::gatherLabels( $mickey->sharedFriend ) );
+ asrt( $names, 'D,G,P' );
+ $names = implode( ',', R::gatherLabels( $pluto->sharedFriend ) );
+ asrt( $names, 'M' );
+ // Now in combination with with() conditions...
+ $donald = R::load( 'friend', $donald->id );
+ $names = implode( ',', R::gatherLabels( $donald->withCondition( ' name = ? ', array( 'M' ) )->sharedFriend ) );
+ asrt( $names, 'M' );
+ // Now in combination with with() conditions...
+ $donald = R::load( 'friend', $donald->id );
+ $names = implode( ',', R::gatherLabels( $donald->with( ' ORDER BY name ' )->sharedFriend ) );
+ asrt( $names, 'G,M' );
+ // Now counting
+ $goofy = R::load( 'friend', $goofy->id );
+ asrt( (int) $goofy->countShared( 'friend' ), 2 );
+ asrt( (int) $donald->countShared( 'friend' ), 2 );
+ asrt( (int) $mickey->countShared( 'friend' ), 3 );
+ asrt( (int) $pluto->countShared( 'friend' ), 1 );
+ }
+
+ /**
+ * Test list beautifications.
+ *
+ * @return void
+ */
+ public function testListBeautifications()
+ {
+ testpack( 'Test list beautifications' );
+ $book = R::dispense( 'book' );
+ $page = R::dispense( 'page' )->setAttr( 'name', 'a' );
+ $book->sharedPage[] = $page;
+ $id = R::store( $book );
+ $book = R::load( 'book', $id );
+ $p = reset( $book->ownBookPage );
+ asrt( $p->page->name, 'a' );
+ $bean = R::dispense( 'bean' );
+ $bean->sharedAclRole[] = R::dispense( 'role' )->setAttr( 'name', 'x' );
+ R::store( $bean );
+ asrt( R::count( 'role' ), 1 );
+ $aclrole = R::getRedBean()->dispense( 'acl_role' );
+ $aclrole->name = 'role';
+ $bean = R::dispense( 'bean' );
+ $bean->sharedAclRole[] = $aclrole;
+ R::store( $bean );
+ asrt( count( $bean->sharedAclRole ), 1 );
+ }
+
+ /**
+ * Test list add and delete.
+ *
+ * @return void
+ */
+ public function testListAddDelete()
+ {
+ testpack( 'Test list add/delete scenarios.' );
+ R::nuke();
+ $b = R::dispense( 'book' );
+ $p = R::dispense( 'page' );
+ $b->title = 'a';
+ $p->name = 'b';
+ $b->xownPage[] = $p;
+ R::store( $b );
+ $b->xownPage = array();
+ R::store( $b );
+ asrt( R::count( 'page' ), 0 );
+ $p = R::dispense( 'page' );
+ $z = R::dispense( 'paper' );
+ $z->xownPage[] = $p;
+ R::store( $z );
+ asrt( R::count( 'page' ), 1 );
+ $z->xownPage = array();
+ R::store( $z );
+ asrt( R::count( 'page' ), 0 );
+ $i = R::dispense( 'magazine' );
+ $i->ownPage[] = R::dispense( 'page' );
+ R::store( $i );
+ asrt( R::count( 'page' ), 1 );
+ $i->ownPage = array();
+ R::store( $i );
+ asrt( R::count( 'page' ), 1 );
+ }
+
+ /**
+ * Test basic and complex common usage scenarios for
+ * relations and associations.
+ *
+ * @return void
+ */
+ public function testScenarios()
+ {
+ list( $q1, $q2 ) = R::dispense( 'quote', 2 );
+ list( $pic1, $pic2 ) = R::dispense( 'picture', 2 );
+ list( $book, $book2, $book3 ) = R::dispense( 'book', 4 );
+ list( $topic1, $topic2, $topic3, $topic4, $topic5 ) = R::dispense( 'topic', 5 );
+ list( $page1, $page2, $page3, $page4, $page5, $page6, $page7 ) = R::dispense( 'page', 7 );
+ $q1->text = 'lorem';
+ $q2->text = 'ipsum';
+ $book->title = 'abc';
+ $book2->title = 'def';
+ $book3->title = 'ghi';
+ $page1->title = 'pagina1';
+ $page2->title = 'pagina2';
+ $page3->title = 'pagina3';
+ $page4->title = 'pagina4';
+ $page5->title = 'pagina5';
+ $page6->title = 'cover1';
+ $page7->title = 'cover2';
+ $topic1->name = 'holiday';
+ $topic2->name = 'cooking';
+ $topic3->name = 'gardening';
+ $topic4->name = 'computing';
+ $topic5->name = 'christmas';
+ // Add one page to the book
+ $book->ownPage[] = $page1;
+ $id = R::store( $book );
+ asrt( count( $book->ownPage ), 1 );
+ asrt( reset( $book->ownPage )->getMeta( 'type' ), 'page' );
+ $book = R::load( 'book', $id );
+ asrt( count( $book->ownPage ), 1 );
+ asrt( reset( $book->ownPage )->getMeta( 'type' ), 'page' );
+ // Performing an own addition
+ $book->ownPage[] = $page2;
+ $id = R::store( $book );
+ $book = R::load( 'book', $id );
+ asrt( count( $book->ownPage ), 2 );
+ // Performing a deletion
+ $book = R::load( 'book', $id );
+ unset( $book->ownPage[1] );
+ $id = R::store( $book );
+ $book = R::load( 'book', $id );
+ asrt( count( $book->ownPage ), 1 );
+ asrt( reset( $book->ownPage )->getMeta( 'type' ), 'page' );
+ asrt( R::count( 'page' ), 2 ); //still exists
+ asrt( reset( $book->ownPage )->id, '2' );
+ // Doing a change in one of the owned items
+ $book->ownPage[2]->title = 'page II';
+ $id = R::store( $book );
+ $book = R::load( 'book', $id );
+ asrt( reset( $book->ownPage )->title, 'page II' );
+ // Change by reference now... don't copy!
+ $refToPage2 = $book->ownPage[2];
+ $refToPage2->title = 'page II b';
+ $id = R::store( $book );
+ $book = R::load( 'book', $id );
+ asrt( reset( $book->ownPage )->title, 'page II b' );
+ // Doing all actions combined
+ $book->ownPage[] = $page3;
+ R::store( $book );
+ $book = R::load( 'book', $id );
+ unset( $book->ownPage[2] );
+ // And test custom key
+ $book->ownPage['customkey'] = $page4;
+ $book->ownPage[3]->title = "THIRD";
+ R::store( $book );
+ $book = R::load( 'book', $id );
+ asrt( count( $book->ownPage ), 2 );
+ $p4 = $book->ownPage[4];
+ $p3 = $book->ownPage[3];
+ asrt( $p4->title, 'pagina4' );
+ asrt( $p3->title, 'THIRD' );
+ // Test replacing an element
+ $book = R::load( 'book', $id );
+ $book->ownPage[4] = $page5;
+ R::store( $book );
+ $book = R::load( 'book', $id );
+ asrt( count( $book->ownPage ), 2 );
+ $p5 = $book->ownPage[5];
+ asrt( $p5->title, 'pagina5' );
+ // Other way around - single bean
+ asrt( $p5->book->title, 'abc' );
+ asrt( R::load( 'page', 5 )->book->title, 'abc' );
+ asrt( R::load( 'page', 3 )->book->title, 'abc' );
+ // Add the other way around - single bean
+ $page1->id = 0;
+ $page1->book = $book2;
+ $page1 = R::load( 'page', R::store( $page1 ) );
+ asrt( $page1->book->title, 'def' );
+ $b2 = R::load( 'book', $id );
+ asrt( count( $b2->ownPage ), 2 );
+ // Remove the other way around - single bean
+ unset( $page1->book );
+ R::store( $page1 );
+ $b2 = R::load( 'book', $book2->id );
+ asrt( count( $b2->ownPage ), 1 ); //does not work
+ $page1->book = NULL;
+ R::store( $page1 );
+ $b2 = R::load( 'book', $book2->id );
+ asrt( count( $b2->ownPage ), 0 ); //works
+ // Re-add the page
+ $b2->ownPage[] = $page1;
+ R::store( $b2 );
+ $b2 = R::load( 'book', $book2->id );
+ asrt( count( $b2->ownPage ), 1 );
+ // Different, less elegant way to remove
+ $page1 = reset( $b2->ownPage );
+ $page1->book_id = NULL;
+ R::store( $page1 );
+ $b2 = R::load( 'book', $book2->id );
+ asrt( count( $b2->ownPage ), 0 );
+ // Re-add the page
+ $b2->ownPage[] = $page1;
+ R::store( $b2 );
+ $b2 = R::load( 'book', $book2->id );
+ asrt( count( $b2->ownPage ), 1 );
+ // Another less elegant way to remove
+ $page1->book = NULL;
+ R::store( $page1 );
+ $cols = R::getColumns( 'page' );
+ asrt( isset( $cols['book'] ), FALSE );
+ $b2 = R::load( 'book', $book2->id );
+ asrt( count( $b2->ownPage ), 0 );
+ // Re-add the page
+ $b2->ownPage[] = $page1;
+ R::store( $b2 );
+ $b2 = R::load( 'book', $book2->id );
+ asrt( count( $b2->ownPage ), 1 );
+ // Another less elegant... just plain ugly... way to remove
+ $page1->book = FALSE;
+ R::store( $page1 );
+ $cols = R::getColumns( 'page' );
+ asrt( isset( $cols['book'] ), FALSE );
+ $b2 = R::load( 'book', $book2->id );
+ asrt( count( $b2->ownPage ), 0 );
+ // Re-add the page
+ $b2->ownPage[] = $page1;
+ R::store( $b2 );
+ $b2 = R::load( 'book', $book2->id );
+ asrt( count( $b2->ownPage ), 1 );
+ // You are not allowed to re-use the field for something else
+ foreach (
+ array(
+ 1, -2.1, array(),
+ TRUE, 'NULL', new \stdClass,
+ 'just a string', array( 'a' => 1 ), 0
+ ) as $value
+ ) {
+ try {
+ $page1->book = $value;
+ fail();
+ } catch ( RedException $e ) {
+ pass();
+ }
+ }
+ // Test fk, not allowed to set to 0
+ $page1 = reset( $b2->ownPage );
+ $page1->book_id = 0;
+ // Even uglier way, but still needs to work
+ $page1 = reset( $b2->ownPage );
+ $page1->book_id = NULL;
+ R::store( $b2 );
+ $b2 = R::load( 'book', $book2->id );
+ asrt( count( $b2->ownPage ), 0 );
+ // Test shared items
+ $book = R::load( 'book', $id );
+ $book->sharedTopic[] = $topic1;
+ $id = R::store( $book );
+ // Add an item
+ asrt( count( $book->sharedTopic ), 1 );
+ asrt( reset( $book->sharedTopic )->name, 'holiday' );
+ $book = R::load( 'book', $id );
+ asrt( count( $book->sharedTopic ), 1 );
+ asrt( reset( $book->sharedTopic )->name, 'holiday' );
+ // Add another item
+ $book->sharedTopic[] = $topic2;
+ $id = R::store( $book );
+ $tidx = R::store( R::dispense( 'topic' ) );
+ $book = R::load( 'book', $id );
+ asrt( count( $book->sharedTopic ), 2 );
+ $t1 = $book->sharedTopic[1];
+ $t2 = $book->sharedTopic[2];
+ asrt( $t1->name, 'holiday' );
+ asrt( $t2->name, 'cooking' );
+ // Remove an item
+ unset( $book->sharedTopic[2] );
+ asrt( count( $book->sharedTopic ), 1 );
+ $id = R::store( $book );
+ $book = R::load( 'book', $id );
+ asrt( count( $book->sharedTopic ), 1 );
+ asrt( reset( $book->sharedTopic )->name, 'holiday' );
+ // Add and change
+ $book->sharedTopic[] = $topic3;
+ $book->sharedTopic[1]->name = 'tropics';
+ $id = R::store( $book );
+ $book = R::load( 'book', $id );
+ asrt( count( $book->sharedTopic ), 2 );
+ asrt( $book->sharedTopic[1]->name, 'tropics' );
+ testids( $book->sharedTopic );
+ R::trash( R::load( 'topic', $tidx ) );
+ $id = R::store( $book );
+ $book = R::load( 'book', $id );
+ // Delete without save
+ unset( $book->sharedTopic[1] );
+ $book = R::load( 'book', $id );
+ asrt( count( $book->sharedTopic ), 2 );
+ $book = R::load( 'book', $id );
+ // Delete without init
+ asrt( ( R::count( 'topic' ) ), 3 );
+ unset( $book->sharedTopic[1] );
+ $id = R::store( $book );
+ asrt( ( R::count( 'topic' ) ), 3 );
+ asrt( count( $book->sharedTopic ), 1 );
+ asrt( count( $book2->sharedTopic ), 0 );
+ // Add same topic to other book
+ $book2->sharedTopic[] = $topic3;
+ asrt( count( $book2->sharedTopic ), 1 );
+ $id2 = R::store( $book2 );
+ asrt( count( $book2->sharedTopic ), 1 );
+ $book2 = R::load( 'book', $id2 );
+ asrt( count( $book2->sharedTopic ), 1 );
+ // Get books for topic
+ asrt( $topic3->countShared('book'), 2 );
+ $t3 = R::load( 'topic', $topic3->id );
+ asrt( count( $t3->sharedBook ), 2 );
+ // Nuke an own-array, replace entire array at once without getting first
+ $page2->id = 0;
+ $page2->title = 'yet another page 2';
+ $page4->id = 0;
+ $page4->title = 'yet another page 4';
+ $book = R::load( 'book', $id );
+ $book->ownPage = array( $page2, $page4 );
+ R::store( $book );
+ $book = R::load( 'book', $id );
+ asrt( count( $book->ownPage ), 2 );
+ asrt( reset( $book->ownPage )->title, 'yet another page 2' );
+ asrt( end( $book->ownPage )->title, 'yet another page 4' );
+ testids( $book->ownPage );
+ // Test with alias format
+ $book3->cover = $page6;
+ $idb3 = R::store( $book3 );
+ $book3 = R::load( 'book', $idb3 );
+ $justACover = $book3->fetchAs( 'page' )->cover;
+ asrt( ( $book3->cover instanceof OODBBean ), TRUE );
+ asrt( $justACover->title, 'cover1' );
+ // No page property
+ asrt( isset( $book3->page ), FALSE );
+ // Test doubling and other side effects ... should not occur..
+ $book3->sharedTopic = array( $topic1, $topic2 );
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ $book3->sharedTopic = array();
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ asrt( count( $book3->sharedTopic ), 0 );
+ $book3->sharedTopic[] = $topic1;
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ // Added only one, not more?
+ asrt( count( $book3->sharedTopic ), 1 );
+ asrt( intval( R::getCell( "select count(*) from book_topic where book_id = $idb3" ) ), 1 );
+ // Add the same
+ $book3->sharedTopic[] = $topic1;
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ asrt( count( $book3->sharedTopic ), 1 );
+ asrt( intval( R::getCell( "select count(*) from book_topic where book_id = $idb3" ) ), 1 );
+ $book3->sharedTopic['differentkey'] = $topic1;
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ asrt( count( $book3->sharedTopic ), 1 );
+ asrt( intval( R::getCell( "select count(*) from book_topic where book_id = $idb3" ) ), 1 );
+ // Ugly assign, auto array generation
+ $book3->ownPage[] = $page1;
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ asrt( count( $book3->ownPage ), 1 );
+ asrt( intval( R::getCell( "select count(*) from page where book_id = $idb3 " ) ), 1 );
+ $book3 = R::load( 'book', $idb3 );
+ $book3->ownPage = array();
+ // No change until saved
+ asrt( intval( R::getCell( "select count(*) from page where book_id = $idb3 " ) ), 1 );
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ asrt( intval( R::getCell( "select count(*) from page where book_id = $idb3 " ) ), 0 );
+ asrt( count( $book3->ownPage ), 0 );
+ $book3 = R::load( 'book', $idb3 );
+ /**
+ * Why do I need to do this ---> why does trash() not set id -> 0?
+ * Because you unset() so trash is done on origin not bean
+ */
+ $page1->id = 0;
+ $page2->id = 0;
+ $page3->id = 0;
+ $book3->ownPage[] = $page1;
+ $book3->ownPage[] = $page2;
+ $book3->ownPage[] = $page3;
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ asrt( intval( R::getCell( "select count(*) from page where book_id = $idb3 " ) ), 3 );
+ asrt( count( $book3->ownPage ), 3 );
+ unset( $book3->ownPage[$page2->id] );
+ $book3->ownPage[] = $page3;
+ $book3->ownPage['try_to_trick_ya'] = $page3;
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ asrt( intval( R::getCell( "select count(*) from page where book_id = $idb3 " ) ), 2 );
+ asrt( count( $book3->ownPage ), 2 );
+ // Delete and re-add
+ $book3 = R::load( 'book', $idb3 );
+ unset( $book3->ownPage[10] );
+ $book3->ownPage[] = $page1;
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ asrt( count( $book3->ownPage ), 2 );
+ $book3 = R::load( 'book', $idb3 );
+ unset( $book3->sharedTopic[1] );
+ $book3->sharedTopic[] = $topic1;
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ asrt( count( $book3->sharedTopic ), 1 );
+ // Test performance
+ $logger = R::debug( true, 1 );
+ $book = R::load( 'book', 1 );
+ $book->sharedTopic = array();
+ R::store( $book );
+ // No more than 1 update
+ asrt( count( $logger->grep( 'UPDATE' ) ), 1 );
+ $book = R::load( 'book', 1 );
+ $logger->clear();
+ print_r( $book->sharedTopic, 1 );
+ // No more than 1 select
+ asrt( count( $logger->grep( 'SELECT' ) ), 1 );
+ $logger->clear();
+ $book->sharedTopic[] = $topic1;
+ $book->sharedTopic[] = $topic2;
+ asrt( count( $logger->grep( 'SELECT' ) ), 0 );
+ R::store( $book );
+ $book->sharedTopic[] = $topic3;
+ // Now do NOT clear all and then add one, just add the one
+ $logger->clear();
+ R::store( $book );
+ $book = R::load( 'book', 1 );
+ asrt( count( $book->sharedTopic ), 3 );
+ // No deletes
+ asrt( count( $logger->grep( "DELETE FROM" ) ), 0 );
+ $book->sharedTopic['a'] = $topic3;
+ unset( $book->sharedTopic['a'] );
+ R::store( $book );
+ $book = R::load( 'book', 1 );
+ asrt( count( $book->sharedTopic ), 3 );
+ // No deletes
+ asrt( count( $logger->grep( "DELETE FROM" ) ), 0 );
+ $book->ownPage = array();
+ R::store( $book );
+ asrt( count( $book->ownPage ), 0 );
+ $book->ownPage[] = $page1;
+ $book->ownPage['a'] = $page2;
+ asrt( count( $book->ownPage ), 2 );
+ R::store( $book );
+ unset( $book->ownPage['a'] );
+ asrt( count( $book->ownPage ), 2 );
+ unset( $book->ownPage[11] );
+ R::store( $book );
+ $book = R::load( 'book', 1 );
+ asrt( count( $book->ownPage ), 1 );
+ $aPage = $book->ownPage[10];
+ unset( $book->ownPage[10] );
+ $aPage->title .= ' changed ';
+ $book->ownPage['anotherPage'] = $aPage;
+ $logger->clear();
+ R::store( $book );
+ $book = R::load( 'book', 1 );
+ asrt( count( $book->ownPage ), 1 );
+ $ap = reset( $book->ownPage );
+ asrt( $ap->title, "pagina1 changed " );
+ // Fix udiff instead of diff
+ $book3->ownPage = array( $page3, $page1 );
+ $i = R::store( $book3 );
+ $book3 = R::load( 'book', $i );
+ asrt( intval( R::getCell( "select count(*) from page where book_id = $idb3 " ) ), 2 );
+ asrt( count( $book3->ownPage ), 2 );
+ $pic1->name = 'aaa';
+ $pic2->name = 'bbb';
+ R::store( $pic1 );
+ R::store( $q1 );
+ $book3->ownPicture[] = $pic1;
+ $book3->ownQuote[] = $q1;
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ // two own-arrays -->forgot array_merge
+ asrt( count( $book3->ownPicture ), 1 );
+ asrt( count( $book3->ownQuote ), 1 );
+ asrt( count( $book3->ownPage ), 2 );
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ unset( $book3->ownPicture[1] );
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ asrt( count( $book3->ownPicture ), 0 );
+ asrt( count( $book3->ownQuote ), 1 );
+ asrt( count( $book3->ownPage ), 2 );
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ $NOTE = 0;
+ $quotes = R::dispense( 'quote', 10 );
+ foreach ( $quotes as &$justSomeQuote ) {
+ $justSomeQuote->note = 'note' . ( ++$NOTE );
+ }
+ $pictures = R::dispense( 'picture', 10 );
+ foreach ( $pictures as &$justSomePic ) {
+ $justSomePic->note = 'note' . ( ++$NOTE );
+ }
+ $topics = R::dispense( 'topic', 10 );
+ foreach ( $topics as &$justSomeTopic ) {
+ $justSomeTopic->note = 'note' . ( ++$NOTE );
+ }
+ for ( $j = 0; $j < 10; $j++ ) {
+ // Do several mutations
+ for ( $x = 0; $x < rand( 1, 20 ); $x++ ) {
+ modgr( $book3, $quotes, $pictures, $topics );
+ }
+ $qbefore = count( $book3->ownQuote );
+ $pbefore = count( $book3->ownPicture );
+ $tbefore = count( $book3->sharedTopic );
+ $qjson = json_encode( $book->ownQuote );
+ $pjson = json_encode( $book->ownPicture );
+ $tjson = json_encode( $book->sharedTopic );
+ $book3 = R::load( 'book', R::store( $book3 ) );
+ asrt( count( $book3->ownQuote ), $qbefore );
+ asrt( count( $book3->ownPicture ), $pbefore );
+ asrt( count( $book3->sharedTopic ), $tbefore );
+ asrt( json_encode( $book->ownQuote ), $qjson );
+ asrt( json_encode( $book->ownPicture ), $pjson );
+ asrt( json_encode( $book->sharedTopic ), $tjson );
+ testids( $book->ownQuote );
+ testids( $book->ownPicture );
+ testids( $book->sharedTopic );
+ }
+ }
+
+ /**
+ * Test parent bean relations.
+ *
+ * @return void
+ */
+ public function testParentBean()
+ {
+ $village = R::dispense( 'village' );
+ $village->name = 'village';
+ $home = R::dispense( 'building' );
+ $home->village = $village;
+ $id = R::store( $home );
+ $home = R::load( 'building', $id );
+ asrt( $home->village->name, 'village' );
+ asrt( R::count( 'village' ), 1 );
+ asrt( R::count( 'building' ), 1 );
+ R::trash( $home );
+ pass();
+ asrt( R::count( 'village' ), 1 );
+ asrt( R::count( 'building' ), 0 );
+ }
+
+ /**
+ * test N-M relations through intermediate beans
+ *
+ * @return void
+ */
+ public function testNMRelationsIntermediate()
+ {
+ list( $mrA, $mrB, $mrC ) = R::dispense( 'person', 3 );
+ list( $projA, $projB, $projC ) = R::dispense( 'project', 3 );
+ $projA->title = 'A';
+ $projB->title = 'B';
+ $projC->title = 'C';
+ $participant = R::dispense( 'participant' );
+ $projA->link( 'participant', array( 'role' => 'manager' ) )->person = $mrA;
+ $projA->link( $participant->setAttr( 'role', 'developer' ) )->person = $mrB;
+ $projB->link( R::dispense( 'participant' )->setAttr( 'role', 'developer' ) )->person = $mrB;
+ $projB->link( 'participant', '{"role":"helpdesk"}' )->person = $mrC;
+ $projC->link( 'participant', '{"role":"sales"}' )->person = $mrC;
+ R::storeAll( array( $projA, $projB, $projC ) );
+ $a = R::findOne( 'project', ' title = ? ', array( 'A' ) );
+ $b = R::findOne( 'project', ' title = ? ', array( 'B' ) );
+ $c = R::findOne( 'project', ' title = ? ', array( 'C' ) );
+ asrt( count( $a->ownParticipant ), 2 );
+ asrt( count( $b->ownParticipant ), 2 );
+ asrt( count( $c->ownParticipant ), 1 );
+ $managers = $developers = 0;
+ foreach ( $a->ownParticipant as $p ) {
+ if ( $p->role === 'manager' ) {
+ $managers++;
+ }
+ if ( $p->role === 'developer' ) {
+ $developers++;
+ }
+ }
+ $p = reset( $a->ownParticipant );
+ asrt( $p->person->getMeta( 'type' ), 'person' );
+ asrt( ( $p->person->id > 0 ), TRUE );
+ asrt( $managers, 1 );
+ asrt( $developers, 1 );
+ asrt( (int) R::count( 'participant' ), 5 );
+ asrt( (int) R::count( 'person' ), 3 );
+ }
+
+ /**
+ * test emulation of sharedList through intermediate beans
+ *
+ * @return void
+ */
+ public function testSharedListIntermediate()
+ {
+ list( $v1, $v2, $v3 ) = R::dispense( 'village', 3 );
+ list( $a1, $a2, $a3 ) = R::dispense( 'army', 3 );
+ $a1->name = 'one';
+ $a2->name = 'two';
+ $a3->name = 'three';
+ $v1->name = 'Ville 1';
+ $v2->name = 'Ville 2';
+ $v3->name = 'Ville 3';
+ $v1->link( 'armyVillage' )->army = $a3;
+ $v2->link( 'army_village' )->army = $a2;
+ $v3->link( 'armyVillage' )->army = $a1;
+ $a2->link( 'army_village' )->village = $v1;
+ $id1 = R::store( $v1 );
+ $id2 = R::store( $v2 );
+ $id3 = R::store( $v3 );
+ $village1 = R::load( 'village', $id1 );
+ $village2 = R::load( 'village', $id2 );
+ $village3 = R::load( 'village', $id3 );
+ asrt( count( $village1->sharedArmy ), 2 );
+ asrt( count( $village2->sharedArmy ), 1 );
+ asrt( count( $village3->sharedArmy ), 1 );
+ }
+
+ /**
+ * test emulation via association renaming
+ *
+ * @return void
+ */
+ public function testAssociationRenaming()
+ {
+ list( $p1, $p2, $p3 ) = R::dispense( 'painting', 3 );
+ list( $m1, $m2, $m3 ) = R::dispense( 'museum', 3 );
+ $p1->name = 'painting1';
+ $p2->name = 'painting2';
+ $p3->name = 'painting3';
+ $m1->thename = 'a';
+ $m2->thename = 'b';
+ $m3->thename = 'c';
+ R::renameAssociation( 'museum_painting', 'exhibited' );
+ // Also test array syntax
+ R::renameAssociation( array( 'museum_museum' => 'center' ) );
+ $m1->link( 'center', array( 'name' => 'History Center' ) )->museum2 = $m2;
+ $m1->link( 'exhibited', '{"from":"2014-02-01","til":"2014-07-02"}' )->painting = $p3;
+ $m2->link( 'exhibited', '{"from":"2014-07-03","til":"2014-10-02"}' )->painting = $p3;
+ $m3->link( 'exhibited', '{"from":"2014-02-01","til":"2014-07-02"}' )->painting = $p1;
+ $m2->link( 'exhibited', '{"from":"2014-02-01","til":"2014-07-02"}' )->painting = $p2;
+ R::storeAll( array( $m1, $m2, $m3 ) );
+ list( $m1, $m2, $m3 ) = array_values( R::findAll( 'museum', ' ORDER BY thename ASC' ) );
+ asrt( count( $m1->sharedMuseum ), 1 );
+ asrt( count( $m1->sharedPainting ), 1 );
+ asrt( count( $m2->sharedPainting ), 2 );
+ asrt( count( $m3->sharedPainting ), 1 );
+ $p3 = reset( $m1->sharedPainting );
+ asrt( count( $p3->ownExhibited ), 2 );
+ asrt( count( $m2->ownExhibited ), 2 );
+ R::storeAll( array( $m1, $m2, $m3 ) );
+ list( $m1, $m2, $m3 ) = array_values( R::findAll( 'museum', ' ORDER BY thename ASC' ) );
+ asrt( count( $m1->sharedPainting ), 1 );
+ asrt( count( $m2->sharedPainting ), 2 );
+ asrt( count( $m3->sharedPainting ), 1 );
+ $p3 = reset( $m1->sharedPainting );
+ asrt( count( $p3->ownExhibited ), 2 );
+ $paintings = $m2->sharedPainting;
+ foreach ( $paintings as $painting ) {
+ if ( $painting->name === 'painting2' ) {
+ pass();
+ $paintingX = $painting;
+ }
+ }
+ unset( $m2->sharedPainting[$paintingX->id] );
+ R::store( $m2 );
+ $m2 = R::load( 'museum', $m2->id );
+ asrt( count( $m2->sharedPainting ), 1 );
+ $left = reset( $m2->sharedPainting );
+ asrt( $left->name, 'painting3' );
+ asrt( count( $m2->ownExhibited ), 1 );
+ $exhibition = reset( $m2->ownExhibited );
+ asrt( $exhibition->from, '2014-07-03' );
+ asrt( $exhibition->til, '2014-10-02' );
+ }
+
+ /**
+ * Test don't try to store other things in shared list.
+ *
+ * @return void
+ */
+ public function testDontTryToStoreOtherThingsInSharedList() {
+
+ $book = R::dispense( 'book' );
+ $book->sharedPage[] = 'nonsense';
+ try {
+ R::store( $book );
+ fail();
+ } catch( RedException $exception) {
+ pass();
+ }
+ $book->sharedPageList = R::dispense( 'page', 2 );
+ R::store( $book );
+ $book->sharedPageList;
+ R::trash( $book );
+ asrt( R::count('page'), 2 );
+ }
+
+ /**
+ * Test whether magic array interface functions like isset() and
+ * unset work correctly with the x-own-list and the List-suffix.
+ *
+ * Array functions do not reveal x-own-lists and list-alias because
+ * you dont want duplicate entries in foreach-loops.
+ * Also offers a slight performance improvement for array access.
+ *
+ * @return void
+ */
+ public function testWhetherIssetWorksWithXList()
+ {
+ R::nuke();
+ $book = R::dispense( 'book' );
+ $page = R::dispense( 'page' );
+ asrt( isset( $book->xownPageList ), FALSE );
+ asrt( isset( $book->ownPageList ), FALSE );
+ asrt( isset( $book->xownPage ), FALSE );
+ asrt( isset( $book->ownPage ), FALSE );
+ $book->xownPageList[] = $page;
+ asrt( isset( $book->xownPageList ), TRUE );
+ asrt( isset( $book->ownPageList ), TRUE );
+ asrt( isset( $book->xownPage ), TRUE );
+ asrt( isset( $book->ownPage ), TRUE );
+ //Test array access
+ asrt( isset( $book['xownPageList'] ), TRUE );
+ asrt( isset( $book['ownPageList'] ), TRUE );
+ asrt( isset( $book['xownPage'] ), TRUE );
+ asrt( isset( $book['ownPage'] ), TRUE );
+ R::store( $book );
+ $book = $book->fresh();
+ asrt( isset( $book->xownPageList ), FALSE );
+ asrt( isset( $book->ownPageList ), FALSE );
+ asrt( isset( $book->xownPage ), FALSE );
+ asrt( isset( $book->ownPage ), FALSE );
+ asrt( isset( $book['xownPageList'] ), FALSE );
+ asrt( isset( $book['ownPageList'] ), FALSE );
+ asrt( isset( $book['xownPage'] ), FALSE );
+ asrt( isset( $book['ownPage'] ), FALSE );
+ $book->xownPageList;
+ asrt( isset( $book->xownPageList ), TRUE );
+ asrt( isset( $book->ownPageList ), TRUE );
+ asrt( isset( $book->xownPage ), TRUE );
+ asrt( isset( $book->ownPage ), TRUE );
+ asrt( isset( $book['xownPageList'] ), TRUE );
+ asrt( isset( $book['ownPageList'] ), TRUE );
+ asrt( isset( $book['xownPage'] ), TRUE );
+ asrt( isset( $book['ownPage'] ), TRUE );
+ $book = $book->fresh();
+ asrt( isset( $book->xownPageList ), FALSE );
+ asrt( isset( $book->ownPageList ), FALSE );
+ asrt( isset( $book->xownPage ), FALSE );
+ asrt( isset( $book->ownPage ), FALSE );
+ asrt( isset( $book['xownPageList'] ), FALSE );
+ asrt( isset( $book['ownPageList'] ), FALSE );
+ asrt( isset( $book['xownPage'] ), FALSE );
+ asrt( isset( $book['ownPage'] ), FALSE );
+ $book->noLoad()->xownPageList;
+ asrt( isset( $book->xownPageList ), TRUE );
+ asrt( isset( $book->ownPageList ), TRUE );
+ //but empty
+ asrt( count( $book->ownPageList ), 0 );
+ asrt( count( $book->xownPageList ), 0 );
+ asrt( count( $book->ownPage ), 0 );
+ asrt( count( $book->xownPage ), 0 );
+ $book->xownPageList[] = $page;
+ asrt( isset( $book->xownPageList ), TRUE );
+ asrt( isset( $book->ownPageList ), TRUE );
+ asrt( isset( $book->xownPage ), TRUE );
+ asrt( isset( $book->ownPage ), TRUE );
+ asrt( isset( $book['xownPageList'] ), TRUE );
+ asrt( isset( $book['ownPageList'] ), TRUE );
+ asrt( isset( $book['xownPage'] ), TRUE );
+ asrt( isset( $book['ownPage'] ), TRUE );
+ unset( $book->xownPageList );
+ asrt( isset( $book->xownPageList ), FALSE );
+ asrt( isset( $book->ownPageList ), FALSE );
+ asrt( isset( $book->xownPage ), FALSE );
+ asrt( isset( $book->ownPage ), FALSE );
+ asrt( isset( $book['xownPageList'] ), FALSE );
+ asrt( isset( $book['ownPageList'] ), FALSE );
+ asrt( isset( $book['xownPage'] ), FALSE );
+ asrt( isset( $book['ownPage'] ), FALSE );
+ $book->xownPageList[] = $page;
+ asrt( isset( $book->xownPageList ), TRUE );
+ asrt( isset( $book->ownPageList ), TRUE );
+ asrt( isset( $book->xownPage ), TRUE );
+ asrt( isset( $book->ownPage ), TRUE );
+ asrt( isset( $book['xownPageList'] ), TRUE );
+ asrt( isset( $book['ownPageList'] ), TRUE );
+ asrt( isset( $book['xownPage'] ), TRUE );
+ asrt( isset( $book['ownPage'] ), TRUE );
+ unset( $book->xownPage );
+ asrt( isset( $book->xownPageList ), FALSE );
+ asrt( isset( $book->ownPageList ), FALSE );
+ asrt( isset( $book->xownPage ), FALSE );
+ asrt( isset( $book->ownPage ), FALSE );
+ asrt( isset( $book['xownPageList'] ), FALSE );
+ asrt( isset( $book['ownPageList'] ), FALSE );
+ asrt( isset( $book['xownPage'] ), FALSE );
+ asrt( isset( $book['ownPage'] ), FALSE );
+ $book = $book->fresh();
+ asrt( isset( $book->xownPageList ), FALSE );
+ asrt( isset( $book->ownPageList ), FALSE );
+ asrt( isset( $book->xownPage ), FALSE );
+ asrt( isset( $book->ownPage ), FALSE );
+ asrt( isset( $book['xownPageList'] ), FALSE );
+ asrt( isset( $book['ownPageList'] ), FALSE );
+ asrt( isset( $book['xownPage'] ), FALSE );
+ asrt( isset( $book['ownPage'] ), FALSE );
+ $book->ownPageList;
+ asrt( isset( $book->xownPageList ), TRUE );
+ asrt( isset( $book->ownPageList ), TRUE );
+ asrt( isset( $book->xownPage ), TRUE );
+ asrt( isset( $book->ownPage ), TRUE );
+ asrt( isset( $book['xownPageList'] ), TRUE );
+ asrt( isset( $book['ownPageList'] ), TRUE );
+ asrt( isset( $book['xownPage'] ), TRUE );
+ asrt( isset( $book['ownPage'] ), TRUE );
+ }
+
+ /**
+ * Test whether you can still set items starting with 'xown' or
+ * 'own' not followed by an uppercase character.
+ *
+ * @return void
+ */
+ public function testConfusionWithXOwnList()
+ {
+ $book = R::dispense( 'book' );
+ $book->xownitem = 1;
+ asrt( isset( $book->xownitem ), TRUE );
+ asrt( (int) $book->xownitem, 1 );
+ asrt( isset( $book->xownItem ), FALSE );
+ asrt( isset( $book->xownItemList ), FALSE );
+ $book->ownitem = 1;
+ asrt( isset( $book->ownitem ), TRUE );
+ asrt( (int) $book->ownitem, 1 );
+ asrt( isset( $book->ownItemList ), FALSE );
+ R::store( $book );
+ $book = $book->fresh();
+ asrt( isset( $book->xownitem ), TRUE );
+ asrt( (int) $book->xownitem, 1 );
+ asrt( isset( $book->xownItem ), FALSE );
+ asrt( isset( $book->xownItemList ), FALSE );
+ asrt( isset( $book->ownitem ), TRUE );
+ asrt( (int) $book->ownitem, 1 );
+ asrt( isset( $book->ownItemList ), FALSE );
+ }
+
+ /**
+ * Test whether we can determine the mode of a list.
+ *
+ * @return void
+ */
+ public function testModeCheckerOfLists()
+ {
+ foreach( array( 'ownPage', 'xownPage', 'ownPageList', 'xownPageList' ) as $listName ) {
+ $book = R::dispense( 'book' );
+ asrt( $book->isListInExclusiveMode( $listName ), FALSE );
+ $book->ownPageList[] = R::dispense( 'page' );
+ asrt( $book->isListInExclusiveMode( $listName ), FALSE );
+ $book = R::dispense( 'book' );
+ asrt( $book->isListInExclusiveMode( $listName ), FALSE );
+ $book->xownPageList[] = R::dispense( 'page' );
+ asrt( $book->isListInExclusiveMode( $listName ), TRUE );
+ $book = R::dispense( 'book' );
+ asrt( $book->isListInExclusiveMode( $listName ), FALSE );
+ $book->ownPage[] = R::dispense( 'page' );
+ asrt( $book->isListInExclusiveMode( $listName ), FALSE );
+ $book = R::dispense( 'book' );
+ asrt( $book->isListInExclusiveMode( $listName ), FALSE );
+ $book->xownPage[] = R::dispense( 'page' );
+ asrt( $book->isListInExclusiveMode( $listName ), TRUE );
+ }
+ }
+}
projects / yaffs-website / blobdiff