ClusterBuilderTest


1   package org.mmbase.module.core;
2   
3   import java.util.*;
4   
5   import junit.framework.Test;
6   import junit.framework.TestCase;
7   import junit.framework.TestSuite;
8   
9   import org.mmbase.module.corebuilders.FieldDefs;
10  import org.mmbase.module.corebuilders.InsRel;
11  import org.mmbase.storage.search.FieldCompareConstraint;
12  import org.mmbase.storage.search.FieldValueConstraint;
13  import org.mmbase.storage.search.RelationStep;
14  import org.mmbase.storage.search.SearchQuery;
15  import org.mmbase.storage.search.SortOrder;
16  import org.mmbase.storage.search.Step;
17  import org.mmbase.storage.search.StepField;
18  import org.mmbase.storage.search.implementation.BasicFieldValueConstraint;
19  import org.mmbase.storage.search.implementation.BasicSearchQuery;
20  import org.mmbase.storage.search.implementation.BasicStep;
21  import org.mmbase.storage.search.implementation.BasicStepField;
22  import org.mmbase.storage.search.implementation.NodeSearchQuery;
23  
24  /**
25   * JUnit tests.
26   *
27   * @author Rob van Maris
28   * @version $Revision: 1.6 $
29   */
30  public class ClusterBuilderTest extends TestCase {
31  
32      /**
33       * JUnit test user.
34       * Nodes created by this user must be removed in the tearDown.
35       */
36      private final static String   JUNIT_USER = "JUnitTester";
37  
38      /** Test instance. */
39      private ClusterBuilder instance;
40  
41      /** MMBase query. */
42      private MMBase mmbase = null;
43  
44      /** News builder, used as builder example. */
45      private MMObjectBuilder news = null;
46  
47      /** People builder, used as builder example. */
48      private MMObjectBuilder people = null;
49  
50      /** Insrel builder, used as relation builder example. */
51      /** Test nodes, created in setUp, deleted in tearDown. */
52      private List testNodes = new ArrayList();
53  
54      public ClusterBuilderTest(java.lang.String   testName) {
55          super(testName);
56      }
57  
58      public static void main(java.lang.String  [] args) {
59          junit.textui.TestRunner.run(suite());
60          System.exit(0);
61      }
62  
63      /**
64       * Sets up before each test.
65       */
66      public void setUp() throws Exception   {
67          MMBaseContext.init();
68          mmbase = MMBase.getMMBase();
69          mmbase.getInsRel();
70          news = mmbase.getBuilder("news");
71          people = mmbase.getBuilder("people");
72          assertTrue(
73              "Builder 'news' must be defined in order to run these tests.",
74              news != null);
75          assertTrue(
76              "Builder 'people' must be defined in order to run these tests.",
77              people != null);
78  
79          instance = mmbase.getClusterBuilder();
80  
81          // Add testnodes.
82          MMObjectNode news1 = news.getNewNode(JUNIT_USER);
83          news1.setValue("title", "_TE$T_1");
84          news1.setValue("body", "News created for testing only.");
85          news.insert(JUNIT_USER, news1);
86          testNodes.add(news1);
87  
88          MMObjectNode news2 = news.getNewNode(JUNIT_USER);
89          news2.setValue("title", "_TE$T_2");
90          news2.setValue("body", "News created for testing only.");
91          news.insert(JUNIT_USER, news2);
92          testNodes.add(news2);
93      }
94  
95      /**
96       * Tears down after each test.
97       */
98      public void tearDown() throws Exception   {
99          // Remove all testnodes.
100         Iterator iTestNodes = testNodes.iterator();
101         while (iTestNodes.hasNext()) {
102             MMObjectNode testNode = (MMObjectNode) iTestNodes.next();
103             MMObjectBuilder builder = testNode.getBuilder();
104             builder.removeRelations(testNode);
105             builder.removeNode(testNode);
106         }
107     }
108 
109     public static Test suite() {
110         TestSuite suite = new TestSuite(ClusterBuilderTest.class);
111 
112         return suite;
113     }
114 
115     /**
116      * Test of TypeRel method getAllowedRelations.
117      * Tests for bug #5795 or similar bugs.
118      */
119     public void testGetAllowedRelations() {
120        int newsNr = news.getObjectType();
121        int peopleNr = people.getObjectType();
122        int relatedNr = mmbase.getRelDef().getNumberByName("related");
123        Enumeration eAllowedRelations = mmbase.getTypeRel().getAllowedRelations(newsNr, peopleNr);
124        assertTrue(eAllowedRelations.hasMoreElements());
125        MMObjectNode typeRelNode = (MMObjectNode) eAllowedRelations.nextElement();
126        assertTrue(typeRelNode.toString(),
127          typeRelNode.getIntValue("rnumber") == relatedNr);
128        eAllowedRelations = mmbase.getTypeRel().getAllowedRelations(peopleNr, newsNr);
129        assertTrue("\nbug #5795 or a similar bug",  eAllowedRelations.hasMoreElements());
130        typeRelNode = (MMObjectNode) eAllowedRelations.nextElement();
131        assertTrue(typeRelNode.toString(),
132          typeRelNode.getIntValue("rnumber") == relatedNr);
133     }
134 
135     /** Test of testGetClusterNodes method, of class org.mmbase.module.core.ClusterBuilder. */
136     public void testGetClusterNodes() throws Exception   {
137         BasicSearchQuery query = new BasicSearchQuery();
138         BasicStep newsStep = query.addStep(news).setAlias("news1");
139         FieldDefs newsTitle = news.getField("title");
140         BasicStepField newsNameField = query.addField(newsStep, newsTitle).setAlias("a_title"); 
141         // should not affect result node fieldnames!
142         query.addSortOrder(newsNameField) .setDirection(SortOrder.ORDER_ASCENDING);
143         FieldDefs newsBody = news.getField("body");
144         query.addField(newsStep, newsBody);
145         FieldDefs newsOwner = news.getField("owner");
146         BasicStepField newsOwnerField = query.addField(newsStep, newsOwner);
147         BasicFieldValueConstraint constraint = new BasicFieldValueConstraint(newsOwnerField, JUNIT_USER);
148         query.setConstraint(constraint);
149         List resultNodes = instance.getClusterNodes(query);
150         Iterator iResultNodes = resultNodes.iterator();
151         Iterator iTestNodes = testNodes.iterator();
152         while (iTestNodes.hasNext()) {
153             MMObjectNode testNode = (MMObjectNode) iTestNodes.next();
154             assertTrue("Found only one news node!", iResultNodes.hasNext());
155             MMObjectNode resultNode = (MMObjectNode) iResultNodes.next();
156             assertTrue(resultNode instanceof ClusterNode);
157             assertTrue(resultNode.getBuilder() == mmbase.getClusterBuilder());
158             assertTrue(resultNode.getStringValue("news1.title") != null
159             && resultNode.getStringValue("news1.title").length() > 0);
160             assertTrue(resultNode.getStringValue("news1.title").equals(testNode.getStringValue("title")));
161             assertTrue(resultNode.getStringValue("news1.body") != null
162             && resultNode.getStringValue("news1.body").length() > 0);
163             assertTrue(resultNode.getStringValue("news1.body").equals(testNode.getStringValue("body")));
164             assertTrue(resultNode.getStringValue("news1.owner") != null
165             && resultNode.getStringValue("news1.owner").length() > 0);
166             assertTrue(resultNode.getStringValue("news1.owner").equals(testNode.getStringValue("owner")));
167         }
168         assertTrue(!iResultNodes.hasNext());
169     }
170 
171     /** Test of getUniqueTableAlias() method, of class org.mmbase.module.core.ClusterBuilder. */
172     public void testGetUniqueTableAlias() {
173         List originalAliases = Arrays.asList(new Object  [] {"test1", "test2"});
174         Set tableAliases = new HashSet();
175         String   alias = instance.getUniqueTableAlias("test", tableAliases, originalAliases);
176         assertTrue(alias.equals("test"));
177         assertTrue(tableAliases.size() == 1);
178         assertTrue(tableAliases.contains("test"));
179         assertTrue(originalAliases.size() == 2);
180 
181         alias = instance.getUniqueTableAlias("test", tableAliases, originalAliases);
182         assertTrue(alias.equals("test0"));
183         assertTrue(tableAliases.size() == 2);
184         assertTrue(tableAliases.contains("test0"));
185         assertTrue(originalAliases.size() == 2);
186 
187         alias = instance.getUniqueTableAlias(
188             "test1", tableAliases, originalAliases);
189         assertTrue(alias.equals("test1"));
190         assertTrue(tableAliases.size() == 3);
191         assertTrue(tableAliases.contains("test1"));
192         assertTrue(originalAliases.size() == 2);
193 
194         alias = instance.getUniqueTableAlias(
195             "test", tableAliases, originalAliases);
196         assertTrue(alias.equals("test3"));
197         assertTrue(tableAliases.size() == 4);
198         assertTrue(tableAliases.contains("test1"));
199         assertTrue(originalAliases.size() == 2);
200 
201         for (int i = 4; i < 10; i++) {
202             alias = instance.getUniqueTableAlias(
203                 "test" + (i - 1), tableAliases, originalAliases);
204             assertTrue(alias, alias.equals("test" + i));
205             assertTrue(tableAliases.size() == i + 1);
206             assertTrue(tableAliases.contains("test" + i));
207             assertTrue(originalAliases.size() == 2);
208         }
209 
210         try {
211             // Can't generate another unique value for this string,
212             // should throw IndexOutOfBoundsException.
213             instance.getUniqueTableAlias("test", tableAliases, originalAliases);
214             fail("Can't generate another unique value for this string, "
215                 + "should throw IndexOutOfBoundsException.");
216         } catch (IndexOutOfBoundsException   e) {}
217 
218         assertTrue(tableAliases.size() == 10);
219         for (int i = 0; i < 10; i++) {
220             if (i == 2) {
221                 assertTrue(!tableAliases.contains("test" + i));
222             } else {
223                 assertTrue(tableAliases.contains("test" + i));
224             }
225         }
226         assertTrue(tableAliases.contains("test"));
227 
228         // Alias containing white space.
229         alias = instance.getUniqueTableAlias(
230             "white space", tableAliases, originalAliases);
231         assertTrue(alias, alias.equals("white space"));
232         assertTrue(tableAliases.contains("white space"));
233     }
234 
235     /** Test of getBuilder() method, of class org.mmbase.module.core.ClusterBuilder. */
236     public void testGetBuilder() {
237         // --- requires role "related" to be defined: ---
238         Integer   related = new Integer  (
239             mmbase.getRelDef().getNumberByName("related"));
240         assertTrue("Role 'related' must be defined to run this test.",
241             related.intValue() != -1);
242 
243         Map nodes = new HashMap();
244         assertTrue(instance.getBuilder("news", nodes).equals(news));
245         assertTrue(nodes.size() == 0);
246 
247         assertTrue(instance.getBuilder("news0", nodes).equals(news));
248         assertTrue(nodes.size() == 0);
249 
250         assertTrue(instance.getBuilder("news1", nodes).equals(news));
251         assertTrue(nodes.size() == 0);
252 
253         assertTrue(instance.getBuilder("related", nodes).equals(mmbase.getInsRel()));
254         assertTrue("Nodes is " + nodes + " should be size 1", nodes.size() == 1);
255         assertTrue(nodes.get("related").equals(related));
256 
257         assertTrue(instance.getBuilder("related0", nodes).
258             equals(mmbase.getInsRel()));
259         assertTrue(nodes.size() == 2);
260         assertTrue(nodes.get("related0").equals(related));
261 
262         try {
263             // Unknown builder or role, should throw IllegalArgumentException.
264             instance.getBuilder("xxxx", nodes);
265             fail("Unknown builder or role, "
266                 + "should throw IllegalArgumentException.");
267         } catch (IllegalArgumentException   e) {}
268     }
269 
270     /** Test of addSteps() method, of class org.mmbase.module.core.ClusterBuilder. */
271     public void testAddSteps() {
272         // --- requires role "related" to be defined: ---
273         int related = mmbase.getRelDef().getNumberByName("related");
274         assertTrue("Role 'related' must be defined to run this test.",
275             related != -1);
276 
277         BasicSearchQuery query = new BasicSearchQuery();
278         Map roles = new HashMap();
279         Map fieldsByName = new HashMap();
280         List tables = Arrays.asList(new Object  [] {"news", "news1"});
281         Map stepsByAlias = instance.addSteps(query, tables, roles, true, fieldsByName);
282         // Test steps and returned map.
283         assertTrue(stepsByAlias.size() == 3);
284         List steps = query.getSteps();
285         assertTrue(steps.size() == 3);
286         Step step0 = (Step) steps.get(0);
287         assertTrue(step0.getTableName().equals("news"));
288         assertTrue(step0.getAlias().equals("news"));
289         assertTrue(stepsByAlias.get("news") == step0);
290         Step step1 = (RelationStep) steps.get(1);
291         assertTrue(step1.getTableName().equals("insrel"));
292         assertTrue(step1.getAlias().startsWith("insrel"));
293         assertTrue(stepsByAlias.get("insrel") == step1);
294         Step step2 = (Step) steps.get(2);
295         assertTrue(step2.getTableName().equals("news"));
296         assertTrue(step2.getAlias().equals("news1"));
297         assertTrue(stepsByAlias.get("news1") == step2);
298         // Test (number)fields and fields map.
299         assertTrue(fieldsByName.toString(), fieldsByName.size() == 2);
300         List fields = query.getFields();
301         assertTrue(fields.size() == 2);
302         StepField field0 = (StepField) fields.get(0);
303         assertTrue(field0.getStep() == step0);
304         assertTrue(field0.getFieldName().equals("number"));
305         assertTrue(fieldsByName.get("news.number") == field0);
306         StepField field1 = (StepField) fields.get(1);
307         assertTrue(field1.getStep() == step2);
308         assertTrue(field1.getFieldName().equals("number"));
309         assertTrue(fieldsByName.get("news1.number") == field1);
310         // Test roles.
311         assertTrue("Roles is " + roles + " not{}", roles.size() == 0);
312 
313         query = new BasicSearchQuery();
314         roles.clear();
315         fieldsByName.clear();
316         tables = Arrays.asList(new Object  [] {"news", "news1"});
317         stepsByAlias = instance.addSteps(query, tables, roles, false, fieldsByName);
318         // Test steps and returned map.
319         assertTrue(stepsByAlias.size() == 3);
320         steps = query.getSteps();
321         assertTrue(steps.size() == 3);
322         step0 = (Step) steps.get(0);
323         assertTrue(step0.getTableName().equals("news"));
324         assertTrue(step0.getAlias().equals("news"));
325         assertTrue(stepsByAlias.get("news") == step0);
326         step1 = (RelationStep) steps.get(1);
327         assertTrue(step1.getTableName().equals("insrel"));
328         assertTrue(step1.getAlias().startsWith("insrel"));
329         assertTrue(stepsByAlias.get("insrel") == step1);
330         step2 = (Step) steps.get(2);
331         assertTrue(step2.getTableName().equals("news"));
332         assertTrue(step2.getAlias().equals("news1"));
333         assertTrue(stepsByAlias.get("news1") == step2);
334         // Test (number)fields and fields map.
335         assertTrue(fieldsByName.size() == 0);
336         fields = query.getFields();
337         assertTrue(fields.size() == 0);
338         // Test roles.
339         assertTrue(roles.size() == 0);
340 
341         query = new BasicSearchQuery();
342         roles.clear();
343         fieldsByName.clear();
344         tables = Arrays.asList(new Object  [] {"news", "related", "news1"});
345         stepsByAlias = instance.addSteps(query, tables, roles, true, fieldsByName);
346         // Test steps and returned map.
347         assertTrue(stepsByAlias.size() == 3);
348         steps = query.getSteps();
349         assertTrue(steps.size() == 3);
350         step0 = (Step) steps.get(0);
351         assertTrue(step0.getTableName().equals("news"));
352         assertTrue(step0.getAlias().equals("news"));
353         assertTrue(stepsByAlias.get("news") == step0);
354         step1 = (RelationStep) steps.get(1);
355         assertTrue(step1.getTableName().equals("insrel"));
356         assertTrue(step1.getAlias().equals("related"));
357         assertTrue(stepsByAlias.get("related") == step1);
358         step2 = (Step) steps.get(2);
359         assertTrue(step2.getTableName().equals("news"));
360         assertTrue(step2.getAlias().equals("news1"));
361         assertTrue(stepsByAlias.get("news1") == step2);
362         // Test (number)fields and fields map.
363         assertTrue(fieldsByName.size() == 3);
364         fields = query.getFields();
365         assertTrue(fields.size() == 3);
366         field0 = (StepField) fields.get(0);
367         assertTrue(field0.getStep() == step0);
368         assertTrue(field0.getFieldName().equals("number"));
369         assertTrue(fieldsByName.get("news.number") == field0);
370         field1 = (StepField) fields.get(1);
371         assertTrue(field1.getStep() == step1);
372         assertTrue(field1.getFieldName().equals("number"));
373         assertTrue(fieldsByName.get("related.number") == field1);
374         StepField field2 = (StepField) fields.get(2);
375         assertTrue(field2.getStep() == step2);
376         assertTrue(field2.getFieldName().equals("number"));
377         assertTrue(fieldsByName.get("news1.number") == field2);
378         // Test roles.
379         assertTrue("Roles is " + roles + " wich has not size 1", roles.size() == 1);
380         Integer   number = (Integer  ) roles.get("related");
381         assertTrue("" + number.intValue() + " != " + related, number.intValue() == related);
382 
383         query = new BasicSearchQuery();
384         roles.clear();
385         fieldsByName.clear();
386         tables = Arrays.asList(new Object  [] {"news", "related", "news1", "related", "news"});
387         stepsByAlias = instance.addSteps(query, tables, roles, true, fieldsByName);
388         // Test steps and returned map.
389         assertTrue(stepsByAlias.size() == 5);
390         steps = query.getSteps();
391         assertTrue(steps.size() == 5);
392         step0 = (Step) steps.get(0);
393         assertTrue(step0.getTableName().equals("news"));
394         assertTrue(step0.getAlias().equals("news"));
395         assertTrue(stepsByAlias.get("news") == step0);
396         step1 = (RelationStep) steps.get(1);
397         assertTrue(step1.getTableName().equals("insrel"));
398         assertTrue(step1.getAlias().equals("related"));
399         assertTrue(stepsByAlias.get("related") == step1);
400         step2 = (Step) steps.get(2);
401         assertTrue(step2.getTableName().equals("news"));
402         assertTrue(step2.getAlias().equals("news1"));
403         assertTrue(stepsByAlias.get("news1") == step2);
404         Step step3 = (Step) steps.get(3);
405         assertTrue(step3.getTableName().equals("insrel"));
406         assertTrue(step3.getAlias().equals("related0"));
407         assertTrue(stepsByAlias.get("related0") == step3);
408         Step step4 = (Step) steps.get(4);
409         assertTrue(step4.getTableName().equals("news"));
410         assertTrue(step4.getAlias().equals("news0"));
411         assertTrue(stepsByAlias.get("news0") == step4);
412         // Test (number)fields and field map.
413         assertTrue(fieldsByName.size() == 3);
414         fields = query.getFields();
415         assertTrue(fields.toString(), fields.size() == 3);
416         for (int i = 0; i < 3; i++) {
417             StepField field = (StepField) fields.get(i);
418             assertTrue(field.getStep() == steps.get(i));
419             assertTrue(field.getFieldName().equals("number"));
420             assertTrue(fieldsByName.get(tables.get(i) + ".number") == field);
421         }
422         // Test roles.
423         assertTrue("Roles is " + roles + " which is not size 2. There are to roles, so related and related0 must be availab.e", roles.size() == 2);
424         number = (Integer  ) roles.get("related");
425         assertTrue(number.intValue() == related);
426     }
427 
428     public void testAddFields() {
429         BasicSearchQuery query = new BasicSearchQuery();
430         Map roles = new HashMap();
431         Map fieldsByName = new HashMap();
432         List tables = Arrays.asList(
433             new Object  [] {"news", "related", "people", "news1"});
434         Map stepsByAlias = instance.addSteps(query, tables, roles, true, fieldsByName);
435         assertTrue(query.getFields().size() == 4);
436         assertTrue(fieldsByName.size() == 4);
437 
438         instance.addFields(query, "news.title", stepsByAlias, fieldsByName);
439 
440         StepField stepField = getField(query, "news", "title");
441         assertTrue(stepField != null);
442         assertTrue(stepField.equals(fieldsByName.get("news.title")));
443         assertTrue(stepField.getAlias() == null);
444         assertTrue(query.getFields().size() == 5);
445         assertTrue(fieldsByName.size() == 5);
446 
447         instance.addFields(query, "related.number", stepsByAlias, fieldsByName);
448         stepField = getField(query, "related", "number");
449         assertTrue(stepField != null);
450         assertTrue(stepField.equals(fieldsByName.get("related.number")));
451         assertTrue(stepField.getAlias() == null);
452         // Not added twice.
453         assertTrue(query.getFields().size() == 5);
454         assertTrue(fieldsByName.size() == 5);
455 
456         instance.addFields(query, "people.firstname", stepsByAlias, fieldsByName);
457         stepField = getField(query, "people", "firstname");
458         assertTrue(stepField != null);
459         assertTrue(stepField.equals(fieldsByName.get("people.firstname")));
460         assertTrue(stepField.getAlias() == null);
461         assertTrue(query.getFields().size() == 6);
462         assertTrue(fieldsByName.size() == 6);
463 
464         instance.addFields(query, "news1.title", stepsByAlias, fieldsByName);
465         stepField = getField(query, "news1", "title");
466         assertTrue(stepField != null);
467         assertTrue(stepField.equals(fieldsByName.get("news1.title")));
468         assertTrue(stepField.getAlias() == null);
469         assertTrue(query.getFields().size() == 7);
470         assertTrue(fieldsByName.size() == 7);
471 
472         try {
473             // Invalid expression, should throw IllegalArgumentException.
474             instance.addFields(query, "newsnumber", stepsByAlias, fieldsByName);
475             fail("Invalid expression, should throw IllegalArgumentException.");
476         } catch (IllegalArgumentException   e) {}
477 
478         try {
479             // Invalid expression, should throw IllegalArgumentException.
480             instance.addFields(query, ".newsnumber", stepsByAlias, fieldsByName);
481             fail("Invalid expression, should throw IllegalArgumentException.");
482         } catch (IllegalArgumentException   e) {}
483 
484         try {
485             // Invalid expression, should throw IllegalArgumentException.
486             instance.addFields(query, "newsnumber.", stepsByAlias, fieldsByName);
487             fail("Invalid expression, should throw IllegalArgumentException.");
488         } catch (IllegalArgumentException   e) {}
489 
490         try {
491             // Unknown table alias, should throw IllegalArgumentException.
492             instance.addFields(query, "xxx.number", stepsByAlias, fieldsByName);
493             fail("Unknown table alias, should throw IllegalArgumentException.");
494         } catch (IllegalArgumentException   e) {}
495 
496         try {
497             // Unknown field name, should throw IllegalArgumentException.
498             instance.addFields(query, "news.xxx", stepsByAlias, fieldsByName);
499             fail("Unknown table alias, should throw IllegalArgumentException.");
500         } catch (IllegalArgumentException   e) {}
501 
502         instance.addFields(query, "f1(news.body,news1.body)", stepsByAlias, fieldsByName);
503         stepField = getField(query, "news", "body");
504         assertTrue(stepField != null);
505         assertTrue(stepField.equals(fieldsByName.get("news.body")));
506         assertTrue(stepField.getAlias() == null);
507         stepField = getField(query, "news1", "body");
508         assertTrue(stepField != null);
509         assertTrue(stepField.equals(fieldsByName.get("news1.body")));
510         assertTrue(query.getFields().size() == 9);
511         assertTrue(fieldsByName.size() == 9);
512     }
513 
514     /** Test of addRelationDirections() method, of class org.mmbase.module.core.ClusterBuilder. */
515     public void testAddRelationDirections() {
516         // --- requires role "related" to be defined: ---
517         int related = mmbase.getRelDef().getNumberByName("related");
518         assertTrue("Role 'related' must be defined to run this test.", related != -1);
519         // --- requires typerel to be defined for
520         //     source, role, destination = "news", "related", "people": ---
521         assertTrue("This (bidirectional) relation-type must be defined to run "
522                    + "this test: source, role, destination = "
523                    + "'news', 'related', 'people'",
524             mmbase.getTypeRel().reldefCorrect(mmbase.getTypeDef().getIntValue("news"),
525                                               mmbase.getTypeDef().getIntValue("people"), related));
526         // --- requires relations to define a 'dir' field --
527         assertTrue("Relations must define a 'dir' field to run this test.", InsRel.usesdir);
528 
529         BasicSearchQuery query = new BasicSearchQuery();
530         Map roles = new HashMap();
531         Map fieldsByName = new HashMap();
532         List tables = Arrays.asList(new Object  [] {"news", "related", "people", "insrel", "news0"});
533         Map stepsByAlias = instance.addSteps(query, tables, roles, true, fieldsByName);
534         instance.addRelationDirections(query, Arrays.asList(new Integer  [] {new Integer  (ClusterBuilder.SEARCH_ALL)}), roles);
535 
536         RelationStep relation1 = (RelationStep) stepsByAlias.get("related");
537         assertTrue(relation1.getDirectionality() == RelationStep.DIRECTIONS_DESTINATION);
538         assertTrue(!relation1.getCheckedDirectionality());
539         RelationStep relation2 = (RelationStep) stepsByAlias.get("insrel");
540         assertTrue(relation2.getDirectionality() == RelationStep.DIRECTIONS_SOURCE);
541         assertTrue(!relation2.getCheckedDirectionality());
542 
543         query = new BasicSearchQuery();
544         stepsByAlias = instance.addSteps(query, tables, roles, true, fieldsByName);
545         instance.addRelationDirections(query, Arrays.asList(new Integer  [] {new Integer  (ClusterBuilder.SEARCH_BOTH)}), roles);
546         relation1 = (RelationStep) stepsByAlias.get("related");
547         assertTrue(relation1.getDirectionality() == RelationStep.DIRECTIONS_DESTINATION);
548         assertTrue(relation1.getCheckedDirectionality());
549         relation2 = (RelationStep) stepsByAlias.get("insrel");
550         assertTrue(relation2.getDirectionality() == RelationStep.DIRECTIONS_SOURCE);
551         assertTrue(relation2.getCheckedDirectionality());
552 
553         query = new BasicSearchQuery();
554         stepsByAlias = instance.addSteps(query, tables, roles, true, fieldsByName);
555         instance.addRelationDirections(query, Arrays.asList(new Integer  [] {new Integer  (ClusterBuilder.SEARCH_EITHER)}), roles);
556         relation1 = (RelationStep) stepsByAlias.get("related");
557         assertTrue(relation1.getDirectionality() == RelationStep.DIRECTIONS_DESTINATION);
558         assertTrue(relation1.getCheckedDirectionality());
559         relation2 = (RelationStep) stepsByAlias.get("insrel");
560         assertTrue(relation2.getDirectionality() == RelationStep.DIRECTIONS_SOURCE);
561         assertTrue(relation2.getCheckedDirectionality());
562 
563         query = new BasicSearchQuery();
564         stepsByAlias = instance.addSteps(query, tables, roles, true, fieldsByName);
565         instance.addRelationDirections(query, Arrays.asList(new Integer  [] {new Integer  (ClusterBuilder.SEARCH_DESTINATION)}), roles);
566         relation1 = (RelationStep) stepsByAlias.get("related");
567         assertTrue(relation1.getDirectionality() == RelationStep.DIRECTIONS_DESTINATION);
568         assertTrue(relation1.getCheckedDirectionality());
569         relation2 = (RelationStep) stepsByAlias.get("insrel");
570         assertTrue(relation2.getDirectionality() == RelationStep.DIRECTIONS_DESTINATION);
571         assertTrue(relation2.getCheckedDirectionality());
572 
573         query = new BasicSearchQuery();
574         stepsByAlias = instance.addSteps(query, tables, roles, true, fieldsByName);
575         instance.addRelationDirections(query, Arrays.asList(new Integer  [] {new Integer  (ClusterBuilder.SEARCH_SOURCE)}), roles);
576         relation1 = (RelationStep) stepsByAlias.get("related");
577         assertTrue(relation1.getDirectionality() == RelationStep.DIRECTIONS_SOURCE);
578         assertTrue(relation1.getCheckedDirectionality());
579         relation2 = (RelationStep) stepsByAlias.get("insrel");
580         assertTrue(relation2.getDirectionality() == RelationStep.DIRECTIONS_SOURCE);
581         assertTrue(relation2.getCheckedDirectionality());
582     }
583 
584     public void testAddSortOrders() {
585         BasicSearchQuery query = new BasicSearchQuery();
586         Map roles = new HashMap();
587         Map fieldsByName = new HashMap();
588         List tables = Arrays.asList(
589             new Object  [] {"news", "related", "people", "news1"});
590         instance.addSteps(query, tables, roles, true, fieldsByName);
591         Vector fieldNames = new Vector(Arrays.asList(
592             new Object  [] {"news.number"}));
593         Vector directions = new Vector();
594         instance.addSortOrders(query, fieldNames, directions, fieldsByName);
595         List sortOrders = query.getSortOrders();
596         assertTrue(sortOrders.size() == 1);
597         SortOrder sortOrder0 = (SortOrder) sortOrders.get(0);
598         assertTrue(sortOrder0.getField()
599             == (StepField) fieldsByName.get("news.number"));
600         assertTrue(sortOrder0.getDirection() == SortOrder.ORDER_ASCENDING);
601 
602         query = new BasicSearchQuery();
603         instance.addSteps(query, tables, roles, true, fieldsByName);
604         fieldNames = new Vector(Arrays.asList(
605             new Object  [] {"news.number", "related.number", "people.firstname"}));
606         directions = new Vector(Arrays.asList(
607             new Object  [] {"DOWN", "UP"}));
608         instance.addSortOrders(query, fieldNames, directions, fieldsByName);
609         sortOrders = query.getSortOrders();
610         assertTrue(sortOrders.size() == 3);
611         sortOrder0 = (SortOrder) sortOrders.get(0);
612         assertTrue(sortOrder0.getField()
613             == (StepField) fieldsByName.get("news.number"));
614         assertTrue(sortOrder0.getDirection() == SortOrder.ORDER_DESCENDING);
615         SortOrder sortOrder1 = (SortOrder) sortOrders.get(1);
616         assertTrue(sortOrder1.getField()
617             == (StepField) fieldsByName.get("related.number"));
618         assertTrue(sortOrder1.getDirection() == SortOrder.ORDER_ASCENDING);
619 
620         // sorOrder2 is on a field that has not been added.
621         SortOrder sortOrder2 = (SortOrder) sortOrders.get(2);
622         StepField sortField2 = sortOrder2.getField();
623         assertTrue(sortField2.getAlias() == null);
624         assertTrue(sortOrder2.getDirection() == SortOrder.ORDER_DESCENDING);
625     }
626 
627     public void testGetNodesStep() throws Exception   {
628         // Get number of a news node.
629         List newsNodes = news.getNodes(new NodeSearchQuery(news));
630         MMObjectNode newsNode = (MMObjectNode) newsNodes.get(0);
631         int nodeNumber = newsNode.getNumber();
632 
633         BasicSearchQuery query = new BasicSearchQuery();
634         BasicStep objectStep = query.addStep(mmbase.getBuilder("object"));
635 
636         assertTrue(
637             instance.getNodesStep(query.getSteps(), -1) == null);
638 
639         // Find step for parentbuilder.
640         assertTrue(
641             instance.getNodesStep(query.getSteps(), nodeNumber) == objectStep);
642 
643         query.addStep(mmbase.getInsRel());
644         BasicStep newsStep = query.addStep(mmbase.getBuilder("news"));
645 
646         // Find step for builder.
647         assertTrue(
648             instance.getNodesStep(query.getSteps(), nodeNumber) == newsStep);
649     }
650 
651     public void testGetMultiLevelSearchQuery() {
652 
653         List snodes = new ArrayList();
654         Iterator iTestNodes = testNodes.iterator();
655         while (iTestNodes.hasNext()) {
656             MMObjectNode testNode = (MMObjectNode) iTestNodes.next();
657             snodes.add(testNode.getIntegerValue("number").toString());
658         }
659         List fields = Arrays.asList(
660             new String  [] {"news.title", "people.number"});
661         String   pdistinct = "YES";
662         List tables = Arrays.asList(
663             new String  [] {"people", "insrel", "news"});
664         String   where = "where lower(people.firstname) like '%test%'";
665         List order = Arrays.asList(
666             new String  [] {"people.number", "news.title"});
667         List directions = Arrays.asList(
668             new String  [] {"DOWN", "UP"});
669         int searchDir = ClusterBuilder.SEARCH_BOTH;
670 
671         SearchQuery query = instance.getMultiLevelSearchQuery(
672             snodes, fields, pdistinct, tables, where, order,
673             directions, searchDir);
674 
675         // Test steps.
676         List steps = query.getSteps();
677         assertTrue(steps.size() == 3);
678         Step step0 = (Step) steps.get(0);
679         assertTrue(step0.getTableName().equals("people"));
680         RelationStep step1 = (RelationStep) steps.get(1);
681         assertTrue(step1.getTableName().equals("insrel"));
682         assertTrue(step1.getRole() == null);
683         assertTrue(step1.getCheckedDirectionality());
684         Step step2 = (Step) steps.get(2);
685         assertTrue(step2.getTableName().equals("news"));
686 
687         // Test nodes.
688         assertTrue(snodes.size() > 0); // For test to succeed.
689         assertTrue(step0.getNodes().size() == 0);
690         assertTrue(step1.getNodes().size() == 0);
691         assertTrue(step2.getNodes().size() == snodes.size());
692         Iterator iSNodes = snodes.iterator();
693         Iterator iNodes = step2.getNodes().iterator();
694         while (iNodes.hasNext()) {
695             Integer   node = (Integer  ) iNodes.next();
696             String   snode = (String  ) iSNodes.next();
697             assertTrue(node.toString() + " " + snode, node.toString().equals(snode));
698         }
699 
700         // Test distinct
701         assertTrue(query.isDistinct());
702 
703         // Test fields.
704         List stepFields = query.getFields();
705         assertTrue(stepFields.size() == 2);
706         StepField field0 = (StepField) stepFields.get(0);
707         assertTrue(field0.getStep().getTableName().equals("news"));
708         assertTrue(field0.getFieldName().equals("title"));
709         StepField field1 = (StepField) stepFields.get(1);
710         assertTrue(field1.getStep().getTableName().equals("people"));
711         assertTrue(field1.getFieldName().equals("number"));
712 
713         // Test sortorders.
714         List sortOrders = query.getSortOrders();
715         assertTrue(sortOrders.size() == 2);
716         SortOrder sortOrder0 = (SortOrder) sortOrders.get(0);
717         assertTrue(sortOrder0.getField() == field1);
718         assertTrue(sortOrder0.getDirection() == SortOrder.ORDER_DESCENDING);
719         SortOrder sortOrder1 = (SortOrder) sortOrders.get(1);
720         assertTrue(sortOrder1.getField() == field0);
721         assertTrue(sortOrder1.getDirection() == SortOrder.ORDER_ASCENDING);
722 
723         // Test constraint.
724         FieldValueConstraint constraint
725             = (FieldValueConstraint) query.getConstraint();
726         assertTrue(constraint.getField().getStep() == step0);
727         assertTrue(constraint.getField().getFieldName().equals("firstname"));
728         assertTrue(constraint.getOperator() == FieldCompareConstraint.LIKE);
729         assertTrue(!constraint.isCaseSensitive());
730         assertTrue(constraint.getValue().equals("%test%"));
731         assertTrue(!constraint.isInverse());
732     }
733 
734     /**
735      * Gets field in query.
736      *
737      * @param query The query.
738      * @param stepAlias The alias of the step.
739      * @param fieldName The name of the field.
740      * @return The field if the field is present in the query, null otherwise.
741      */
742     private BasicStepField getField(
743             SearchQuery query, String   stepAlias, String   fieldName) {
744         BasicStepField result = null;
745         Iterator iFields = query.getFields().iterator();
746         while (iFields.hasNext()) {
747             BasicStepField field = (BasicStepField) iFields.next();
748             if (field.getStep().getAlias().equals(stepAlias)
749             && field.getFieldName().equals(fieldName)) {
750                 // Found.
751                 result = field;
752                 break;
753             }
754         }
755         return result;
756     }
757 
758 }
759
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags