www.aleph1.co.uk Git - yaffs-website/blob - vendor/gabordemooij/redbean/testing/RedUNIT/Base/Copy.php

   1 <?php
   2
   3 namespace RedUNIT\Base;
   4
   5 use RedUNIT\Base as Base;
   6 use RedBeanPHP\Facade as R;
   7 use RedBeanPHP\OODBBean as OODBBean;
   8
   9 /**
  10  * Copy
  11  *
  12  * Tests whether we can make a copy or a deep copy of a bean
  13  * and whether recursion is handled well. Also tests
  14  * versioning: copying can be used to implement a versioning feature,
  15  * some test cases will reflect this particular use case.
  16  *
  17  * @file    RedUNIT/Base/Copy.php
  18  * @desc    Tests whether we can make a deep copy of a bean.
  19  * @author  Gabor de Mooij and the RedBeanPHP Community
  20  * @license New BSD/GPLv2
  21  *
  22  * (c) G.J.G.T. (Gabor) de Mooij and the RedBeanPHP Community.
  23  * This source file is subject to the New BSD/GPLv2 License that is bundled
  24  * with this source code in the file license.txt.
  25  */
  26 class Copy extends Base
  27 {
  28         /**
  29          * Test whether recursion happens
  30          */
  31         public function testCopyRecursion()
  32         {
  33                 $document = R::dispense( 'document' );
  34                 $id = R::store( $document );
  35                 $document->ownDocument[] = $document;
  36                 R::store( $document );
  37                 $duplicate = R::dup( $document );
  38                 pass(); //if RB cant handle this is will crash (nesting level error from PHP).
  39                 $id2 = R::store( $duplicate );
  40                 $duplicate = R::load( 'document', $id );
  41                 asrt( (int) $document->document_id, $id );
  42                 asrt( (int) $duplicate->document_id, $id2 );
  43                 // Export variant
  44                 $duplicate = R::exportAll( $document );
  45                 asrt( (int) $duplicate[0]['document_id'], $id );
  46         }
  47
  48         /**
  49          * Test real world scenario: Versioning
  50          */
  51         public function testVersioning()
  52         {
  53                 $document = R::dispense( 'document' );
  54                 $page = R::dispense( 'page' );
  55                 $document->title = 'test';
  56                 $page->content = 'lorem ipsum';
  57                 $user = R::dispense( 'user' );
  58                 $user->name = 'Leo';
  59                 $document->sharedUser[] = $user;
  60                 $document->ownPage[]    = $page;
  61                 $document->starship_id = 3;
  62                 $document->planet      = R::dispense( 'planet' );
  63                 R::store( $document );
  64                 $duplicate = R::dup( $document );
  65                 R::store( $duplicate );
  66                 $duplicate = R::dup( $document );
  67                 R::store( $duplicate );
  68                 asrt( R::count( 'planet' ), 1 );
  69                 asrt( R::count( 'user' ), 1 );
  70                 asrt( R::count( 'document' ), 3 );
  71                 asrt( R::count( 'page' ), 3 );
  72                 asrt( R::count( 'spaceship' ), 0 );
  73         }
  74
  75         /**
  76          * Same as above but now with intermediate save, counts must be same
  77          */
  78         public function testVersioningIntermediateSaves()
  79         {
  80                 $document = R::dispense( 'document' );
  81                 $page = R::dispense( 'page' );
  82                 $document->title = 'test';
  83                 $page->content = 'lorem ipsum';
  84                 $user = R::dispense( 'user' );
  85                 $user->name = 'Leo';
  86                 $document->sharedUser[] = $user;
  87                 $document->ownPage[]    = $page;
  88                 $document->starship_id = 3;
  89                 $document->planet = R::dispense( 'planet' );
  90                 R::store( $document );
  91                 $duplicate = R::dup( $document );
  92                 R::store( $document );
  93                 R::store( $duplicate );
  94                 R::store( $document );
  95                 $duplicate = R::dup( $document );
  96                 R::store( $document );
  97                 R::store( $duplicate );
  98                 asrt( R::count( 'planet' ), 1 );
  99                 asrt( R::count( 'user' ), 1 );
 100                 asrt( R::count( 'document' ), 3 );
 101                 asrt( R::count( 'page' ), 3 );
 102                 asrt( R::count( 'spaceship' ), 0 );
 103                 // same, but now with intermediate save, counts must be same
 104                 R::freeze( TRUE );
 105                 $document = R::dispense( 'document' );
 106                 $page     = R::dispense( 'page' );
 107                 $document->title = 'test';
 108                 $page->content = 'lorem ipsum';
 109                 $user = R::dispense( 'user' );
 110                 $user->name = 'Leo';
 111                 $document->sharedUser[] = $user;
 112                 $document->ownPage[]    = $page;
 113                 $document->starship_id = 3;
 114                 $document->planet      = R::dispense( 'planet' );
 115                 R::store( $document );
 116                 $duplicate = R::dup( $document );
 117                 R::store( $document );
 118                 R::store( $duplicate );
 119                 R::store( $document );
 120                 $duplicate = R::dup( $document );
 121                 R::store( $document );
 122                 R::store( $duplicate );
 123                 asrt( R::count( 'planet' ), 2 );
 124                 asrt( R::count( 'user' ), 2 );
 125                 asrt( R::count( 'document' ), 6 );
 126                 asrt( R::count( 'page' ), 6 );
 127                 asrt( R::count( 'spaceship' ), 0 );
 128                 R::freeze( FALSE );
 129         }
 130
 131         /**
 132          * Test Recursion
 133          */
 134         public function testRecursion()
 135         {
 136                 list( $d1, $d2 ) = R::dispense( 'document', 2 );
 137                 $page = R::dispense( 'page' );
 138                 list( $p1, $p2 ) = R::dispense( 'paragraph', 2 );
 139                 list( $e1, $e2 ) = R::dispense( 'excerpt', 2 );
 140                 $id2 = R::store( $d2 );
 141                 $p1->name = 'a';
 142                 $p2->name = 'b';
 143                 $page->title = 'my page';
 144                 $page->ownParagraph = array( $p1, $p2 );
 145                 $p1->ownExcerpt[]  = $e1;
 146                 $p2->ownExcerpt[]  = $e2;
 147                 $e1->ownDocument[] = $d2;
 148                 $e2->ownDocument[] = $d1;
 149                 $d1->ownPage[]     = $page;
 150                 $id1 = R::store( $d1 );
 151                 $d1 = R::load( 'document', $id1 );
 152                 $d = R::dup( $d1 );
 153                 $ids = array();
 154                 asrt( ( $d instanceof OODBBean ), TRUE );
 155                 asrt( count( $d->ownPage ), 1 );
 156                 foreach ( end( $d->ownPage )->ownParagraph as $p ) {
 157                         foreach ( $p->ownExcerpt as $e ) {
 158                                 $ids[] = end( $e->ownDocument )->id;
 159                         }
 160                 }
 161                 sort( $ids );
 162                 asrt( (int) $ids[0], 0 );
 163                 asrt( (int) $ids[1], $id1 );
 164                 R::store( $d );
 165                 pass();
 166                 $phillies = R::dispense( 'diner' );
 167                 list( $lonelyman, $man, $woman ) = R::dispense( 'guest', 3 );
 168                 $attendant = R::dispense( 'employee' );
 169                 $lonelyman->name = 'Bennie Moten';
 170                 $man->name       = 'Daddy Stovepipe';
 171                 $woman->name     = 'Mississippi Sarah';
 172                 $attendant->name = 'Gus Cannon';
 173                 $phillies->sharedGuest = array( $lonelyman, $man, $woman );
 174                 $phillies->ownEmployee[] = $attendant;
 175                 $props = R::dispense( 'prop', 2 );
 176                 $props[0]->kind = 'cigarette';
 177                 $props[1]->kind = 'coffee';
 178                 $thought = R::dispense( 'thought' );
 179                 $thought->content = 'Blues';
 180                 $thought2 = R::dispense( 'thought' );
 181                 $thought2->content = 'Jazz';
 182                 $woman->ownProp[]  = $props[0];
 183                 $man->sharedProp[] = $props[1];
 184                 $attendant->ownThought = array( $thought, $thought2 );
 185                 R::store( $phillies );
 186                 $diner  = R::findOne( 'diner' );
 187                 $diner2 = R::dup( $diner );
 188                 $id2    = R::store( $diner2 );
 189                 $diner2 = R::load( 'diner', $id2 );
 190                 asrt( count( $diner->ownEmployee ), 1 );
 191                 asrt( count( $diner2->ownEmployee ), 1 );
 192                 asrt( count( $diner->sharedGuest ), 3 );
 193                 asrt( count( $diner2->sharedGuest ), 3 );
 194                 $employee = reset( $diner->ownEmployee );
 195                 asrt( count( $employee->ownThought ), 2 );
 196                 $employee = reset( $diner2->ownEmployee );
 197                 asrt( count( $employee->ownThought ), 2 );
 198                 // Can we change something in the duplicate without changing the original?
 199                 $employee->name = 'Marvin';
 200                 $thought = R::dispense( 'thought' );
 201                 $thought->content = 'depression';
 202                 $employee->ownThought[] = $thought;
 203                 array_pop( $diner2->sharedGuest );
 204                 $guest       = reset( $diner2->sharedGuest );
 205                 $guest->name = 'Arthur Dent';
 206                 $id2         = R::store( $diner2 );
 207                 $diner2      = R::load( 'diner', $id2 );
 208                 asrt( count( $diner->ownEmployee ), 1 );
 209                 asrt( count( $diner2->ownEmployee ), 1 );
 210                 asrt( count( $diner->sharedGuest ), 3 );
 211                 asrt( count( $diner2->sharedGuest ), 2 );
 212                 $employeeOld = reset( $diner->ownEmployee );
 213                 asrt( count( $employeeOld->ownThought ), 2 );
 214                 $employee = reset( $diner2->ownEmployee );
 215                 asrt( count( $employee->ownThought ), 3 );
 216                 asrt( $employee->name, 'Marvin' );
 217                 asrt( $employeeOld->name, 'Gus Cannon' );
 218                 // However the shared beans must not be copied
 219                 asrt( R::count( 'guest' ), 3 );
 220                 asrt( R::count( 'guest_prop' ), 1 );
 221                 $arthur = R::findOne( 'guest', ' ' . R::getWriter()->esc( 'name' ) . ' = ? ', array( 'Arthur Dent' ) );
 222                 asrt( $arthur->name, 'Arthur Dent' );
 223         }
 224 }