/** * Tests basic traversal. * * @return void */ public function testBasicTraversal() { R::nuke(); $pageA = R::dispense('page')->setAttr('title', 'a'); $pageB = R::dispense('page')->setAttr('title', 'b'); $pageC = R::dispense('page')->setAttr('title', 'c'); $pageD = R::dispense('page')->setAttr('title', 'd'); $pageE = R::dispense('page')->setAttr('title', 'e'); $pageF = R::dispense('page')->setAttr('title', 'f'); $pageG = R::dispense('page')->setAttr('title', 'g'); $pageH = R::dispense('page')->setAttr('title', 'h'); $pageA->ownPage = array($pageB, $pageC); $pageB->ownPage = array($pageD); $pageC->ownPage = array($pageE, $pageF); $pageD->ownPage = array($pageG); $pageF->ownPage = array($pageH); R::store($pageA); $pageA = $pageA->fresh(); //also tests non-existant column handling by count(). asrt(R::count('page', ' price = ? ', array('5')), 0); asrt(R::count('tag', ' title = ? ', array('new')), 0); $pageA->traverse('ownPageList', function ($bean) { $bean->price = 5; }); R::store($pageA); asrt(R::count('page', ' price = ? ', array('5')), 7); }
/** * Tests the handling of trashed beans in frozen mode. * Are the lists unset etc? * * @return void */ public function testTrash() { R::nuke(); $book = R::dispense('book'); $book->xownPageList[] = R::dispense('page'); $book->sharedTagList[] = R::dispense('tag'); R::store($book); $book = $book->fresh(); R::freeze(TRUE); $book->xownPageList = array(); R::store($book); $book = $book->fresh(); asrt(R::count('page'), 0); $book->xownPageList[] = R::dispense('page'); R::store($book); $book = $book->fresh(); asrt(R::count('page'), 1); $book->xownPageList; $book->sharedTagList; R::trash($book); asrt(R::count('book'), 0); asrt(R::count('page'), 0); asrt(R::count('tag'), 1); asrt(R::count('book_tag'), 0); R::freeze(FALSE); }
/** * @param string $DBTable * @param int $startPage * @param int $maxResults */ public function setParams($DBTable, $maxResults, $startPage) { $this->DBTable = $DBTable; $this->maxResults = $maxResults; $this->startPage = $startPage; $this->storedNumber = Facade::count($this->DBTable); }
/** * Tests quick trash method: R::trash( type, id ). * * @return void */ public function testQuickTrash() { R::nuke(); $bean = R::dispense('bean'); $id = R::store($bean); asrt(R::count('bean'), 1); R::trash('bean', $id); asrt(R::count('bean'), 0); }
public function testCategoryDeletion() { Scripts::CreateCategory('Berlin'); $this->byLinkText('System Settings')->click(); $this->byLinkText('Categories')->click(); $this->byName('delete-ideas')->click(); $this->byName('delete-category')->click(); $numberOfCategories = RedBean::count('categories'); $this->assertEquals($numberOfCategories, 1); }
/** * Test whether we can use foreign keys with keywords. * * @return void */ public function testKWConflicts() { R::nuke(); $metrics = R::dispense('metrics'); $constraint = R::dispense('constraint'); $constraint->xownMetrics[] = $metrics; R::store($constraint); asrt(1, R::count('metrics')); R::trash($constraint); asrt(0, R::count('metrics')); }
/** * @brief inits the class */ public static function init() { session_start(); if (R::count("user") < 1) { self::register(["username" => "admin", "password" => "admin"]); } if ($_SESSION["is_loggedin"]) { self::$is_loggedin = true; self::$user = $_SESSION["user"]; } }
/** * In the past it was not possible to export beans * like 'feed' (Model_Feed). * * @return void */ public function testExportIssue() { R::nuke(); $feed = R::dispense('feed'); $feed->post = array('first', 'second'); R::store($feed); $rows = R::getAll('SELECT * FROM feed'); asrt($rows[0]['post'], '["first","second"]'); $feed = $feed->fresh(); asrt(is_array($feed->post), TRUE); asrt($feed->post[0], 'first'); asrt($feed->post[1], 'second'); R::store($feed); $rows = R::getAll('SELECT * FROM feed'); asrt($rows[0]['post'], '["first","second"]'); $feed = R::load('feed', $feed->id); $feed->post[] = 'third'; R::store($feed); $rows = R::getAll('SELECT * FROM feed'); asrt($rows[0]['post'], '["first","second","third"]'); $feed = $feed->fresh(); asrt(is_array($feed->post), TRUE); asrt($feed->post[0], 'first'); asrt($feed->post[1], 'second'); asrt($feed->post[2], 'third'); //now the catch: can we use export? //PHP Fatal error: Call to a member function export() on a non-object $feeds = R::exportAll(R::find('feed')); asrt(is_array($feeds), TRUE); $feed = reset($feeds); asrt($feed['post'][0], 'first'); asrt($feed['post'][1], 'second'); asrt($feed['post'][2], 'third'); //can we also dup()? $feedOne = R::findOne('feed'); R::store(R::dup($feedOne)); asrt(R::count('feed'), 2); //can we delete? R::trash($feedOne); asrt(R::count('feed'), 1); $feedTwo = R::findOne('feed'); $feed = $feedTwo->export(); asrt($feed['post'][0], 'first'); asrt($feed['post'][1], 'second'); asrt($feed['post'][2], 'third'); }
/** * Tests no-load modifier for lists. * * @return void */ public function testNoLoad() { $book = R::dispense(array('_type' => 'book', 'title' => 'Book of Lorem Ipsum', 'ownPage' => array(array('_type' => 'page', 'content' => 'Lorem Ipsum')), 'sharedTag' => array(array('_type' => 'tag', 'label' => 'testing')))); R::store($book); $book = $book->fresh(); asrt(R::count('book'), 1); asrt(count($book->ownPage), 1); //now try with no-load $book = $book->fresh(); asrt(count($book->noLoad()->ownPage), 0); asrt(count($book->noLoad()->sharedTag), 0); //now try to add with no-load $book = $book->fresh(); $book->noLoad()->xownPageList[] = R::dispense('page'); $book->noLoad()->sharedTagList[] = R::dispense('tag'); R::store($book); $book = $book->fresh(); asrt(count($book->ownPage), 2); asrt(count($book->sharedTagList), 2); //no-load overrides with and withCondition $book = $book->fresh(); asrt(count($book->with(' invalid sql ')->noLoad()->ownPage), 0); asrt(count($book->withCondition(' invalid sql ')->noLoad()->sharedTag), 0); //no-load overrides all and alias $book = $book->fresh(); asrt(count($book->all()->noLoad()->ownPage), 0); asrt(count($book->alias('nothing')->noLoad()->sharedTag), 0); //no-load gets cleared $book = $book->fresh(); asrt(count($book->ownPage), 2); asrt(count($book->sharedTagList), 2); //We cant clear with no-load accidentally? $book = $book->fresh(); $book->noLoad()->ownPage = array(); $book->noLoad()->sharedTagList = array(); R::store($book); asrt(count($book->ownPage), 2); asrt(count($book->sharedTagList), 2); //No-load does not have effect if list is already cached $book = $book->fresh(); $book->ownPage; $book->sharedTag; asrt(count($book->ownPage), 2); asrt(count($book->sharedTagList), 2); }
/** * Test whether we can duplicate part of a tree * without infinite loops. * * @return void */ public function testDupPortionOfATree() { R::nuke(); $article = R::dispense('article'); $article->name = 'article 1'; list($article2, $article3) = R::dispense('article', 2); $article2->name = 'article 2'; $article3->name = 'article 3'; list($article4, $article5) = R::dispense('article', 2); $article4->name = 'article 4'; $article5->name = 'article 5'; list($article6, $article7) = R::dispense('article', 2); $article6->name = 'article 6'; $article7->name = 'article 7'; $article3->xownArticleList[] = $article7; $article4->xownArticleList[] = $article6; $article2->xownArticleList = array($article5, $article4); $article->xownArticleList = array($article2, $article3); R::store($article); asrt(R::count('article'), 7); $article2 = $article2->fresh(); $dupArticle2 = R::duplicate($article2); $dupArticle2->name = 'article 2b'; $dupBeans = $dupArticle2->xownArticleList; foreach ($dupBeans as $dupBean) { $list[] = $dupBean->name; } sort($list); $listStr = implode(',', $list); asrt($listStr, 'article 4,article 5'); foreach ($dupBeans as $dupBean) { if ($dupBean->name === 'article 4') { $dup4 = $dupBean; } } asrt(isset($dup4), TRUE); $dupBeans = $dup4->xownArticleList; foreach ($dupBeans as $dupBean) { asrt($dupBean->name, 'article 6'); } //so we have extracted part of the tree, can we store it? $id = R::store($dupArticle2); asrt($id > 0, TRUE); asrt(R::count('article'), 11); $originalArticle = $article->fresh(); asrt($originalArticle->name, 'article 1'); $subArticles = $originalArticle->xownArticleList; $list = array(); foreach ($subArticles as $subArticle) { $list[] = $subArticle->name; } sort($list); $listStr = implode(',', $list); asrt($listStr, 'article 2,article 2b,article 3'); foreach ($subArticles as $subArticle) { if ($subArticle->name === 'article 2') { $sub2 = $subArticle; } if ($subArticle->name === 'article 3') { $sub3 = $subArticle; } } $subArticles = $sub2->xownArticleList; $list = array(); foreach ($subArticles as $subArticle) { $list[] = $subArticle->name; } sort($list); $listStr = implode(',', $list); asrt($listStr, 'article 4,article 5'); $subArticles = $sub3->xownArticleList; $list = array(); foreach ($subArticles as $subArticle) { $list[] = $subArticle->name; } sort($list); $listStr = implode(',', $list); asrt($listStr, 'article 7'); $subArticles = $sub2->xownArticleList; foreach ($subArticles as $subArticle) { if ($subArticle->name === 'article 4') { $sub4 = $subArticle; } if ($subArticle->name === 'article 5') { $sub5 = $subArticle; } } asrt(count($sub4->xownArticleList), 1); $subBeans = $sub4->xownArticleList; $subBean = reset($subBeans); asrt($subBean->name, 'article 6'); asrt(count($sub5->xownArticleList), 0); $dupArticle2 = $dupArticle2->fresh(); $subArticles = $dupArticle2->xownArticleList; $list = array(); foreach ($subArticles as $subArticle) { $list[] = $subArticle->name; } sort($list); $listStr = implode(',', $list); asrt($listStr, 'article 4,article 5'); foreach ($subArticles as $subArticle) { if ($subArticle->name === 'article 4') { $sub4 = $subArticle; } if ($subArticle->name === 'article 5') { $sub5 = $subArticle; } } asrt(count($sub4->xownArticleList), 1); $subBeans = $sub4->xownArticleList; $subBean = reset($subBeans); asrt($subBean->name, 'article 6'); asrt(count($sub5->xownArticleList), 0); }
/** * Test conditions and aliases. */ public function testConditionsAndAliases() { R::nuke(); $author = R::xdispense(AUTHOR); $author->name = 'Mr. Quill'; $book = R::xdispense(BOOK); $book->title = 'Good Stories'; $book2 = R::xdispense(BOOK); $book2->title = 'Good Stories 2'; $friend = R::xdispense(FRIEND); $friend->name = 'Muse'; $publisher = R::xdispense(PUBLISHER); $publisher->name = 'Good Books'; $author->{BOOKLIST} = array($book, $book2); $author->{FRIENDLIST}[] = $friend; $author->{PUBLISHER} = $publisher; $coAuthor = R::xdispense(AUTHOR); $coAuthor->name = 'Xavier'; $book2->{COAUTHOR} = $coAuthor; R::store($author); $author = $author->fresh(); asrt(R::count(AUTHOR), 2); //Can we use with and withCondition? asrt(count($author->{BOOKLIST}), 2); asrt(count($author->with(' LIMIT 1 ')->{BOOKLIST}), 1); asrt(count($author->withCondition(' title LIKE ? ', array('%2%'))->{BOOKLIST}), 1); //Can we use an alias? $book2 = $book2->fresh(); asrt($book2->fetchAs(AUTHOR)->{COAUTHOR}->name, 'Xavier'); $coAuthor = $book2->fetchAs(AUTHOR)->{COAUTHOR}->fresh(); asrt(count($coAuthor->alias(COAUTHOR)->{BOOKLIST}), 1); }
/** * Tests dependencies (variation). * * @return void */ public function testDependency4() { R::nuke(); $can = $this->createBeanInCan(TRUE); R::store($can); R::trash($can); $can = $this->createCanForBean(); asrt(R::count('bean'), 1); R::trash($can); asrt(R::count('bean'), 0); $can = $this->createBeanInCan(TRUE); R::store($can); R::trash($can); $can = $this->createCanForBean(); asrt(R::count('bean'), 1); R::trash($can); asrt(R::count('bean'), 0); }
/** * Test trashAll(). */ public function testMultiDeleteUpdate() { testpack('test multi delete and multi update'); $beans = R::dispenseLabels('bean', array('a', 'b')); $ids = R::storeAll($beans); asrt((int) R::count('bean'), 2); R::trashAll(R::batch('bean', $ids)); asrt((int) R::count('bean'), 0); testpack('test assocManager check'); $rb = new OODB(R::getWriter()); try { $rb->getAssociationManager(); fail(); } catch (RedException $e) { pass(); } }
/** * Tests whether we can store an empty bean. * An empty bean has no properties, only ID. Normally we would * skip the ID field in an INSERT, this test forces the driver * to specify a value for the ID field. Different writers have to * use different values: Mysql uses NULL to insert a new auto-generated ID, * while Postgres has to use DEFAULT. */ public function testEmptyBean() { testpack('Test Empty Bean Storage.'); R::nuke(); $bean = R::dispense('emptybean'); $id = R::store($bean); asrt($id > 0, TRUE); asrt(R::count('emptybean'), 1); $bean = R::dispense('emptybean'); $id = R::store($bean); asrt($id > 0, TRUE); asrt(R::count('emptybean'), 2); //also test in frozen mode R::freeze(TRUE); $bean = R::dispense('emptybean'); $id = R::store($bean); asrt($id > 0, TRUE); asrt(R::count('emptybean'), 3); R::freeze(FALSE); }
/** * Test whether we cannot add unique constraints on chilled tables, * otherwise you cannot avoid this from happening when adding beans to the * shared list :) -- this is almost a theoretical issue however we want it * to work according to specifications! * * @return void */ public function testDontAddUniqueConstraintForChilledBeanTypes() { R::nuke(); $person = R::dispense('person'); $role = R::dispense('role'); $person->sharedRole[] = $role; R::store($person); $person->sharedRole[] = R::dispense('role'); R::store($person); $bean = R::getRedBean()->dispense('person_role'); $bean->personId = $person->id; $bean->roleId = $role->id; try { R::store($bean); fail(); } catch (\Exception $e) { pass(); } asrt(R::count('person_role'), 2); R::nuke(); $link = R::getRedBean()->dispense('person_role'); $person = R::dispense('person'); $role = R::dispense('role'); $link->person = $person; $link->role = $role; R::store($link); R::freeze(array('person_role')); $person->sharedRole[] = R::dispense('role'); R::store($person); $bean = R::getRedBean()->dispense('person_role'); $bean->personId = $person->id; $bean->roleId = $role->id; try { R::store($bean); pass(); } catch (\Exception $e) { fail(); } asrt(R::count('person_role'), 3); R::freeze(array()); //set freeze to FALSE and clear CHILL LIST! }
/** * Test Full fluid UUID support. * */ public function testFullSupport() { //Rewire objects to support UUIDs. $oldToolBox = R::getToolBox(); $oldAdapter = $oldToolBox->getDatabaseAdapter(); $uuidWriter = new \UUIDWriterPostgres($oldAdapter); $newRedBean = new OODB($uuidWriter); $newToolBox = new ToolBox($newRedBean, $oldAdapter, $uuidWriter); R::configureFacadeWithToolbox($newToolBox); list($mansion, $rooms, $ghosts, $key) = R::dispenseAll('mansion,room*3,ghost*4,key'); $mansion->name = 'Haunted Mansion'; $mansion->xownRoomList = $rooms; $rooms[0]->name = 'Green Room'; $rooms[1]->name = 'Red Room'; $rooms[2]->name = 'Blue Room'; $ghosts[0]->name = 'zero'; $ghosts[1]->name = 'one'; $ghosts[2]->name = 'two'; $ghosts[3]->name = 'three'; $rooms[0]->noLoad()->sharedGhostList = array($ghosts[0], $ghosts[1]); $rooms[1]->noLoad()->sharedGhostList = array($ghosts[0], $ghosts[2]); $rooms[2]->noLoad()->sharedGhostList = array($ghosts[1], $ghosts[3], $ghosts[2]); $rooms[2]->xownKey = array($key); //Can we store a bean hierachy with UUIDs? R::debug(1); $id = R::store($mansion); //exit; asrt(is_string($id), TRUE); asrt(strlen($id), 36); $haunted = R::load('mansion', $id); asrt($haunted->name, 'Haunted Mansion'); asrt(is_string($haunted->id), TRUE); asrt(strlen($haunted->id), 36); asrt(is_array($haunted->xownRoomList), TRUE); asrt(count($haunted->ownRoom), 3); $rooms = $haunted->xownRoomList; //Do some counting... $greenRoom = NULL; foreach ($rooms as $room) { if ($room->name === 'Green Room') { $greenRoom = $room; break; } } asrt(!is_null($greenRoom), TRUE); asrt(is_array($greenRoom->with(' ORDER BY id ')->sharedGhostList), TRUE); asrt(count($greenRoom->sharedGhostList), 2); $names = array(); foreach ($greenRoom->sharedGhost as $ghost) { $names[] = $ghost->name; } sort($names); $names = implode(',', $names); asrt($names, 'one,zero'); $rooms = $haunted->xownRoomList; $blueRoom = NULL; foreach ($rooms as $room) { if ($room->name === 'Blue Room') { $blueRoom = $room; break; } } asrt(!is_null($blueRoom), TRUE); asrt(is_array($blueRoom->sharedGhostList), TRUE); asrt(count($blueRoom->sharedGhostList), 3); $names = array(); foreach ($blueRoom->sharedGhost as $ghost) { $names[] = $ghost->name; } sort($names); $names = implode(',', $names); asrt($names, 'one,three,two'); $rooms = $haunted->xownRoomList; $redRoom = NULL; foreach ($rooms as $room) { if ($room->name === 'Red Room') { $redRoom = $room; break; } } $names = array(); foreach ($redRoom->sharedGhost as $ghost) { $names[] = $ghost->name; } sort($names); $names = implode(',', $names); asrt($names, 'two,zero'); asrt(!is_null($redRoom), TRUE); asrt(is_array($redRoom->sharedGhostList), TRUE); asrt(count($redRoom->sharedGhostList), 2); //Can we repaint a room? $redRoom->name = 'Yellow Room'; $id = R::store($redRoom); $yellowRoom = R::load('room', $id); asrt($yellowRoom->name, 'Yellow Room'); asrt(!is_null($yellowRoom), TRUE); asrt(is_array($yellowRoom->sharedGhostList), TRUE); asrt(count($yellowRoom->sharedGhostList), 2); //Can we throw one ghost out? array_pop($yellowRoom->sharedGhost); R::store($yellowRoom); $yellowRoom = $yellowRoom->fresh(); asrt($yellowRoom->name, 'Yellow Room'); asrt(!is_null($yellowRoom), TRUE); asrt(is_array($yellowRoom->sharedGhostList), TRUE); asrt(count($yellowRoom->sharedGhostList), 1); //can we remove one of the rooms? asrt(R::count('key'), 1); $list = $mansion->withCondition(' "name" = ? ', array('Blue Room'))->xownRoomList; $room = reset($list); unset($mansion->xownRoomList[$room->id]); R::store($mansion); asrt(R::count('room'), 2); //and what about its dependent beans? asrt(R::count('key'), 0); asrt(R::count('ghost_room'), 3); //and can we find ghosts? $ghosts = R::find('ghost'); asrt(count($ghosts), 4); $ghosts = R::findAll('ghost', 'ORDER BY id'); asrt(count($ghosts), 4); $ghosts = R::findAll('ghost', 'ORDER BY id LIMIT 2'); asrt(count($ghosts), 2); $ghostZero = R::findOne('ghost', ' "name" = ? ', array('zero')); asrt($ghostZero instanceof OODBBean, TRUE); //can we create link properties on existing tables? $blackRoom = R::dispense('room'); $blackRoom->name = 'Black Room'; $ghostZero->link('ghost_room', array('mood' => 'grumpy'))->room = $blackRoom; R::store($ghostZero); $ghostZero = $ghostZero->fresh(); $list = $ghostZero->sharedRoomList; asrt(count($list), 3); $ghostZero = $ghostZero->fresh(); $list = $ghostZero->withCondition(' ghost_room.mood = ? ', array('grumpy'))->sharedRoomList; asrt(count($list), 1); //can we load a batch? $ids = R::getCol('SELECT id FROM ghost'); $ghosts = R::batch('ghost', $ids); asrt(count($ghosts), 4); //can we do an aggregation? $ghosts = $greenRoom->aggr('ownGhostRoom', 'ghost', 'ghost'); asrt(count($ghosts), 2); //can we duplicate the mansion? asrt(R::count('mansion'), 1); asrt(R::count('room'), 3); asrt(R::count('ghost'), 4); $copy = R::dup($mansion); R::store($copy); asrt(R::count('mansion'), 2); asrt(R::count('room'), 5); //black room does not belong to mansion 1 asrt(R::count('ghost'), 4); //can we do some counting using the list? asrt($copy->countOwn('room'), 2); $rooms = $copy->withCondition(' "name" = ? ', array('Green Room'))->xownRoomList; $room = reset($rooms); asrt($room->countShared('ghost'), 2); //Finally restore old toolbox R::configureFacadeWithToolbox($oldToolBox); }
/** * Test whether a duplicate bean in the list isnt saved. * This was an issue with Postgres while testing the threeway tables. * Postgres returned the ID as a string while other drivers returned * a numeric value causing different outcome in array_diff when * calculating the shared additions. * * @return void */ public function testIssueWithDriverReturnID() { AQueryWriter::clearRenames(); R::nuke(); $book = R::dispense('book'); $page = R::dispense('page'); $book->sharedPageList[] = $page; R::store($book); asrt(R::count('page'), 1); $book = $book->fresh(); $book->sharedPageList[] = $page; R::store($book); //don't save the duplicate bean! asrt(R::count('page'), 1); $book = $book->fresh(); $page->item = 2; //even if we change a property ? $book->sharedPageList[] = $page; R::store($book); foreach ($book->sharedPageList as $listItem) { asrt(is_string($listItem->id), TRUE); } //same test but for own-list R::nuke(); $book = R::dispense('book'); $page = R::dispense('page'); $book->ownPageList[] = $page; R::store($book); asrt(R::count('page'), 1); $book = $book->fresh(); $book->ownPageList[] = $page; R::store($book); //don't save the duplicate bean! asrt(R::count('page'), 1); $book = $book->fresh(); $book->ownPageList[] = $page; $page->item = 3; R::store($book); //don't save the duplicate bean! asrt(R::count('page'), 1); foreach ($book->ownPageList as $listItem) { asrt(is_string($listItem->id), TRUE); } AQueryWriter::clearRenames(); }
/** * Tests the complex use case for findMulti(). * * @return void */ public function testMultiAdvanced() { $this->insertBookData(); $collection = R::findMulti('book,page,text,category', ' SELECT book.*, page.*, text.*, category.* FROM book LEFT JOIN page ON page.book_id = book.id LEFT JOIN text ON text.page_id = page.id LEFT JOIN book_category ON book_category.book_id = book.id LEFT JOIN category ON book_category.category_id = category.id '); asrt(count($collection), 4); asrt(isset($collection['book']), TRUE); asrt(isset($collection['page']), TRUE); asrt(isset($collection['text']), TRUE); asrt(isset($collection['category']), TRUE); asrt(count($collection['book']), 5); asrt(count($collection['page']), 9); asrt(count($collection['text']), 11); asrt(count($collection['category']), 3); foreach ($collection['book'] as $bean) { asrt($bean instanceof OODBBean, TRUE); } foreach ($collection['page'] as $bean) { asrt($bean instanceof OODBBean, TRUE); } foreach ($collection['text'] as $bean) { asrt($bean instanceof OODBBean, TRUE); } foreach ($collection['category'] as $bean) { asrt($bean instanceof OODBBean, TRUE); } foreach ($collection['book'] as $book) { $titles[] = $book->title; } asrt(in_array('Diehard C', $titles), TRUE); asrt(in_array('Adventures in JavaScript', $titles), TRUE); asrt(in_array('CSS ala Picasso', $titles), TRUE); asrt(in_array('PHP Tips and Tricks', $titles), TRUE); asrt(in_array('Secrets of SQL', $titles), TRUE); $collection = R::findMulti('book,page,text,category,book_category', ' SELECT book.*, page.*, text.*, category.*, book_category.* FROM book LEFT JOIN page ON page.book_id = book.id LEFT JOIN text ON text.page_id = page.id LEFT JOIN book_category ON book_category.book_id = book.id LEFT JOIN category ON book_category.category_id = category.id WHERE category_id > ? ORDER BY book.title ASC ', array(0), array(array('b' => 'page', 'a' => 'text', 'do' => function ($a, $b) { $b->noLoad()->ownTextList[] = $a; $b->clearHistory(); }, 'matcher' => function ($a, $b) { return $a->page_id == $b->id; }), array('b' => 'book', 'a' => 'page', 'do' => function ($a, $b) { $b->noLoad()->ownPageList[] = $a; $b->clearHistory(); }, 'matcher' => function ($a, $b) { return $a->book_id == $b->id; }), array('b' => 'category', 'a' => 'book', 'do' => function ($a, $b) { $a->noLoad()->sharedCategoryList[] = $b; $a->clearHistory(); }, 'matcher' => function ($a, $b, $beans) { foreach ($beans['book_category'] as $bean) { if ($bean->book_id == $a->id && $bean->category_id == $b->id) { return TRUE; } } return FALSE; }))); $books = $collection['book']; $book = reset($books); asrt($book->title, 'Adventures in JavaScript'); R::nuke(); asrt(count($book->ownPageList), 3); $page = reset($book->ownPageList); asrt(count($page->ownTextList), 1); asrt(count($book->sharedCategoryList), 2); $categories = array(); foreach ($book->sharedCategoryList as $category) { $categories[] = $category->name; } sort($categories); asrt(implode(',', $categories), 'Programming,Web Development'); $book = next($books); asrt($book->title, 'CSS ala Picasso'); asrt(count($book->ownPage), 1); $page = reset($book->ownPage); asrt(count($page->ownTextList), 2); $texts = array(); foreach ($page->ownTextList as $text) { $texts[] = $text->content; } asrt(in_array('Now we use it for applications...', $texts), TRUE); $categories = array(); foreach ($book->sharedCategoryList as $category) { $categories[] = $category->name; } sort($categories); asrt(implode(',', $categories), 'Design,Programming,Web Development'); $book = next($books); asrt($book->title, 'Diehard C'); asrt(count($book->ownPageList), 2); $page = reset($book->ownPageList); asrt(count($page->ownTextList), 2); $page = next($book->ownPageList); asrt(count($page->ownTextList), 1); $categories = array(); foreach ($book->sharedCategoryList as $category) { $categories[] = $category->name; } sort($categories); asrt(implode(',', $categories), 'Programming'); //should have no effect, nothing should have changed R::storeAll($books); asrt(R::count('book'), 0); asrt(R::count('page'), 0); asrt(R::count('text'), 0); }
/** * Test Recursion */ public function testRecursion() { list($d1, $d2) = R::dispense('document', 2); $page = R::dispense('page'); list($p1, $p2) = R::dispense('paragraph', 2); list($e1, $e2) = R::dispense('excerpt', 2); $id2 = R::store($d2); $p1->name = 'a'; $p2->name = 'b'; $page->title = 'my page'; $page->ownParagraph = array($p1, $p2); $p1->ownExcerpt[] = $e1; $p2->ownExcerpt[] = $e2; $e1->ownDocument[] = $d2; $e2->ownDocument[] = $d1; $d1->ownPage[] = $page; $id1 = R::store($d1); $d1 = R::load('document', $id1); $d = R::dup($d1); $ids = array(); asrt($d instanceof OODBBean, TRUE); asrt(count($d->ownPage), 1); foreach (end($d->ownPage)->ownParagraph as $p) { foreach ($p->ownExcerpt as $e) { $ids[] = end($e->ownDocument)->id; } } sort($ids); asrt((int) $ids[0], 0); asrt((int) $ids[1], $id1); R::store($d); pass(); $phillies = R::dispense('diner'); list($lonelyman, $man, $woman) = R::dispense('guest', 3); $attendant = R::dispense('employee'); $lonelyman->name = 'Bennie Moten'; $man->name = 'Daddy Stovepipe'; $woman->name = 'Mississippi Sarah'; $attendant->name = 'Gus Cannon'; $phillies->sharedGuest = array($lonelyman, $man, $woman); $phillies->ownEmployee[] = $attendant; $props = R::dispense('prop', 2); $props[0]->kind = 'cigarette'; $props[1]->kind = 'coffee'; $thought = R::dispense('thought'); $thought->content = 'Blues'; $thought2 = R::dispense('thought'); $thought2->content = 'Jazz'; $woman->ownProp[] = $props[0]; $man->sharedProp[] = $props[1]; $attendant->ownThought = array($thought, $thought2); R::store($phillies); $diner = R::findOne('diner'); $diner2 = R::dup($diner); $id2 = R::store($diner2); $diner2 = R::load('diner', $id2); asrt(count($diner->ownEmployee), 1); asrt(count($diner2->ownEmployee), 1); asrt(count($diner->sharedGuest), 3); asrt(count($diner2->sharedGuest), 3); $employee = reset($diner->ownEmployee); asrt(count($employee->ownThought), 2); $employee = reset($diner2->ownEmployee); asrt(count($employee->ownThought), 2); // Can we change something in the duplicate without changing the original? $employee->name = 'Marvin'; $thought = R::dispense('thought'); $thought->content = 'depression'; $employee->ownThought[] = $thought; array_pop($diner2->sharedGuest); $guest = reset($diner2->sharedGuest); $guest->name = 'Arthur Dent'; $id2 = R::store($diner2); $diner2 = R::load('diner', $id2); asrt(count($diner->ownEmployee), 1); asrt(count($diner2->ownEmployee), 1); asrt(count($diner->sharedGuest), 3); asrt(count($diner2->sharedGuest), 2); $employeeOld = reset($diner->ownEmployee); asrt(count($employeeOld->ownThought), 2); $employee = reset($diner2->ownEmployee); asrt(count($employee->ownThought), 3); asrt($employee->name, 'Marvin'); asrt($employeeOld->name, 'Gus Cannon'); // However the shared beans must not be copied asrt(R::count('guest'), 3); asrt(R::count('guest_prop'), 1); $arthur = R::findOne('guest', ' ' . R::getWriter()->esc('name') . ' = ? ', array('Arthur Dent')); asrt($arthur->name, 'Arthur Dent'); }
/** * Test count and wipe. * * @return void */ public function testCountAndWipe() { testpack("Test count and wipe"); $page = R::dispense("page"); $page->name = "ABC"; R::store($page); $n1 = R::count("page"); $page = R::dispense("page"); $page->name = "DEF"; R::store($page); $n2 = R::count("page"); asrt($n1 + 1, $n2); R::wipe("page"); asrt(R::count("page"), 0); asrt(R::getRedBean()->count("page"), 0); asrt(R::getRedBean()->count("kazoo"), 0); // non existing table R::freeze(TRUE); asrt(R::getRedBean()->count("kazoo"), 0); // non existing table R::freeze(FALSE); $page = R::dispense('page'); $page->name = 'foo'; R::store($page); $page = R::dispense('page'); $page->name = 'bar'; R::store($page); asrt(R::count('page', ' name = ? ', array('foo')), 1); // Now count something that does not exist, this should return 0. (just be polite) asrt(R::count('teapot', ' name = ? ', array('flying')), 0); asrt(R::count('teapot'), 0); $currentDriver = $this->currentlyActiveDriverID; // Some drivers don't support that many error codes. if ($currentDriver === 'mysql' || $currentDriver === 'postgres') { try { R::count('teaport', ' for tea '); fail(); } catch (SQL $e) { pass(); } } }
public function testWhetherWeCanAddToLists() { $book = $this->_createBook(); $book->ownPage[] = R::dispense('page'); R::store($book); asrt(R::count('page'), 3); $book = $this->_createBook(); $book->ownPageList[] = R::dispense('page'); R::store($book); asrt(R::count('page'), 3); $book = $this->_createBook(); $book->xownPage[] = R::dispense('page'); R::store($book); asrt(R::count('page'), 3); $book = $this->_createBook(); $book->xownPageList[] = R::dispense('page'); R::store($book); asrt(R::count('page'), 3); $ads = R::dispense('ad', 3); $book = $this->_createBook(); $book->alias('magazine')->ownAd = $ads; $book->ownPage[] = R::dispense('page'); R::store($book); asrt(R::count('ad'), 6); asrt(R::count('page'), 3); $ads = R::dispense('ad', 3); $book = $this->_createBook(); $book->alias('magazine')->ownAdList = $ads; $book->ownPageList[] = R::dispense('page'); R::store($book); asrt(R::count('ad'), 6); asrt(R::count('page'), 3); $ads = R::dispense('ad', 3); $book = $this->_createBook(); $book->alias('magazine')->xownAd = $ads; $book->xownPage[] = R::dispense('page'); R::store($book); asrt(R::count('ad'), 3); asrt(R::count('page'), 3); $ads = R::dispense('ad', 3); $book = $this->_createBook(); $book->alias('magazine')->xownAdList = $ads; $book->xownPageList[] = R::dispense('page'); R::store($book); asrt(R::count('ad'), 3); asrt(R::count('page'), 3); $book = $this->_createBook(); $book->sharedTag[] = R::dispense('tag'); R::store($book); asrt(R::count('tag'), 3); $book = $this->_createBook(); $book->sharedTagList[] = R::dispense('tag'); R::store($book); asrt(R::count('tag'), 3); }
/** * @return int */ public function count($userid = NULL) { $count = R::count($this->tbname); return $count; }
/** * Test multiple assiociation. * * @return void */ public function testMultiAssociationDissociation() { $wines = R::dispense('wine', 3); $cheese = R::dispense('cheese', 3); $olives = R::dispense('olive', 3); R::getRedBean()->getAssociationManager()->associate($wines, array_merge($cheese, $olives)); asrt(R::count('cheese'), 3); asrt(R::count('olive'), 3); asrt(R::count('wine'), 3); asrt(count($wines[0]->sharedCheese), 3); asrt(count($wines[0]->sharedOlive), 3); asrt(count($wines[1]->sharedCheese), 3); asrt(count($wines[1]->sharedOlive), 3); asrt(count($wines[2]->sharedCheese), 3); asrt(count($wines[2]->sharedOlive), 3); R::getRedBean()->getAssociationManager()->unassociate($wines, $olives); asrt(count($wines[0]->sharedCheese), 3); asrt(count($wines[0]->sharedOlive), 0); asrt(count($wines[1]->sharedCheese), 3); asrt(count($wines[1]->sharedOlive), 0); asrt(count($wines[2]->sharedCheese), 3); asrt(count($wines[2]->sharedOlive), 0); R::getRedBean()->getAssociationManager()->unassociate(array($wines[1]), $cheese); asrt(count($wines[0]->sharedCheese), 3); asrt(count($wines[0]->sharedOlive), 0); asrt(count($wines[1]->sharedCheese), 0); asrt(count($wines[1]->sharedOlive), 0); asrt(count($wines[2]->sharedCheese), 3); asrt(count($wines[2]->sharedOlive), 0); R::getRedBean()->getAssociationManager()->unassociate(array($wines[2]), $cheese); asrt(count($wines[0]->sharedCheese), 3); asrt(count($wines[0]->sharedOlive), 0); asrt(count($wines[1]->sharedCheese), 0); asrt(count($wines[1]->sharedOlive), 0); asrt(count($wines[2]->sharedCheese), 0); asrt(count($wines[2]->sharedOlive), 0); }
/** * 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 effect of via on shared list removal of beans. * * @return void */ public function testViaAndRemove() { R::nuke(); $project = R::dispense('project'); $employees = R::dispense('employee', 2); $project->via('partcipant')->sharedEmployeeList = $employees; R::store($project); asrt(R::count('employee'), 2); asrt(R::count('participant'), 2); $project = $project->fresh(); $project->sharedEmployee = array(); R::store($project); asrt(R::count('employee'), 2); asrt(R::count('participant'), 0); }
/** * Test aggr with basic aliasing. * * @return void */ public function testAggrWithOnlyAlias() { R::nuke(); $book = R::dispense('book'); $page1 = R::dispense('page'); $page1->name = 'Page 1'; $text1 = R::dispense('text'); $text1->content = 'Text 1'; $page1->content = $text1; $book->xownPageList[] = $page1; $page2 = R::dispense('page'); $page2->name = 'Page 2'; $text2 = R::dispense('text'); $text2->content = 'Text 2'; $page2->content = $text2; $book->xownPageList[] = $page2; R::store($book); $book = $book->fresh(); $texts = $book->aggr('ownPageList', 'content', 'text'); R::nuke(); asrt(count($texts), 2); foreach ($texts as $text) { asrt($text instanceof OODBBean, TRUE); } $pages = $book->ownPageList; asrt(count($pages), 2); asrt(R::count('page'), 0); foreach ($pages as $page) { asrt($page instanceof OODBBean, TRUE); $text = $page->content; asrt($text instanceof OODBBean, TRUE); $text->content = 'CHANGED'; } foreach ($texts as $text) { asrt($text->content, 'CHANGED'); } }
public static function count($tbname) { $count = R::count($tbname); return $count; }
/** * Test Facade transactions. * * @return void * * @throws\Exception */ public function testTransactionInFacade() { testpack('Test transaction in facade'); $bean = R::dispense('bean'); $bean->name = 'a'; R::store($bean); R::trash($bean); R::freeze(TRUE); $bean = R::dispense('bean'); $bean->name = 'a'; R::store($bean); asrt(R::count('bean'), 1); R::trash($bean); asrt(R::count('bean'), 0); $bean = R::dispense('bean'); $bean->name = 'a'; $id = R::transaction(function () use(&$bean) { return R::transaction(function () use(&$bean) { return R::store($bean); }); }); asrt((int) $id, (int) $bean->id); R::trash($bean); $bean = R::dispense('bean'); $bean->name = 'a'; $id = R::transaction(function () use(&$bean) { return R::store($bean); }); asrt((int) $id, (int) $bean->id); R::trash($bean); $bean = R::dispense('bean'); $bean->name = 'a'; try { R::transaction(function () use($bean) { R::store($bean); R::transaction(function () { throw new \Exception(); }); }); } catch (\Exception $e) { pass(); } asrt(R::count('bean'), 0); $bean = R::dispense('bean'); $bean->name = 'a'; try { R::transaction(function () use($bean) { R::transaction(function () use($bean) { R::store($bean); throw new \Exception(); }); }); } catch (\Exception $e) { pass(); } asrt(R::count('bean'), 0); $bean = R::dispense('bean'); $bean->name = 'a'; try { R::transaction(function () use($bean) { R::transaction(function () use($bean) { R::store($bean); }); }); } catch (\Exception $e) { pass(); } asrt(R::count('bean'), 1); R::freeze(FALSE); try { R::transaction('nope'); fail(); } catch (\Exception $e) { pass(); } testpack('Test Camelcase 2 underscore'); $names = array('oneACLRoute' => 'one_acl_route', 'ALLUPPERCASE' => 'alluppercase', 'clientServerArchitecture' => 'client_server_architecture', 'camelCase' => 'camel_case', 'peer2peer' => 'peer2peer', 'fromUs4You' => 'from_us4_you', 'lowercase' => 'lowercase', 'a1A2b' => 'a1a2b'); $bean = R::dispense('bean'); foreach ($names as $name => $becomes) { $bean->{$name} = 1; asrt(isset($bean->{$becomes}), TRUE); } testpack('Misc Tests'); R::debug(1); flush(); ob_start(); R::exec('SELECT 123'); $out = ob_get_contents(); ob_end_clean(); flush(); pass(); asrt(strpos($out, 'SELECT 123') !== FALSE, TRUE); R::debug(0); flush(); ob_start(); R::exec('SELECT 123'); $out = ob_get_contents(); ob_end_clean(); flush(); pass(); asrt($out, ''); R::debug(0); pass(); testpack('test to string override'); $band = R::dispense('band'); $str = strval($band); asrt($str, 'bigband'); testpack('test whether we can use isset/set in model'); $band->setProperty('property1', 123); asrt($band->property1, 123); asrt($band->checkProperty('property1'), TRUE); asrt($band->checkProperty('property2'), FALSE); $band = new \Model_Band(); $bean = R::dispense('band'); $bean->property3 = 123; $band->loadBean($bean); $bean->property4 = 345; $band->setProperty('property1', 123); asrt($band->property1, 123); asrt($band->checkProperty('property1'), TRUE); asrt($band->checkProperty('property2'), FALSE); asrt($band->property3, 123); asrt($band->property4, 345); testpack('Can we pass a\\PDO object to Setup?'); $pdo = new \PDO('sqlite:test.db'); R::addDatabase('pdo', $pdo); R::selectDatabase('pdo'); R::getCell('SELECT 123;'); testpack('Test array interface of beans'); $bean = R::dispense('bean'); $bean->hello = 'hi'; $bean->world = 'planet'; asrt($bean['hello'], 'hi'); asrt(isset($bean['hello']), TRUE); asrt(isset($bean['bye']), FALSE); $bean['world'] = 'sphere'; asrt($bean->world, 'sphere'); foreach ($bean as $key => $el) { if ($el == 'sphere' || $el == 'hi' || $el == 0) { pass(); } else { fail(); } if ($key == 'hello' || $key == 'world' || $key == 'id') { pass(); } else { fail(); } } asrt(count($bean), 3); unset($bean['hello']); asrt(count($bean), 2); asrt(count(R::dispense('countable')), 1); // Otherwise untestable... $bean->setBeanHelper(new SimpleFacadeBeanHelper()); R::getRedBean()->setBeanHelper(new SimpleFacadeBeanHelper()); pass(); // Test whether properties like owner and shareditem are still possible testpack('Test Bean Interface for Lists'); $bean = R::dispense('bean'); // Must not be list, because first char after own is lowercase asrt(is_array($bean->owner), FALSE); // Must not be list, because first char after shared is lowercase asrt(is_array($bean->shareditem), FALSE); asrt(is_array($bean->own), FALSE); asrt(is_array($bean->shared), FALSE); asrt(is_array($bean->own_item), FALSE); asrt(is_array($bean->shared_item), FALSE); asrt(is_array($bean->{'own item'}), FALSE); asrt(is_array($bean->{'shared Item'}), FALSE); }