[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/cms/src/model/lmbCmsNode.class.php');
  10  lmb_require('limb/dbal/src/lmbSimpleDb.class.php');
  11  lmb_require('limb/active_record/src/lmbActiveRecord.class.php');
  12  
  13  class lmbTestingNodeObject extends lmbActiveRecord
  14  {
  15    protected $_db_table_name = 'testing_node_object';
  16  
  17    protected $_has_one = array('node' => array('field' => 'node_id',
  18                                                'class' => 'lmbCmsNode'));
  19  }
  20  
  21  class lmbTestingNodeChild extends lmbCmsNode{}
  22  
  23  class lmbCmsNodeTest extends UnitTestCase
  24  {
  25    protected $db;
  26    protected $tree;
  27  
  28    function setUp()
  29    {
  30      $toolkit = lmbToolkit :: instance();
  31      $this->db = new lmbSimpleDb($toolkit->getDefaultDbConnection());
  32      $this->tree = $toolkit->getCmsTree();
  33  
  34      $this->_cleanUp();
  35    }
  36  
  37    function tearDown()
  38    {
  39      $this->_cleanUp();
  40    }
  41  
  42    function _cleanUp()
  43    {
  44      $this->tree->deleteAll();
  45      $this->db->delete('class_name');
  46      $this->db->delete('testing_node_object');
  47    }
  48  
  49    function testSavingNewNodeInEmptyTreeCreatesTreeRootNode()
  50    {
  51      $this->assertNull($this->tree->getRootNode());
  52  
  53      $node = new lmbCmsNode();
  54      $node->setTitle($title = 'Some title');
  55      $node->setIdentifier($identifier = 'my_node');
  56      $node->setControllerName('MyController');
  57      $node->save();
  58  
  59      $node2 = lmbActiveRecord :: findById('lmbCmsNode', $node->getId());
  60      $this->assertEqual($node2->title, $title);
  61      $this->assertEqual($node2->identifier, $identifier);
  62      $this->assertEqual($node2->id, $node->getId());
  63      $this->assertEqual($node2->parent_id, $this->tree->getRootNode()->get('id'));
  64      $this->assertEqual($node2->children, 0);
  65  
  66      $root_node = $node2->getParent();
  67      $this->assertEqual($root_node->identifier, '');
  68      $this->assertEqual($root_node->id, $node2->parent_id);
  69    }
  70  
  71    function testLoadByPath()
  72    {
  73      $object1 = $this->_createNode('root', $parent_node = null);
  74      $object2 = $this->_createNode('child', $object1);
  75  
  76      $object3 = new lmbCmsNode();
  77      $object3->loadByPath('/root/child');
  78      $this->assertEqual($object3->title, $object2->title);
  79  
  80      $object4 = new lmbCmsNode();
  81      $object4->loadByPath('/root');
  82      $this->assertEqual($object4->title, $object1->title);
  83    }
  84  
  85    function testPreserveNodeClass()
  86    {
  87      $node = new lmbTestingNodeChild();
  88      $node->setIdentifier('node2');
  89      $node->setTitle('title_a');
  90      $node->save();
  91  
  92      $nodes = lmbActiveRecord :: find('lmbCmsNode', 'id = '. $node->id);
  93      $nodes->rewind();
  94      $node2 = $nodes->current();
  95      $this->assertIsA($node2, 'lmbTestingNodeChild');
  96      $this->assertEqual($node2->title, $node->title);
  97    }
  98  
  99    function testDestroyAlsoRemovesChildren()
 100    {
 101      $node1 = $this->_createNode('root', $parent_node = null);
 102      $node2 = $this->_createNode('child', $node1);
 103  
 104      $this->assertEqual($this->tree->countChildrenAll('/'), 2);
 105  
 106      $node3 = lmbActiveRecord :: findById('lmbCmsNode', $node1->getId());
 107  
 108      $node3->destroy();
 109  
 110      $this->assertEqual($this->tree->countChildrenAll('/'), 0);
 111    }
 112  
 113    function testGetChildren()
 114    {
 115      $object1 = $this->_createNode('root', $parent_node = null);
 116      $object2 = $this->_createNode('folder1', $object1);
 117      $object3 = $this->_createNode('child1', $object2);
 118      $object4 = $this->_createNode('child2', $object2);
 119  
 120      $object5 = lmbActiveRecord :: findById('lmbCmsNode', $object2->getId());
 121      $children = $object5->getKids();
 122      $children->rewind();
 123      $this->assertTrue($children->valid());
 124      $child1 = $children->current();
 125      $this->assertEqual($child1->title, $object3->title);
 126  
 127      $children->next();
 128      $this->assertTrue($children->valid());
 129      $child2 = $children->current();
 130      $this->assertEqual($child2->title, $object4->title);
 131    }
 132  
 133    function testSaveAndLoadLinkedObject()
 134    {
 135      $node = $this->_createNode('root', $parent_node = null);
 136      $object = new lmbTestingNodeObject();
 137      $object->setContent('test content');
 138      $node->setObject($object);
 139      $object->setNode($node);
 140      $node->save();
 141  
 142      $test_node = lmbActiveRecord :: findById('lmbCmsNode', $node->getId());
 143      $this->assertEqual($test_node->getObject()->getContent(), $object->getContent());
 144  
 145      $object2 = lmbActiveRecord :: findById('lmbTestingNodeObject', $object->getId());
 146      $this->assertEqual($object2->content, $object->content);
 147      $this->assertEqual($object2->getNode()->title, $node->title);
 148    }
 149  
 150    function testGetObjectOnNoLinkedObject()
 151    {
 152      $node = $this->_createNode('root');
 153      $this->assertNull($node->getObject());
 154    }
 155  
 156    function testDestroyNodeWithLinkedObject()
 157    {
 158      $node1 = $this->_createNode('root');
 159      $object1 = $this->_initObject($node1);
 160      $node1->save();
 161  
 162      $node1->destroy();
 163  
 164      $nodes = lmbActiveRecord :: find('lmbCmsNode'); //it's a root node

 165      $this->assertEqual($nodes->count(), 1);
 166      $this->assertEqual($nodes[0]->getParentId(), 0);//root

 167  
 168      $objects = lmbActiveRecord :: find('lmbTestingNodeObject');
 169      $this->assertEqual($objects->count(), 0);
 170    }
 171  
 172    function testDestroyKidsWithLinkedObjects()
 173    {
 174      $node1 = $this->_createNode('root');
 175      $object1 = $this->_initObject($node1);
 176      $node1->save();
 177  
 178      $node2 = $this->_createNode('node2', $node1);
 179      $object2 = $this->_initObject($node2);
 180      $node2->save();
 181  
 182      $node1->destroy();
 183  
 184      $nodes = lmbActiveRecord :: find('lmbCmsNode'); //it's a root node

 185      $this->assertEqual($nodes->count(), 1);
 186      $this->assertEqual($nodes[0]->getParentId(), 0);//root

 187  
 188      $objects = lmbActiveRecord :: find('lmbTestingNodeObject');
 189      $this->assertEqual($objects->count(), 0);
 190    }
 191  
 192    function testDestroyLinkedObjectDoDestroyNode()
 193    {
 194      $node1 = $this->_createNode('root');
 195      $object1 = $this->_initObject($node1);
 196      $node1->save();
 197  
 198      $object2 = lmbActiveRecord :: findById('lmbTestingNodeObject', $object1->id);
 199      $object2->destroy();
 200  
 201      $nodes = lmbActiveRecord :: find('lmbCmsNode'); //it's a root node

 202      $this->assertEqual($nodes->count(), 1);
 203      $this->assertEqual($nodes[0]->getParentId(), 0);
 204    }
 205  
 206    function testDestroyNodeUsingTreeAlgorithm()
 207    {
 208      $node1 = $this->_createNode('root');
 209      $object1 = $this->_initObject($node1);
 210      $node1->save();
 211  
 212      $node2 = $this->_createNode('folder', $node1);
 213      $object2 = $this->_initObject($node2);
 214      $node2->save();
 215  
 216      $node3 = $this->_createNode('child', $node2);
 217      $object3 = $this->_initObject($node3);
 218      $node3->save();
 219  
 220      $node1_1 = lmbActiveRecord :: findById('lmbCmsNode', $node1->id);
 221      $this->assertEqual($this->tree->countChildren($node1_1), 1);
 222  
 223      $node2->destroy();
 224  
 225      $node1_2 = lmbActiveRecord :: findById('lmbCmsNode', $node1->id);
 226      $this->assertEqual($this->tree->countChildren($node1_2), 0);
 227  
 228      $nodes = lmbActiveRecord :: find('lmbCmsNode');
 229      $this->assertEqual($nodes[0]->getParentId(), 0);//root

 230      $this->assertEqual($nodes[1]->getId(), $node1->getId());
 231  
 232      $objects = lmbActiveRecord :: find('lmbTestingNodeObject');
 233      $this->assertEqual($objects->count(), 1);
 234    }
 235  
 236    function testSaveAndLoadControllerName()
 237    {
 238      $node = $this->_createNode('root');
 239      $node->setControllerName('SomeController');
 240      $node->save();
 241  
 242      $node1 = lmbActiveRecord :: findById('lmbCmsNode', $node->id);
 243      $this->assertEqual($node1->getControllerName(), 'SomeController');
 244    }
 245  
 246    function testSaveNodeFromObject()
 247    {
 248      $node = $this->_initNode('root');
 249      $object = $this->_initObject($node);
 250      $object->save();
 251  
 252      $node1 = lmbActiveRecord :: findById('lmbCmsNode', $node->id);
 253      $this->assertEqual($node1->getObject()->content, $object->content);
 254    }
 255  
 256    function testGenerateNewIdentifier()
 257    {
 258      $node = $this->_createNode('root');
 259      $identifier = lmbCmsNode :: generateIdentifier($node->id);
 260      $this->assertEqual($identifier, 1);
 261    }
 262  
 263    function testGenerateNewIdentifierAfterNonNumericIdentifier()
 264    {
 265      $root = $this->_createNode('root');
 266      $child1 = $this->_createNode('alfa', $root);
 267      $identifier = lmbCmsNode :: generateIdentifier($root->id);
 268      $this->assertEqual($identifier, 'alfa1');
 269    }
 270  
 271    function testGenerateNewIdentifierAfterNumericIdentifier()
 272    {
 273      $root = $this->_createNode('root');
 274      $child1 = $this->_createNode('alfa', $root);
 275      $child2 = $this->_createNode('alfa1', $root);
 276      $identifier = lmbCmsNode :: generateIdentifier($root->id);
 277      $this->assertEqual($identifier, 'alfa2');
 278    }
 279  
 280    function testGetPath()
 281    {
 282      $old_gateway_path = lmbCmsNode :: getGatewayPath();
 283      $new_gateway_path = 'http://localhost/';
 284      lmbCmsNode :: setGatewayPath($new_gateway_path);
 285      $root = $this->_createNode('root');
 286      $level1 = $this->_createNode('level1', $root);
 287      $level2 = $this->_createNode('level2', $level1);
 288  
 289      $this->assertEqual($level2->getRelativeUrlPath(), 'root/level1/level2');
 290      $this->assertEqual($level2->getAbsoluteUrlPath(), '/root/level1/level2');
 291      $this->assertEqual($level2->getUrlPath(), $new_gateway_path . 'root/level1/level2');
 292  
 293      lmbCmsNode :: setGatewayPath($old_gateway_path);
 294  
 295    }
 296  
 297    protected function _initObject($node)
 298    {
 299      $object = new lmbTestingNodeObject();
 300      $object->setContent('test content' . mt_rand(0, 1000));
 301      $node->setObject($object);
 302      $object->setNode($node);
 303      return $object;
 304    }
 305  
 306    protected function _initNode($node_identifier, $parent_node = null)
 307    {
 308      $node = new lmbCmsNode();
 309      $node->setTitle('title_'. mt_rand(0, 10000));
 310      $node->setIdentifier($node_identifier);
 311      $node->setControllerName('lmbController');
 312      if($parent_node)
 313        $node->setParent($parent_node);
 314      return $node;
 315    }
 316  
 317    protected function _createNode($node_identifier, $parent_node = null)
 318    {
 319      $node = $this->_initNode($node_identifier, $parent_node);
 320      $node->save();
 321      return $node;
 322    }
 323  }
 324  
 325  ?>