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

   1 <?php
   2
   3 namespace RedUNIT\Base;
   4
   5 use RedUNIT\Base as Base;
   6 use RedBeanPHP\Facade as R;
   7 use RedBeanPHP\ToolBox as ToolBox;
   8 use RedBeanPHP\AssociationManager as AssociationManager;
   9 use RedBeanPHP\RedException\SQL as SQL;
  10 use RedBeanPHP\QueryWriter\AQueryWriter as AQueryWriter;
  11
  12 /**
  13  * Via
  14  *
  15  * Tests the via() function to hop over an N-M table to
  16  * obtain a indirectly related bean, i.e. given person, participant
  17  * and project you should be able to obtain a the project associated
  18  * with a certain person via() the participant entity.
  19  *
  20  * @file    RedUNIT/Base/Via.php
  21  * @desc    Via tests
  22  * @author  Gabor de Mooij and the RedBeanPHP Community
  23  * @license New BSD/GPLv2
  24  *
  25  * (c) G.J.G.T. (Gabor) de Mooij and the RedBeanPHP Community.
  26  * This source file is subject to the New BSD/GPLv2 License that is bundled
  27  * with this source code in the file license.txt.
  28  */
  29 class Via extends Base
  30 {
  31         /**
  32          * Tests fix for issue #378.
  33          * Via property does not get cleared properly.
  34          *
  35          * @return void
  36          */
  37         public function testIssue378()
  38         {
  39                 R::nuke();
  40                 $mediaBean = R::dispense('media');
  41                 $fooPerson = R::dispense('person');
  42                 $mediaBean->sharedPersonList[] = $fooPerson;
  43                 R::store($mediaBean);
  44                 asrt( count( $mediaBean->sharedPersonList ), 1 );
  45                 $person = R::findOne('person');
  46                 $person->via('relation')->sharedMarriageList[] = R::dispense('marriage');
  47                 //this second one caused the via property to not get cleared
  48                 $person->via('relation')->sharedMarriageList;
  49                 asrt( count( $person->sharedMediaList ), 1 );
  50                 //also found this scenario, non-existing property
  51                 $book = R::dispense('book');
  52                 $book->sharedPage[] = R::dispense('page');
  53                 R::store($book);
  54                 $book = $book->fresh();
  55                 $book->via('garbage')->nothing;
  56                 asrt( count( $book->sharedPageList ), 1 );
  57                 //yet another
  58                 $book = R::dispense('magazine');
  59                 $book->ownAdList[] = R::dispense('ad');
  60                 $book->sharedPage[] = R::dispense('page');
  61                 R::store($book);
  62                 $book = $book->fresh();
  63                 $book->via('garbage')->ownAdList;
  64                 asrt( count( $book->sharedPageList ), 1 );
  65                 $book = R::dispense('folder');
  66                 $book->sharedPage[] = R::dispense('page');
  67                 R::store($book);
  68                 $book = $book->fresh();
  69                 $book->via('garbage')->sharedItemList[] = R::dispense('item');
  70                 asrt( count( $book->sharedPageList ), 1 );
  71                 $book = R::dispense('folder2');
  72                 $book->sharedPage[] = R::dispense('page');
  73                 R::store($book);
  74                 $book = $book->fresh();
  75                 $book->via('garbage')->sharedItemList[] = R::dispense('item');
  76                 $book->via('garbage')->sharedItemList[] = R::dispense('item');
  77                 asrt( count( $book->sharedPageList ), 1 );
  78                 $book = R::dispense('folder3');
  79                 $book->sharedPage[] = R::dispense('page');
  80                 R::store($book);
  81                 $book = $book->fresh();
  82                 $book->via('garbage')->item = R::dispense('item');
  83                 asrt( count( $book->sharedPageList ), 1 );
  84                 $book = R::dispense('folder3');
  85                 $book->sharedPage[] = R::dispense('page');
  86                 R::store($book);
  87                 $book = $book->fresh();
  88                 $book->via('garbage')->item = 'test';
  89                 asrt( count( $book->sharedPageList ), 1 );
  90                 //yet another
  91                 $book = R::dispense('leaflet');
  92                 $book->title = 'leaflet';
  93                 $book->sharedPage[] = R::dispense('page');
  94                 R::store($book);
  95                 $book = $book->fresh();
  96                 $book->via('garbage')->title;
  97                 asrt( count( $book->sharedPageList ), 1 );
  98                 //yet another
  99                 $book = R::dispense('paper');
 100                 $book->author = R::dispense('author');
 101                 $book->sharedPage[] = R::dispense('page');
 102                 R::store($book);
 103                 $book = $book->fresh();
 104                 $book->via('garbage')->author;
 105                 asrt( count( $book->sharedPageList ), 1 );
 106                 $book = R::dispense('paper2');
 107                 $book->sharedPage[] = R::dispense('page');
 108                 R::store($book);
 109                 $book = $book->fresh();
 110                 $book->via('garbage')->author;
 111                 asrt( count( $book->sharedPageList ), 1 );
 112                 //yet another one
 113                 $book = R::dispense('archive');
 114                 $book->sharedItem[] = R::dispense('item');
 115                 $book->sharedPage[] = R::dispense('page');
 116                 R::store($book);
 117                 $book = $book->fresh();
 118                 unset( $book->via('garbage')->sharedItem );
 119                 asrt( count( $book->sharedPageList ), 1 );
 120                 //theoretic cases
 121                 $book = R::dispense('guide');
 122                 $book->sharedItem[] = R::dispense('item');
 123                 $book->sharedPage[] = R::dispense('page');
 124                 R::store($book);
 125                 $book = $book->fresh();
 126                 $book->via('relation')->countShared('item');
 127                 $book->via('relation')->countShared('item');
 128                 asrt( count( $book->sharedPageList ), 1 );
 129                 $book = R::dispense('catalogue');
 130                 $book->sharedPage[] = R::dispense('page');
 131                 R::store($book);
 132                 $book = $book->fresh();
 133                 $book->via('relation')->countShared('item');
 134                 $book->via('relation')->countShared('item');
 135                 asrt( count( $book->sharedPageList ), 1 );
 136                 $book = R::dispense('tabloid');
 137                 $book->ownItemList[] = R::dispense('item');
 138                 $book->sharedPage[] = R::dispense('page');
 139                 R::store($book);
 140                 $book = $book->fresh();
 141                 $book->via('relation')->countOwn('item');
 142                 $book->via('relation')->countOwn('item');
 143                 asrt( count( $book->sharedPageList ), 1 );
 144                 $book = R::dispense('booklet');
 145                 $book->ownItemList[] = R::dispense('item');
 146                 $book->sharedPage[] = R::dispense('page');
 147                 R::store($book);
 148                 $book = $book->fresh();
 149                 $book->via('relation')->countOwn('item');
 150                 $book->via('relation')->countOwn('item');
 151                 asrt( count( $book->sharedPageList ), 1 );
 152                 AQueryWriter::clearRenames();
 153         }
 154
 155         /**
 156          * Via specific tests.
 157          *
 158          * @return void
 159          */
 160         public function testViaAndSQL()
 161         {
 162                 R::nuke();
 163                 list($p1, $p2) = R::dispense('participant', 2);
 164                 list($e1, $e2) = R::dispense('employee', 2);
 165                 list($x1, $x2) = R::dispense('project', 2);
 166                 $e1->name = 'Anna';
 167                 $e2->name = 'John';
 168                 $p1->project = $x1;
 169                 $p1->employee = $e1;
 170                 $p1->arole = 'designer';
 171                 $p2->project = $x1;
 172                 $p2->employee = $e2;
 173                 $p2->arole = 'coder';
 174                 R::storeAll(array( $p1, $p2 ));
 175                 $project = R::load('project', $x1->id);
 176                 $designers = $project
 177                                 ->withCondition(' participant.arole = ? ', array( 'designer' ) )
 178                                 ->via( 'participant' )
 179                                 ->sharedEmployeeList;
 180                 $anna = reset( $designers );
 181                 asrt(count($designers), 1);
 182                 asrt($anna->name, 'Anna');
 183                 $coders = $project
 184                                 ->withCondition(' participant.arole = ? ', array( 'coder' ) )
 185                                 ->via( 'participant' )
 186                                 ->sharedEmployeeList;
 187                 $john = reset( $coders );
 188                 asrt(count($coders), 1);
 189                 asrt($john->name, 'John');
 190         }
 191
 192         /**
 193          * Test Via and Link together.
 194          *
 195          * @return void
 196          */
 197         public function testViaAndLink()
 198         {
 199                 R::nuke();
 200                 list( $John, $Anna, $Celine ) = R::dispense( 'employee', 3 );
 201                 $John->badge   = 'John';
 202                 $Anna->badge   = 'Anna';
 203                 $Celine->badge = 'Celine';
 204                 $project = R::dispense( 'project' );
 205                 $project->name = 'x';
 206                 $project2 = R::dispense( 'project' );
 207                 $project2->name = 'y';
 208                 $John->link( 'participant', array(
 209                          'arole' => 'designer'
 210                 ) )->project = $project;
 211                 $Anna->link( 'participant', array(
 212                          'arole' => 'developer'
 213                 ) )->project = $project;
 214                 $Celine->link( 'participant', array(
 215                          'arole' => 'sales'
 216                 ) )->project = $project2;
 217                 $Anna->link('participant', array(
 218                          'arole' => 'lead'
 219                 ) )->project = $project2;
 220                 R::storeAll( array( $project, $project2, $John, $Anna, $Celine )  );
 221                 $employees = $project
 222                         ->with(' ORDER BY badge ASC ')
 223                         ->via( 'participant' )
 224                         ->sharedEmployee;
 225                 asrt( is_array( $employees ), TRUE );
 226                 asrt( count( $employees ), 2 );
 227                 $badges = array();
 228                 foreach( $employees as $employee ) {
 229                         $badges[] = $employee->badge;
 230                 }
 231                 asrt( implode( ',', $badges ), 'Anna,John' );
 232                 $employees = $project2
 233                         ->with(' ORDER BY badge ASC ')
 234                         ->via( 'participant' )
 235                         ->sharedEmployee;
 236                 asrt( is_array( $employees ), TRUE );
 237                 asrt( count( $employees ), 2 );
 238                 $badges = array();
 239                 foreach( $employees as $employee ) {
 240                         $badges[] = $employee->badge;
 241                 }
 242                 asrt( implode( ',', $badges ), 'Anna,Celine' );
 243                 $projects = $John->sharedProject;
 244                 asrt( is_array( $projects ), TRUE );
 245                 asrt( count( $projects ), 1 );
 246                 $projectList = array();
 247                 foreach( $projects as $project ) {
 248                         $projectList[] =  $project->name;
 249                 }
 250                 sort( $projectList );
 251                 asrt( implode( ',', $projectList ), 'x' );
 252                 $projects = $Anna->sharedProject;
 253                 asrt( is_array( $projects ), TRUE );
 254                 asrt( count( $projects ), 2 );
 255                 $projectList = array();
 256                 foreach( $projects as $project ) {
 257                         $projectList[] =  $project->name;
 258                 }
 259                 sort( $projectList );
 260                 asrt( implode( ',', $projectList ), 'x,y' );
 261                 $projects = $Anna->via( 'participant' )->sharedProject;
 262                 asrt( is_array( $projects ), TRUE );
 263                 asrt( count( $projects ), 2 );
 264                 $projectList = array();
 265                 foreach( $projects as $project ) {
 266                         $projectList[] =  $project->name;
 267                 }
 268                 sort( $projectList );
 269                 asrt( implode( ',', $projectList ), 'x,y' );
 270                 $projects = $Celine->via( 'participant' )->sharedProject;
 271                 asrt( is_array( $projects ), TRUE );
 272                 asrt( count( $projects ), 1 );
 273                 $projectList = array();
 274                 foreach( $projects as $project ) {
 275                         $projectList[] =  $project->name;
 276                 }
 277                 sort( $projectList );
 278                 asrt( implode( ',', $projectList ), 'y' );
 279                 $roles = $Anna->ownParticipant;
 280                 asrt( is_array( $roles ), TRUE );
 281                 asrt( count( $roles ), 2 );
 282                 $roleList = array();
 283                 foreach( $roles as $role ) {
 284                         $roleList[] = $role->arole;
 285                 }
 286                 sort( $roleList );
 287                 asrt( implode( ',', $roleList ), 'developer,lead' );
 288                 $project2->sharedEmployee[] = $John;
 289                 R::store( $project2 );
 290                 $projects = $John->sharedProject;
 291                 asrt( is_array( $projects ), TRUE );
 292                 asrt( count( $projects ), 2 );
 293                 $projectList = array();
 294                 foreach( $projects as $project ) {
 295                         $projectList[] =  $project->name;
 296                 }
 297                 sort( $projectList );
 298                 asrt( implode( ',', $projectList ), 'x,y' );
 299                 $projects = $John->via( 'participant' )->sharedProject;
 300                 asrt( is_array( $projects ), TRUE );
 301                 asrt( count( $projects ), 2 );
 302                 $projectList = array();
 303                 foreach( $projects as $project ) {
 304                         $projectList[] =  $project->name;
 305                 }
 306                 sort( $projectList );
 307                 asrt( implode( ',', $projectList ), 'x,y' );
 308         }
 309
 310         /**
 311          * Test effect of via on shared list removal of beans.
 312          *
 313          * @return void
 314          */
 315         public function testViaAndRemove()
 316         {
 317                 R::nuke();
 318                 $project   = R::dispense( 'project' );
 319                 $employees = R::dispense( 'employee', 2);
 320                 $project->via( 'partcipant' )->sharedEmployeeList = $employees;
 321                 R::store( $project );
 322                 asrt( R::count('employee'), 2 );
 323                 asrt( R::count('participant'), 2 );
 324                 $project = $project->fresh();
 325                 $project->sharedEmployee = array();
 326                 R::store( $project );
 327                 asrt( R::count( 'employee' ), 2 );
 328                 asrt( R::count( 'participant' ), 0 );
 329         }
 330 }