[Wikitty-commits] r766 - in trunk: src/site src/site/rst/user wikitty-api/src/main/java/org/nuiton/wikitty/search wikitty-api/src/main/java/org/nuiton/wikitty/search/operators wikitty-api/src/main/java/org/nuiton/wikitty/storage wikitty-api/src/test/java/org/nuiton/wikitty/api wikitty-solr-impl/src/main/java/org/nuiton/wikitty/storage/solr wikitty-solr-impl/src/test/java/org/nuiton/wikitty/storage/solr

Author: jcouteau Date: 2011-04-08 11:43:14 +0200 (Fri, 08 Apr 2011) New Revision: 766 Url: http://nuiton.org/repositories/revision/wikitty/766 Log: * Remove Like and Unlike search * Create False search * Add tests for each kind of search * Associated search do not throw exception when nothing found * All kind of searches now implemented in InMemorySearchEngine Added: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/False.java trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/storage/solr/SolrSearch2Test.java Removed: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/Like.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/Unlike.java Modified: trunk/src/site/rst/user/generation.rst.vm trunk/src/site/site_fr.xml trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/RestrictionHelper.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Search.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/RestrictionName.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/storage/WikittySearchEngineInMemory.java trunk/wikitty-api/src/test/java/org/nuiton/wikitty/api/AbstractSearchTest.java trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/storage/solr/Restriction2Solr.java trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolr.java trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/storage/solr/SolrSearchTest.java Modified: trunk/src/site/rst/user/generation.rst.vm =================================================================== --- trunk/src/site/rst/user/generation.rst.vm 2011-04-07 15:53:15 UTC (rev 765) +++ trunk/src/site/rst/user/generation.rst.vm 2011-04-08 09:43:14 UTC (rev 766) @@ -89,6 +89,13 @@ La génération est effectuée ensuite à chaque fois que vous lancez un build. +Vous pourriez être étonné que le lien entre vos entités soit représenté par une +chaîne de caractère. En fait, dans vos entité Wikitty, un lien vers un autre +Wikitty estreprésenté par son identifiant qui est une chaîne de caractères. +Ainsi, un getXXXXX vous retournera l'identifiant d'un Wikitty qu'il faudra +récupérer en passant par le proxy. Vous pouvez alors utiliser le cache pour +limiter les appels côté serveur. + Subtilités de modélisation ========================== Modified: trunk/src/site/site_fr.xml =================================================================== --- trunk/src/site/site_fr.xml 2011-04-07 15:53:15 UTC (rev 765) +++ trunk/src/site/site_fr.xml 2011-04-08 09:43:14 UTC (rev 766) @@ -59,6 +59,8 @@ <item name="Migration" href="user/migration.html"/> <item name="Hessian" href="user/hessian.html"/> <item name="Sécurité" href="user/security.html"/> + <item name="Recherche" href="user/search.html"/> + <item name="FAQ" href="user/faq.html"/> </menu> <menu name="Developpeur"> Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/RestrictionHelper.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/RestrictionHelper.java 2011-04-07 15:53:15 UTC (rev 765) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/RestrictionHelper.java 2011-04-08 09:43:14 UTC (rev 766) @@ -24,18 +24,17 @@ */ package org.nuiton.wikitty.search; +import org.nuiton.wikitty.search.operators.False; import org.nuiton.wikitty.search.operators.RestrictionName; import org.nuiton.wikitty.search.operators.Restriction; import org.nuiton.wikitty.search.operators.StartsWith; import org.nuiton.wikitty.search.operators.Not; -import org.nuiton.wikitty.search.operators.Like; import org.nuiton.wikitty.search.operators.EndsWith; import org.nuiton.wikitty.search.operators.And; import org.nuiton.wikitty.search.operators.Or; import org.nuiton.wikitty.search.operators.Less; import org.nuiton.wikitty.search.operators.Greater; import org.nuiton.wikitty.search.operators.GreaterOrEqual; -import org.nuiton.wikitty.search.operators.Unlike; import org.nuiton.wikitty.search.operators.NotEquals; import org.nuiton.wikitty.search.operators.LessOrEqual; import org.nuiton.wikitty.search.operators.Keyword; @@ -90,24 +89,6 @@ return eq; } - public static Restriction like(Element element, String value, Like.SearchAs searchAs) { - Like like = new Like(); - like.setName(RestrictionName.LIKE); - like.setElement(element); - like.setValue(value); - like.setSearchAs(searchAs); - return like; - } - - public static Restriction unlike(Element element, String value, Like.SearchAs searchAs) { - Unlike unlike = new Unlike(); - unlike.setName(RestrictionName.UNLIKE); - unlike.setElement(element); - unlike.setValue(value); - unlike.setSearchAs(searchAs); - return unlike; - } - public static Restriction neq(Element element, String value) { NotEquals neq = new NotEquals(); neq.setName(RestrictionName.NOT_EQUALS); @@ -278,6 +259,12 @@ return isNotNull; } + public static False isFalse() { + False falseRestriction = new False(); + falseRestriction.setName(RestrictionName.FALSE); + return falseRestriction; + } + static ThreadLocal<SimpleDateFormat> myFormats = new ThreadLocal<SimpleDateFormat>() { @Override protected SimpleDateFormat initialValue() { Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Search.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Search.java 2011-04-07 15:53:15 UTC (rev 765) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Search.java 2011-04-08 09:43:14 UTC (rev 766) @@ -25,7 +25,6 @@ package org.nuiton.wikitty.search; import org.nuiton.wikitty.search.operators.Restriction; -import org.nuiton.wikitty.search.operators.Like; import org.nuiton.wikitty.search.operators.SubSearch; import org.nuiton.wikitty.search.operators.Element; import java.util.ArrayList; @@ -159,7 +158,8 @@ * Contains. * * @param element - * @param value + * @param value1 + * @param values * @return */ public Search contains(String element, String value1, String ... values) { @@ -185,7 +185,8 @@ * Contains. * * @param element - * @param value + * @param value1 + * @param values * @return */ public Search in(String element, String value1, String ... values) { @@ -209,7 +210,6 @@ /** * Looking find specific extension * - * @param element * @param value * @return {@code this} */ @@ -221,7 +221,6 @@ /** * Looking find specific id * - * @param element * @param value * @return {@code this} */ @@ -247,7 +246,6 @@ /** * Equals each collection elements. * - * @param element * @param values * @return {@code this} */ @@ -259,44 +257,6 @@ } /** - * Like. - * - * @param element - * @param value - * @param searchAs - * @return {@code this} - */ - public Search like(String element, String value, Like.SearchAs searchAs) { - restrictions.add(RestrictionHelper.like(elt(element), value, searchAs)); - return this; - } - - public Search like(String element, String value) { - restrictions.add(RestrictionHelper.like( - elt(element), value, Like.SearchAs.AsText)); - return this; - } - - /** - * Unlike. - * - * @param element - * @param value - * @param searchAs - * @return {@code this} - */ - public Search unlike(String element, String value, Like.SearchAs searchAs) { - restrictions.add(RestrictionHelper.unlike(elt(element), value, searchAs)); - return this; - } - - public Search unlike(String element, String value) { - restrictions.add(RestrictionHelper.unlike( - elt(element), value, Like.SearchAs.AsText)); - return this; - } - - /** * Not equals. * * @param element @@ -311,7 +271,6 @@ /** * Not equals. * - * @param element * @param value * @return {@code this} */ @@ -320,10 +279,9 @@ return this; } - /** + /** * Not equals. * - * @param element * @param value * @return {@code this} */ @@ -381,11 +339,12 @@ } /** - * Between. + * Restrict search so that the element value is between lower and upper + * values (it can also be equals) * - * @param element - * @param lowerValue - * @param upperValue + * @param element the element you put the restriction on + * @param lowerValue the lower bound + * @param upperValue the upper bound * @return {@code this} */ public Search bw(String element, String lowerValue, String upperValue) { @@ -477,6 +436,16 @@ } /** + * False. + * + * @return {@code this} + */ + public Search isFalse() { + restrictions.add(RestrictionHelper.isFalse()); + return this; + } + + /** * Not (sub query). * * @return sub query Added: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/False.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/False.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/False.java 2011-04-08 09:43:14 UTC (rev 766) @@ -0,0 +1,46 @@ +package org.nuiton.wikitty.search.operators; + +import java.io.Serializable; + +/** + * User: couteau + * Date: 08/04/11 + */ +public class False extends Restriction implements Serializable { + + // serialVersionUID is used for serialization. + private static final long serialVersionUID = 1L; + + /** + * Default constructor + */ + public False() { + super(); + } + + /** + * Equality test based attributes values + * + * @param other Value to compare + */ + public boolean equals(Object other) { + if (this == other) { + return true; + } + if (!(other instanceof False)) { + return false; + } + + final False falseOther = (False) other; + + return super.equals(falseOther); + } + + public int hashCode() { + // equals use objects that are not constant through time + // then, unable to create hashCode from those objects + // returning a constant hash-code + return Greater.class.hashCode(); + } + +} \ No newline at end of file Deleted: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/Like.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/Like.java 2011-04-07 15:53:15 UTC (rev 765) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/Like.java 2011-04-08 09:43:14 UTC (rev 766) @@ -1,58 +0,0 @@ -/* - * #%L - * Wikitty :: api - * - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2009 - 2010 CodeLutin, Benjamin Poussin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ - -package org.nuiton.wikitty.search.operators; - -import java.io.Serializable; - -/** - * Like is use on String field type, to precise some particularity on search. - * - * @author ruchaud - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class Like extends BinaryOperator implements Serializable { - - // serialVersionUID is used for serialization. - private static final long serialVersionUID = 1L; - - public enum SearchAs {AsText, ToLowerCase}; - protected SearchAs searchAs; - - public Like() { - } - - public SearchAs getSearchAs() { - return searchAs; - } - - public void setSearchAs(SearchAs searchAs) { - this.searchAs = searchAs; - } - -} Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/RestrictionName.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/RestrictionName.java 2011-04-07 15:53:15 UTC (rev 765) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/RestrictionName.java 2011-04-08 09:43:14 UTC (rev 766) @@ -32,8 +32,6 @@ */ public enum RestrictionName { EQUALS, - LIKE, - UNLIKE, NOT_EQUALS, LESS, LESS_OR_EQUAL, Deleted: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/Unlike.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/Unlike.java 2011-04-07 15:53:15 UTC (rev 765) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/operators/Unlike.java 2011-04-08 09:43:14 UTC (rev 766) @@ -1,59 +0,0 @@ -/* - * #%L - * Wikitty :: api - * - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2009 - 2010 CodeLutin, Benjamin Poussin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ -package org.nuiton.wikitty.search.operators; - -import java.io.Serializable; - -import org.nuiton.wikitty.search.operators.Like.SearchAs; - -/** - * UnLike is use on String field type, to precise some particularity on search - * (case insensitive for example). - * - * @author martel - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class Unlike extends BinaryOperator implements Serializable { - - // serialVersionUID is used for serialization. - private static final long serialVersionUID = 1L; - - protected SearchAs searchAs; - - public Unlike() { - } - - public SearchAs getSearchAs() { - return searchAs; - } - - public void setSearchAs(SearchAs searchAs) { - this.searchAs = searchAs; - } - -} Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/storage/WikittySearchEngineInMemory.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/storage/WikittySearchEngineInMemory.java 2011-04-07 15:53:15 UTC (rev 765) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/storage/WikittySearchEngineInMemory.java 2011-04-08 09:43:14 UTC (rev 766) @@ -24,12 +24,17 @@ */ package org.nuiton.wikitty.storage; +import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.LinkedList; import java.util.List; import java.util.Map.Entry; +import java.util.regex.Matcher; +import java.util.regex.Pattern; import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyUtil; import org.nuiton.wikitty.entities.FieldType; import org.nuiton.wikitty.entities.FieldType.TYPE; import org.nuiton.wikitty.entities.Wikitty; @@ -38,9 +43,17 @@ import org.nuiton.wikitty.search.TreeNodeResult; import org.nuiton.wikitty.search.operators.And; import org.nuiton.wikitty.search.operators.AssociatedRestriction; +import org.nuiton.wikitty.search.operators.Between; import org.nuiton.wikitty.search.operators.BinaryOperator; +import org.nuiton.wikitty.search.operators.Contains; import org.nuiton.wikitty.search.operators.Element; +import org.nuiton.wikitty.search.operators.In; +import org.nuiton.wikitty.search.operators.Keyword; +import org.nuiton.wikitty.search.operators.Not; +import org.nuiton.wikitty.search.operators.Null; +import org.nuiton.wikitty.search.operators.Or; import org.nuiton.wikitty.search.operators.Restriction; +import org.nuiton.wikitty.search.operators.RestrictionName; import org.nuiton.wikitty.services.WikittyTransaction; public class WikittySearchEngineInMemory implements WikittySearchEngine { @@ -72,19 +85,52 @@ Restriction restriction, Wikitty w) { if (restriction instanceof BinaryOperator) { BinaryOperator binOp = (BinaryOperator) restriction; - if (binOp.getElement().getName().equals(Element.ELT_EXTENSION)) { - return w.hasExtension(binOp.getValue()); - } + String fqfieldName = binOp.getElement().getName(); + + //Checks on extensions if (Element.ELT_EXTENSION.equals(fqfieldName)) { - return true; + boolean checked = false; + + switch (restriction.getName()) { + case NOT_EQUALS: + checked = !w.getExtensionNames().contains(binOp.getValue()); + break; + case EQUALS: + checked = w.getExtensionNames().contains(binOp.getValue()); + break; + } + + return checked; + + //Checks on id } else if (Element.ELT_ID.equals(fqfieldName)) { - return w.getId().equals(binOp.getValue()); - } // si les wikitty n'ont meme pas l'extension concerné + + boolean checked = false; + + switch (restriction.getName()) { + case NOT_EQUALS: + checked = !w.getId().equals(binOp.getValue()); + break; + case EQUALS: + checked = w.getId().equals(binOp.getValue()); + break; + } + + return checked; + } + + // si les wikitty n'ont meme pas l'extension concerné // Le check restriction, ne doit pas tester les champs // si les wikitty n'ont meme pas l'extension concerné String[] extName = fqfieldName.split("\\."); if (!w.hasField(extName[0], extName[1])) { + + //return true in case of not equals + if (RestrictionName.NOT_EQUALS == restriction.getName()) { + return true; + } + return false; } // recupere la valeur dans le wikitty @@ -104,9 +150,21 @@ } value = t.getValidValue(value); boolean checked = false; + switch (restriction.getName()) { case EQUALS: - checked = value.equals(o); + if (value instanceof String && o instanceof String) { + + String pattern = (String)value; + pattern = pattern.replace("*","\\p{ASCII}*"); + pattern = pattern.replace("?","\\p{ASCII}"); + + Pattern p = Pattern.compile(pattern); + Matcher m = p.matcher((String)o); + checked = m.matches(); + } else { + checked = value.equals(o); + } break; case LESS: checked = ((Comparable) o).compareTo(value) < 0; @@ -137,6 +195,86 @@ break; } return checked; + } else if (restriction instanceof Null) { + Null nullRes = (Null) restriction; + + String fqfieldName = nullRes.getFieldName(); + + //check my wikitty got the right extension before doing anything. + String[] extName = fqfieldName.split("\\."); + if (!w.hasField(extName[0], extName[1])) { + return false; + } + // get the value in the wikitty + Object o = w.getFqField(fqfieldName); + + //No null on extensions, always return false + if (fqfieldName.equals(Element.ELT_EXTENSION)) { + return false; + } + + //No null on ids, always return false + if (fqfieldName.equals(Element.ELT_ID)) { + return false; + } + + boolean checked = false; + + switch (nullRes.getName()) { + case IS_NULL: + checked = (o == null); + break; + case IS_NOT_NULL: + checked = (o != null); + break; + } + + return checked; + + } else if (restriction instanceof In) { + In in = (In) restriction; + String fqfieldName = in.getElement().getName(); + String testedValue = String.valueOf(w.getFqField(fqfieldName)); + for (String value : in.getValue()){ + if (testedValue.equals(value)) { + return true; + } + } + + return false; + + } else if (restriction instanceof Contains) { + Contains contains = (Contains) restriction; + + String fqfieldName = contains.getElement().getName(); + List<String> values = contains.getValue(); + + String extension = WikittyUtil.getExtensionNameFromFQFieldName(fqfieldName); + String fieldName = WikittyUtil.getFieldNameFromFQFieldName(fqfieldName); + + if (!w.hasField(extension, fieldName)) { + return false; + } + + // Get field as string and then split it to take into account not + // multivalued fields. + String testedValuesAsString = w.getFieldAsString(extension, fieldName); + + if('[' == testedValuesAsString.charAt(0)){ + testedValuesAsString = testedValuesAsString.substring(1, testedValuesAsString.length()); + } + + List<String> testedValues = Arrays.asList(testedValuesAsString.split(",")); + + + for (Object value : values){ + if (!testedValues.contains(String.valueOf(value))) { + return false; + } + } + + return true; + } else if (restriction instanceof And) { And and = (And) restriction; for (Restriction sub : and.getRestrictions()) { @@ -145,6 +283,30 @@ } } return true; + } else if (restriction instanceof Or) { + Or or = (Or) restriction; + for (Restriction sub : or.getRestrictions()) { + if (checkRestriction(transaction, sub, w)) { + return true; + } + } + return false; + } else if (restriction instanceof Keyword) { + Keyword keyword = (Keyword) restriction; + + String value = keyword.getValue(); + + for(String fieldName : w.getAllFieldNames()) { + String testedValue = String.valueOf(w.getFqField(fieldName)); + if (testedValue.contains(value)) { + return true; + } + } + return false; + } else if (restriction instanceof Not) { + Not or = (Not) restriction; + Restriction sub = or.getRestriction(); + return !checkRestriction(transaction, sub, w); } else if (restriction instanceof AssociatedRestriction) { AssociatedRestriction ass = (AssociatedRestriction) restriction; @@ -172,7 +334,62 @@ //Check that my field is contained in the sub-restriction results. return associatedList.contains(String.valueOf(o)); - } else { + } else if (restriction instanceof Between) { + + Between op = (Between) restriction; + + Object max = op.getMax(); + Object min = op.getMin(); + + //No between on extensions, always return false + if (op.getElement().getName().equals(Element.ELT_EXTENSION)) { + return false; + } + + //No between on ids, always return false + if (op.getElement().getName().equals(Element.ELT_ID)) { + return false; + } + + String fqfieldName = op.getElement().getName(); + + // si les wikitty n'ont meme pas l'extension concerné + // Le check restriction, ne doit pas tester les champs + // si les wikitty n'ont meme pas l'extension concerné + String[] extName = fqfieldName.split("\\."); + if (!w.hasField(extName[0], extName[1])) { + return false; + } + + // recupere la valeur dans le wikitty + Object o = w.getFqField(fqfieldName); + + // recupere le type de la valeur + FieldType t = w.getFieldType(fqfieldName); + + if (!(min instanceof Collection) && t.isCollection()) { + // on doit encapsuler dans une collection, car la creation + // de la requete ajoute autant de v == o && ... que de valeurs + // dans la collection (champs multi-value solr). Mais + // dans le inmemory on doit retrouve des collections et non pas + // des objets seuls :( + min = Collections.singleton(min); + } + min = t.getValidValue(min); + + if (!(max instanceof Collection) && t.isCollection()) { + // on doit encapsuler dans une collection, car la creation + // de la requete ajoute autant de v == o && ... que de valeurs + // dans la collection (champs multi-value solr). Mais + // dans le inmemory on doit retrouve des collections et non pas + // des objets seuls :( + max = Collections.singleton(max); + } + max = t.getValidValue(max); + + return ((Comparable) o).compareTo(min) >= 0 + && ((Comparable) o).compareTo(max) <= 0; + } else{ throw new UnsupportedOperationException(restriction.getName() + " Search Not yet implemented"); } } Modified: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/api/AbstractSearchTest.java =================================================================== --- trunk/wikitty-api/src/test/java/org/nuiton/wikitty/api/AbstractSearchTest.java 2011-04-07 15:53:15 UTC (rev 765) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/api/AbstractSearchTest.java 2011-04-08 09:43:14 UTC (rev 766) @@ -6,7 +6,6 @@ import org.nuiton.wikitty.WikittyProxy; import org.nuiton.wikitty.WikittyService; import org.nuiton.wikitty.entities.ExtensionFactory; -import org.nuiton.wikitty.entities.FieldFactory; import org.nuiton.wikitty.entities.FieldType; import org.nuiton.wikitty.entities.Wikitty; import org.nuiton.wikitty.entities.WikittyExtension; @@ -28,6 +27,7 @@ public static final String PRODUCT_CATEGORY = "category"; public static final String CATEGORY_NAME = "name"; public static final String VERSION = "1.0"; + public static String W_ID =""; protected WikittyProxy proxy = new WikittyProxy(getWikittyService()); @@ -96,9 +96,411 @@ product3.setField(EXT_PRODUCT, PRODUCT_CATEGORY, category2.getId()); proxy.store(product3); + W_ID = product3.getId(); + } @Test + public void testEq() throws Exception { + + Search query = Search.query().eq("Product.price", "3"); + + Criteria eqCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(eqCriteria); + + Assert.assertEquals(1, results.getAll().size()); + + Wikitty resultW = results.getFirst(); + + Assert.assertEquals("Screwdriver", resultW.getFieldAsString(EXT_PRODUCT, + PRODUCT_NAME)); + Assert.assertEquals(3, resultW.getFieldAsInt(EXT_PRODUCT, + PRODUCT_PRICE)); + + + //Test using pattern matching + Search query2 = Search.query().eq("Product.name", "*dri*"); + + Criteria eqCriteria2 = query2.criteria(); + + PagedResult<Wikitty> results2 = proxy.findAllByCriteria(eqCriteria2); + + Assert.assertEquals(1, results2.getAll().size()); + + Wikitty resultW2 = results.getFirst(); + + Assert.assertEquals("Screwdriver", resultW2.getFieldAsString(EXT_PRODUCT, + PRODUCT_NAME)); + Assert.assertEquals(3, resultW2.getFieldAsInt(EXT_PRODUCT, + PRODUCT_PRICE)); + + //Test using pattern matching + Search query3 = Search.query().eq("Product.name", "*dri?er"); + + Criteria eqCriteria3 = query3.criteria(); + + PagedResult<Wikitty> results3 = proxy.findAllByCriteria(eqCriteria3); + + Assert.assertEquals(1, results3.getAll().size()); + + Wikitty resultW3 = results.getFirst(); + + Assert.assertEquals("Screwdriver", resultW3.getFieldAsString(EXT_PRODUCT, + PRODUCT_NAME)); + Assert.assertEquals(3, resultW3.getFieldAsInt(EXT_PRODUCT, + PRODUCT_PRICE)); + } + + @Test + public void testNeq() throws Exception { + Search query = Search.query().neq("Product.price", "3"); + + Criteria neqCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(neqCriteria); + + Assert.assertEquals(4, results.getAll().size()); + + } + + @Test + public void testBw() throws Exception { + + Search query = Search.query().bw("Product.price", "3", "5"); + + Criteria bwCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(bwCriteria); + + Assert.assertEquals(1, results.getAll().size()); + + Wikitty resultW = results.getFirst(); + + Assert.assertEquals("Screwdriver", resultW.getFieldAsString(EXT_PRODUCT, + PRODUCT_NAME)); + Assert.assertEquals(3, resultW.getFieldAsInt(EXT_PRODUCT, + PRODUCT_PRICE)); + } + + @Test + public void testLt() throws Exception { + + Search query = Search.query().lt("Product.price", "20"); + + Criteria bwCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(bwCriteria); + + Assert.assertEquals(1, results.getAll().size()); + + Wikitty resultW = results.getFirst(); + + Assert.assertEquals("Screwdriver", resultW.getFieldAsString(EXT_PRODUCT, + PRODUCT_NAME)); + Assert.assertEquals(3, resultW.getFieldAsInt(EXT_PRODUCT, + PRODUCT_PRICE)); + + } + + @Test + public void testLe() throws Exception { + + Search query = Search.query().le("Product.price", "20"); + + Criteria bwCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(bwCriteria); + + Assert.assertEquals(2, results.getAll().size()); + } + + @Test + public void testGt() throws Exception { + + Search query = Search.query().gt("Product.price", "20"); + + Criteria bwCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(bwCriteria); + + Assert.assertEquals(1, results.getAll().size()); + + Wikitty resultW = results.getFirst(); + + Assert.assertEquals("Paint Blue", resultW.getFieldAsString(EXT_PRODUCT, + PRODUCT_NAME)); + Assert.assertEquals(22, resultW.getFieldAsInt(EXT_PRODUCT, + PRODUCT_PRICE)); + + } + + @Test + public void testGe() throws Exception { + + Search query = Search.query().ge("Product.price", "20"); + + Criteria bwCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(bwCriteria); + + Assert.assertEquals(2, results.getAll().size()); + + } + + @Test + public void testContains() throws Exception { + + Search query = Search.query().contains("Product.price", "3"); + + Criteria inCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(inCriteria); + + Assert.assertEquals(1, results.getAll().size()); + + Wikitty resultW = results.getFirst(); + + Assert.assertEquals("Screwdriver", resultW.getFieldAsString(EXT_PRODUCT, + PRODUCT_NAME)); + Assert.assertEquals(3, resultW.getFieldAsInt(EXT_PRODUCT, + PRODUCT_PRICE)); + + //TODO JC-07-04-2011 do a test with multi-valued field + + } + + @Test + public void testIn() throws Exception { + + Search query = Search.query().in("Product.price","1","2","3","4","5"); + + Criteria inCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(inCriteria); + + Assert.assertEquals(1, results.getAll().size()); + + Wikitty resultW = results.getFirst(); + + Assert.assertEquals("Screwdriver", resultW.getFieldAsString(EXT_PRODUCT, + PRODUCT_NAME)); + Assert.assertEquals(3, resultW.getFieldAsInt(EXT_PRODUCT, + PRODUCT_PRICE)); + } + + @Test + public void testExteq() throws Exception { + Search query = Search.query().exteq(EXT_PRODUCT); + + Criteria exteqCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(exteqCriteria); + + Assert.assertEquals(3, results.getAll().size()); + } + + @Test + public void testExtneq() throws Exception { + Search query = Search.query().extneq(EXT_PRODUCT); + + Criteria extneqCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(extneqCriteria); + + Assert.assertEquals(2, results.getAll().size()); + + } + + @Test + public void testIdeq() throws Exception { + Search query = Search.query().ideq(W_ID); + + Criteria ideqCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(ideqCriteria); + + Assert.assertEquals(1, results.getAll().size()); + + Wikitty resultW = results.getFirst(); + + Assert.assertEquals("Paint Blue", resultW.getFieldAsString(EXT_PRODUCT, + PRODUCT_NAME)); + Assert.assertEquals(22, resultW.getFieldAsInt(EXT_PRODUCT, + PRODUCT_PRICE)); + + } + + @Test + public void testIdneq() throws Exception { + + Search query = Search.query().idneq(W_ID); + + Criteria idneqCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(idneqCriteria); + + Assert.assertEquals(4, results.getAll().size()); + } + + @Test + public void testUnlike() throws Exception { + /*Search query = Search.query().unlike("Product.name", "*dri*"); + + Criteria likeCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(likeCriteria); + + Assert.assertEquals(4, results.getAll().size());*/ + } + + @Test + public void testSw() throws Exception { + Search query = Search.query().sw("Product.name", "Scre"); + + Criteria swCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(swCriteria); + + Assert.assertEquals(1, results.getAll().size()); + + Wikitty resultW = results.getFirst(); + + Assert.assertEquals("Screwdriver", resultW.getFieldAsString(EXT_PRODUCT, + PRODUCT_NAME)); + Assert.assertEquals(3, resultW.getFieldAsInt(EXT_PRODUCT, + PRODUCT_PRICE)); + + } + + @Test + public void testNsw() throws Exception { + + Search query = Search.query().nsw("Product.name", "Scre"); + + Criteria nswCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(nswCriteria); + + Assert.assertEquals(4, results.getAll().size()); + } + + @Test + public void testEw() throws Exception { + + Search query = Search.query().ew("Product.name", "ver"); + + Criteria ewCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(ewCriteria); + + Assert.assertEquals(1, results.getAll().size()); + + Wikitty resultW = results.getFirst(); + + Assert.assertEquals("Screwdriver", resultW.getFieldAsString(EXT_PRODUCT, + PRODUCT_NAME)); + Assert.assertEquals(3, resultW.getFieldAsInt(EXT_PRODUCT, + PRODUCT_PRICE)); + + } + + @Test + public void testNotew() throws Exception { + + Search query = Search.query().notew("Product.name", "ver"); + + Criteria notewCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(notewCriteria); + + Assert.assertEquals(4, results.getAll().size()); + + } + + @Test + public void testKeyword() throws Exception { + + Search query = Search.query().keyword("Paint"); + + Criteria keywordCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(keywordCriteria); + + Assert.assertEquals(2, results.getAll().size()); + + } + + @Test + public void testIsNull() throws Exception { + + Search query = Search.query().isNull("Product.name"); + + Criteria isNull = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(isNull); + + Assert.assertEquals(0, results.getAll().size()); + + } + + @Test + public void testIsNotNull() throws Exception { + + Search query = Search.query().isNotNull("Product.name"); + + Criteria isNotNull = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(isNotNull); + + Assert.assertEquals(3, results.getAll().size()); + + } + + @Test + public void testAnd() throws Exception { + + Search query = Search.query().and().bw("Product.price", "15", "25") + .sw("Product.name", "Paint"); + + Criteria andCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(andCriteria); + + Assert.assertEquals(2, results.getAll().size()); + + } + + @Test + public void testOr() throws Exception { + + Search query = Search.query(); + + query.or().gt("Product.price", "20").sw("Product.name", "Screw"); + + Criteria bwCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(bwCriteria); + + Assert.assertEquals(2, results.getAll().size()); + + } + + @Test + public void testNot() throws Exception { + + Search query = Search.query(); + + query.not().ge("Product.price", "20"); + + Criteria bwCriteria = query.criteria(); + + PagedResult<Wikitty> results = proxy.findAllByCriteria(bwCriteria); + + Assert.assertEquals(3, results.getAll().size()); + } + + @Test public void testAssociated() throws Exception { /* Following request mean is : @@ -108,12 +510,10 @@ */ Search query = Search.query().bw("Product.price", "15", "25") - .sw("Product.name", "Paint"); - - Search associatedSearch = query.associated("Product.category") + .sw("Product.name", "Paint").associated("Product.category") .eq("Category.name", "Hardware"); - Criteria associatedCriteria = associatedSearch.criteria(); + Criteria associatedCriteria = query.criteria(); PagedResult<Wikitty> results = proxy.findAllByCriteria(associatedCriteria); @@ -123,7 +523,27 @@ Assert.assertEquals("Paint", resultW.getFieldAsString(EXT_PRODUCT, PRODUCT_NAME)); Assert.assertEquals(20, resultW.getFieldAsInt(EXT_PRODUCT, PRODUCT_PRICE)); + + + + //Test with an associated search that returns nothing + query = Search.query().bw("Product.price", "15", "25") + .sw("Product.name", "Paint").associated("Product.category") + .eq("Category.name", "don't return anything"); + + associatedCriteria = query.criteria(); + + results = proxy.findAllByCriteria(associatedCriteria); + + Assert.assertEquals(0, results.getAll().size()); } + @Test + public void testComplexQueries() throws Exception { + //TODO JC-07-04-2011 Write test + } + + //TODO JC-07-04-2011 Write test on sortBy, facets, and with other types (date,...) + public abstract WikittyService getWikittyService(); } Modified: trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/storage/solr/Restriction2Solr.java =================================================================== --- trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/storage/solr/Restriction2Solr.java 2011-04-07 15:53:15 UTC (rev 765) +++ trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/storage/solr/Restriction2Solr.java 2011-04-08 09:43:14 UTC (rev 766) @@ -49,15 +49,12 @@ import org.nuiton.wikitty.search.operators.Keyword; import org.nuiton.wikitty.search.operators.Less; import org.nuiton.wikitty.search.operators.LessOrEqual; -import org.nuiton.wikitty.search.operators.Like; import org.nuiton.wikitty.search.operators.Not; import org.nuiton.wikitty.search.operators.NotEquals; import org.nuiton.wikitty.search.operators.Or; import org.nuiton.wikitty.search.operators.Restriction; import org.nuiton.wikitty.search.RestrictionHelper; import org.nuiton.wikitty.search.operators.StartsWith; -import org.nuiton.wikitty.search.operators.Unlike; -import org.nuiton.wikitty.search.operators.Like.SearchAs; import org.nuiton.wikitty.search.operators.Null; /** @@ -94,9 +91,9 @@ this.fieldModifer = fieldModifer; } - public String toSolr(Restriction restriction) { + /*public String toSolr(Restriction restriction) { return toSolr(restriction, null); - } + }*/ public String toSolr(Restriction restriction, SolrServer solr) throws WikittyException { @@ -108,22 +105,16 @@ return false2solr(); case NOT: Not not = (Not) restriction; - return not2solr(not); + return not2solr(not, solr); case AND: And and = (And) restriction; - return and2solr(and); + return and2solr(and, solr); case OR: Or or = (Or) restriction; - return or2solr(or); + return or2solr(or, solr); case EQUALS: Equals eq = (Equals) restriction; return eq2solr(eq); - case LIKE: - Like like = (Like) restriction; - return like2solr(like); - case UNLIKE: - Unlike unlike = (Unlike) restriction; - return unlike2solr(unlike); case NOT_EQUALS: NotEquals neq = (NotEquals) restriction; return neq2solr(neq); @@ -199,7 +190,7 @@ } private String associated2solr(AssociatedRestriction associated, SolrServer solr) throws WikittyException { - String subQuery = toSolr( associated.getRestriction() ); + String subQuery = toSolr( associated.getRestriction(), solr); SolrQuery query = new SolrQuery(WikittySolrConstant.SOLR_QUERY_PARSER + subQuery); query.setRows(MAX_SUBQUERY_RESULT); QueryResponse resp = null; @@ -210,12 +201,11 @@ } SolrDocumentList solrResults = resp.getResults(); - Restriction generatedRestriction = null; + Restriction generatedRestriction; long size = solrResults.size(); if ( size == 0 ) { - throw new WikittyException("Associated " + associated.getElement().getName() + " do not retrieved any result"); - } - if ( size == 1 ) { + generatedRestriction = RestrictionHelper.isFalse(); + } else if ( size == 1 ) { generatedRestriction = RestrictionHelper.eq( associated.getElement(), (String) solrResults.get(0).getFieldValue(WikittySolrConstant.SOLR_ID) ); } else { @@ -234,17 +224,17 @@ } else { and = RestrictionHelper.and( Arrays.asList(new Restriction[]{ associated.getParentRestrictionDto(), generatedRestriction }) ); } - return toSolr(and); + return toSolr(and, solr); } - private String not2solr(Not not) throws WikittyException { + private String not2solr(Not not, SolrServer solr) throws WikittyException { if (not.getRestriction() == null) { throw new WikittyException( "not.restriction" ); } - return "( *:* - " + toSolr(not.getRestriction()) + " )"; + return "( *:* - " + toSolr(not.getRestriction(), solr) + " )"; } - private String and2solr(And and) throws WikittyException { + private String and2solr(And and, SolrServer solr) throws WikittyException { if (and.getRestrictions() == null) { throw new WikittyException( "and.restrictions is null" ); } @@ -255,16 +245,16 @@ StringBuffer result = new StringBuffer(); for (Restriction restriction : and.getRestrictions()) { if (first) { - result.append("( ").append(toSolr(restriction)); + result.append("( ").append(toSolr(restriction, solr)); first = false; } else { - result.append(" AND ").append(toSolr(restriction)); + result.append(" AND ").append(toSolr(restriction, solr)); } } return result.append(" )").toString(); } - private String or2solr(Or or) throws WikittyException { + private String or2solr(Or or, SolrServer solr) throws WikittyException { if (or.getRestrictions() == null) { throw new WikittyException("or.restrictions is null"); } @@ -280,7 +270,7 @@ } else { result.append(" OR "); } - result.append(toSolr(restriction)); + result.append(toSolr(restriction, solr)); } return result.append(" )").toString(); } @@ -289,54 +279,6 @@ return element2solr(eq.getElement()) + ":" + value2solr(eq.getValue()); } - private String like2solr(Like like) throws WikittyException { - SearchAs searchAs = like.getSearchAs(); - String element2solr = element2solr(like.getElement()); - if(element2solr.endsWith(WikittySolrConstant.SUFFIX_STRING)) { // is string - switch(searchAs) { - case AsText: - element2solr += WikittySolrConstant.SUFFIX_STRING_FULLTEXT; - break; - case ToLowerCase: - element2solr += WikittySolrConstant.SUFFIX_STRING_LOWERCASE; - break; - } - } - - // Warning if you need add searchAs, AsText and ToLowerCase need search - // at lowercase - String value2solr = value2solr(like.getValue()); - if(!element2solr.endsWith(WikittySolrConstant.SUFFIX_DATE)) { // is not date - value2solr = value2solr.toLowerCase(); - } - - return element2solr + ":" + value2solr; - } - - private String unlike2solr(Unlike unlike) throws WikittyException { - SearchAs searchAs = unlike.getSearchAs(); - String element2solr = element2solr(unlike.getElement()); - if(element2solr.endsWith(WikittySolrConstant.SUFFIX_STRING)) { // is string - switch(searchAs) { - case AsText: - element2solr += WikittySolrConstant.SUFFIX_STRING_FULLTEXT; - break; - case ToLowerCase: - element2solr += WikittySolrConstant.SUFFIX_STRING_LOWERCASE; - break; - } - } - - // Warning if you need add searchAs, AsText and ToLowerCase need search - // at lowercase - String value2solr = value2solr(unlike.getValue()); - if(!element2solr.endsWith(WikittySolrConstant.SUFFIX_DATE)) { // is not date - value2solr = value2solr.toLowerCase(); - } - - return "-" + element2solr + ":" + value2solr; - } - private String neq2solr(NotEquals neq) throws WikittyException { return "-" + element2solr(neq.getElement()) + ":" Modified: trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolr.java =================================================================== --- trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolr.java 2011-04-07 15:53:15 UTC (rev 765) +++ trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/storage/solr/WikittySearchEngineSolr.java 2011-04-08 09:43:14 UTC (rev 766) @@ -695,7 +695,7 @@ if (facetCriteria != null) { for (Criteria facet : facetCriteria) { String queryFacet = - restriction2Solr.toSolr(facet.getRestriction()); + restriction2Solr.toSolr(facet.getRestriction(), solrServer); facetQueryToName.put(queryFacet, facet.getName()); query.addFacetQuery(queryFacet); } Added: trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/storage/solr/SolrSearch2Test.java =================================================================== --- trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/storage/solr/SolrSearch2Test.java (rev 0) +++ trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/storage/solr/SolrSearch2Test.java 2011-04-08 09:43:14 UTC (rev 766) @@ -0,0 +1,27 @@ +package org.nuiton.wikitty.storage.solr; + +import org.nuiton.wikitty.WikittyConfig; +import org.nuiton.wikitty.WikittyService; +import org.nuiton.wikitty.api.AbstractSearchTest; + +/** + * User: couteau + * Date: 06/04/11 + */ +public class SolrSearch2Test extends AbstractSearchTest { + + WikittyService service; + + @Override + public WikittyService getWikittyService() { + + if (service == null) { + WikittyConfig config = new WikittyConfig(); + service = new WikittyServiceSolr(config); + } + + service.clear(null); + + return service; + } +} \ No newline at end of file Modified: trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/storage/solr/SolrSearchTest.java =================================================================== --- trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/storage/solr/SolrSearchTest.java 2011-04-07 15:53:15 UTC (rev 765) +++ trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/storage/solr/SolrSearchTest.java 2011-04-08 09:43:14 UTC (rev 766) @@ -49,7 +49,6 @@ import org.nuiton.wikitty.entities.WikittyGroup; import org.nuiton.wikitty.entities.WikittyGroupImpl; import org.nuiton.wikitty.search.operators.Element; -import org.nuiton.wikitty.search.operators.Like.SearchAs; import org.nuiton.wikitty.search.RestrictionHelper; import org.nuiton.wikitty.search.Search; @@ -351,33 +350,6 @@ } @Test - public void testSearchNonSensitive() throws Exception { - - Criteria criteria = Search.query() - .like("Test.name_s", "cHaIsE", SearchAs.ToLowerCase) - .criteria() - .setFirstIndex(0).setEndIndex(Criteria.ALL_ELEMENTS); - - PagedResult<String> result = ws.findAllByCriteria(null, criteria)[0]; - List<String> list = result.getAll(); - assertEquals(1, list.size()); - - Wikitty w = ws.restore(null, list.get(0)); - assertEquals("chaise", w.getFieldAsString("Test", "name")); - assertEquals(113311, w.getFieldAsInt("Test", "amount")); - assertEquals(AbstractTestConformance.parse("26/09/2009"), w.getFieldAsDate("Test", "buildDate")); - - criteria = Search.query() - .unlike("Test.name_s", "cHaIsE", SearchAs.ToLowerCase) - .criteria() - .setFirstIndex(0).setEndIndex(Criteria.ALL_ELEMENTS); - - result = ws.findAllByCriteria(null, criteria)[0]; - list = result.getAll(); - assertEquals(12, list.size()); - } - - @Test public void testFindAllByExample() throws Exception { Wikitty example = new WikittyImpl(); example.addExtension(extProduct); @@ -463,7 +435,7 @@ // on ignore ce test car le like toLowercase devrait disparaitre et pour l'instant il ne marche pas :( // @Ignore - @Test + /*@Test public void testLikeSearch() throws Exception { Criteria criteria = Search.query().like("Category.name", "hArDwArE").criteria(); PagedResult<String> pagedResult = ws.findAllByCriteria(null, criteria)[0]; @@ -487,11 +459,11 @@ criteria = Search.query().like("Test.description", "helped").criteria(); pagedResult = ws.findAllByCriteria(null, criteria)[0]; assertEquals(1, pagedResult.getNumFound()); - } + }*/ // on ignore ce test car le like toLowercase devrait disparaitre et pour l'instant il ne marche pas :( // @Ignore - @Test +/* @Test public void testLikeStrict() throws Exception { Criteria criteria = Search.query() @@ -514,7 +486,7 @@ result = ws.findAllByCriteria(null, criteria)[0]; list = result.getAll(); assertEquals(5, list.size()); - } + }*/ /** test that doing a search with a date criteria is possible */ @Test @@ -613,10 +585,10 @@ // avec accent specifiquement sur le champs name // mais sans accent pour la recherche // et et majuscule - Criteria criteria = Search.query().like( + /*Criteria criteria = Search.query().like( WikittyGroup.FQ_FIELD_WIKITTYGROUP_NAME, "CECA").criteria(); PagedResult<String> result = ws.findAllByCriteria(null, criteria)[0]; - Assert.assertEquals(1, result.size()); + Assert.assertEquals(1, result.size());*/ } } }