[Summary view] [Print] [Text view]

   1  <?php
   2  /*

   3   * Limb PHP Framework

   4   *

   5   * @link http://limb-project.com

   6   * @copyright  Copyright &copy; 2004-2007 BIT(http://bit-creative.com)

   7   * @license    LGPL http://www.gnu.org/copyleft/lesser.html

   8   */
   9  lmb_require('limb/active_record/src/lmbAROneToManyCollection.class.php');
  10  lmb_require('limb/core/src/lmbCollectionDecorator.class.php');
  11  lmb_require('limb/dbal/src/lmbSimpleDb.class.php');
  12  require_once(dirname(__FILE__) . '/lmbAROneToManyRelationsTest.class.php');
  13  
  14  Mock :: generate('LectureForTest', 'MockLectureForTest');
  15  
  16  class lmbARTestingDSDecorator extends lmbCollectionDecorator
  17  {
  18    protected $value;
  19  
  20    function setValue($value)
  21    {
  22      $this->value = $value;
  23    }
  24  
  25    protected function _processRecord($record)
  26    {
  27      $record->set('value', $this->value);
  28    }
  29  
  30    function current()
  31    {
  32      $record = parent :: current();
  33      $this->_processRecord($record);
  34      return $record;
  35    }
  36  
  37    function at($pos)
  38    {
  39      $record = parent :: at($pos);
  40      $this->_processRecord($record);
  41      return $record;
  42    }
  43  }
  44  
  45  class LectureForTestStub extends LectureForTest
  46  {
  47    var $save_calls = 0;
  48  
  49    function save($error_list = null)
  50    {
  51      parent :: save($error_list);
  52      $this->save_calls++;
  53    }
  54  }
  55  
  56  
  57  class SpecialCourseForTest extends CourseForTest
  58  {
  59    protected $_has_many = array('lectures' => array('field' => 'course_id',
  60                                                     'class' => 'LectureForTest',
  61                                                     'sort_params' => array('id' => 'DESC')));
  62  }
  63  
  64  class VerySpecialCourseForTest extends CourseForTest
  65  {
  66    protected $_has_many = array('lectures' => array('field' => 'course_id',
  67                                                     'class' => 'SpecialLectureForTest'));
  68  }
  69  
  70  class SpecialLectureForTest extends LectureForTest
  71  {
  72    protected $_default_sort_params = array('id' => 'DESC');
  73  }
  74  
  75  class lmbAROneToManyCollectionTest extends UnitTestCase
  76  {
  77    function setUp()
  78    {
  79      $this->_dbCleanUp();
  80    }
  81  
  82    function tearDown()
  83    {
  84      $this->_dbCleanUp();
  85    }
  86  
  87    function _dbCleanUp()
  88    {
  89      lmbActiveRecord :: delete('CourseForTest');
  90      lmbActiveRecord :: delete('LectureForTest');
  91    }
  92  
  93    function testAddToWithExistingOwner()
  94    {
  95      $course = $this->_createCourseAndSave();
  96  
  97      $l1 = $this->_createLecture();
  98      $l2 = $this->_createLecture();
  99  
 100      $collection = new lmbAROneToManyCollection('lectures', $course);
 101      $collection->add($l1);
 102      $collection->add($l2);
 103  
 104      $arr = $collection->getArray();
 105  
 106      $this->assertEqual($arr[0]->getTitle(), $l1->getTitle());
 107      $this->assertEqual($arr[1]->getTitle(), $l2->getTitle());
 108      $this->assertEqual(sizeof($arr), 2);
 109  
 110      $collection2 = new lmbAROneToManyCollection('lectures', $course);
 111      $arr = $collection2->getArray();
 112  
 113      $this->assertEqual($arr[0]->getTitle(), $l1->getTitle());
 114      $this->assertEqual($arr[1]->getTitle(), $l2->getTitle());
 115      $this->assertEqual(sizeof($arr), 2);
 116    }
 117  
 118    function testResetCollectionOnAddForExistingOwner()
 119    {
 120      $course = $this->_createCourseAndSave();
 121  
 122      $lectures = $course->getLectures();
 123      $lectures->rewind();
 124      $this->assertFalse($lectures->valid());
 125  
 126      $l1 = $this->_createLecture();
 127      $l2 = $this->_createLecture();
 128  
 129      $course->addToLectures($l1);
 130      $course->addToLectures($l2);
 131  
 132      $lectures = $course->getLectures();
 133      $lectures->rewind();
 134      $lecture = $lectures->current();
 135      $this->assertEqual($lecture->getTitle(), $l1->getTitle());
 136    }
 137  
 138    function testAddToWithNonSavedOwner()
 139    {
 140      $course = $this->_createCourse();
 141  
 142      $l1 = $this->_createLecture();
 143      $l2 = $this->_createLecture();
 144  
 145      $collection = new lmbAROneToManyCollection('lectures', $course);
 146      $collection->add($l1);
 147      $collection->add($l2);
 148  
 149      $arr = $collection->getArray();
 150      $this->assertEqual(sizeof($arr), 2);
 151      $this->assertEqual($arr[0]->getTitle(), $l1->getTitle());
 152      $this->assertEqual($arr[1]->getTitle(), $l2->getTitle());
 153  
 154      $collection2 = new lmbAROneToManyCollection('lectures', $course);
 155      $arr = $collection2->getArray();
 156  
 157      $this->assertEqual(sizeof($arr), 0);
 158    }
 159  
 160    function testSaveWithExistingOwnerDoesNothing()
 161    {
 162      $l1 = new MockLectureForTest();
 163      $l2 = new MockLectureForTest();
 164  
 165      $course = $this->_createCourseAndSave();
 166  
 167      $collection = new lmbAROneToManyCollection('lectures', $course);
 168      $collection->add($l1);
 169      $collection->add($l2);
 170  
 171      $l1->expectNever('save');
 172      $l2->expectNever('save');
 173  
 174      $collection->save();
 175    }
 176  
 177    function testSaveWithNonSavedOwner()
 178    {
 179      $l1 = $this->_createLecture();
 180      $l2 = $this->_createLecture();
 181  
 182      $course = $this->_createCourse();
 183  
 184      $collection = new lmbAROneToManyCollection('lectures', $course);
 185      $collection->add($l1);
 186      $collection->add($l2);
 187  
 188      $collection2 = new lmbAROneToManyCollection('lectures', $course);
 189      $this->assertEqual(sizeof($collection2->getArray()), 0);
 190  
 191      $course->save();
 192      $collection->save();
 193  
 194      $collection3 = new lmbAROneToManyCollection('lectures', $course);
 195      $arr = $collection3->getArray();
 196      $this->assertEqual(sizeof($arr), 2);
 197      $this->assertEqual($arr[0]->getTitle(), $l1->getTitle());
 198      $this->assertEqual($arr[1]->getTitle(), $l2->getTitle());
 199    }
 200  
 201    function testSavingOwnerDoesntAffectCollection()
 202    {
 203      $l1 = new LectureForTestStub();
 204      $l1->setTitle('Physics');
 205      $l2 = new LectureForTestStub();
 206      $l2->setTitle('Math');
 207  
 208      $course = $this->_createCourse();
 209  
 210      $collection = new lmbAROneToManyCollection('lectures', $course);
 211      $collection->add($l1);
 212  
 213      $course->save();
 214  
 215      $collection->add($l2);
 216  
 217      //items in memory

 218      $arr = $collection->getArray();
 219      $this->assertEqual(sizeof($arr), 2);
 220      $this->assertEqual($arr[0]->getTitle(), $l1->getTitle());
 221      $this->assertEqual($arr[1]->getTitle(), $l2->getTitle());
 222      $this->assertEqual($l1->save_calls, 0);
 223      $this->assertEqual($l2->save_calls, 0);
 224  
 225      //...and not db yet

 226      $collection2 = new lmbAROneToManyCollection('lectures', $course);
 227      $this->assertEqual(sizeof($collection2->getArray()), 0);
 228  
 229      $collection->save();
 230  
 231      $collection3 = new lmbAROneToManyCollection('lectures', $course);
 232      $arr = $collection3->getArray();
 233      $this->assertEqual(sizeof($arr), 2);
 234      $this->assertEqual($arr[0]->getTitle(), $l1->getTitle());
 235      $this->assertEqual($arr[1]->getTitle(), $l2->getTitle());
 236  
 237      //check items not saved twice

 238      $collection->save();
 239  
 240      $this->assertEqual($l1->save_calls, 1);
 241      $this->assertEqual($l2->save_calls, 1);
 242  
 243      $collection4 = new lmbAROneToManyCollection('lectures', $course);
 244      $arr = $collection4->getArray();
 245      $this->assertEqual(sizeof($arr), 2);
 246      $this->assertEqual($arr[0]->getTitle(), $l1->getTitle());
 247      $this->assertEqual($arr[1]->getTitle(), $l2->getTitle());
 248    }
 249  
 250    function testLoadOnlyProperRecordsWithExistingOwner()
 251    {
 252      $l1 = $this->_createLecture();
 253      $l2 = $this->_createLecture();
 254  
 255      $course1 = $this->_createCourseAndSave(array($l1, $l2));
 256  
 257      $l3 = $this->_createLecture();
 258      $l4 = $this->_createLecture();
 259  
 260      $course2 = $this->_createCourseAndSave(array($l3, $l4));
 261  
 262      $collection1 = new lmbAROneToManyCollection('lectures', $course1);
 263      $this->assertEqual($collection1->count(), 2);
 264      $arr = $collection1->getArray();
 265      $this->assertEqual(sizeof($arr), 2);
 266      $this->assertEqual($arr[0]->getTitle(), $l1->getTitle());
 267      $this->assertEqual($arr[1]->getTitle(), $l2->getTitle());
 268  
 269      $collection2 = new lmbAROneToManyCollection('lectures', $course2);
 270      $this->assertEqual($collection2->count(), 2);
 271      $arr = $collection2->getArray();
 272      $this->assertEqual(sizeof($arr), 2);
 273      $this->assertEqual($arr[0]->getTitle(), $l3->getTitle());
 274      $this->assertEqual($arr[1]->getTitle(), $l4->getTitle());
 275    }
 276  
 277    function testCountWithExistingOwner()
 278    {
 279      $l1 = $this->_createLecture();
 280      $l2 = $this->_createLecture();
 281  
 282      $course = $this->_createCourseAndSave();
 283  
 284      $collection = new lmbAROneToManyCollection('lectures', $course);
 285      $collection->add($l1);
 286      $collection->add($l2);
 287  
 288      $this->assertEqual($collection->count(), 2);
 289    }
 290  
 291    function testCountWithNonSavedOwner()
 292    {
 293      $l1 = $this->_createLecture();
 294      $l2 = $this->_createLecture();
 295  
 296      $course = $this->_initCourse();
 297  
 298      $collection = new lmbAROneToManyCollection('lectures', $course);
 299      $this->assertEqual($collection->count(), 0);
 300  
 301      $collection->add($l1);
 302      $collection->add($l2);
 303  
 304      $this->assertEqual($collection->count(), 2);
 305    }
 306  
 307    function testImplementsCountable()
 308    {
 309      $l1 = $this->_createLecture();
 310      $l2 = $this->_createLecture();
 311  
 312      $course = $this->_initCourse();
 313      $collection = new lmbAROneToManyCollection('lectures', $course);
 314  
 315      $this->assertEqual(sizeof($collection), 0);
 316  
 317      $collection->add($l1);
 318      $collection->add($l2);
 319  
 320      $this->assertEqual(sizeof($collection), 2);
 321    }
 322  
 323    function testPartiallyImplementsArrayAccess()
 324    {
 325      $l1 = $this->_createLecture();
 326      $l2 = $this->_createLecture();
 327  
 328      $course = $this->_initCourse();
 329      $collection = new lmbAROneToManyCollection('lectures', $course);
 330  
 331      $collection[] = $l1;
 332      $collection[] = $l2;
 333  
 334      $this->assertEqual($collection[0]->getId(), $l1->getId());
 335      $this->assertEqual($collection[1]->getId(), $l2->getId());
 336      $this->assertNull($collection[2]);
 337  
 338      $this->assertTrue(isset($collection[0]));
 339      $this->assertTrue(isset($collection[1]));
 340      $this->assertFalse(isset($collection[2]));
 341  
 342      //we can't really implement just every php array use case

 343      $this->assertNull($collection['foo']);
 344      $this->assertFalse(isset($collection['foo']));
 345      $collection[3] = 'foo';
 346      $this->assertNull($collection[3]);
 347    }
 348  
 349    function testRemoveAllWithExistingOwner()
 350    {
 351      $l1 = $this->_createLecture();
 352      $l2 = $this->_createLecture();
 353  
 354      $course = $this->_createCourseAndSave(array($l1, $l2));
 355  
 356      $collection = new lmbAROneToManyCollection('lectures', $course);
 357      $collection->removeAll();
 358  
 359      $course2 = lmbActiveRecord :: findById('CourseForTest', $course->getId());
 360  
 361      $collection = new lmbAROneToManyCollection('lectures', $course2);
 362      $this->assertEqual(sizeof($collection->getArray()), 0);
 363    }
 364  
 365    function testRemoveAllWithNonSavedOwner()
 366    {
 367      $l1 = $this->_createLecture();
 368      $l2 = $this->_createLecture();
 369  
 370      $course = $this->_createCourse();
 371  
 372      $collection = new lmbAROneToManyCollection('lectures', $course);
 373      $collection->add($l1);
 374