1: <?php
  2: 
  3: /**
  4:  * Test case for the Relation data type
  5:  *
  6:  * @package alpha::tests
  7:  * @since 1.0
  8:  * @author John Collins <dev@alphaframework.org>
  9:  * @version $Id: Relation_Test.php 1617 2012-12-19 15:05:31Z alphadevx $
 10:  * @license http://www.opensource.org/licenses/bsd-license.php The BSD License
 11:  * @copyright Copyright (c) 2012, John Collins (founder of Alpha Framework).
 12:  * All rights reserved.
 13:  *
 14:  * <pre>
 15:  * Redistribution and use in source and binary forms, with or
 16:  * without modification, are permitted provided that the
 17:  * following conditions are met:
 18:  *
 19:  * * Redistributions of source code must retain the above
 20:  *   copyright notice, this list of conditions and the
 21:  *   following disclaimer.
 22:  * * Redistributions in binary form must reproduce the above
 23:  *   copyright notice, this list of conditions and the
 24:  *   following disclaimer in the documentation and/or other
 25:  *   materials provided with the distribution.
 26:  * * Neither the name of the Alpha Framework nor the names
 27:  *   of its contributors may be used to endorse or promote
 28:  *   products derived from this software without specific
 29:  *   prior written permission.
 30:  *
 31:  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 32:  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 33:  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 34:  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 35:  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 36:  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 37:  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 38:  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 39:  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 40:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 41:  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 42:  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 43:  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 44:  * </pre>
 45:  *
 46:  */
 47: class Relation_Test extends PHPUnit_Framework_TestCase {
 48:     /**
 49:      * A Relation for testing
 50:      *
 51:      * @var Relation
 52:      * @since 1.0
 53:      */
 54:     private $rel1;
 55: 
 56:     /**
 57:      * A PersonObject for testing
 58:      *
 59:      * @var PersonObject
 60:      * @since 1.2.1
 61:      */
 62:     private $person;
 63: 
 64:     /**
 65:      * Called before the test functions will be executed
 66:      * this function is defined in PHPUnit_TestCase and overwritten
 67:      * here
 68:      *
 69:      * @since 1.0
 70:      */
 71:     protected function setUp() {
 72:         $this->rel1 = new Relation();
 73: 
 74:         $rights = new RightsObject();
 75:         $rights->rebuildTable();
 76: 
 77:         $article = new ArticleObject();
 78:         $article->rebuildTable();
 79: 
 80:         $comment = new ArticleCommentObject();
 81:         $comment->rebuildTable();
 82: 
 83:         $this->person = new PersonObject();
 84:         $this->person->set('displayName', $_SESSION['currentUser']->getDisplayName());
 85:         $this->person->set('email', $_SESSION['currentUser']->get('email'));
 86:         $this->person->set('password', 'password');
 87:         $this->person->rebuildTable();
 88:         $this->person->save();
 89:     }
 90: 
 91:     /**
 92:      * Called after the test functions are executed
 93:      * this function is defined in PHPUnit_TestCase and overwritten
 94:      * here
 95:      *
 96:      * @since 1.0
 97:      */
 98:     protected function tearDown() {
 99:         unset($this->rel1);
100:         $person = new PersonObject();
101:         $person->dropTable();
102: 
103:         $rights = new RightsObject();
104:         $rights->dropTable();
105:         $rights->dropTable('Person2Rights');
106: 
107:         $comment = new ArticleCommentObject();
108:         $comment->dropTable();
109: 
110:         $article = new ArticleObject();
111:         $article->dropTable();
112:     }
113: 
114:     /**
115:      * Testing passing a valid BO name to setRelatedClass
116:      *
117:      * @since 1.0
118:      */
119:     public function testSetRelatedClassPass() {
120:         try {
121:             $this->rel1->setRelatedClass('ArticleObject');
122:         }catch (AlphaException $e) {
123:             $this->fail('Testing passing a valid BO name to setRelatedClass');
124:         }
125:     }
126: 
127:     /**
128:      * Testing passing an invalid BO name to setRelatedClass
129:      *
130:      * @since 1.0
131:      */
132:     public function testSetRelatedClassFail() {
133:         try {
134:             $this->rel1->setRelatedClass('XyzObject');
135:             $this->fail('Testing passing an invalid BO name to setRelatedClass');
136:         }catch (AlphaException $e) {
137:             $this->assertEquals('The class [XyzObject] is not defined anywhere!'
138:                 , $e->getMessage()
139:                 , 'Testing passing an invalid BO name to setRelatedClass');
140:         }
141:     }
142: 
143:     /**
144:      * Testing passing a valid field name to setRelatedClassField
145:      *
146:      * @since 1.0
147:      */
148:     public function testSetRelatedClassFieldPass() {
149:         try {
150:             $this->rel1->setRelatedClass('PersonObject');
151:             $this->rel1->setRelatedClassField('email');
152:         }catch (AlphaException $e) {
153:             $this->fail('Testing passing a valid field name to setRelatedClassField');
154:         }
155:     }
156: 
157:     /**
158:      * Testing passing an invalid field name to setRelatedClassField
159:      *
160:      * @since 1.0
161:      */
162:     public function testSetRelatedClassFieldFail() {
163:         try {
164:             $this->rel1->setRelatedClass('PersonObject');
165:             $this->rel1->setRelatedClassField('doesNotExist');
166:             $this->fail('Testing passing an invalid field name to setRelatedClassField');
167:         }catch (AlphaException $e) {
168:             $this->assertEquals('The field [doesNotExist] was not found in the class [PersonObject]'
169:                 , $e->getMessage()
170:                 , 'Testing passing an invalid field name to setRelatedClassField');
171:         }
172:     }
173: 
174:     /**
175:      * Testing passing a valid type name to setRelationType
176:      *
177:      * @since 1.0
178:      */
179:     public function testSetRelationTypePass() {
180:         try {
181:             $this->rel1->setRelationType('MANY-TO-ONE');
182:         }catch (AlphaException $e) {
183:             $this->fail('Testing passing a valid type name to setRelationType');
184:         }
185:     }
186: 
187:     /**
188:      * Testing passing an invalid type name to setRelationType
189:      *
190:      * @since 1.0
191:      */
192:     public function testSetRelationTypeFail() {
193:         try {
194:             $this->rel1->setRelationType('blah');
195:             $this->fail('Testing passing an invalid type name to setRelationType');
196:         }catch (AlphaException $e) {
197:             $this->assertEquals('Relation type of [blah] is invalid!'
198:                 , $e->getMessage()
199:                 , 'Testing passing an invalid type name to setRelationType');
200:         }
201:     }
202: 
203:     /**
204:      * Testing setValue method with a valid value
205:      *
206:      * @since 1.0
207:      */
208:     public function testSetValuePass() {
209:         try {
210:             $this->rel1->setValue(100);
211:             $this->rel1->setValue('2777');
212:         }catch (AlphaException $e) {
213:             $this->fail('Testing setValue method with a valid value');
214:         }
215:     }
216: 
217:     /**
218:      * Testing setValue method with an invalid value
219:      *
220:      * @since 1.0
221:      */
222:     public function testSetValueFail() {
223:         try {
224:             $this->rel1->setValue('xyz');
225:             $this->fail('Testing setValue method with an invalid value');
226:         }catch (AlphaException $e) {
227:             $this->assertEquals('[xyz] not a valid Relation value!  A maximum of 11 characters is allowed.'
228:                 , $e->getMessage()
229:                 , 'Testing setValue method with an invalid value');
230:         }
231:     }
232: 
233:     /**
234:      * Testing that the display field value of the related class is accessed correctly
235:      *
236:      * @since 1.0
237:      */
238:     public function testSetRelatedClassDisplayFieldPass() {
239:         try {
240:             $this->rel1->setRelatedClass('PersonObject');
241:             // assuming here that user #1 is the default Administrator account
242:             $this->rel1->setValue(1);
243:             $this->rel1->setRelatedClassDisplayField('state');
244:             $this->assertEquals('Active', $this->rel1->getRelatedClassDisplayFieldValue(), 'Testing that the display field value of the related class is accessed correctly');          
245:         }catch (AlphaException $e) {
246:             $this->fail('Testing that the display field value of the related class is accessed correctly');
247:         }
248:     }
249: 
250:     /**
251:      * Testing that getRelatedClassDisplayFieldValue() will fail to load an invalid class definition
252:      *
253:      * @since 1.0
254:      */
255:     public function testGetRelatedClassDisplayFieldValueFail() {
256:         try {
257:             $this->rel1->setRelatedClassDisplayField('someField');
258:             $value = $this->rel1->getRelatedClassDisplayFieldValue();
259:             $this->fail('Testing that getRelatedClassDisplayFieldValue() will fail to load an invalid class definition');
260:         }catch (AlphaException $e) {
261:             $this->assertEquals('The class [] is not defined anywhere!'
262:                 , $e->getMessage()
263:                 , 'Testing that getRelatedClassDisplayFieldValue() will fail to load an invalid class definition');
264:         }
265:     }
266: 
267:     /**
268:      * Testing the getRelatedClassDisplayFieldValue() method on ONE-TO-MANY and MANY-TO-MANY relations
269:      *
270:      * @since 1.2.1
271:      */
272:     public function testGetRelatedClassDisplayFieldValuePass() {
273:         $oneToManyRel = new Relation();
274:         $oneToManyRel->setRelatedClass('PersonObject');
275:         $oneToManyRel->setRelatedClassField('OID');
276:         $oneToManyRel->setRelatedClassDisplayField('displayName');
277:         $oneToManyRel->setRelationType('ONE-TO-MANY');
278:         $oneToManyRel->setValue($this->person->getOID());
279: 
280:         $this->assertEquals($_SESSION['currentUser']->getDisplayName(), $oneToManyRel->getRelatedClassDisplayFieldValue(), 'testing the getRelatedClassDisplayFieldValue() method on ONE-TO-MANY relation');
281: 
282:         $group = new RightsObject();
283:         $group->set('name', 'unittestgroup');
284:         $group->save();
285: 
286:         $person1 = new PersonObject();
287:         $person1->set('displayName', 'user1');
288:         $person1->set('email', 'user1@test.com');
289:         $person1->set('password', 'password');
290:         $person1->save();
291:         $lookup = $person1->getPropObject('rights')->getLookup();
292:         $lookup->setValue(array($person1->getOID(), $group->getOID()));
293:         $lookup->save();
294: 
295:         $person2 = new PersonObject();
296:         $person2->set('displayName', 'user2');
297:         $person2->set('email', 'user2@test.com');
298:         $person2->set('password', 'password');
299:         $person2->save();
300:         $lookup = $person2->getPropObject('rights')->getLookup();
301:         $lookup->setValue(array($person2->getOID(), $group->getOID()));
302:         $lookup->save();
303: 
304:         $person2->getPropObject('rights')->setValue($group->getOID());
305: 
306:         try {
307:             $this->assertEquals('user1@test.com,user2@test.com', $person2->getPropObject('rights')->getRelatedClassDisplayFieldValue(), 'testing the getRelatedClassDisplayFieldValue() method on MANY-TO-MANY relation');
308:             $this->fail('testing the getRelatedClassDisplayFieldValue() method on MANY-TO-MANY relation');
309:         }catch (IllegalArguementException $e) {
310:             $this->assertEquals($e->getMessage(), 'Tried to load related MANY-TO-MANY fields but no accessingClassName parameter set on the call to getRelatedClassDisplayFieldValue!', 'testing the getRelatedClassDisplayFieldValue() method on MANY-TO-MANY relation');
311:         }
312: 
313:         $this->assertEquals('user1@test.com,user2@test.com', $person2->getPropObject('rights')->getRelatedClassDisplayFieldValue('RightsObject'), 'testing the getRelatedClassDisplayFieldValue() method on MANY-TO-MANY relation');
314:     }
315: 
316:     /**
317:      * Testing the getRelatedClass() method with different relation types.
318:      *
319:      * @since 1.2.1
320:      */
321:     public function testGetRelatedClass() {
322:         $oneToOneRel = new Relation();
323:         $oneToOneRel->setRelatedClass('ArticleCommentObject');
324:         $oneToOneRel->setRelatedClassField('articleOID');
325:         $oneToOneRel->setRelatedClassDisplayField('content');
326:         $oneToOneRel->setRelationType('ONE-TO-ONE');
327: 
328:         $this->assertEquals('ArticleCommentObject', $oneToOneRel->getRelatedClass(), 'testing the getRelatedClass() method on a ONE-TO-ONE relation');
329: 
330:         $oneToManyRel = new Relation();
331:         $oneToManyRel->setRelatedClass('ArticleCommentObject');
332:         $oneToManyRel->setRelatedClassField('articleOID');
333:         $oneToManyRel->setRelatedClassDisplayField('content');
334:         $oneToManyRel->setRelationType('ONE-TO-MANY');
335: 
336:         $this->assertEquals('ArticleCommentObject', $oneToManyRel->getRelatedClass(), 'testing the getRelatedClass() method on a ONE-TO-MANY relation');
337: 
338:         $manyToManyRel = new Relation();
339:         $manyToManyRel->setRelatedClass('PersonObject', 'left');
340:         $manyToManyRel->setRelatedClassDisplayField('email', 'left');
341:         $manyToManyRel->setRelatedClass('RightsObject', 'right');
342:         $manyToManyRel->setRelatedClassDisplayField('name', 'right');
343:         $manyToManyRel->setRelationType('MANY-TO-MANY');
344: 
345:         $this->assertEquals('PersonObject', $manyToManyRel->getRelatedClass('left'), 'testing the getRelatedClass() method on a MANY-TO-MANY relation');
346:         $this->assertEquals('RightsObject', $manyToManyRel->getRelatedClass('right'), 'testing the getRelatedClass() method on a MANY-TO-MANY relation');
347:     }
348: 
349:     /**
350:      * Testing the getSide() method on a MANY-TO-MANY relation
351:      *
352:      * @since 1.2.1
353:      */
354:     public function testGetSidePass() {
355: 
356:         $manyToManyRel = new Relation();
357:         $manyToManyRel->setRelatedClass('PersonObject', 'left');
358:         $manyToManyRel->setRelatedClassDisplayField('email', 'left');
359:         $manyToManyRel->setRelatedClass('RightsObject', 'right');
360:         $manyToManyRel->setRelatedClassDisplayField('name', 'right');
361:         $manyToManyRel->setRelationType('MANY-TO-MANY');
362: 
363:         $this->assertEquals('left', $manyToManyRel->getSide('PersonObject'), 'testing the getSide() method on a MANY-TO-MANY relation');
364:         $this->assertEquals('right', $manyToManyRel->getSide('RightsObject'), 'testing the getSide() method on a MANY-TO-MANY relation');
365:     }
366: 
367:     /**
368:      * Testing the getSide() method on a ONE-TO-MANY relation
369:      *
370:      * @since 1.2.1
371:      */
372:     public function testGetSideFail() {
373: 
374:         $oneToManyRel = new Relation();
375:         $oneToManyRel->setRelatedClass('ArticleCommentObject');
376:         $oneToManyRel->setRelatedClassField('articleOID');
377:         $oneToManyRel->setRelatedClassDisplayField('content');
378:         $oneToManyRel->setRelationType('ONE-TO-MANY');
379: 
380:         try{
381:             $oneToManyRel->getSide('ArticleCommentObject');
382:             $this->fail('testing the getSide() method on a ONE-TO-MANY relation');
383:         }catch (IllegalArguementException $e) {
384:             $this->assertEquals('Error trying to determine the MANY-TO-MANY relationship side for the classname [ArticleCommentObject]', $e->getMessage(), 'testing the getSide() method on a ONE-TO-MANY relation');
385:         }
386: 
387:     }
388: 
389:     /**
390:      * Testing the getRelatedObject method
391:      *
392:      * @since 1.2.1
393:      */
394:     public function testGetRelatedObject() {
395:         $oneToOneRel = new Relation();
396:         $oneToOneRel->setRelatedClass('PersonObject');
397:         $oneToOneRel->setRelatedClassField('OID');
398:         $oneToOneRel->setRelatedClassDisplayField('displayName');
399:         $oneToOneRel->setRelationType('ONE-TO-ONE');
400:         $oneToOneRel->setValue($this->person->getOID());
401: 
402:         $this->assertEquals($_SESSION['currentUser']->getDisplayName(), $oneToOneRel->getRelatedObject()->get('displayName'), 'testing the getRelatedObject method');
403:     }
404: 
405:     /**
406:      * Testing the getRelatedObjects method with a ONE-TO-MANY and MANY-TO-MANY relation
407:      *
408:      * @since 1.2.1
409:      */
410:     public function testGetRelatedObjects() {
411: 
412:         $group = new RightsObject();
413:         $group->set('name', 'unittestgroup');
414:         $group->save();
415: 
416:         $person1 = new PersonObject();
417:         $person1->set('displayName', 'user1');
418:         $person1->set('email', 'user1@test.com');
419:         $person1->set('password', 'password');
420:         $person1->save();
421:         $lookup = $person1->getPropObject('rights')->getLookup();
422:         $lookup->setValue(array($person1->getOID(), $group->getOID()));
423:         $lookup->save();
424: 
425:         $person2 = new PersonObject();
426:         $person2->set('displayName', 'user2');
427:         $person2->set('email', 'user2@test.com');
428:         $person2->set('password', 'password');
429:         $person2->save();
430:         $lookup = $person2->getPropObject('rights')->getLookup();
431:         $lookup->setValue(array($person2->getOID(), $group->getOID()));
432:         $lookup->save();
433: 
434:         $person2->getPropObject('rights')->setValue($group->getOID());
435: 
436:         $this->assertEquals(2, count($group->getPropObject('members')->getRelatedObjects('RightsObject')), 'testing the getRelatedObjects method with a MANY-TO-MANY relation');
437:         $this->assertTrue($group->getPropObject('members')->getRelatedObjects('RightsObject')[0] instanceof PersonObject, 'testing the getRelatedObjects method with a MANY-TO-MANY relation');
438: 
439:         $article = new ArticleObject();
440:         $article->set('title', 'unit test');
441:         $article->set('description', 'unit test');
442:         $article->set('content', 'unit test');
443:         $article->set('author', 'unit test');
444:         $article->save();
445: 
446:         $comment1 = new ArticleCommentObject();
447:         $comment1->set('content', 'unit test');
448:         $comment1->getPropObject('articleOID')->setValue($article->getOID());
449:         $comment1->save();
450: 
451:         $comment2 = new ArticleCommentObject();
452:         $comment2->set('content', 'unit test');
453:         $comment2->getPropObject('articleOID')->setValue($article->getOID());
454:         $comment2->save();
455: 
456:         $this->assertEquals(2, count($article->getPropObject('comments')->getRelatedObjects()), 'testing the getRelatedObjects method with a ONE-TO-MANY relation');
457:         $this->assertTrue($article->getPropObject('comments')->getRelatedObjects()[0] instanceof ArticleCommentObject, 'testing the getRelatedObjects method with a ONE-TO-MANY relation');
458:     }
459: }
460: 
461: ?>