TypeRelTest


1   package org.mmbase.module.corebuilders;
2   
3   import org.mmbase.bridge.*;
4   
5   /**
6    * JUnit tests for TypeRel
7    *
8    * @author  Michiel Meeuwissen 
9    * @version $Id: TypeRelTest.java,v 1.12 2006/08/30 18:08:17 michiel Exp $
10   */
11  public class TypeRelTest extends org.mmbase.tests.BridgeTest {
12  
13      static protected String    UNIDIR_ROLE = "unidirectionalrelation";
14      static protected String    BIDIR_ROLE  = "bidirectionalrelation";
15      static protected String    INH_ROLE    =  "inheritancerelation";
16      static protected String    MULTILEVEL_ROLE    =  "multileveltestrelation";
17      static protected String    OTHER_ROLE   = "this_role_does_not_exist";
18      static protected String    RELATED_ROLE   = "related";
19  
20      static protected String    SOURCE        = "source";
21      static protected String    DESTINATION   = "destination";
22      static protected String    BOTH          = "both";
23  
24  
25      static protected Cloud cloud = null;
26      static protected NodeManager relDefManager;
27      static protected NodeManager typeRelManager;
28      static protected NodeManager insRelManager; 
29      static protected NodeManager newsManager; 
30      static protected NodeManager urlsManager; 
31      static protected NodeManager objectManager; 
32      static protected NodeList    createdNodes;
33  
34      static protected Node        news;
35      static protected Node        url;
36      static protected Node        object;
37      static protected Node        typerel;
38  
39      public TypeRelTest(String   testName) {
40          super(testName);
41      }
42  
43  
44      public void testListRelations() {       
45          RelationManagerList rml = cloud.getRelationManagers();
46          assertTrue(rml != null);
47          assertTrue(rml.size() > 0);
48          if (rml.size() == 0) {
49              fail("cannot test");
50          }       
51      }
52  
53      protected Node createRelDefNode(String   role, int dir) {
54          // create a new relation-definition
55          Node reldef = relDefManager.createNode();
56          assertTrue(relDefManager.getName().equals("reldef"));
57          assertTrue("Manager of reldefnode is not 'reldef' but " + reldef.getNodeManager().getName(), reldef.getNodeManager().getName().equals("reldef"));
58          assertTrue(reldef.getNodeManager().hasField("sname"));
59          reldef.setValue("sname", role);
60          reldef.setValue("dname", "d" + role );
61          reldef.setValue("sguiname", role);
62          reldef.setValue("dguiname", "d" + role);
63          reldef.setIntValue("dir", dir);
64          reldef.setNodeValue("builder", insRelManager);
65          reldef.commit();
66          createdNodes.add(reldef);
67          return reldef;
68      }
69  
70      /**
71       * Create bidirection relation type, and check if relationmanager in both directions can be found.
72       */
73      public void testBidirectionalCloud1() {
74          Node reldef = createRelDefNode(BIDIR_ROLE, 2);
75          typerel = typeRelManager.createNode();
76          typerel.setNodeValue("snumber", newsManager);
77          typerel.setNodeValue("dnumber", urlsManager);
78          typerel.setNodeValue("rnumber", reldef);
79          typerel.commit();
80          createdNodes.add(typerel);
81  
82          // now this relation must exist.        
83          // check if it can be found by cloud
84          RelationManagerList rml = cloud.getRelationManagers(newsManager, urlsManager, BIDIR_ROLE);
85          assertTrue(rml.size() > 0);
86          assertTrue(rml.contains(typerel));
87      }
88  
89      public void testBidirectionalCloud2() {
90          RelationManagerList rml = cloud.getRelationManagers(urlsManager, newsManager, BIDIR_ROLE);
91          assertTrue(rml.size() > 0);          
92          assertTrue(rml.contains(typerel));
93      }
94  
95  
96      public void testBidirectionalNodeManagerAllowedRelations1() {
97          // by source-manager
98          RelationManagerList rml = newsManager.getAllowedRelations((NodeManager) null, null, null);
99          assertTrue(rml.contains(typerel));
100     }
101     public void testBidirectionalNodeManagerAllowedRelations2() {
102         // by source-manager
103         RelationManagerList rml = newsManager.getAllowedRelations(urlsManager, null, null);
104         assertTrue(rml.contains(typerel));
105     }
106     public void testBidirectionalNodeManagerAllowedRelations3() {
107         // by source-manager
108         RelationManagerList rml = newsManager.getAllowedRelations(urlsManager, BIDIR_ROLE, null);
109         assertTrue(rml.contains(typerel));
110     }
111 
112 
113     public void testBidirectionalNodeManagerAllowedRelations4() {
114         // by source-manager
115         RelationManagerList rml = newsManager.getAllowedRelations(urlsManager, BIDIR_ROLE, DESTINATION);
116         assertTrue(rml.contains(typerel));
117     }
118     public void testBidirectionalNodeManagerAllowedRelations5() {
119         // by source-manager
120         RelationManagerList rml = newsManager.getAllowedRelations(urlsManager, BIDIR_ROLE, SOURCE);
121         assertFalse(rml.contains(typerel));
122     }
123     public void testBidirectionalNodeManagerAllowedRelations6() {
124         // by source-manager
125         RelationManagerList rml = newsManager.getAllowedRelations(urlsManager, BIDIR_ROLE, BOTH);
126         assertTrue(rml.contains(typerel));
127     }
128     public void testBidirectionalNodeManagerAllowedRelations7() {
129         // by source-manager
130         try {
131             newsManager.getAllowedRelations(urlsManager, OTHER_ROLE, null);
132             fail("Should have thrown exception for non-existing relations");
133         } catch (NotFoundException e) {
134         };
135     }
136     public void testBidirectionalNodeManagerAllowedRelations8() {
137         // by source-manager        
138         RelationManagerList rml = newsManager.getAllowedRelations(urlsManager, RELATED_ROLE, null);
139         assertFalse(rml.contains(typerel));
140     }
141 
142     public void testBidirectionalNodeManagerAllowedRelations9() {
143         // by source-manager
144         RelationManagerList rml = newsManager.getAllowedRelations();
145         assertTrue(rml.contains(typerel));
146     }
147 
148 
149     public void testBidirectionalNodeManagerAllowedRelations10() {
150         // by destination-manager
151         RelationManagerList rml = urlsManager.getAllowedRelations();
152         assertTrue(rml.contains(typerel));
153     }
154 
155 
156         
157 
158     public void testBidirectionalNode1() {
159         RelationManager rm = newsManager.getAllowedRelations(urlsManager, BIDIR_ROLE, DESTINATION).getRelationManager(0);
160         Relation r = rm.createRelation(news, url);
161         r.commit();
162         createdNodes.add(r);
163         // no exception should have occured.
164     }
165 
166     public void testBidirectionalNode2() {
167         RelationManager rm = newsManager.getAllowedRelations(urlsManager, BIDIR_ROLE, DESTINATION).getRelationManager(0);
168         Relation r = rm.createRelation(url, news);
169         r.commit();
170         createdNodes.add(r);
171     }
172 
173     public void testBidirectionalNode3() {
174         RelationManager rm = newsManager.getAllowedRelations(urlsManager, BIDIR_ROLE, DESTINATION).getRelationManager(0);
175         try {
176             Relation r = rm.createRelation(news, object);
177             r.commit();
178             createdNodes.add(r);
179             fail("Should not have been allowed");
180         } catch (BridgeException e) {
181         }
182         // no exception should have occured.
183     }
184 
185 
186 
187     public void testBidirectionalNode4() {
188         // make sure it is the right direction now.
189         NodeList nl = news.getRelatedNodes(urlsManager, BIDIR_ROLE, null);
190         assertTrue("" + nl, nl.contains(url));
191     }        
192     public void testBidirectionalNode5() {
193         NodeList nl = url.getRelatedNodes(newsManager);
194         assertTrue(nl.contains(news));
195     }                   
196 
197     public void testBidirectionalRelations() {
198         
199     }
200 
201 
202     
203     /*
204      * Create unidirection relation type, and check if relationmanager in only one direction can be found.
205      */
206 
207     public void testUnidirectionalCloud1() {
208         Node reldef = createRelDefNode(UNIDIR_ROLE, 1);
209 
210         typerel = typeRelManager.createNode();
211         typerel.setNodeValue("snumber", newsManager);
212         typerel.setNodeValue("dnumber", urlsManager);
213         typerel.setNodeValue("rnumber", reldef);
214         typerel.commit();
215         createdNodes.add(typerel);
216 
217 
218         // now this relation must exist.
219         RelationManagerList rml = cloud.getRelationManagers(newsManager, urlsManager, UNIDIR_ROLE);
220         assertTrue(rml.size() > 0);
221         assertTrue(rml.contains(typerel));
222     }
223 
224     public void testUnidirectionalCloud2() {
225         RelationManagerList rml = cloud.getRelationManagers(urlsManager, newsManager, UNIDIR_ROLE);
226         assertTrue(rml.size() == 0);
227         assertFalse(rml.contains(typerel));
228     }
229 
230 
231     public void testUnidirectionalNodeManagerAllowedRelations1() {
232         // by source-manager
233         RelationManagerList rml = newsManager.getAllowedRelations((NodeManager) null, null, null);
234         assertTrue(rml.contains(typerel));
235     }
236     public void testUnidirectionalNodeManagerAllowedRelations2() {
237         // by source-manager
238         RelationManagerList rml = newsManager.getAllowedRelations(urlsManager, null, null);
239         assertTrue(rml.contains(typerel));
240     }
241     public void testUnidirectionalNodeManagerAllowedRelations3() {
242         // by source-manager
243         RelationManagerList rml = newsManager.getAllowedRelations(urlsManager, UNIDIR_ROLE, null);
244         assertTrue(rml.contains(typerel));
245     }
246 
247 
248     public void testUnidirectionalNodeManagerAllowedRelations4() {
249         // by source-manager
250         RelationManagerList rml = newsManager.getAllowedRelations(urlsManager, UNIDIR_ROLE, DESTINATION);
251         assertTrue(rml.contains(typerel));
252     }
253     public void testUnidirectionalNodeManagerAllowedRelations5() {
254         // by source-manager
255         RelationManagerList rml = newsManager.getAllowedRelations(urlsManager, UNIDIR_ROLE, SOURCE);
256         assertFalse(rml.contains(typerel));
257     }
258     public void testUnidirectionalNodeManagerAllowedRelations6() {
259         // by source-manager
260         RelationManagerList rml = newsManager.getAllowedRelations(urlsManager, UNIDIR_ROLE, BOTH);
261         assertTrue(rml.contains(typerel));
262     }
263     public void testUnidirectionalNodeManagerAllowedRelations7() {
264         try {
265             newsManager.getAllowedRelations(urlsManager, OTHER_ROLE, null);
266             fail("Should have thrown exception for non-existing relations");
267         } catch (NotFoundException e) {
268         };
269     }
270     public void testUnidirectionalNodeManagerAllowedRelations8() {
271         RelationManagerList rml = newsManager.getAllowedRelations(urlsManager, RELATED_ROLE, null);
272         assertFalse(rml.contains(typerel));
273     }
274 
275     public void testUnidirectionalNodeManagerAllowedRelations9() {
276         RelationManagerList rml = newsManager.getAllowedRelations();
277         assertTrue(rml.contains(typerel));
278     }
279 
280     public void testUnidirectionalNodeManagerAllowedRelations10() {
281         RelationManagerList rml = urlsManager.getAllowedRelations();
282         assertFalse(rml.contains(typerel));
283     }
284 
285         
286 
287     public void testUnidirectionalNode1() {
288         RelationManager rm = newsManager.getAllowedRelations(urlsManager, UNIDIR_ROLE, DESTINATION).getRelationManager(0);
289         Relation r = rm.createRelation(news, url);
290         r.commit();
291         createdNodes.add(r);
292         // no exception should have occured.
293     }
294 
295     public void testUnidirectionalNode2() {
296         RelationManager rm = newsManager.getAllowedRelations(urlsManager, UNIDIR_ROLE, DESTINATION).getRelationManager(0);
297         Relation r = rm.createRelation(url, news);
298         r.commit();
299         createdNodes.add(r);
300                            
301     }
302 
303     public void testUnidirectionalNode3() {
304         // make sure it is the right direction now.
305         NodeList nl = news.getRelatedNodes(urlsManager, UNIDIR_ROLE, null);
306         assertTrue(nl.contains(url));
307     }        
308     public void testUnidirectionalNode4() {
309         NodeList nl = url.getRelatedNodes(newsManager, UNIDIR_ROLE, null);
310         assertFalse(nl.contains(news));
311     }                   
312 
313 
314 
315     public void testInheritanceRelations() {
316         Node reldef = createRelDefNode(INH_ROLE, 2);
317 
318         Node typerel = typeRelManager.createNode();
319         typerel.setNodeValue("snumber", objectManager);
320         typerel.setNodeValue("dnumber", urlsManager);
321         typerel.setNodeValue("rnumber", reldef);
322         typerel.commit();
323         createdNodes.add(typerel);
324 
325         // now this relation must exist.
326         RelationManagerList rm1 = cloud.getRelationManagers(objectManager, urlsManager, INH_ROLE);
327         assertTrue(rm1.size() > 0);
328 
329         RelationManagerIterator it = rm1.relationManagerIterator();
330         while (it.hasNext()) {
331             RelationManager rm = it.nextRelationManager(); // no exceptions..
332         }
333 
334         RelationManager rmi11 = cloud.getRelationManager(objectManager, urlsManager, INH_ROLE);
335         assertNotNull(rmi11);
336 
337         RelationManager rmi12 = cloud.getRelationManager("object", "urls", INH_ROLE);
338         assertNotNull(rmi12);
339 
340         RelationManagerList rm2 = cloud.getRelationManagers(newsManager, urlsManager, INH_ROLE);
341         assertTrue(rm2.size() > 0);
342 
343         RelationManager rmi21 = cloud.getRelationManager(newsManager, urlsManager, INH_ROLE);
344         assertNotNull(rmi21);
345 
346         RelationManager rmi22 = cloud.getRelationManager("news", "urls", INH_ROLE);
347         assertNotNull(rmi22);
348     }
349 
350 
351     public void testMultiLevelQuery() {      
352         Node reldef = createRelDefNode(MULTILEVEL_ROLE, 2);
353         Node typerel = typeRelManager.createNode();
354         typerel.setNodeValue("snumber", objectManager);
355         typerel.setNodeValue("dnumber", urlsManager);
356         typerel.setNodeValue("rnumber", reldef);
357         typerel.commit();
358         createdNodes.add(typerel);
359 
360         RelationManager rm = newsManager.getAllowedRelations(urlsManager, MULTILEVEL_ROLE, DESTINATION).getRelationManager(0);
361         Relation r = rm.createRelation(news, url);
362         r.commit();
363         createdNodes.add(r);
364 
365         NodeList nl = cloud.getList(null, // startnodes
366                                     "news," + MULTILEVEL_ROLE + ",urls", // path
367                                     "",   // fields
368                                     null, // constraints
369                                     null, // orderby
370                                     null, // directions
371                                     null, // searchDir
372                                     false // distinct
373                                     );
374        
375         assertTrue(nl.size() == 1);
376         System.out.println(nl);
377         System.out.println(nl.size());
378         NodeList nl2 = cloud.getList(null, // startnodes
379                                     "news," + MULTILEVEL_ROLE + ",object", // path
380                                     "",   // fields
381                                     null, // constraints
382                                     null, // orderby
383                                     null, // directions
384                                     null, // searchDir
385                                     false // distinct
386                                     );
387         System.out.println(nl2);
388         assertTrue(nl2.size() == 1);
389 
390     }
391 
392     private void testDestinationManagers(NodeManager sourceManager) {
393         RelationManagerList destinationManagers = sourceManager.getAllowedRelations((NodeManager) null, null, DESTINATION);
394         RelationManagerIterator i = destinationManagers.relationManagerIterator();
395         while(i.hasNext()) {
396             RelationManager rm = i.nextRelationManager();
397             assertTrue("" + rm.getSourceManager() + " is not " + sourceManager, 
398                        rm.getSourceManager().equals(sourceManager));
399         }
400     }
401 
402     public void testDestinationManagers() {
403         testDestinationManagers(newsManager);
404         testDestinationManagers(urlsManager);
405         testDestinationManagers(objectManager);
406 
407     }
408     private void testSourceManagers(NodeManager destinationManager) {
409         RelationManagerList sourceManagers      = destinationManager.getAllowedRelations((NodeManager) null, null, SOURCE);
410         RelationManagerIterator i = sourceManagers.relationManagerIterator();
411         while(i.hasNext()) {
412             RelationManager rm = i.nextRelationManager();
413             assertTrue("" + rm.getSourceManager() + " is not " + destinationManager, 
414                        rm.getDestinationManager().equals(destinationManager));
415         }
416     }
417     public void testSourceManagers() {
418         testSourceManagers(newsManager);
419         testSourceManagers(urlsManager);
420         testSourceManagers(objectManager);
421     }
422     
423     
424     private void testManagers(NodeManager manager) {
425         RelationManagerList managers  = manager.getAllowedRelations((NodeManager) null, null, null);
426         RelationManagerIterator i = managers.relationManagerIterator();
427         Cloud cloud = manager.getCloud();
428         while(i.hasNext()) {
429             RelationManager rm = i.nextRelationManager();
430             assertTrue("Both " + rm.getDestinationManager() + " and " + rm.getSourceManager() + " are not " + manager, 
431                        rm.getDestinationManager().equals(manager) || rm.getSourceManager().equals(manager));
432 
433             RelationManager refetched = cloud.getRelationManager(rm.getSourceManager(), rm.getDestinationManager(), rm.getForwardRole());
434             assertTrue(refetched.getSourceManager().equals(rm.getSourceManager()));
435             assertTrue(refetched.getDestinationManager().equals(rm.getDestinationManager()));
436             assertTrue(refetched.getForwardRole().equals(rm.getForwardRole()));
437         }
438     }
439 
440     public void testManagers() {
441         testManagers(newsManager);
442         testManagers(urlsManager);
443         testManagers(objectManager);
444     }
445 
446 
447     public void testClearUpMess() {
448         //        System.out.println("Clearing up the mess");
449         NodeIterator i = createdNodes.nodeIterator();
450         while (i.hasNext()) i.next(); // fast forward.
451 
452         while (i.hasPrevious()) {
453             Node node = (Node) i.previous();
454             System.out.print("D"); //eleting " + node);
455             node.delete();
456         }
457     }
458 
459     /**
460      * Sets up before each test.
461      */
462     public void setUp() throws Exception   {
463         if (cloud == null) {            
464             startMMBase();
465             //cloud = getRemoteCloud();
466             cloud = getCloud();
467             
468             // needed builders for this test.
469             try {
470                 relDefManager  = cloud.getNodeManager("reldef");
471                 typeRelManager = cloud.getNodeManager("typerel");
472                 insRelManager  = cloud.getNodeManager("insrel");
473                 newsManager    = cloud.getNodeManager("news");
474                 urlsManager    = cloud.getNodeManager("urls");
475                 objectManager  = cloud.getNodeManager("object");
476             } catch (NotFoundException e) {
477                 throw new Exception  ("Test cases cannot be performed because " + e.getMessage() + " Please arrange this in your cloud before running this TestCase.");
478              }
479 
480             createdNodes = cloud.createNodeList();
481             assertNotNull("Could not create remotely a nodelist" , createdNodes);
482 
483             news = newsManager.createNode();
484             news.setValue("title", "test node");
485             news.commit();
486             createdNodes.add(news);
487             
488             url = urlsManager.createNode();
489             url.setValue("url", "http://test.mmbase.org");
490             url.setValue("name", "test url");
491             url.commit();
492             createdNodes.add(url);
493 
494             object = objectManager.createNode();
495             object.commit();
496             createdNodes.add(object);
497 
498         }
499     }
500     
501 }
502     
503
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags