KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > mmbase > storage > search > implementation > database > BasicQueryHandlerTest


1 package org.mmbase.storage.search.implementation.database;
2
3 import org.mmbase.module.corebuilders.FieldDefs;
4 import org.mmbase.storage.search.*;
5 import org.mmbase.storage.search.implementation.*;
6 import junit.framework.*;
7 import junit.textui.TestRunner;
8 import java.util.*;
9 import org.mmbase.module.core.*;
10
11 /**
12  * JUnit tests.
13  *
14  * @author Rob van Maris
15  * @version $Id: BasicQueryHandlerTest.java,v 1.9 2006/01/26 10:43:54 michiel Exp $
16  */
17 public class BasicQueryHandlerTest extends TestCase {
18
19     /**
20      * JUnit test user.
21      * Nodes created by this user must be removed in the tearDown.
22      */
23     private final static String JavaDoc JUNIT_USER = "JUnitTester";
24
25     /** Test instance. */
26     private BasicQueryHandler instance;
27
28     /** MMBase query. */
29     private MMBase mmbase = null;
30
31     /** News builder, used as builder example. */
32     private MMObjectBuilder news = null;
33
34     /**
35      * Typedef builder, used as builder example where we need a number
36      * of nodes (there are > 5 typedef nodes for the core nodetypes).
37      */
38     private MMObjectBuilder typedef = null;
39
40     /** Insrel builder, used as relation builder example. */
41     /** Test nodes, created in setUp, deleted in tearDown. */
42     private List testNodes = new ArrayList();
43
44     public BasicQueryHandlerTest(java.lang.String JavaDoc testName) {
45         super(testName);
46     }
47
48     public static void main(java.lang.String JavaDoc[] args) {
49         TestRunner.run(suite());
50         System.exit(0);
51     }
52
53     /**
54      * Sets up before each test.
55      */
56     public void setUp() throws Exception JavaDoc {
57         MMBaseContext.init();
58         mmbase = MMBase.getMMBase();
59         news = mmbase.getBuilder("news");
60         typedef = mmbase.getBuilder("typedef");
61
62         // Disallowed fields map.
63 // disallowedValues = new HashMap();
64 // disallowedValues.put("number", "m_number");
65 // disallowedValues.put("snumber", "m_snumber");
66 // disallowedValues.put("dnumber", "m_dnumber");
67 // disallowedValues.put("title", "m_title");
68 // disallowedValues.put("i", "m_i");
69
70         SqlHandler sqlHandler = new BasicSqlHandler();
71         instance = new BasicQueryHandler(sqlHandler);
72
73         // Add testnodes.
74 MMObjectNode news1 = news.getNewNode(JUNIT_USER);
75         news1.setValue("title", "_TE$T_1");
76         news1.setValue("body", "News created for testing only.");
77         news.insert(JUNIT_USER, news1);
78         testNodes.add(news1);
79
80         MMObjectNode news2 = news.getNewNode(JUNIT_USER);
81         news2.setValue("title", "_TE$T_2");
82         news2.setValue("body", "News created for testing only.");
83         news.insert(JUNIT_USER, news2);
84         testNodes.add(news2);
85     }
86
87     /**
88      * Tears down after each test.
89      */
90     public void tearDown() throws Exception JavaDoc {
91         // Remove all testnodes.
92 Iterator iTestNodes = testNodes.iterator();
93         while (iTestNodes.hasNext()) {
94             MMObjectNode testNode = (MMObjectNode) iTestNodes.next();
95             MMObjectBuilder builder = testNode.getBuilder();
96             builder.removeRelations(testNode);
97             builder.removeNode(testNode);
98         }
99     }
100
101     /** Test of getNodes method, of class org.mmbase.storage.search.implementation.database.BasicQueryHandler. */
102     public void testGetNodes() throws Exception JavaDoc {
103         BasicSearchQuery query = null;
104         // Test for real nodes.
105 // TODO: add number field as well, once the queryhandler can be
106 // properly initialized with the disallowed2allowed map specified
107 // for the database that is actually used (instead of a dummy map
108 // as is now the case).
109 {
110             query = new BasicSearchQuery();
111             BasicStep newsStep = query.addStep(news) .setAlias("news1");
112             FieldDefs newsTitle = news.getField("title");
113             BasicStepField newsTitleField = query.addField(newsStep, newsTitle) .setAlias("a_title"); // should not affect result node fieldnames!
114 query.addSortOrder(newsTitleField) .setDirection(SortOrder.ORDER_ASCENDING);
115             FieldDefs newsDescription = news.getField("body");
116             query.addField(newsStep, newsDescription);
117             FieldDefs otypeDescription = news.getField("otype");
118             query.addField(newsStep, otypeDescription);
119             FieldDefs newsOwner = news.getField("owner");
120             BasicStepField newsOwnerField = query.addField(newsStep, newsOwner);
121             BasicFieldValueConstraint constraint = new BasicFieldValueConstraint(newsOwnerField, JUNIT_USER);
122             query.setConstraint(constraint);
123             List resultNodes = instance.getNodes(query, mmbase.getBuilder("news"));
124             Iterator iResultNodes = resultNodes.iterator();
125             Iterator iTestNodes = testNodes.iterator();
126             while (iTestNodes.hasNext()) {
127                 MMObjectNode testNode = (MMObjectNode) iTestNodes.next();
128                 assertTrue(iResultNodes.hasNext());
129                 MMObjectNode resultNode = (MMObjectNode) iResultNodes.next();
130                 assertTrue(resultNode.getBuilder() == news);
131                 assertTrue(resultNode.getStringValue("title") != null
132                 && resultNode.getStringValue("title").length() > 0);
133                 assertTrue("" + resultNode.getStringValue("title") + "!=" + testNode.getStringValue("title"), resultNode.getStringValue("title").equals(testNode.getStringValue("title")));
134                 assertTrue(resultNode.getStringValue("body") != null
135                 && resultNode.getStringValue("body").length() > 0);
136                 assertTrue(resultNode.getStringValue("body").equals(testNode.getStringValue("body")));
137                 assertTrue(resultNode.getStringValue("owner") != null
138                 && resultNode.getStringValue("owner").length() > 0);
139                 assertTrue(resultNode.getStringValue("owner").equals(testNode.getStringValue("owner")));
140             }
141             assertTrue(!iResultNodes.hasNext());
142         }
143
144         // Test for clusternodes.
145 {
146             query = new BasicSearchQuery();
147             BasicStep newsStep = query.addStep(news)
148                 .setAlias("news1");
149             FieldDefs newsTitle = news.getField("title");
150             BasicStepField newsTitleField = query.addField(newsStep, newsTitle)
151                 .setAlias("a_title"); // should not affect result node fieldnames!
152 query.addSortOrder(newsTitleField)
153                 .setDirection(SortOrder.ORDER_ASCENDING);
154             FieldDefs newsDescription = news.getField("body");
155             query.addField(newsStep, newsDescription);
156             FieldDefs newsOwner = news.getField("owner");
157             BasicStepField newsOwnerField = query.addField(newsStep, newsOwner);
158             BasicFieldValueConstraint constraint
159             = new BasicFieldValueConstraint(newsOwnerField, JUNIT_USER);
160             query.setConstraint(constraint);
161             List resultNodes = instance.getNodes(query, mmbase.getClusterBuilder());
162             Iterator iResultNodes = resultNodes.iterator();
163             Iterator iTestNodes = testNodes.iterator();
164             while (iTestNodes.hasNext()) {
165                 MMObjectNode testNode = (MMObjectNode) iTestNodes.next();
166                 assertTrue(iResultNodes.hasNext());
167                 MMObjectNode resultNode = (MMObjectNode) iResultNodes.next();
168                 assertTrue(resultNode instanceof ClusterNode);
169                 assertTrue(resultNode.getBuilder() == mmbase.getClusterBuilder());
170                 assertTrue(resultNode.toString(),
171                     resultNode.getStringValue("news1.title") != null
172                     && resultNode.getStringValue("news1.title").length() > 0);
173                 assertTrue(resultNode.getStringValue("news1.title").equals(testNode.getStringValue("title")));
174                 assertTrue(resultNode.getStringValue("news1.body") != null
175                 && resultNode.getStringValue("news1.body").length() > 0);
176                 assertTrue(resultNode.getStringValue("news1.body").equals(testNode.getStringValue("body")));
177                 assertTrue(resultNode.getStringValue("news1.owner") != null
178                 && resultNode.getStringValue("news1.owner").length() > 0);
179                 assertTrue(resultNode.getStringValue("news1.owner").equals(testNode.getStringValue("owner")));
180             }
181             assertTrue(!iResultNodes.hasNext());
182         }
183
184         // Test for clusternodes using NodeSearchQuery, should still return clusternodes
185 {
186             NodeSearchQuery nodeQuery = new NodeSearchQuery(news);
187             FieldDefs newsTitle = news.getField("title");
188             BasicStepField newsTitleField = nodeQuery.getField(newsTitle);
189             nodeQuery.addSortOrder(newsTitleField)
190                 .setDirection(SortOrder.ORDER_ASCENDING);
191             FieldDefs newsOwner = news.getField("owner");
192             BasicStepField newsOwnerField = nodeQuery.getField(newsOwner);
193             BasicFieldValueConstraint constraint
194             = new BasicFieldValueConstraint(newsOwnerField, JUNIT_USER);
195             nodeQuery.setConstraint(constraint);
196             List resultNodes = instance.getNodes(nodeQuery, mmbase.getClusterBuilder());
197             Iterator iResultNodes = resultNodes.iterator();
198             Iterator iTestNodes = testNodes.iterator();
199             while (iTestNodes.hasNext()) {
200                 MMObjectNode testNode = (MMObjectNode) iTestNodes.next();
201                 assertTrue(iResultNodes.hasNext());
202                 MMObjectNode resultNode = (MMObjectNode) iResultNodes.next();
203                 assertTrue(resultNode instanceof ClusterNode);
204                 assertTrue(resultNode.getBuilder() == mmbase.getClusterBuilder());
205                 assertTrue(resultNode.toString(),
206                     resultNode.getStringValue("news.title") != null
207                     && resultNode.getStringValue("news.title").length() > 0);
208                 assertTrue(resultNode.getStringValue("news.title").equals(testNode.getStringValue("title")));
209                 assertTrue(resultNode.getStringValue("news.body") != null
210                 && resultNode.getStringValue("news.body").length() > 0);
211                 assertTrue(resultNode.getStringValue("news.body").equals(testNode.getStringValue("body")));
212                 assertTrue(resultNode.getStringValue("news.owner") != null
213                 && resultNode.getStringValue("news.owner").length() > 0);
214                 assertTrue(resultNode.getStringValue("news.owner").equals(testNode.getStringValue("owner")));
215             }
216             assertTrue(!iResultNodes.hasNext());
217         }
218
219         // Test for result nodes.
220 {
221             query = new BasicSearchQuery();
222             BasicStep newsStep = query.addStep(news)
223                 .setAlias("news1");
224             FieldDefs newsTitle = news.getField("title");
225             BasicStepField newsTitleField = query.addField(newsStep, newsTitle)
226                 .setAlias("a_title");
227             query.addSortOrder(newsTitleField)
228                 .setDirection(SortOrder.ORDER_ASCENDING);
229             FieldDefs newsDescription = news.getField("body");
230             query.addField(newsStep, newsDescription);
231             FieldDefs newsOwner = news.getField("owner");
232             BasicStepField newsOwnerField = query.addField(newsStep, newsOwner);
233             BasicFieldValueConstraint constraint
234             = new BasicFieldValueConstraint(newsOwnerField, JUNIT_USER);
235             query.setConstraint(constraint);
236             List resultNodes = instance.getNodes(query, new ResultBuilder(mmbase, query));
237             Iterator iResultNodes = resultNodes.iterator();
238             Iterator iTestNodes = testNodes.iterator();
239             while (iTestNodes.hasNext()) {
240                 MMObjectNode testNode = (MMObjectNode) iTestNodes.next();
241                 assertTrue(iResultNodes.hasNext());
242                 MMObjectNode resultNode = (MMObjectNode) iResultNodes.next();
243                 assertTrue(resultNode instanceof ResultNode);
244                 assertTrue(resultNode.getBuilder() instanceof ResultBuilder);
245                 assertTrue(resultNode.getStringValue("a_title") != null
246                 && resultNode.getStringValue("a_title").length() > 0);
247                 assertTrue(resultNode.getStringValue("a_title").equals(testNode.getStringValue("title")));
248                 assertTrue(resultNode.getStringValue("body") != null
249                 && resultNode.getStringValue("body").length() > 0);
250                 assertTrue(resultNode.getStringValue("body").equals(testNode.getStringValue("body")));
251                 assertTrue(resultNode.getStringValue("owner") != null
252                 && resultNode.getStringValue("owner").length() > 0);
253                 assertTrue(resultNode.getStringValue("owner").equals(testNode.getStringValue("owner")));
254             }
255             assertTrue(!iResultNodes.hasNext());
256         }
257
258         // Test for result nodes with aggregated fields.
259 {
260             query = new BasicSearchQuery(true);
261             BasicStep newsStep = query.addStep(news)
262                 .setAlias("news1");
263             FieldDefs newsTitle = news.getField("title");
264             query.addAggregatedField(
265                 newsStep, newsTitle, AggregatedField.AGGREGATION_TYPE_MIN).
266                 setAlias("minName");
267             query.addAggregatedField(
268                 newsStep, newsTitle, AggregatedField.AGGREGATION_TYPE_MAX).
269                 setAlias("maxName");
270
271             FieldDefs newsOwner = news.getField("owner");
272             BasicStepField newsOwnerField = new BasicStepField(newsStep, newsOwner);
273             BasicFieldValueConstraint constraint
274                 = new BasicFieldValueConstraint(newsOwnerField, JUNIT_USER);
275             query.setConstraint(constraint);
276             List resultNodes = instance.getNodes(query, new ResultBuilder(mmbase, query));
277             assertTrue(resultNodes.size() == 1);
278
279             // Determine min/max title from testnodes.
280 Iterator iTestNodes = testNodes.iterator();
281             String JavaDoc minName =
282                 ((MMObjectNode)testNodes.get(0)).getStringValue("title");
283             String JavaDoc maxName =
284                 ((MMObjectNode)testNodes.get(0)).getStringValue("title");
285             while (iTestNodes.hasNext()) {
286                 MMObjectNode testNode = (MMObjectNode) iTestNodes.next();
287                 String JavaDoc title = testNode.getStringValue("title");
288                 if (title.compareTo(minName) < 0) {
289                     minName = title;
290                 } else if (title.compareTo(maxName) > 0) {
291                     maxName = title;
292                 }
293             }
294
295             // Compare with resultnodes.
296 ResultNode result = (ResultNode) resultNodes.get(0);
297             assertTrue(result.getStringValue("minName").equals(minName));
298             assertTrue(result.getStringValue("maxName").equals(maxName));
299         }
300
301         // Test weak offset support.
302 query = new NodeSearchQuery(typedef);
303         List typedefNodes = instance.getNodes(query, typedef);
304         assertTrue(
305             "In order to run this test, more than 5 typedef nodes are required.",
306             typedefNodes.size() > 5);
307
308         query.setOffset(2);
309         List resultNodes = instance.getNodes(query, typedef);
310         assertTrue(resultNodes.size() == typedefNodes.size() - 2);
311
312         query.setMaxNumber(3);
313         resultNodes = instance.getNodes(query, typedef);
314         assertTrue(resultNodes.size() == 3);
315
316     }
317
318     /** Test of getSupportLevel(int,SearchQuery) method, of class org.mmbase.storage.search.implementation.database.BasicQueryHandler. */
319     public void testGetSupportLevel() throws Exception JavaDoc {
320         BasicSearchQuery query = new BasicSearchQuery();
321
322         // Support for max number optimal only when set to default (= -1),
323 // weak otherwise.
324 assertTrue(instance.getSupportLevel(SearchQueryHandler.FEATURE_MAX_NUMBER, query)
325         == SearchQueryHandler.SUPPORT_OPTIMAL);
326         query.setMaxNumber(100);
327         assertTrue(instance.getSupportLevel(SearchQueryHandler.FEATURE_MAX_NUMBER, query)
328         == SearchQueryHandler.SUPPORT_NONE);
329         query.setMaxNumber(-1);
330         assertTrue(instance.getSupportLevel(SearchQueryHandler.FEATURE_MAX_NUMBER, query)
331         == SearchQueryHandler.SUPPORT_OPTIMAL);
332
333         // Support for offset optimal only when set to default (= 0),
334 // weak otherwise.
335 assertTrue(instance.getSupportLevel(SearchQueryHandler.FEATURE_OFFSET, query)
336         == SearchQueryHandler.SUPPORT_OPTIMAL);
337         query.setOffset(100);
338         assertTrue(instance.getSupportLevel(SearchQueryHandler.FEATURE_OFFSET, query)
339         == SearchQueryHandler.SUPPORT_NONE);
340         query.setOffset(0);
341         assertTrue(instance.getSupportLevel(SearchQueryHandler.FEATURE_OFFSET, query)
342         == SearchQueryHandler.SUPPORT_OPTIMAL);
343
344         // TODO: (later) test whith partial/full support for offset/maxNumber
345 }
346
347     /** Test of second getSupportLevel(Constraint,SearchQuery) method, of class org.mmbase.storage.search.implementation.database.BasicQueryHandler. */
348     public void testGetSupportLevel2() throws Exception JavaDoc {
349         // Should return basic support level of constraint.
350 SearchQuery query = new BasicSearchQuery();
351         Constraint constraint = new TestConstraint(SearchQueryHandler.SUPPORT_NONE);
352         assertTrue(instance.getSupportLevel(constraint, query) == SearchQueryHandler.SUPPORT_NONE);
353         constraint = new TestConstraint(SearchQueryHandler.SUPPORT_WEAK);
354         assertTrue(instance.getSupportLevel(constraint, query) == SearchQueryHandler.SUPPORT_WEAK);
355         constraint = new TestConstraint(SearchQueryHandler.SUPPORT_NORMAL);
356         assertTrue(instance.getSupportLevel(constraint, query) == SearchQueryHandler.SUPPORT_NORMAL);
357         constraint = new TestConstraint(SearchQueryHandler.SUPPORT_OPTIMAL);
358         assertTrue(instance.getSupportLevel(constraint, query) == SearchQueryHandler.SUPPORT_OPTIMAL);
359     }
360
361     public static Test suite() {
362         TestSuite suite = new TestSuite(BasicQueryHandlerTest.class);
363
364         return suite;
365     }
366
367 }
368
Popular Tags