It searches for a OODBBean Bean Object in the
database. It does not matter how this bean has been stored.
RedBean uses the primary key ID $id and the string $type
to find the bean. The $type specifies what kind of bean you
are looking for; this is the same type as used with the
dispense() function. If RedBean finds the bean it will return
the OODB Bean object; if it cannot find the bean
RedBean will return a new bean of type $type and with
primary key ID 0. In the latter case it acts basically the
same as dispense().
Important note:
If the bean cannot be found in the database a new bean of
the specified type will be generated and returned.
public function testDatabaseInstallation() { $this->url('index.php'); //All Fields initially with empty $this->fillFields(array('hostname' => 'localhost', 'username' => 'root', 'password' => '', 'database' => 'phpback_test', 'adminemail' => '*****@*****.**', 'adminname' => 'admin', 'adminpass' => 'admin', 'adminrpass' => 'admin')); //Submit form $this->byName('install-form')->submit(); //Should delete first intallation files $this->assertFileNotExists('install/index.php'); $this->assertFileNotExists('install/install1.php'); $this->assertFileNotExists('install/database_tables.sql'); //Should create configuration file $this->assertFileExists('application/config/database.php'); include 'application/config/database.php'; $this->assertEquals($db['default']['username'], 'root'); $this->assertEquals($db['default']['password'], ''); $this->assertEquals($db['default']['database'], 'phpback_test'); $this->assertEquals($db['default']['username'], 'root'); $this->assertEquals($db['default']['dbdriver'], 'mysqli'); //Should have updated database with new tables $this->assertEquals(RedBean::inspect(), array('_sessions', 'categories', 'comments', 'flags', 'ideas', 'logs', 'settings', 'users', 'votes')); //Should have created the admin user $adminUser = RedBean::load('users', 1); $this->assertEquals($adminUser->name, 'admin'); $this->assertEquals($adminUser->email, '*****@*****.**'); $this->assertEquals($adminUser->isadmin, '3'); $this->assertEquals($adminUser->votes, '20'); }
/** * Test tainted. * * @return void */ public function testTainted() { testpack('Original Tainted Tests'); $redbean = R::getRedBean(); $spoon = $redbean->dispense("spoon"); asrt($spoon->getMeta("tainted"), TRUE); $spoon->dirty = "yes"; asrt($spoon->getMeta("tainted"), TRUE); testpack('Tainted List test'); $note = R::dispense('note'); $note->text = 'abc'; $note->ownNote[] = R::dispense('note')->setAttr('text', 'def'); $id = R::store($note); $note = R::load('note', $id); asrt($note->isTainted(), FALSE); // Shouldn't affect tainted $note->text; asrt($note->isTainted(), FALSE); $note->ownNote; asrt($note->isTainted(), TRUE); testpack('Tainted Test Old Value'); $text = $note->old('text'); asrt($text, 'abc'); asrt($note->hasChanged('text'), FALSE); $note->text = 'xxx'; asrt($note->hasChanged('text'), TRUE); $text = $note->old('text'); asrt($text, 'abc'); testpack('Tainted Non-exist'); asrt($note->hasChanged('text2'), FALSE); testpack('Misc Tainted Tests'); $bean = R::dispense('bean'); $bean->hasChanged('prop'); $bean->old('prop'); }
/** * Test types. * Test how RedBeanPHP OODB and OODBBean handle type and type casts. * * Rules: * * 1. before storing a bean all types are preserved except booleans (they are converted to STRINGS '0' or '1') * 2. after store-reload all bean property values are STRINGS or NULL * (or ARRAYS but that's only from a user perspective because these are lazy loaded) * 3. the ID returned by store() is an INTEGER (if possible; on 32 bit systems overflowing values will be cast to STRINGS!) * * After loading: * ALL VALUES EXCEPT NULL -> STRING * NULL -> NULL * * @note Why not simply return bean->id in store()? Because not every driver returns the same type: * databases without insert_id support require a separate query or a suffix returning STRINGS, not INTEGERS. * * @note Why not preserve types? I.e. I store integer, why do I get back a string? * Answer: types are handled different across database platforms, would cause overhead to inspect every value for type, * also PHP is a dynamically typed language so types should not matter that much. Another reason: due to the nature * of RB columns in the database might change (INT -> STRING) this would cause return types to change as well which would * cause 'cascading errors', i.e. a column gets widened and suddenly your code would break. * * @note Unfortunately the 32/64-bit issue cannot be tested fully. Return-strategy store() is probably the safest * solution. * * @return void */ public function testTypes() { testpack('Beans can only contain STRING and NULL after reload'); R::nuke(); $bean = R::dispense('bean'); $bean->number = 123; $bean->float = 12.3; $bean->bool = false; $bean->bool2 = true; $bean->text = 'abc'; $bean->null = null; $bean->datetime = new \DateTime('NOW', new \DateTimeZone('Europe/Amsterdam')); $id = R::store($bean); asrt(is_int($id), TRUE); asrt(is_float($bean->float), TRUE); asrt(is_integer($bean->number), TRUE); asrt(is_string($bean->bool), TRUE); asrt(is_string($bean->bool2), TRUE); asrt(is_string($bean->datetime), TRUE); asrt(is_string($bean->text), TRUE); asrt(is_null($bean->null), TRUE); $bean = R::load('bean', $id); asrt(is_string($bean->id), TRUE); asrt(is_string($bean->float), TRUE); asrt(is_string($bean->number), TRUE); asrt(is_string($bean->bool), TRUE); asrt(is_string($bean->bool2), TRUE); asrt(is_string($bean->datetime), TRUE); asrt(is_string($bean->text), TRUE); asrt(is_null($bean->null), TRUE); asrt($bean->bool, '0'); asrt($bean->bool2, '1'); }
/** * Via specific tests. * * @return void */ public function testViaAndSQL() { R::nuke(); list($p1, $p2) = R::dispense('participant', 2); list($e1, $e2) = R::dispense('employee', 2); list($x1, $x2) = R::dispense('project', 2); $e1->name = 'Anna'; $e2->name = 'John'; $p1->project = $x1; $p1->employee = $e1; $p1->arole = 'designer'; $p2->project = $x1; $p2->employee = $e2; $p2->arole = 'coder'; R::storeAll(array($p1, $p2)); $project = R::load('project', $x1->id); $designers = $project->withCondition(' participant.arole = ? ', array('designer'))->via('participant')->sharedEmployeeList; $anna = reset($designers); asrt(count($designers), 1); asrt($anna->name, 'Anna'); $coders = $project->withCondition(' participant.arole = ? ', array('coder'))->via('participant')->sharedEmployeeList; $john = reset($coders); asrt(count($coders), 1); asrt($john->name, 'John'); }
/** * Test SQLite table rebuilding. * * @return void */ public function testRebuilder() { $toolbox = R::getToolBox(); $adapter = $toolbox->getDatabaseAdapter(); $writer = $toolbox->getWriter(); $redbean = $toolbox->getRedBean(); $pdo = $adapter->getDatabase(); $book = R::dispense('book'); $page = R::dispense('page'); $book->xownPage[] = $page; $id = R::store($book); $book = R::load('book', $id); asrt(count($book->xownPage), 1); asrt((int) R::getCell('SELECT COUNT(*) FROM page'), 1); R::trash($book); asrt((int) R::getCell('SELECT COUNT(*) FROM page'), 0); $book = R::dispense('book'); $page = R::dispense('page'); $book->xownPage[] = $page; $id = R::store($book); $book = R::load('book', $id); asrt(count($book->xownPage), 1); asrt((int) R::getCell('SELECT COUNT(*) FROM page'), 1); $book->added = 2; R::store($book); $book->added = 'added'; R::store($book); R::trash($book); asrt((int) R::getCell('SELECT COUNT(*) FROM page'), 0); }
/** * Test NULL handling, setting a property to NULL must * cause a change. * * @return void */ public function testBasicNullHandling() { // NULL can change bean $bean = R::dispense('bean'); $bean->bla = 'a'; R::store($bean); $bean = $bean->fresh(); asrt($bean->hasChanged('bla'), FALSE); $bean->bla = NULL; asrt($bean->hasChanged('bla'), TRUE); // NULL test $page = R::dispense('page'); $book = R::dispense('book'); $page->title = 'a NULL page'; $page->book = $book; $book->title = 'Why NUll is painful..'; R::store($page); $bookid = $page->book->id; unset($page->book); $id = R::store($page); $page = R::load('page', $id); $page->title = 'another title'; R::store($page); pass(); $page = R::load('page', $id); $page->title = 'another title'; $page->book_id = NULL; R::store($page); pass(); }
/** * Some basic tests. * * @return void */ public function testTags() { list($c, $d, $e, $f) = R::dispense('coffee', 4); R::tag($c, 'strong,black'); R::tag($d, 'black'); R::tag($e, 'strong,sweet'); R::tag($f, 'black,strong'); asrt(count(R::taggedAll('coffee', 'strong,sweet')), 1); asrt(count(R::taggedAll('coffee', 'strong')), 3); asrt(count(R::taggedAll('coffee', '')), 0); asrt(count(R::taggedAll('coffee', 'sweet')), 1); asrt(count(R::taggedAll('coffee', 'sweet,strong')), 1); asrt(count(R::taggedAll('coffee', 'black,strong')), 2); asrt(count(R::taggedAll('coffee', array('black', 'strong'))), 2); asrt(count(R::taggedAll('coffee', 'salty')), 0); $blog = R::dispense('blog'); $blog->title = 'testing'; $blog->blog = 'tesing'; R::store($blog); $blogpost = R::load("blog", 1); $post = R::dispense("post"); $post->message = "hello"; R::tag($post, "lousy,smart"); asrt(implode(',', R::tag($post)), "lousy,smart"); R::tag($post, "clever,smart"); $tagz = implode(',', R::tag($post)); asrt($tagz == "smart,clever" || $tagz == "clever,smart", TRUE); R::tag($blog, array("smart", "interesting")); asrt(implode(',', R::tag($blog)), "smart,interesting"); try { R::tag($blog, array("smart", "interesting", "lousy!")); pass(); } catch (RedException $e) { fail(); } asrt(implode(',', R::tag($blog)), "smart,interesting,lousy!"); R::untag($blog, array("smart", "interesting")); asrt(implode(",", R::tag($blog)), "lousy!"); asrt(R::hasTag($blog, array("lousy!")), TRUE); asrt(R::hasTag($blog, array("lousy!", "smart")), TRUE); asrt(R::hasTag($blog, array("lousy!", "smart"), TRUE), FALSE); R::tag($blog, FALSE); asrt(count(R::tag($blog)), 0); R::tag($blog, array("funny", "comic")); asrt(count(R::tag($blog)), 2); R::addTags($blog, array("halloween")); asrt(count(R::tag($blog)), 3); asrt(R::hasTag($blog, array("funny", "commic", "halloween"), TRUE), FALSE); R::unTag($blog, "funny"); R::addTags($blog, "horror"); asrt(count(R::tag($blog)), 3); asrt(R::hasTag($blog, array("horror", "commic", "halloween"), TRUE), FALSE); //no double tags R::addTags($blog, "horror"); asrt(R::hasTag($blog, array("horror", "commic", "halloween"), TRUE), FALSE); asrt(R::hasTag($blog, "horror,commic,halloween", TRUE), FALSE); asrt(count(R::tag($blog)), 3); testpack("fetch tagged items"); }
/** * Cant have underscored beans * @expectedException \RedBeanPHP\RedException */ public function testTwoWordsUnderscoredBean() { R::freeze(false); $testName = R::dispense('test_name'); $id = R::store($testName); R::load('test_name', $id); R::freeze($this->frozen); }
public function testDisableVoteIdea() { Scripts::LoginUser('*****@*****.**', 'Gates123'); $this->url('home/profile/4'); $this->byLinkText('Delete votes')->click(); $voteidea = RedBean::load('ideas', 3); $this->assertEquals($voteidea->votes, '0'); }
/** * Test UTF8 handling. * * @return void */ public function testUTF8() { $str = '𠜎ὃ𠻗𠻹𠻺𠼭𠼮𠽌𠾴𠾼𠿪𡁜'; $bean = R::dispense('bean'); $bean->bla = $str; R::store($bean); $bean = R::load('bean', $bean->id); asrt($bean->bla, $str); pass(); }
/** * Store a new record. * * @param Request $request * @return Response */ public function store(Request $request) { $item_id = $request->input('item_id'); $item = R::load('item', $item_id); $attribute = R::dispense('attribute'); $attribute->key = $request->input('key'); $attribute->value = $request->input('value'); $item->ownAttributeList[] = $attribute; R::store($item); echo "<pre>\n"; var_dump($attribute->export()); var_dump($item->export()); }
/** * Test to make sure stash cache works with recursively opening models * with FUSE. * * @return void */ public function testIssue259() { testpack('Testing Issue #259 - Stash Cache breaks model delegation in open().'); $mother = R::dispense('mother'); $mother->desc = 'I am mother'; R::store($mother); $child = R::dispense('child'); $child->mother = $mother; $child->desc = 'I am child'; $id = R::store($child); R::findOne('child', ' id = ?', array($id)); R::find('child', ' id = ? ', array($id)); R::load('child', $id); }
/** * 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'); }
/** * Test if RedBeanPHP can properly handle keywords. * * @return void */ public function testKeywords() { $keywords = array('anokeyword', 'znokeyword', 'group', 'drop', 'inner', 'join', 'select', 'table', 'int', 'cascade', 'float', 'call', 'in', 'status', 'order', 'limit', 'having', 'else', 'if', 'while', 'distinct', 'like'); foreach ($keywords as $k) { R::nuke(); $bean = R::dispense($k); $bean->{$k} = $k; $id = R::store($bean); $bean = R::load($k, $id); $bean2 = R::dispense('other'); $bean2->name = $k; $bean->bean = $bean2; $bean->ownBean[] = $bean2; $bean->sharedBean[] = $bean2; $id = R::store($bean); R::trash($bean); pass(); } }
/** * Test BIG INT primary key support. * * @return void */ public function testBigIntSupport() { R::nuke(); $createPageTableSQL = ' CREATE TABLE `page` ( id BIGINT(20) UNSIGNED NOT NULL, book_id BIGINT(20) UNSIGNED NOT NULL, magazine_id BIGINT(20) UNSIGNED NOT NULL, title VARCHAR(255), PRIMARY KEY ( id ) ) ENGINE = InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci AUTO_INCREMENT = 1223372036854775808'; $createBookTableSQL = ' CREATE TABLE `book` ( id BIGINT(20) UNSIGNED NOT NULL, title VARCHAR(255), PRIMARY KEY ( id ) ) ENGINE = InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci AUTO_INCREMENT = 2223372036854775808'; $createPagePageTableSQL = ' CREATE TABLE `page_page` ( id BIGINT(20) UNSIGNED NOT NULL, page_id BIGINT(20) UNSIGNED NOT NULL, page2_id BIGINT(20) UNSIGNED NOT NULL, PRIMARY KEY ( id ) ) ENGINE = InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci AUTO_INCREMENT = 3223372036854775808'; R::exec($createBookTableSQL); R::exec($createPageTableSQL); R::exec($createPagePageTableSQL); //insert some records $book1ID = '2223372036854775808'; $book2ID = '2223372036854775809'; $page1ID = '1223372036854775808'; $page2ID = '1223372036854775809'; $page3ID = '1223372036854775890'; $pagePage1ID = '3223372036854775808'; $insertBook1SQL = "\n\t\t\tINSERT INTO book (id, title) VALUES( '{$book1ID}', 'book 1' );\n\t\t"; $insertBook2SQL = "\n\t\t\tINSERT INTO book (id, title) VALUES( '{$book2ID}', 'book 2' );\n\t\t"; $insertPage1SQL = "\n\t\t\tINSERT INTO page (id, book_id, title, magazine_id) VALUES( '{$page1ID}', '{$book1ID}', 'page 1 of book 1', '{$book2ID}' );\n\t\t"; $insertPage2SQL = "\n\t\t\tINSERT INTO page (id, book_id, title) VALUES( '{$page2ID}', '{$book1ID}', 'page 2 of book 1' );\n\t\t"; $insertPage3SQL = "\n\t\t\tINSERT INTO page (id, book_id, title) VALUES( '{$page3ID}', '{$book2ID}', 'page 1 of book 2' );\n\t\t"; $insertPagePage1SQL = "\n\t\t\tINSERT INTO page_page (id, page_id, page2_id) VALUES( '{$pagePage1ID}', '{$page2ID}', '{$page3ID}' );\n\t\t"; R::exec($insertBook1SQL); R::exec($insertBook2SQL); R::exec($insertPage1SQL); R::exec($insertPage2SQL); R::exec($insertPage3SQL); R::exec($insertPagePage1SQL); //basic tour of basic functions.... $book1 = R::load('book', $book1ID); asrt($book1->id, $book1ID); asrt($book1->title, 'book 1'); $book2 = R::load('book', $book2ID); asrt($book2->id, $book2ID); asrt($book2->title, 'book 2'); asrt(count($book1->ownPage), 2); asrt(count($book1->fresh()->with('LIMIT 1')->ownPage), 1); asrt(count($book1->fresh()->withCondition(' title = ? ', array('page 2 of book 1'))->ownPage), 1); asrt(count($book2->ownPage), 1); asrt($book2->fresh()->countOwn('page'), 1); $page1 = R::load('page', $page1ID); asrt(count($page1->sharedPage), 0); asrt($page1->fetchAs('book')->magazine->id, $book2ID); $page2 = R::load('page', $page2ID); asrt(count($page2->sharedPage), 1); asrt($page2->fresh()->countShared('page'), 1); $page3 = R::findOne('page', ' title = ? ', array('page 1 of book 2')); asrt($page3->id, $page3ID); asrt($page3->book->id, $book2ID); }
/** * Test BIG INT primary key support. * * @return void */ public function testBigIntSupport() { R::nuke(); $createPageTableSQL = ' CREATE TABLE page ( id BIGSERIAL PRIMARY KEY, book_id BIGSERIAL, magazine_id BIGSERIAL, title VARCHAR(255) )'; $createBookTableSQL = ' CREATE TABLE book ( id BIGSERIAL PRIMARY KEY, title VARCHAR(255) )'; $createPagePageTableSQL = ' CREATE TABLE page_page ( id BIGSERIAL PRIMARY KEY, page_id BIGSERIAL, page2_id BIGSERIAL ) '; R::exec($createBookTableSQL); R::exec($createPageTableSQL); R::exec($createPagePageTableSQL); //insert some records $book1ID = '2223372036854775808'; $book2ID = '2223372036854775809'; $page1ID = '1223372036854775808'; $page2ID = '1223372036854775809'; $page3ID = '1223372036854775890'; $pagePage1ID = '3223372036854775808'; R::exec("ALTER SEQUENCE book_id_seq RESTART WITH {$book1ID}"); R::exec("ALTER SEQUENCE page_id_seq RESTART WITH {$page1ID}"); R::exec("ALTER SEQUENCE page_page_id_seq RESTART WITH {$pagePage1ID}"); $insertBook1SQL = "\n\t\t\tINSERT INTO book (title) VALUES( 'book 1' );\n\t\t"; $insertBook2SQL = "\n\t\t\tINSERT INTO book (title) VALUES( 'book 2' );\n\t\t"; $insertPage1SQL = "\n\t\t\tINSERT INTO page (id, book_id, title, magazine_id) VALUES( '{$page1ID}', '{$book1ID}', 'page 1 of book 1', '{$book2ID}' );\n\t\t"; $insertPage2SQL = "\n\t\t\tINSERT INTO page (id, book_id, title) VALUES( '{$page2ID}', '{$book1ID}', 'page 2 of book 1' );\n\t\t"; $insertPage3SQL = "\n\t\t\tINSERT INTO page (id, book_id, title) VALUES( '{$page3ID}', '{$book2ID}', 'page 1 of book 2' );\n\t\t"; $insertPagePage1SQL = "\n\t\t\tINSERT INTO page_page (id, page_id, page2_id) VALUES( '{$pagePage1ID}', '{$page2ID}', '{$page3ID}' );\n\t\t"; R::exec($insertBook1SQL); R::exec($insertBook2SQL); R::exec($insertPage1SQL); R::exec($insertPage2SQL); R::exec($insertPage3SQL); R::exec($insertPagePage1SQL); //basic tour of basic functions.... $book1 = R::load('book', $book1ID); asrt($book1->id, $book1ID); asrt($book1->title, 'book 1'); $book2 = R::load('book', $book2ID); asrt($book2->id, $book2ID); asrt($book2->title, 'book 2'); asrt(count($book1->ownPage), 2); asrt(count($book1->fresh()->with('LIMIT 1')->ownPage), 1); asrt(count($book1->fresh()->withCondition(' title = ? ', array('page 2 of book 1'))->ownPage), 1); asrt(count($book2->ownPage), 1); asrt($book2->fresh()->countOwn('page'), 1); $page1 = R::load('page', $page1ID); asrt(count($page1->sharedPage), 0); asrt($page1->fetchAs('book')->magazine->id, $book2ID); $page2 = R::load('page', $page2ID); asrt(count($page2->sharedPage), 1); asrt($page2->fresh()->countShared('page'), 1); $page3 = R::findOne('page', ' title = ? ', array('page 1 of book 2')); asrt($page3->id, $page3ID); asrt($page3->book->id, $book2ID); }
/** * Test types of strings. * * @return void */ public function testTypesStrings() { $bean = R::dispense('bean'); $bean->data = 'abcdefghijk'; R::store($bean); $cols = R::getColumns('bean'); asrt($cols['data'], 'text'); $bean = R::load('bean', $bean->id); asrt($bean->data, 'abcdefghijk'); $bean->data = '(1,2)'; R::store($bean); $cols = R::getColumns('bean'); asrt($cols['data'], 'text'); $bean->data = '[(1.2,1.4),(2.2,34)]'; R::store($bean); $cols = R::getColumns('bean'); asrt($cols['data'], 'text'); $bean->data = '<(9.2,1.2),7.9>'; R::store($bean); $cols = R::getColumns('bean'); asrt($cols['data'], 'text'); $bean->data = '$25'; R::store($bean); $cols = R::getColumns('bean'); asrt($cols['data'], 'text'); $bean->data = '2012-10-10 10:00:00'; R::store($bean); $cols = R::getColumns('bean'); asrt($cols['data'], 'text'); }
/** * Test explicit flush. * * @return void */ public function testExplicitCacheFlush() { testpack('Test cache flush (explicit)'); R::debug(true, 1); $logger = R::getDatabaseAdapter()->getDatabase()->getLogger(); $bean = R::dispense('bean'); $bean->title = 'abc'; $id1 = R::store($bean); $logger->clear(); $bean = R::load('bean', $id1); asrt($bean->title, 'abc'); asrt(count($logger->grep('SELECT *')), 1); $bean = R::load('bean', $id1); asrt(count($logger->grep('SELECT *')), 1); R::getWriter()->flushCache(); $bean = R::load('bean', $id1); asrt(count($logger->grep('SELECT *')), 2); R::getWriter()->flushCache(); R::getWriter()->setUseCache(FALSE); }
/** * Test traversal with aliases. * * @return void */ public function testTraversalWithAlias() { R::nuke(); $book = R::dispense('book'); $cats = R::dispense('category', 3); $cats[0]->gname = 'SF'; $cats[1]->gname = 'Fantasy'; $cats[2]->gname = 'Horror'; $book->genre = $cats[0]; $book->name = 'Space Story'; $cats[0]->genre = $cats[1]; $cats[2]->genre = $cats[1]; R::store($book); $book2 = R::dispense('book'); $book2->genre = $cats[2]; $book2->name = 'Ghost Story'; R::store($book2); $fantasy = R::load('category', $cats[1]->id); $cats = array(); $book = $book->fresh(); $book->fetchAs('category')->traverse('genre', function ($cat) use(&$cats) { $cats[] = $cat->gname; }); asrt(implode(',', $cats), 'SF,Fantasy'); $catList = array(); $fantasy->alias('genre')->with(' ORDER BY gname ASC ')->traverse('ownCategory', function ($cat) use(&$catList) { $catList[] = $cat->gname; }); asrt(implode(',', $catList), 'Horror,SF'); }
/** * Test prettier tables using via(). */ public function testViaPrettification() { R::nuke(); R::renameAssociation('tbl_author_tbl_friend', 'tbl_author_friend'); $author = R::xdispense(AUTHOR); $author->name = 'Mr. Quill'; $friend = R::xdispense(FRIEND); $friend->name = 'Muse'; $author->{FRIENDLIST}[] = $friend; $id = R::store($author); //print_r(R::inspect()); exit; $author = R::load(AUTHOR, $id); $tables = array_flip(R::inspect()); asrt(isset($tables['tbl_author_friend']), TRUE); asrt(isset($tables['tbl_author_tbl_friend']), FALSE); asrt(count($author->{FRIENDLIST}), 1); AQueryWriter::clearRenames(); }
public function testDisableBanUser() { Scripts::LoginAdmin(); $this->byLinkText('Users Management')->click(); $this->byLinkText('Banned List ')->click(); $this->byLinkText('Disable ban')->click(); $passdisbann = RedBean::load('users', 3); $this->assertEquals($passdisbann->banned, '0'); }
/** * Test common Facade usage scenarios. * * @return void */ public function testCommonUsageFacade() { $toolbox = R::getToolBox(); $adapter = $toolbox->getDatabaseAdapter(); $writer = $toolbox->getWriter(); $redbean = $toolbox->getRedBean(); $pdo = $adapter->getDatabase(); $a = new AssociationManager($toolbox); asrt(R::getRedBean() instanceof OODB, TRUE); asrt(R::getToolBox() instanceof ToolBox, TRUE); asrt(R::getDatabaseAdapter() instanceof Adapter, TRUE); asrt(R::getWriter() instanceof QueryWriter, TRUE); $book = R::dispense("book"); asrt($book instanceof OODBBean, TRUE); $book->title = "a nice book"; $id = R::store($book); asrt($id > 0, TRUE); $book = R::load("book", (int) $id); asrt($book->title, "a nice book"); asrt(R::load('book', 999)->title, NULL); R::freeze(TRUE); try { R::load('bookies', 999); fail(); } catch (\Exception $e) { pass(); } R::freeze(FALSE); $author = R::dispense("author"); $author->name = "me"; R::store($author); $book9 = R::dispense("book"); $author9 = R::dispense("author"); $author9->name = "mr Nine"; $a9 = R::store($author9); $book9->author_id = $a9; $bk9 = R::store($book9); $book9 = R::load("book", $bk9); $author = R::load("author", $book9->author_id); asrt($author->name, "mr Nine"); R::trash($author); R::trash($book9); pass(); $book2 = R::dispense("book"); $book2->title = "second"; R::store($book2); $book3 = R::dispense("book"); $book3->title = "third"; R::store($book3); asrt(count(R::find("book")), 3); asrt(count(R::findAll("book")), 3); asrt(count(R::findAll("book", " LIMIT 2")), 2); asrt(count(R::find("book", " id=id ")), 3); asrt(count(R::find("book", " title LIKE ?", array("third"))), 1); asrt(count(R::find("book", " title LIKE ?", array("%d%"))), 2); // Find without where clause asrt(count(R::findAll('book', ' order by id')), 3); R::trash($book3); R::trash($book2); asrt(count(R::getAll("SELECT * FROM book ")), 1); asrt(count(R::getCol("SELECT title FROM book ")), 1); asrt((int) R::getCell("SELECT 123 "), 123); $book = R::dispense("book"); $book->title = "not so original title"; $author = R::dispense("author"); $author->name = "Bobby"; R::store($book); $aid = R::store($author); $author = R::findOne("author", " name = ? ", array("Bobby")); }
/** * Test ENUM functionality offered by Label Maker. * * @return void */ public function testENUM() { testpack('test ENUM'); $coffee = R::dispense('coffee'); $coffee->taste = R::enum('flavour:mocca'); //did we create an enum? asrt(implode('', R::gatherLabels(R::enum('flavour'))), 'MOCCA'); R::store($coffee); $coffee = $coffee->fresh(); //test enum identity check - with alias asrt($coffee->fetchAs('flavour')->taste->equals(R::enum('flavour:mocca')), TRUE); asrt($coffee->fetchAs('flavour')->taste->equals(R::enum('flavour:banana')), FALSE); //now we have two flavours asrt(R::count('flavour'), 2); asrt(implode(',', R::gatherLabels(R::enum('flavour'))), 'BANANA,MOCCA'); $coffee->flavour = R::enum('flavour:mocca'); R::store($coffee); //same results, can we have multiple flavours? asrt($coffee->fetchAs('flavour')->taste->equals(R::enum('flavour:mocca')), TRUE); asrt($coffee->fetchAs('flavour')->taste->equals(R::enum('flavour:banana')), FALSE); asrt($coffee->flavour->equals(R::enum('flavour:mocca')), TRUE); //no additional mocca enum... asrt(R::count('flavour'), 2); $drink = R::dispense('drink'); $drink->flavour = R::enum('flavour:choco'); R::store($drink); //now we have three! asrt(R::count('flavour'), 3); $drink = R::load('drink', $drink->id); asrt($drink->flavour->equals(R::enum('flavour:mint')), FALSE); asrt($drink->flavour->equals(R::enum('flavour:choco')), TRUE); asrt(R::count('flavour'), 4); //trash should not affect flavour! R::trash($drink); asrt(R::count('flavour'), 4); }
/** * ExportAll. * * @return void */ public function testExportAll() { testpack('Test exportAll'); $redbean = R::getRedBean(); $bean = new OODBBean(); $bean->import(array("a" => 1, "b" => 2)); $bean->setMeta("justametaproperty", "hellothere"); $arr = $bean->export(); asrt(is_array($arr), TRUE); asrt(isset($arr["a"]), TRUE); asrt(isset($arr["b"]), TRUE); asrt($arr["a"], 1); asrt($arr["b"], 2); asrt(isset($arr["__info"]), FALSE); $arr = $bean->export(TRUE); asrt(isset($arr["__info"]), TRUE); asrt($arr["a"], 1); asrt($arr["b"], 2); $exportBean = $redbean->dispense("abean"); $exportBean->setMeta("metaitem.bla", 1); $exportedBean = $exportBean->export(TRUE); asrt($exportedBean["__info"]["metaitem.bla"], 1); asrt($exportedBean["__info"]["type"], "abean"); // Can we determine whether a bean is empty? testpack('test $bean->isEmpty() function'); $bean = R::dispense('bean'); asrt($bean->isEmpty(), TRUE); asrt(count($bean) > 0, TRUE); $bean->property = 1; asrt($bean->isEmpty(), FALSE); asrt(count($bean) > 0, TRUE); $bean->property = 0; asrt($bean->isEmpty(), TRUE); asrt(count($bean) > 0, TRUE); $bean->property = FALSE; asrt($bean->isEmpty(), TRUE); asrt(count($bean) > 0, TRUE); $bean->property = NULL; asrt($bean->isEmpty(), TRUE); asrt(count($bean) > 0, TRUE); unset($bean->property); asrt($bean->isEmpty(), TRUE); asrt(count($bean) > 0, TRUE); // Export bug I found $bandmember = R::dispense('bandmember'); $bandmember->name = 'Duke'; $instrument = R::dispense('instrument'); $instrument->name = 'Piano'; $bandmember->ownInstrument[] = $instrument; $a = R::exportAll($bandmember); pass(); asrt(isset($a[0]), TRUE); asrt((int) $a[0]['id'], 0); asrt($a[0]['name'], 'Duke'); asrt($a[0]['ownInstrument'][0]['name'], 'Piano'); R::nuke(); $v = R::dispense('village'); $b = R::dispense('building'); $v->name = 'a'; $b->name = 'b'; $v->ownBuilding[] = $b; $id = R::store($v); $a = R::exportAll($v); asrt($a[0]['name'], 'a'); asrt($a[0]['ownBuilding'][0]['name'], 'b'); $v = R::load('village', $id); $b2 = R::dispense('building'); $b2->name = 'c'; $v->ownBuilding[] = $b2; $a = R::exportAll($v); asrt($a[0]['name'], 'a'); asrt($a[0]['ownBuilding'][0]['name'], 'b'); asrt(count($a[0]['ownBuilding']), 2); list($r1, $r2) = R::dispense('army', 2); $r1->name = '1'; $r2->name = '2'; $v->sharedArmy[] = $r2; $a = R::exportAll($v); asrt(count($a[0]['sharedArmy']), 1); R::store($v); $v = R::load('village', $id); $a = R::exportAll($v); asrt(count($a[0]['sharedArmy']), 1); asrt($a[0]['name'], 'a'); asrt($a[0]['ownBuilding'][0]['name'], 'b'); asrt(count($a[0]['ownBuilding']), 2); $v->sharedArmy[] = $r1; $a = R::exportAll($v); asrt(count($a[0]['sharedArmy']), 2); $v = R::load('village', $id); $a = R::exportAll($v); asrt(count($a[0]['sharedArmy']), 1); $v->sharedArmy[] = $r1; R::store($v); $v = R::load('village', $id); $a = R::exportAll($v); asrt(count($a[0]['sharedArmy']), 2); }
/** * All kinds of tests for basic CRUD. * * Does the data survive? * * @return void */ public function testUpdatingBeans() { testpack('Test basic support UUID/override ID default value'); $bean = R::dispense('bean'); R::store($bean); if ($this->currentlyActiveDriverID === 'mysql') { //otherwise UTF8 causes index overflow in mysql: SQLSTATE[42000]: Syntax error or access violation: 1071 Specified key was too long; max key length is 767 bytes R::exec('alter table bean modify column id char(3);'); } else { R::getWriter()->widenColumn('bean', 'id', R::getWriter()->scanType('abc')); } $bean->id = 'abc'; R::store($bean); asrt($bean->id, 'abc'); testpack('Test Update'); try { R::store(array()); fail(); } catch (RedException $e) { pass(); } $toolbox = R::getToolBox(); $adapter = $toolbox->getDatabaseAdapter(); $writer = $toolbox->getWriter(); $redbean = $toolbox->getRedBean(); $pdo = $adapter->getDatabase(); $page = $redbean->dispense("page"); $page->name = "old name"; $id = $redbean->store($page); asrt($page->getMeta('tainted'), FALSE); $page->setAttr('name', "new name"); asrt($page->getMeta('tainted'), TRUE); $id = $redbean->store($page); $page = $redbean->load("page", $id); asrt($page->name, "new name"); // Null should == NULL after saving $page->rating = NULL; $newid = $redbean->store($page); $page = $redbean->load("page", $id); asrt($page->name, "new name"); asrt($page->rating === NULL, TRUE); asrt(!$page->rating, TRUE); $page->rating = FALSE; $newid = $redbean->store($page); asrt($newid, $id); $page = $redbean->load("page", $id); asrt($page->name, "new name"); asrt((bool) $page->rating, FALSE); asrt($page->rating == FALSE, TRUE); asrt(!$page->rating, TRUE); $page->rating = TRUE; $newid = $redbean->store($page); asrt($newid, $id); $page = $redbean->load("page", $id); asrt($page->name, "new name"); asrt((bool) $page->rating, TRUE); asrt($page->rating == TRUE, TRUE); asrt($page->rating == TRUE, TRUE); $page->rating = NULL; R::store($page); $page = R::load('page', $page->id); asrt($page->rating, NULL); $page->rating = "1"; $newid = $redbean->store($page); asrt($newid, $id); $page = $redbean->load("page", $id); asrt($page->name, "new name"); asrt($page->rating, "1"); $page->rating = "0"; $newid = $redbean->store($page); asrt($page->rating, "0"); $page->rating = 0; $newid = $redbean->store($page); asrt($page->rating, 0); $page->rating = "0"; $newid = $redbean->store($page); asrt($newid, $id); $page = $redbean->load("page", $id); asrt($page->name, "new name"); asrt(!$page->rating, TRUE); asrt($page->rating == 0, TRUE); asrt($page->rating == FALSE, TRUE); $page->rating = 5; $newid = $redbean->store($page); asrt($newid, $id); $page = $redbean->load("page", $id); asrt($page->name, "new name"); asrt(strval($page->rating), "5"); $page->rating = 300; $newid = $redbean->store($page); asrt($newid, $id); $page = $redbean->load("page", $id); asrt($page->name, "new name"); asrt(strval($page->rating), "300"); $page->rating = -2; $newid = $redbean->store($page); asrt($newid, $id); $page = $redbean->load("page", $id); asrt($page->name, "new name"); asrt(strval($page->rating), "-2"); $page->rating = 2.5; $newid = $redbean->store($page); asrt($newid, $id); $page = $redbean->load("page", $id); asrt($page->name, "new name"); asrt($page->rating == 2.5, TRUE); $page->rating = -3.3; $newid = $redbean->store($page); asrt($newid, $id); $page = $redbean->load("page", $id); asrt($page->name, "new name"); asrt($page->rating == -3.3, TRUE); $page->rating = "good"; $newid = $redbean->store($page); asrt($newid, $id); $page = $redbean->load("page", $id); asrt($page->name, "new name"); asrt($page->rating, "good"); $longtext = str_repeat('great! because..', 100); $page->rating = $longtext; $newid = $redbean->store($page); asrt($newid, $id); $page = $redbean->load("page", $id); asrt($page->name, "new name"); asrt($page->rating, $longtext); // Test leading zeros $numAsString = "0001"; $page->numasstring = $numAsString; $redbean->store($page); $page = $redbean->load("page", $id); asrt($page->numasstring, "0001"); $page->numnotstring = "0.123"; $redbean->store($page); $page = $redbean->load("page", $id); asrt($page->numnotstring == 0.123, TRUE); $page->numasstring2 = "00.123"; $redbean->store($page); $page = $redbean->load("page", $id); asrt($page->numasstring2, "00.123"); try { $redbean->trash(array()); fail(); } catch (RedException $e) { pass(); } $redbean->trash($page); asrt((int) $pdo->GetCell("SELECT count(*) FROM page"), 0); }
function updatePackageCost($id, $cost, $label) { $packageCost = R::load('packagecost', $id); $packageCost->cost = $cost; $packageCost->label = $label; R::store($packageCost); return json_encode(R::exportAll($packageCost)); }
public function testDeclinedIdea() { Scripts::ApproveIdea(); $this->url('/home/idea/1/Relativity-Theory'); $this->select($this->byName('Changestatusbutton'))->selectOptionByValue('Declined'); $declinedidea = RedBean::load('ideas', 2); $this->assertEquals($declinedidea->status, 'Declined'); $this->byName('deleteidea')->click(); $this->assertNotContains('Relativity Theory', $this->byTag('body')->text()); //la unica manera que podia demostrar que se habia echo lo queria }
/** * Tests whether aliasing plays nice with beautification. * * @return void */ public function testAliasWithBeautify() { /** * Ensure that aliased column aren't beautified */ $points = R::dispense('point', 2); $line = R::dispense('line'); $line->pointA = $points[0]; $line->pointB = $points[1]; R::store($line); $line2 = R::dispense('line'); $line2->pointA = $line->fetchAs('point')->pointA; $line2->pointB = R::dispense('point'); R::store($line2); //now we have two points per line (1-to-x) //I want to know which lines cross A: $a = R::load('point', $line->pointA->id); //reload A $lines = $a->alias('pointA')->ownLine; asrt(count($lines), 2); }
/** * More variations... * * @return void */ public function testEmbeddedSQLPart2() { list($book1, $book2, $book3) = R::dispense('book', 3); $book1->position = 1; $book2->position = 2; $book3->position = 3; $shelf = R::dispense('shelf'); $shelf->ownBook = array($book1, $book2, $book3); $id = R::store($shelf); $shelf = R::load('shelf', $id); $books = $shelf->with(' ORDER BY position ASC ')->ownBook; $book1 = array_shift($books); asrt((int) $book1->position, 1); $book2 = array_shift($books); asrt((int) $book2->position, 2); $book3 = array_shift($books); asrt((int) $book3->position, 3); $books = $shelf->with(' ORDER BY position DESC ')->ownBook; $book1 = array_shift($books); asrt((int) $book1->position, 3); $book2 = array_shift($books); asrt((int) $book2->position, 2); $book3 = array_shift($books); asrt((int) $book3->position, 1); //R::debug(1); $shelf = R::load('shelf', $id); $books = $shelf->with(' AND position > 2 ')->ownBook; asrt(count($books), 1); $shelf = R::load('shelf', $id); $books = $shelf->with(' AND position < ? ', array(3))->ownBook; asrt(count($books), 2); $shelf = R::load('shelf', $id); $books = $shelf->with(' AND position = 1 ')->ownBook; asrt(count($books), 1); $shelf = R::load('shelf', $id); $books = $shelf->withCondition(' position > -1 ')->ownBook; asrt(count($books), 3); // With-condition should not affect storing $shelf = R::load('shelf', $id); $books = $shelf->with(' AND position = 1 ')->ownBook; asrt(count($books), 1); asrt(count($shelf->ownBook), 1); $book = reset($shelf->ownBook); $book->title = 'Trees and other Poems'; R::store($shelf); $books = $shelf->withCondition(' position > -1 ')->ownBook; asrt(count($books), 3); asrt(count($shelf->ownBook), 3); $shelf = R::load('shelf', $id); $books = $shelf->with(' AND position = 1 ')->ownBook; // Also with trashing -- just trash one! $shelf->ownBook = array(); R::store($shelf); $books = $shelf->withCondition(' position > -1 ')->ownBook; asrt(count($books), 2); // With should cause a reload of a list $shelf = R::load('shelf', $id); $books = $shelf->with(' AND position = 2 ')->ownBook; asrt(count($books), 1); $books = $shelf->withCondition(' position > -1 ')->ownBook; asrt(count($books), 2); $book = reset($books); $book->title = 'Venetian Music'; // Should not affect storage (fact that we used with twice, unsetting prop) R::store($shelf); $shelf = R::load('shelf', $id); asrt(count($shelf->ownBook), 2); // Alias list($game1, $game2, $game3) = R::dispense('game', 3); list($t1, $t2, $t3) = R::dispense('team', 3); $t1->name = 'Bats'; $t2->name = 'Tigers'; $t3->name = 'Eagles'; $game1->name = 'a'; $game1->team1 = $t1; $game1->team2 = $t2; $game2->name = 'b'; $game2->team1 = $t1; $game2->team2 = $t3; $game3->name = 'c'; $game3->team1 = $t2; $game3->team2 = $t3; R::storeAll(array($game1, $game2, $game3)); $team1 = R::load('team', $t1->id); $team2 = R::load('team', $t2->id); $team3 = R::load('team', $t3->id); asrt(count($team1->alias('team1')->ownGame), 2); asrt(count($team2->alias('team1')->ownGame), 1); $team1 = R::load('team', $t1->id); $team2 = R::load('team', $t2->id); asrt(count($team1->alias('team2')->ownGame), 0); asrt(count($team2->alias('team2')->ownGame), 1); asrt(count($team3->alias('team1')->ownGame), 0); $team3 = R::load('team', $t3->id); asrt(count($team3->alias('team2')->ownGame), 2); $team1 = R::load('team', $t1->id); $games = $team1->alias('team1')->ownGame; $game4 = R::dispense('game'); $game4->name = 'd'; $game4->team2 = $t3; $team1->alias('team1')->ownGame[] = $game4; R::store($team1); $team1 = R::load('team', $t1->id); asrt(count($team1->alias('team1')->ownGame), 3); foreach ($team1->ownGame as $g) { if ($g->name == 'a') { $game = $g; } } $game->name = 'match'; R::store($team1); $team1 = R::load('team', $t1->id); asrt(count($team1->alias('team1')->ownGame), 3); $found = 0; foreach ($team1->ownGame as $g) { if ($g->name == 'match') { $found = 1; } } if ($found) { pass(); } $team1->ownGame = array(); R::store($team1); $team1 = R::load('team', $t1->id); asrt(count($team1->alias('team1')->ownGame), 0); $team1->ownBook[] = $book1; R::store($team1); $team1 = R::load('team', $t1->id); asrt(count($team1->alias('team1')->ownGame), 0); asrt(count($team1->ownBook), 1); }
/** * 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); }