Apache/lucene
1
0
Fork 0
mirror of https://github.com/apache/lucene.git synced 2025-02-22 01:56:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

SOLR-2002: minor cleanups to dih tests

Browse Source 
git-svn-id: https://svn.apache.org/repos/asf/lucene/dev/trunk@1022165 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Robert Muir 2010-10-13 16:11:07 +00:00
parent b8215fdec0
commit 54ef52a621
32 changed files with 674 additions and 863 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
solr/contrib/dataimporthandler/src/extras/test/java/org/apache/solr/handler/dataimport/TestMailEntityProcessor.java
View File

@ -16,9 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import junit.framework.Assert;
import org.apache.solr.SolrTestCaseJ4;
import org.apache.solr.common.SolrInputDocument;
import org.junit.Ignore;
import org.junit.Test;
@ -47,7 +44,7 @@ import java.util.Map;
* @see org.apache.solr.handler.dataimport.MailEntityProcessor
* @since solr 1.4
*/
public class TestMailEntityProcessor extends SolrTestCaseJ4 {
public class TestMailEntityProcessor extends AbstractDataImportHandlerTestCase {
// Credentials
private static final String user = "user";
@ -72,7 +69,7 @@ public class TestMailEntityProcessor extends SolrTestCaseJ4 {
rp.command = "full-import";
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
Assert.assertEquals("top1 did not return 2 messages", swi.docs.size(), 2);
assertEquals("top1 did not return 2 messages", swi.docs.size(), 2);
}
@Test
@ -89,7 +86,7 @@ public class TestMailEntityProcessor extends SolrTestCaseJ4 {
rp.command = "full-import";
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
Assert.assertEquals("top2 and its children did not return 8 messages", swi.docs.size(), 8);
assertEquals("top2 and its children did not return 8 messages", swi.docs.size(), 8);
}
@Test
@ -107,7 +104,7 @@ public class TestMailEntityProcessor extends SolrTestCaseJ4 {
rp.command = "full-import";
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
Assert.assertEquals("top2 and its direct children did not return 5 messages", swi.docs.size(), 5);
assertEquals("top2 and its direct children did not return 5 messages", swi.docs.size(), 5);
}
@Test
@ -125,7 +122,7 @@ public class TestMailEntityProcessor extends SolrTestCaseJ4 {
rp.command = "full-import";
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
Assert.assertEquals("top2 and its direct children did not return 3 messages", swi.docs.size(), 3);
assertEquals("top2 and its direct children did not return 3 messages", swi.docs.size(), 3);
}
@Test
@ -144,7 +141,7 @@ public class TestMailEntityProcessor extends SolrTestCaseJ4 {
rp.command = "full-import";
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
Assert.assertEquals("top2 and its direct children did not return 3 messages", swi.docs.size(), 3);
assertEquals("top2 and its direct children did not return 3 messages", swi.docs.size(), 3);
}
@Test
@ -162,7 +159,7 @@ public class TestMailEntityProcessor extends SolrTestCaseJ4 {
rp.command = "full-import";
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
Assert.assertEquals("top2 and its direct children did not return 3 messages", swi.docs.size(), 3);
assertEquals("top2 and its direct children did not return 3 messages", swi.docs.size(), 3);
}
private String getConfigFromMap(Map<String, String> params) {

25
solr/contrib/dataimporthandler/src/extras/test/java/org/apache/solr/handler/dataimport/TestTikaEntityProcessor.java
View File

@ -16,31 +16,16 @@
*/
package org.apache.solr.handler.dataimport;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
/**Testcase for TikaEntityProcessor
* @version $Id$
* @since solr 1.5
*/
public class TestTikaEntityProcessor extends AbstractDataImportHandlerTestCase {
@Before
public void setUp() throws Exception {
super.setUp();
}
@After
public void tearDown() throws Exception {
super.tearDown();
}
public String getSchemaFile() {
return "dataimport-schema-no-unique-key.xml";
}
public String getSolrConfigFile() {
return "dataimport-solrconfig.xml";
@BeforeClass
public static void beforeClass() throws Exception {
initCore("dataimport-solrconfig.xml", "dataimport-schema-no-unique-key.xml");
}
public void testIndexingWithTikaEntityProcessor() throws Exception {
@ -55,7 +40,7 @@ public class TestTikaEntityProcessor extends AbstractDataImportHandlerTestCase {
" </entity>" +
" </document>" +
"</dataConfig>";
super.runFullImport(conf);
runFullImport(conf);
assertQ(req("*:*"), "//*[@numFound='1']");
}
}

32
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/AbstractDataImportHandlerTestCase.java
View File

@ -16,11 +16,14 @@
*/
package org.apache.solr.handler.dataimport;
import org.apache.solr.SolrTestCaseJ4;
import org.apache.solr.core.SolrCore;
import org.apache.solr.request.LocalSolrQueryRequest;
import org.apache.solr.util.AbstractSolrTestCase;
import org.apache.solr.common.util.NamedList;
import org.junit.After;
import org.junit.Before;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.File;
import java.util.HashMap;
@ -38,14 +41,16 @@ import java.util.Map;
* @since solr 1.3
*/
public abstract class AbstractDataImportHandlerTestCase extends
AbstractSolrTestCase {
SolrTestCaseJ4 {
@Override
@Before
public void setUp() throws Exception {
super.setUp();
}
@Override
@After
public void tearDown() throws Exception {
// remove dataimport.properties
File f = new File("solr/conf/dataimport.properties");
@ -140,6 +145,29 @@ public abstract class AbstractDataImportHandlerTestCase extends
return result;
}
public static File createFile(File tmpdir, String name, byte[] content,
boolean changeModifiedTime) throws IOException {
File file = new File(tmpdir.getAbsolutePath() + File.separator + name);
file.deleteOnExit();
FileOutputStream f = new FileOutputStream(file);
f.write(content);
f.close();
if (changeModifiedTime)
file.setLastModified(System.currentTimeMillis() - 3600000);
return file;
}
public static Map<String, String> getField(String col, String type,
String re, String srcCol, String splitBy) {
HashMap<String, String> vals = new HashMap<String, String>();
vals.put("column", col);
vals.put("type", type);
vals.put("regex", re);
vals.put("sourceColName", srcCol);
vals.put("splitBy", splitBy);
return vals;
}
static class TestContext extends Context {
private final Map<String, String> entityAttrs;
private final Context delegate;

115
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestCachedSqlEntityProcessor.java
View File

@ -16,8 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Test;
import java.util.ArrayList;
@ -33,25 +31,23 @@ import java.util.Map;
* @version $Id$
* @since solr 1.3
*/
public class TestCachedSqlEntityProcessor extends SolrTestCaseJ4 {
public class TestCachedSqlEntityProcessor extends AbstractDataImportHandlerTestCase {
@Test
public void withoutWhereClause() {
List fields = new ArrayList();
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "id"));
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "desc"));
fields.add(createMap("column", "id"));
fields.add(createMap("column", "desc"));
String q = "select * from x where id=${x.id}";
Map<String, String> entityAttrs = AbstractDataImportHandlerTestCase.createMap(
"query", q);
Map<String, String> entityAttrs = createMap("query", q);
MockDataSource ds = new MockDataSource();
VariableResolverImpl vr = new VariableResolverImpl();
vr.addNamespace("x", AbstractDataImportHandlerTestCase.createMap("id", 1));
Context context = AbstractDataImportHandlerTestCase.getContext(null, vr, ds, Context.FULL_DUMP, fields, entityAttrs);
vr.addNamespace("x", createMap("id", 1));
Context context = getContext(null, vr, ds, Context.FULL_DUMP, fields, entityAttrs);
List<Map<String, Object>> rows = new ArrayList<Map<String, Object>>();
rows.add(AbstractDataImportHandlerTestCase.createMap("id", 1, "desc", "one"));
rows.add(AbstractDataImportHandlerTestCase.createMap("id", 1, "desc",
"another one"));
rows.add(createMap("id", 1, "desc", "one"));
rows.add(createMap("id", 1, "desc", "another one"));
MockDataSource.setIterator(vr.replaceTokens(q), rows.iterator());
EntityProcessor csep = new EntityProcessorWrapper( new CachedSqlEntityProcessor(), null);
csep.init(context);
@ -62,7 +58,7 @@ public class TestCachedSqlEntityProcessor extends SolrTestCaseJ4 {
break;
rows.add(r);
}
Assert.assertEquals(2, rows.size());
assertEquals(2, rows.size());
ds.close();
csep.init(context);
rows = new ArrayList<Map<String, Object>>();
@ -72,28 +68,27 @@ public class TestCachedSqlEntityProcessor extends SolrTestCaseJ4 {
break;
rows.add(r);
}
Assert.assertEquals(2, rows.size());
Assert.assertEquals(2, rows.get(0).size());
Assert.assertEquals(2, rows.get(1).size());
assertEquals(2, rows.size());
assertEquals(2, rows.get(0).size());
assertEquals(2, rows.get(1).size());
}
@Test
public void withoutWhereClauseWithTransformers() {
List fields = new ArrayList();
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "id"));
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "desc"));
fields.add(createMap("column", "id"));
fields.add(createMap("column", "desc"));
String q = "select * from x where id=${x.id}";
Map<String, String> entityAttrs = AbstractDataImportHandlerTestCase.createMap(
Map<String, String> entityAttrs = createMap(
"query", q, "transformer", UppercaseTransformer.class.getName());
MockDataSource ds = new MockDataSource();
VariableResolverImpl vr = new VariableResolverImpl();
vr.addNamespace("x", AbstractDataImportHandlerTestCase.createMap("id", 1));
Context context = AbstractDataImportHandlerTestCase.getContext(null, vr, ds, Context.FULL_DUMP, fields, entityAttrs);
vr.addNamespace("x", createMap("id", 1));
Context context = getContext(null, vr, ds, Context.FULL_DUMP, fields, entityAttrs);
List<Map<String, Object>> rows = new ArrayList<Map<String, Object>>();
rows.add(AbstractDataImportHandlerTestCase.createMap("id", 1, "desc", "one"));
rows.add(AbstractDataImportHandlerTestCase.createMap("id", 1, "desc",
"another one"));
rows.add(createMap("id", 1, "desc", "one"));
rows.add(createMap("id", 1, "desc", "another one"));
MockDataSource.setIterator(vr.replaceTokens(q), rows.iterator());
EntityProcessor csep = new EntityProcessorWrapper( new CachedSqlEntityProcessor(), null);
csep.init(context);
@ -104,7 +99,7 @@ public class TestCachedSqlEntityProcessor extends SolrTestCaseJ4 {
break;
rows.add(r);
}
Assert.assertEquals(2, rows.size());
assertEquals(2, rows.size());
ds.close();
csep.init(context);
rows = new ArrayList<Map<String, Object>>();
@ -113,30 +108,29 @@ public class TestCachedSqlEntityProcessor extends SolrTestCaseJ4 {
if (r == null)
break;
rows.add(r);
Assert.assertEquals(r.get("desc").toString().toUpperCase(Locale.ENGLISH), r.get("desc"));
assertEquals(r.get("desc").toString().toUpperCase(Locale.ENGLISH), r.get("desc"));
}
Assert.assertEquals(2, rows.size());
Assert.assertEquals(2, rows.get(0).size());
Assert.assertEquals(2, rows.get(1).size());
assertEquals(2, rows.size());
assertEquals(2, rows.get(0).size());
assertEquals(2, rows.get(1).size());
}
@Test
public void withoutWhereClauseWithMultiRowTransformer() {
List fields = new ArrayList();
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "id"));
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "desc"));
fields.add(createMap("column", "id"));
fields.add(createMap("column", "desc"));
String q = "select * from x where id=${x.id}";
Map<String, String> entityAttrs = AbstractDataImportHandlerTestCase.createMap(
Map<String, String> entityAttrs = createMap(
"query", q, "transformer", DoubleTransformer.class.getName());
MockDataSource ds = new MockDataSource();
VariableResolverImpl vr = new VariableResolverImpl();
vr.addNamespace("x", AbstractDataImportHandlerTestCase.createMap("id", 1));
Context context = AbstractDataImportHandlerTestCase.getContext(null, vr, ds, Context.FULL_DUMP, fields, entityAttrs);
vr.addNamespace("x", createMap("id", 1));
Context context = getContext(null, vr, ds, Context.FULL_DUMP, fields, entityAttrs);
List<Map<String, Object>> rows = new ArrayList<Map<String, Object>>();
rows.add(AbstractDataImportHandlerTestCase.createMap("id", 1, "desc", "one"));
rows.add(AbstractDataImportHandlerTestCase.createMap("id", 1, "desc",
"another one"));
rows.add(createMap("id", 1, "desc", "one"));
rows.add(createMap("id", 1, "desc", "another one"));
MockDataSource.setIterator(vr.replaceTokens(q), rows.iterator());
EntityProcessor csep = new EntityProcessorWrapper( new CachedSqlEntityProcessor(), null);
csep.init(context);
@ -147,7 +141,7 @@ public class TestCachedSqlEntityProcessor extends SolrTestCaseJ4 {
break;
rows.add(r);
}
Assert.assertEquals(4, rows.size());
assertEquals(4, rows.size());
ds.close();
csep.init(context);
rows = new ArrayList<Map<String, Object>>();
@ -157,9 +151,9 @@ public class TestCachedSqlEntityProcessor extends SolrTestCaseJ4 {
break;
rows.add(r);
}
Assert.assertEquals(4, rows.size());
Assert.assertEquals(2, rows.get(0).size());
Assert.assertEquals(2, rows.get(1).size());
assertEquals(4, rows.size());
assertEquals(2, rows.get(0).size());
assertEquals(2, rows.get(1).size());
}
public static class DoubleTransformer extends Transformer {
@ -190,43 +184,42 @@ public class TestCachedSqlEntityProcessor extends SolrTestCaseJ4 {
@Test
public void withWhereClause() {
List fields = new ArrayList();
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "id"));
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "desc"));
fields.add(createMap("column", "id"));
fields.add(createMap("column", "desc"));
String q = "select * from x";
Map<String, String> entityAttrs = AbstractDataImportHandlerTestCase.createMap(
Map<String, String> entityAttrs = createMap(
"query", q, EntityProcessorBase.CACHE_KEY,"id", EntityProcessorBase.CACHE_LOOKUP ,"x.id");
MockDataSource ds = new MockDataSource();
VariableResolverImpl vr = new VariableResolverImpl();
Map xNamespace = AbstractDataImportHandlerTestCase.createMap("id", 0);
Map xNamespace = createMap("id", 0);
vr.addNamespace("x", xNamespace);
Context context = AbstractDataImportHandlerTestCase.getContext(null, vr, ds, Context.FULL_DUMP, fields, entityAttrs);
Context context = getContext(null, vr, ds, Context.FULL_DUMP, fields, entityAttrs);
doWhereTest(q, context, ds, xNamespace);
}
@Test
public void withKeyAndLookup() {
List fields = new ArrayList();
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "id"));
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "desc"));
fields.add(createMap("column", "id"));
fields.add(createMap("column", "desc"));
String q = "select * from x";
Map<String, String> entityAttrs = AbstractDataImportHandlerTestCase.createMap("query", q, "where", "id=x.id");
Map<String, String> entityAttrs = createMap("query", q, "where", "id=x.id");
MockDataSource ds = new MockDataSource();
VariableResolverImpl vr = new VariableResolverImpl();
Map xNamespace = AbstractDataImportHandlerTestCase.createMap("id", 0);
Map xNamespace = createMap("id", 0);
vr.addNamespace("x", xNamespace);
Context context = AbstractDataImportHandlerTestCase.getContext(null, vr, ds, Context.FULL_DUMP, fields, entityAttrs);
Context context = getContext(null, vr, ds, Context.FULL_DUMP, fields, entityAttrs);
doWhereTest(q, context, ds, xNamespace);
}
private void doWhereTest(String q, Context context, MockDataSource ds, Map xNamespace) {
List<Map<String, Object>> rows = new ArrayList<Map<String, Object>>();
rows.add(AbstractDataImportHandlerTestCase.createMap("id", 1, "desc", "one"));
rows.add(AbstractDataImportHandlerTestCase.createMap("id", 2, "desc", "two"));
rows.add(AbstractDataImportHandlerTestCase.createMap("id", 2, "desc",
"another two"));
rows.add(AbstractDataImportHandlerTestCase.createMap("id", 3, "desc", "three"));
rows.add(AbstractDataImportHandlerTestCase.createMap("id", 3, "desc", "another three"));
rows.add(AbstractDataImportHandlerTestCase.createMap("id", 3, "desc", "another another three"));
rows.add(createMap("id", 1, "desc", "one"));
rows.add(createMap("id", 2, "desc", "two"));
rows.add(createMap("id", 2, "desc", "another two"));
rows.add(createMap("id", 3, "desc", "three"));
rows.add(createMap("id", 3, "desc", "another three"));
rows.add(createMap("id", 3, "desc", "another another three"));
MockDataSource.setIterator(q, rows.iterator());
EntityProcessor csep = new EntityProcessorWrapper(new CachedSqlEntityProcessor(), null);
csep.init(context);
@ -237,7 +230,7 @@ public class TestCachedSqlEntityProcessor extends SolrTestCaseJ4 {
break;
rows.add(r);
}
Assert.assertEquals(0, rows.size());
assertEquals(0, rows.size());
ds.close();
csep.init(context);
@ -249,7 +242,7 @@ public class TestCachedSqlEntityProcessor extends SolrTestCaseJ4 {
break;
rows.add(r);
}
Assert.assertEquals(2, rows.size());
assertEquals(2, rows.size());
csep.init(context);
rows = new ArrayList<Map<String, Object>>();
@ -260,6 +253,6 @@ public class TestCachedSqlEntityProcessor extends SolrTestCaseJ4 {
break;
rows.add(r);
}
Assert.assertEquals(3, rows.size());
assertEquals(3, rows.size());
}
}

9
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestClobTransformer.java
View File

@ -16,9 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import junit.framework.Assert;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Test;
import java.io.StringReader;
@ -35,7 +32,7 @@ import java.util.*;
* @see org.apache.solr.handler.dataimport.ClobTransformer
* @since solr 1.4
*/
public class TestClobTransformer extends SolrTestCaseJ4 {
public class TestClobTransformer extends AbstractDataImportHandlerTestCase {
@Test
public void simple() throws Exception {
List<Map<String, String>> flds = new ArrayList<Map<String, String>>();
@ -45,7 +42,7 @@ public class TestClobTransformer extends SolrTestCaseJ4 {
f.put(ClobTransformer.CLOB, "true");
f.put(DataImporter.NAME, "description");
flds.add(f);
Context ctx = AbstractDataImportHandlerTestCase.getContext(null, new VariableResolverImpl(), null, Context.FULL_DUMP, flds, Collections.EMPTY_MAP);
Context ctx = getContext(null, new VariableResolverImpl(), null, Context.FULL_DUMP, flds, Collections.EMPTY_MAP);
Transformer t = new ClobTransformer();
Map<String, Object> row = new HashMap<String, Object>();
Clob clob = (Clob) Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{Clob.class}, new InvocationHandler() {
@ -59,6 +56,6 @@ public class TestClobTransformer extends SolrTestCaseJ4 {
row.put("dsc", clob);
t.transformRow(row, ctx);
Assert.assertEquals("hello!", row.get("dsc"));
assertEquals("hello!", row.get("dsc"));
}
}

11
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestContentStreamDataSource.java
View File

@ -16,9 +16,7 @@
*/
package org.apache.solr.handler.dataimport;
import junit.framework.TestCase;
import org.apache.commons.io.FileUtils;
import org.apache.solr.SolrTestCaseJ4;
import org.apache.solr.client.solrj.embedded.JettySolrRunner;
import org.apache.solr.client.solrj.impl.CommonsHttpSolrServer;
import org.apache.solr.client.solrj.request.DirectXmlRequest;
@ -26,11 +24,10 @@ import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.params.ModifiableSolrParams;
import org.apache.solr.util.AbstractSolrTestCase;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;
import java.io.File;
import java.util.List;
@ -41,7 +38,7 @@ import java.util.List;
* @version $Id$
* @since solr 1.4
*/
public class TestContentStreamDataSource extends SolrTestCaseJ4 {
public class TestContentStreamDataSource extends AbstractDataImportHandlerTestCase {
private static final String CONF_DIR = "." + File.separator + "solr" + File.separator + "conf" + File.separator;
SolrInstance instance = null;
JettySolrRunner jetty;
@ -119,7 +116,7 @@ public class TestContentStreamDataSource extends SolrTestCaseJ4 {
public void setUp() throws Exception {
File home = new File(SolrTestCaseJ4.TEMP_DIR,
File home = new File(TEMP_DIR,
getClass().getName() + "-" + System.currentTimeMillis());
@ -141,7 +138,7 @@ public class TestContentStreamDataSource extends SolrTestCaseJ4 {
}
public void tearDown() throws Exception {
AbstractSolrTestCase.recurseDelete(homeDir);
recurseDelete(homeDir);
}
}

30
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestDataConfig.java
View File

@ -16,7 +16,7 @@
*/
package org.apache.solr.handler.dataimport;
import junit.framework.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import org.w3c.dom.Document;
@ -34,25 +34,9 @@ import java.util.List;
* @since solr 1.3
*/
public class TestDataConfig extends AbstractDataImportHandlerTestCase {
@Override
public void setUp() throws Exception {
super.setUp();
}
@Override
public void tearDown() throws Exception {
super.tearDown();
}
@Override
public String getSchemaFile() {
return "dataimport-schema.xml";
}
@Override
public String getSolrConfigFile() {
return "dataimport-nodatasource-solrconfig.xml";
@BeforeClass
public static void beforeClass() throws Exception {
initCore("dataimport-nodatasource-solrconfig.xml", "dataimport-schema.xml");
}
@Test
@ -62,20 +46,20 @@ public class TestDataConfig extends AbstractDataImportHandlerTestCase {
rows.add(createMap("id", "1", "desc", "one"));
MockDataSource.setIterator("select * from x", rows.iterator());
super.runFullImport(loadDataConfig("data-config-with-datasource.xml"));
runFullImport(loadDataConfig("data-config-with-datasource.xml"));
assertQ(req("id:1"), "//*[@numFound='1']");
}
@Test
public void basic() throws Exception {
public void testBasic() throws Exception {
javax.xml.parsers.DocumentBuilder builder = DocumentBuilderFactory
.newInstance().newDocumentBuilder();
Document doc = builder.parse(new ByteArrayInputStream(xml.getBytes()));
DataConfig dc = new DataConfig();
dc.readFromXml(doc.getDocumentElement());
Assert.assertEquals("atrimlisting", dc.document.entities.get(0).name);
assertEquals("atrimlisting", dc.document.entities.get(0).name);
}
private static final String xml = "<dataConfig>\n"

25
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestDateFormatTransformer.java
View File

@ -16,8 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Test;
import java.text.SimpleDateFormat;
@ -31,40 +29,37 @@ import java.util.*;
* @version $Id$
* @since solr 1.3
*/
public class TestDateFormatTransformer extends SolrTestCaseJ4 {
public class TestDateFormatTransformer extends AbstractDataImportHandlerTestCase {
@Test
@SuppressWarnings("unchecked")
public void testTransformRow_SingleRow() throws Exception {
List fields = new ArrayList();
fields.add(AbstractDataImportHandlerTestCase.createMap(DataImporter.COLUMN,
"lastModified"));
fields.add(AbstractDataImportHandlerTestCase.createMap(DataImporter.COLUMN,
fields.add(createMap(DataImporter.COLUMN, "lastModified"));
fields.add(createMap(DataImporter.COLUMN,
"dateAdded", RegexTransformer.SRC_COL_NAME, "lastModified",
DateFormatTransformer.DATE_TIME_FMT, "MM/dd/yyyy"));
SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy");
Date now = format.parse(format.format(new Date()));
Map row = AbstractDataImportHandlerTestCase.createMap("lastModified", format
.format(now));
Map row = createMap("lastModified", format.format(now));
VariableResolverImpl resolver = new VariableResolverImpl();
resolver.addNamespace("e", row);
Context context = AbstractDataImportHandlerTestCase.getContext(null, resolver,
Context context = getContext(null, resolver,
null, Context.FULL_DUMP, fields, null);
new DateFormatTransformer().transformRow(row, context);
Assert.assertEquals(now, row.get("dateAdded"));
assertEquals(now, row.get("dateAdded"));
}
@Test
@SuppressWarnings("unchecked")
public void testTransformRow_MultipleRows() throws Exception {
List fields = new ArrayList();
fields.add(AbstractDataImportHandlerTestCase.createMap(DataImporter.COLUMN,
"lastModified"));
fields.add(AbstractDataImportHandlerTestCase.createMap(DataImporter.COLUMN,
fields.add(createMap(DataImporter.COLUMN, "lastModified"));
fields.add(createMap(DataImporter.COLUMN,
"dateAdded", RegexTransformer.SRC_COL_NAME, "lastModified",
DateFormatTransformer.DATE_TIME_FMT, "MM/dd/yyyy hh:mm:ss.SSS"));
@ -81,13 +76,13 @@ public class TestDateFormatTransformer extends SolrTestCaseJ4 {
VariableResolverImpl resolver = new VariableResolverImpl();
resolver.addNamespace("e", row);
Context context = AbstractDataImportHandlerTestCase.getContext(null, resolver,
Context context = getContext(null, resolver,
null, Context.FULL_DUMP, fields, null);
new DateFormatTransformer().transformRow(row, context);
List output = new ArrayList();
output.add(now1);
output.add(now2);
Assert.assertEquals(output, row.get("dateAdded"));
assertEquals(output, row.get("dateAdded"));
}
}

265
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestDocBuilder.java
View File

@ -16,10 +16,9 @@
*/
package org.apache.solr.handler.dataimport;
import org.apache.solr.SolrTestCaseJ4;
import org.apache.solr.common.SolrInputDocument;
import static org.apache.solr.handler.dataimport.AbstractDataImportHandlerTestCase.createMap;
import org.junit.Assert;
import org.junit.After;
import org.junit.Test;
import java.util.*;
@ -32,183 +31,155 @@ import java.util.*;
* @version $Id$
* @since solr 1.3
*/
public class TestDocBuilder extends SolrTestCaseJ4 {
public class TestDocBuilder extends AbstractDataImportHandlerTestCase {
@After
public void tearDown() throws Exception {
MockDataSource.clearCache();
super.tearDown();
}
@Test
public void loadClass() throws Exception {
Class clz = DocBuilder.loadClass("RegexTransformer", null);
Assert.assertNotNull(clz);
assertNotNull(clz);
}
@Test
public void singleEntityNoRows() {
try {
DataImporter di = new DataImporter();
di.loadAndInit(dc_singleEntity);
DataConfig cfg = di.getConfig();
DataConfig.Entity ent = cfg.document.entities.get(0);
MockDataSource.setIterator("select * from x", new ArrayList().iterator());
ent.dataSrc = new MockDataSource();
ent.isDocRoot = true;
DataImporter.RequestParams rp = new DataImporter.RequestParams();
rp.command = "full-import";
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
Assert.assertEquals(Boolean.TRUE, swi.deleteAllCalled);
Assert.assertEquals(Boolean.TRUE, swi.commitCalled);
Assert.assertEquals(0, swi.docs.size());
Assert.assertEquals(1, di.getDocBuilder().importStatistics.queryCount
.get());
Assert
.assertEquals(0, di.getDocBuilder().importStatistics.docCount.get());
Assert.assertEquals(0, di.getDocBuilder().importStatistics.rowsCount
.get());
} finally {
MockDataSource.clearCache();
}
DataImporter di = new DataImporter();
di.loadAndInit(dc_singleEntity);
DataConfig cfg = di.getConfig();
DataConfig.Entity ent = cfg.document.entities.get(0);
MockDataSource.setIterator("select * from x", new ArrayList().iterator());
ent.dataSrc = new MockDataSource();
ent.isDocRoot = true;
DataImporter.RequestParams rp = new DataImporter.RequestParams();
rp.command = "full-import";
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
assertEquals(Boolean.TRUE, swi.deleteAllCalled);
assertEquals(Boolean.TRUE, swi.commitCalled);
assertEquals(0, swi.docs.size());
assertEquals(1, di.getDocBuilder().importStatistics.queryCount.get());
assertEquals(0, di.getDocBuilder().importStatistics.docCount.get());
assertEquals(0, di.getDocBuilder().importStatistics.rowsCount.get());
}
@Test
public void testDeltaImportNoRows_MustNotCommit() {
try {
DataImporter di = new DataImporter();
di.loadAndInit(dc_deltaConfig);
DataConfig cfg = di.getConfig();
DataConfig.Entity ent = cfg.document.entities.get(0);
MockDataSource.setIterator("select * from x", new ArrayList().iterator());
MockDataSource.setIterator("select id from x", new ArrayList().iterator());
ent.dataSrc = new MockDataSource();
ent.isDocRoot = true;
DataImporter.RequestParams rp = new DataImporter.RequestParams(createMap("command", "delta-import"));
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
Assert.assertEquals(Boolean.FALSE, swi.deleteAllCalled);
Assert.assertEquals(Boolean.FALSE, swi.commitCalled);
Assert.assertEquals(0, swi.docs.size());
Assert.assertEquals(1, di.getDocBuilder().importStatistics.queryCount.get());
Assert.assertEquals(0, di.getDocBuilder().importStatistics.docCount.get());
Assert.assertEquals(0, di.getDocBuilder().importStatistics.rowsCount.get());
} finally {
MockDataSource.clearCache();
}
DataImporter di = new DataImporter();
di.loadAndInit(dc_deltaConfig);
DataConfig cfg = di.getConfig();
DataConfig.Entity ent = cfg.document.entities.get(0);
MockDataSource.setIterator("select * from x", new ArrayList().iterator());
MockDataSource.setIterator("select id from x", new ArrayList().iterator());
ent.dataSrc = new MockDataSource();
ent.isDocRoot = true;
DataImporter.RequestParams rp = new DataImporter.RequestParams(createMap("command", "delta-import"));
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
assertEquals(Boolean.FALSE, swi.deleteAllCalled);
assertEquals(Boolean.FALSE, swi.commitCalled);
assertEquals(0, swi.docs.size());
assertEquals(1, di.getDocBuilder().importStatistics.queryCount.get());
assertEquals(0, di.getDocBuilder().importStatistics.docCount.get());
assertEquals(0, di.getDocBuilder().importStatistics.rowsCount.get());
}
@Test
public void singleEntityOneRow() {
try {
DataImporter di = new DataImporter();
di.loadAndInit(dc_singleEntity);
DataConfig cfg = di.getConfig();
DataConfig.Entity ent = cfg.document.entities.get(0);
List l = new ArrayList();
l.add(createMap("id", 1, "desc", "one"));
MockDataSource.setIterator("select * from x", l.iterator());
ent.dataSrc = new MockDataSource();
ent.isDocRoot = true;
DataImporter.RequestParams rp = new DataImporter.RequestParams();
rp.command = "full-import";
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
Assert.assertEquals(Boolean.TRUE, swi.deleteAllCalled);
Assert.assertEquals(Boolean.TRUE, swi.commitCalled);
Assert.assertEquals(1, swi.docs.size());
Assert.assertEquals(1, di.getDocBuilder().importStatistics.queryCount
.get());
Assert
.assertEquals(1, di.getDocBuilder().importStatistics.docCount.get());
Assert.assertEquals(1, di.getDocBuilder().importStatistics.rowsCount
.get());
DataImporter di = new DataImporter();
di.loadAndInit(dc_singleEntity);
DataConfig cfg = di.getConfig();
DataConfig.Entity ent = cfg.document.entities.get(0);
List l = new ArrayList();
l.add(createMap("id", 1, "desc", "one"));
MockDataSource.setIterator("select * from x", l.iterator());
ent.dataSrc = new MockDataSource();
ent.isDocRoot = true;
DataImporter.RequestParams rp = new DataImporter.RequestParams();
rp.command = "full-import";
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
assertEquals(Boolean.TRUE, swi.deleteAllCalled);
assertEquals(Boolean.TRUE, swi.commitCalled);
assertEquals(1, swi.docs.size());
assertEquals(1, di.getDocBuilder().importStatistics.queryCount.get());
assertEquals(1, di.getDocBuilder().importStatistics.docCount.get());
assertEquals(1, di.getDocBuilder().importStatistics.rowsCount.get());
for (int i = 0; i < l.size(); i++) {
Map<String, Object> map = (Map<String, Object>) l.get(i);
SolrInputDocument doc = swi.docs.get(i);
for (Map.Entry<String, Object> entry : map.entrySet()) {
Assert.assertEquals(entry.getValue(), doc.getFieldValue(entry
.getKey()));
}
for (int i = 0; i < l.size(); i++) {
Map<String, Object> map = (Map<String, Object>) l.get(i);
SolrInputDocument doc = swi.docs.get(i);
for (Map.Entry<String, Object> entry : map.entrySet()) {
assertEquals(entry.getValue(), doc.getFieldValue(entry.getKey()));
}
} finally {
MockDataSource.clearCache();
}
}
@Test
public void testImportCommand() {
try {
DataImporter di = new DataImporter();
di.loadAndInit(dc_singleEntity);
DataConfig cfg = di.getConfig();
DataConfig.Entity ent = cfg.document.entities.get(0);
List l = new ArrayList();
l.add(createMap("id", 1, "desc", "one"));
MockDataSource.setIterator("select * from x", l.iterator());
ent.dataSrc = new MockDataSource();
ent.isDocRoot = true;
DataImporter.RequestParams rp = new DataImporter.RequestParams(createMap("command", "import"));
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
Assert.assertEquals(Boolean.FALSE, swi.deleteAllCalled);
Assert.assertEquals(Boolean.TRUE, swi.commitCalled);
Assert.assertEquals(1, swi.docs.size());
Assert.assertEquals(1, di.getDocBuilder().importStatistics.queryCount
.get());
Assert
.assertEquals(1, di.getDocBuilder().importStatistics.docCount.get());
Assert.assertEquals(1, di.getDocBuilder().importStatistics.rowsCount
.get());
DataImporter di = new DataImporter();
di.loadAndInit(dc_singleEntity);
DataConfig cfg = di.getConfig();
DataConfig.Entity ent = cfg.document.entities.get(0);
List l = new ArrayList();
l.add(createMap("id", 1, "desc", "one"));
MockDataSource.setIterator("select * from x", l.iterator());
ent.dataSrc = new MockDataSource();
ent.isDocRoot = true;
DataImporter.RequestParams rp = new DataImporter.RequestParams(createMap("command", "import"));
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
assertEquals(Boolean.FALSE, swi.deleteAllCalled);
assertEquals(Boolean.TRUE, swi.commitCalled);
assertEquals(1, swi.docs.size());
assertEquals(1, di.getDocBuilder().importStatistics.queryCount.get());
assertEquals(1, di.getDocBuilder().importStatistics.docCount.get());
assertEquals(1, di.getDocBuilder().importStatistics.rowsCount.get());
for (int i = 0; i < l.size(); i++) {
Map<String, Object> map = (Map<String, Object>) l.get(i);
SolrInputDocument doc = swi.docs.get(i);
for (Map.Entry<String, Object> entry : map.entrySet()) {
Assert.assertEquals(entry.getValue(), doc.getFieldValue(entry
.getKey()));
}
for (int i = 0; i < l.size(); i++) {
Map<String, Object> map = (Map<String, Object>) l.get(i);
SolrInputDocument doc = swi.docs.get(i);
for (Map.Entry<String, Object> entry : map.entrySet()) {
assertEquals(entry.getValue(), doc.getFieldValue(entry.getKey()));
}
} finally {
MockDataSource.clearCache();
}
}
@Test
public void singleEntityMultipleRows() {
try {
DataImporter di = new DataImporter();
di.loadAndInit(dc_singleEntity);
DataConfig cfg = di.getConfig();
DataConfig.Entity ent = cfg.document.entities.get(0);
ent.isDocRoot = true;
DataImporter.RequestParams rp = new DataImporter.RequestParams();
rp.command = "full-import";
List l = new ArrayList();
l.add(createMap("id", 1, "desc", "one"));
l.add(createMap("id", 2, "desc", "two"));
l.add(createMap("id", 3, "desc", "three"));
DataImporter di = new DataImporter();
di.loadAndInit(dc_singleEntity);
DataConfig cfg = di.getConfig();
DataConfig.Entity ent = cfg.document.entities.get(0);
ent.isDocRoot = true;
DataImporter.RequestParams rp = new DataImporter.RequestParams();
rp.command = "full-import";
List l = new ArrayList();
l.add(createMap("id", 1, "desc", "one"));
l.add(createMap("id", 2, "desc", "two"));
l.add(createMap("id", 3, "desc", "three"));
MockDataSource.setIterator("select * from x", l.iterator());
ent.dataSrc = new MockDataSource();
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
Assert.assertEquals(Boolean.TRUE, swi.deleteAllCalled);
Assert.assertEquals(Boolean.TRUE, swi.commitCalled);
Assert.assertEquals(3, swi.docs.size());
for (int i = 0; i < l.size(); i++) {
Map<String, Object> map = (Map<String, Object>) l.get(i);
SolrInputDocument doc = swi.docs.get(i);
for (Map.Entry<String, Object> entry : map.entrySet()) {
Assert.assertEquals(entry.getValue(), doc.getFieldValue(entry.getKey()));
}
Assert.assertEquals(map.get("desc"), doc.getFieldValue("desc_s"));
MockDataSource.setIterator("select * from x", l.iterator());
ent.dataSrc = new MockDataSource();
SolrWriterImpl swi = new SolrWriterImpl();
di.runCmd(rp, swi);
assertEquals(Boolean.TRUE, swi.deleteAllCalled);
assertEquals(Boolean.TRUE, swi.commitCalled);
assertEquals(3, swi.docs.size());
for (int i = 0; i < l.size(); i++) {
Map<String, Object> map = (Map<String, Object>) l.get(i);
SolrInputDocument doc = swi.docs.get(i);
for (Map.Entry<String, Object> entry : map.entrySet()) {
assertEquals(entry.getValue(), doc.getFieldValue(entry.getKey()));
}
Assert.assertEquals(1, di.getDocBuilder().importStatistics.queryCount
.get());
Assert
.assertEquals(3, di.getDocBuilder().importStatistics.docCount.get());
Assert.assertEquals(3, di.getDocBuilder().importStatistics.rowsCount
.get());
} finally {
MockDataSource.clearCache();
assertEquals(map.get("desc"), doc.getFieldValue("desc_s"));
}
assertEquals(1, di.getDocBuilder().importStatistics.queryCount.get());
assertEquals(3, di.getDocBuilder().importStatistics.docCount.get());
assertEquals(3, di.getDocBuilder().importStatistics.rowsCount.get());
}
static class SolrWriterImpl extends SolrWriter {

61
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestDocBuilder2.java
View File

@ -16,16 +16,14 @@
*/
package org.apache.solr.handler.dataimport;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.Assert;
import org.apache.solr.request.LocalSolrQueryRequest;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Date;
import java.io.File;
/**
@ -38,24 +36,9 @@ import java.io.File;
*/
public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
@Before
public void setUp() throws Exception {
super.setUp();
}
@After
public void tearDown() throws Exception {
super.tearDown();
}
@Override
public String getSchemaFile() {
return "dataimport-schema.xml";
}
@Override
public String getSolrConfigFile() {
return "dataimport-solrconfig.xml";
@BeforeClass
public static void beforeClass() throws Exception {
initCore("dataimport-solrconfig.xml", "dataimport-schema.xml");
}
@Test
@ -65,7 +48,7 @@ public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
rows.add(createMap("id", "1", "desc", "one"));
MockDataSource.setIterator("select * from x", rows.iterator());
super.runFullImport(loadDataConfig("single-entity-data-config.xml"));
runFullImport(loadDataConfig("single-entity-data-config.xml"));
assertQ(req("id:1"), "//*[@numFound='1']");
}
@ -77,7 +60,7 @@ public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
rows.add(createMap("id", "1", "desC", "one"));
MockDataSource.setIterator("select * from x", rows.iterator());
super.runFullImport(dataConfigWithCaseInsensitiveFields);
runFullImport(dataConfigWithCaseInsensitiveFields);
assertQ(req("id:1"), "//*[@numFound='1']");
assertTrue("Start event listener was not called", StartEventListener.executed);
@ -91,7 +74,7 @@ public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
rows.add(createMap("id", "1", "desc", "one"));
MockDataSource.setIterator("select * from x", rows.iterator());
super.runFullImport(dataConfigWithDynamicTransformer);
runFullImport(dataConfigWithDynamicTransformer);
assertQ(req("id:1"), "//*[@numFound='1']");
assertQ(req("dynamic_s:test"), "//*[@numFound='1']");
@ -134,7 +117,7 @@ public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
rows.add(createMap("id", "1", "desc", "one"));
MockDataSource.setIterator("select * from x", rows.iterator());
super.runFullImport(loadDataConfig("data-config-with-transformer.xml"));
runFullImport(loadDataConfig("data-config-with-transformer.xml"));
}
@Test
@ -145,7 +128,7 @@ public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
rows.add(createMap("id", "2", "desc", "two", "$skipDoc", "true"));
MockDataSource.setIterator("select * from x", rows.iterator());
super.runFullImport(dataConfigWithDynamicTransformer);
runFullImport(dataConfigWithDynamicTransformer);
assertQ(req("id:1"), "//*[@numFound='1']");
assertQ(req("id:2"), "//*[@numFound='0']");
@ -159,7 +142,7 @@ public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
rows.add(createMap("id", "2", "desc", "two", "$skipRow", "true"));
MockDataSource.setIterator("select * from x", rows.iterator());
super.runFullImport(dataConfigWithDynamicTransformer);
runFullImport(dataConfigWithDynamicTransformer);
assertQ(req("id:1"), "//*[@numFound='1']");
assertQ(req("id:2"), "//*[@numFound='0']");
@ -179,7 +162,7 @@ public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
rows.add(createMap("name_s", "xyz", "$skipRow", "true"));
MockDataSource.setIterator("4", rows.iterator());
super.runFullImport(dataConfigWithTwoEntities);
runFullImport(dataConfigWithTwoEntities);
assertQ(req("id:3"), "//*[@numFound='1']");
assertQ(req("id:4"), "//*[@numFound='1']");
assertQ(req("name_s:abcd"), "//*[@numFound='1']");
@ -194,7 +177,7 @@ public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
rows.add(createMap("id", "2", "desc", "two", "$stopTransform", "true"));
MockDataSource.setIterator("select * from x", rows.iterator());
super.runFullImport(dataConfigForSkipTransform);
runFullImport(dataConfigForSkipTransform);
assertQ(req("id:1"), "//*[@numFound='1']");
assertQ(req("id:2"), "//*[@numFound='1']");
@ -210,7 +193,7 @@ public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
rows.add(createMap("id", "3", "desc", "two", "$deleteDocById", "2"));
MockDataSource.setIterator("select * from x", rows.iterator());
super.runFullImport(dataConfigForSkipTransform);
runFullImport(dataConfigForSkipTransform);
assertQ(req("id:1"), "//*[@numFound='1']");
assertQ(req("id:2"), "//*[@numFound='0']");
@ -223,7 +206,7 @@ public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
rows.add(createMap("id", "3", "desc", "two", "$deleteDocByQuery", "desc:one"));
MockDataSource.setIterator("select * from x", rows.iterator());
super.runFullImport(dataConfigForSkipTransform);
runFullImport(dataConfigForSkipTransform);
assertQ(req("id:1"), "//*[@numFound='0']");
assertQ(req("id:2"), "//*[@numFound='0']");
@ -239,15 +222,15 @@ public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
Map<String, String> params = createMap("baseDir", tmpdir.getAbsolutePath());
TestFileListEntityProcessor.createFile(tmpdir, "a.xml", "a.xml".getBytes(), true);
TestFileListEntityProcessor.createFile(tmpdir, "b.xml", "b.xml".getBytes(), true);
TestFileListEntityProcessor.createFile(tmpdir, "c.props", "c.props".getBytes(), true);
super.runFullImport(dataConfigFileList, params);
createFile(tmpdir, "a.xml", "a.xml".getBytes(), true);
createFile(tmpdir, "b.xml", "b.xml".getBytes(), true);
createFile(tmpdir, "c.props", "c.props".getBytes(), true);
runFullImport(dataConfigFileList, params);
assertQ(req("*:*"), "//*[@numFound='3']");
// Add a new file after a full index is done
TestFileListEntityProcessor.createFile(tmpdir, "t.xml", "t.xml".getBytes(), false);
super.runFullImport(dataConfigFileList, params);
createFile(tmpdir, "t.xml", "t.xml".getBytes(), false);
runFullImport(dataConfigFileList, params);
// we should find only 1 because by default clean=true is passed
// and this particular import should find only one file t.xml
assertQ(req("*:*"), "//*[@numFound='1']");
@ -255,7 +238,7 @@ public class TestDocBuilder2 extends AbstractDataImportHandlerTestCase {
public static class MockTransformer extends Transformer {
public Object transformRow(Map<String, Object> row, Context context) {
Assert.assertTrue("Context gave incorrect data source", context.getDataSource("mockDs") instanceof MockDataSource2);
assertTrue("Context gave incorrect data source", context.getDataSource("mockDs") instanceof MockDataSource2);
return row;
}
}

16
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestEntityProcessorBase.java
View File

@ -16,8 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Test;
import java.util.ArrayList;
@ -33,7 +31,7 @@ import java.util.Map;
* @version $Id$
* @since solr 1.3
*/
public class TestEntityProcessorBase extends SolrTestCaseJ4 {
public class TestEntityProcessorBase extends AbstractDataImportHandlerTestCase {
@Test
public void multiTransformer() {
@ -41,10 +39,10 @@ public class TestEntityProcessorBase extends SolrTestCaseJ4 {
Map<String, String> entity = new HashMap<String, String>();
entity.put("transformer", T1.class.getName() + "," + T2.class.getName()
+ "," + T3.class.getName());
fields.add(TestRegexTransformer.getField("A", null, null, null, null));
fields.add(TestRegexTransformer.getField("B", null, null, null, null));
fields.add(getField("A", null, null, null, null));
fields.add(getField("B", null, null, null, null));
Context context = AbstractDataImportHandlerTestCase.getContext(null, null, new MockDataSource(), Context.FULL_DUMP,
Context context = getContext(null, null, new MockDataSource(), Context.FULL_DUMP,
fields, entity);
Map<String, Object> src = new HashMap<String, Object>();
src.put("A", "NA");
@ -52,9 +50,9 @@ public class TestEntityProcessorBase extends SolrTestCaseJ4 {
EntityProcessorWrapper sep = new EntityProcessorWrapper(new SqlEntityProcessor(), null);
sep.init(context);
Map<String, Object> res = sep.applyTransformer(src);
Assert.assertNotNull(res.get("T1"));
Assert.assertNotNull(res.get("T2"));
Assert.assertNotNull(res.get("T3"));
assertNotNull(res.get("T1"));
assertNotNull(res.get("T2"));
assertNotNull(res.get("T3"));
}
static class T1 extends Transformer {

43
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestErrorHandling.java
View File

@ -23,6 +23,9 @@ import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.junit.Before;
import org.junit.BeforeClass;
/**
* Tests exception handling during imports in DataImportHandler
*
@ -31,23 +34,35 @@ import java.util.Properties;
*/
public class TestErrorHandling extends AbstractDataImportHandlerTestCase {
@BeforeClass
public static void beforeClass() throws Exception {
initCore("dataimport-solrconfig.xml", "dataimport-schema.xml");
}
@Before @Override
public void setUp() throws Exception {
super.setUp();
clearIndex();
assertU(commit());
}
public void testMalformedStreamingXml() throws Exception {
StringDataSource.xml = malformedXml;
super.runFullImport(dataConfigWithStreaming);
runFullImport(dataConfigWithStreaming);
assertQ(req("id:1"), "//*[@numFound='1']");
assertQ(req("id:2"), "//*[@numFound='1']");
}
public void testMalformedNonStreamingXml() throws Exception {
StringDataSource.xml = malformedXml;
super.runFullImport(dataConfigWithoutStreaming);
runFullImport(dataConfigWithoutStreaming);
assertQ(req("id:1"), "//*[@numFound='1']");
assertQ(req("id:2"), "//*[@numFound='1']");
}
public void testAbortOnError() throws Exception {
StringDataSource.xml = malformedXml;
super.runFullImport(dataConfigAbortOnError);
runFullImport(dataConfigAbortOnError);
assertQ(req("*:*"), "//*[@numFound='0']");
}
@ -56,30 +71,10 @@ public class TestErrorHandling extends AbstractDataImportHandlerTestCase {
List<Map<String, Object>> rows = new ArrayList<Map<String, Object>>();
rows.add(createMap("id", "3", "desc", "exception-transformer"));
MockDataSource.setIterator("select * from foo", rows.iterator());
super.runFullImport(dataConfigWithTransformer);
runFullImport(dataConfigWithTransformer);
assertQ(req("*:*"), "//*[@numFound='3']");
}
@Override
public String getSchemaFile() {
return "dataimport-schema.xml";
}
@Override
public String getSolrConfigFile() {
return "dataimport-solrconfig.xml";
}
@Override
public void setUp() throws Exception {
super.setUp();
}
@Override
public void tearDown() throws Exception {
super.tearDown();
}
public static class StringDataSource extends DataSource<Reader> {
public static String xml = "";

15
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestEvaluatorBag.java
View File

@ -16,9 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import static org.junit.Assert.assertEquals;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Before;
import org.junit.Test;
@ -26,15 +23,13 @@ import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.*;
import junit.framework.Assert;
/**
* <p> Test for EvaluatorBag </p>
*
* @version $Id$
* @since solr 1.3
*/
public class TestEvaluatorBag extends SolrTestCaseJ4 {
public class TestEvaluatorBag extends AbstractDataImportHandlerTestCase {
private static final String ENCODING = "UTF-8";
VariableResolverImpl resolver;
@ -91,10 +86,10 @@ public class TestEvaluatorBag extends SolrTestCaseJ4 {
VariableResolverImpl vr = new VariableResolverImpl();
vr.addNamespace("a",m);
List l = EvaluatorBag.parseParams(" 1 , a.b, 'hello!', 'ds,o,u\'za',",vr);
Assert.assertEquals(new Double(1),l.get(0));
Assert.assertEquals("B",((EvaluatorBag.VariableWrapper)l.get(1)).resolve());
Assert.assertEquals("hello!",l.get(2));
Assert.assertEquals("ds,o,u'za",l.get(3));
assertEquals(new Double(1),l.get(0));
assertEquals("B",((EvaluatorBag.VariableWrapper)l.get(1)).resolve());
assertEquals("hello!",l.get(2));
assertEquals("ds,o,u'za",l.get(3));
}
@Test

8
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestFieldReader.java
View File

@ -16,10 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import junit.framework.Assert;
import static org.apache.solr.handler.dataimport.AbstractDataImportHandlerTestCase.createMap;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Test;
import java.util.ArrayList;
@ -33,7 +29,7 @@ import java.util.Map;
* @see org.apache.solr.handler.dataimport.FieldReaderDataSource
* @since 1.4
*/
public class TestFieldReader extends SolrTestCaseJ4 {
public class TestFieldReader extends AbstractDataImportHandlerTestCase {
@Test
public void simple() {
@ -45,7 +41,7 @@ public class TestFieldReader extends SolrTestCaseJ4 {
l.add(createMap("xml", xml));
MockDataSource.setIterator("select * from a", l.iterator());
di.runCmd(rp, sw);
Assert.assertEquals(sw.docs.get(0).getFieldValue("y"), "Hello");
assertEquals(sw.docs.get(0).getFieldValue("y"), "Hello");
MockDataSource.clearCache();
}

61
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestFileListEntityProcessor.java
View File

@ -16,12 +16,9 @@ package org.apache.solr.handler.dataimport;
* limitations under the License.
*/
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Test;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.*;
@ -33,7 +30,7 @@ import java.util.*;
* @version $Id$
* @since solr 1.3
*/
public class TestFileListEntityProcessor extends SolrTestCaseJ4 {
public class TestFileListEntityProcessor extends AbstractDataImportHandlerTestCase {
@Test
@SuppressWarnings("unchecked")
@ -45,10 +42,10 @@ public class TestFileListEntityProcessor extends SolrTestCaseJ4 {
createFile(tmpdir, "a.xml", "a.xml".getBytes(), false);
createFile(tmpdir, "b.xml", "b.xml".getBytes(), false);
createFile(tmpdir, "c.props", "c.props".getBytes(), false);
Map attrs = AbstractDataImportHandlerTestCase.createMap(
Map attrs = createMap(
FileListEntityProcessor.FILE_NAME, "xml$",
FileListEntityProcessor.BASE_DIR, tmpdir.getAbsolutePath());
Context c = AbstractDataImportHandlerTestCase.getContext(null,
Context c = getContext(null,
new VariableResolverImpl(), null, Context.FULL_DUMP, Collections.EMPTY_LIST, attrs);
FileListEntityProcessor fileListEntityProcessor = new FileListEntityProcessor();
fileListEntityProcessor.init(c);
@ -59,7 +56,7 @@ public class TestFileListEntityProcessor extends SolrTestCaseJ4 {
break;
fList.add((String) f.get(FileListEntityProcessor.ABSOLUTE_FILE));
}
Assert.assertEquals(2, fList.size());
assertEquals(2, fList.size());
}
@Test
@ -88,37 +85,37 @@ public class TestFileListEntityProcessor extends SolrTestCaseJ4 {
minLength = content.length;
smallestFile = "c.props";
}
Map attrs = AbstractDataImportHandlerTestCase.createMap(
Map attrs = createMap(
FileListEntityProcessor.FILE_NAME, ".*",
FileListEntityProcessor.BASE_DIR, tmpdir.getAbsolutePath(),
FileListEntityProcessor.BIGGER_THAN, String.valueOf(minLength));
List<String> fList = getFiles(null, attrs);
Assert.assertEquals(2, fList.size());
assertEquals(2, fList.size());
Set<String> l = new HashSet<String>();
l.add(new File(tmpdir, "a.xml").getAbsolutePath());
l.add(new File(tmpdir, "b.xml").getAbsolutePath());
Assert.assertEquals(l, new HashSet<String>(fList));
attrs = AbstractDataImportHandlerTestCase.createMap(
assertEquals(l, new HashSet<String>(fList));
attrs = createMap(
FileListEntityProcessor.FILE_NAME, ".*",
FileListEntityProcessor.BASE_DIR, tmpdir.getAbsolutePath(),
FileListEntityProcessor.SMALLER_THAN, String.valueOf(minLength+1));
fList = getFiles(null, attrs);
l.clear();
l.add(new File(tmpdir, smallestFile).getAbsolutePath());
Assert.assertEquals(l, new HashSet<String>(fList));
attrs = AbstractDataImportHandlerTestCase.createMap(
assertEquals(l, new HashSet<String>(fList));
attrs = createMap(
FileListEntityProcessor.FILE_NAME, ".*",
FileListEntityProcessor.BASE_DIR, tmpdir.getAbsolutePath(),
FileListEntityProcessor.SMALLER_THAN, "${a.x}");
VariableResolverImpl resolver = new VariableResolverImpl();
resolver.addNamespace("a", AbstractDataImportHandlerTestCase.createMap("x", "4"));
resolver.addNamespace("a", createMap("x", "4"));
fList = getFiles(resolver, attrs);
Assert.assertEquals(l, new HashSet<String>(fList));
assertEquals(l, new HashSet<String>(fList));
}
@SuppressWarnings("unchecked")
static List<String> getFiles(VariableResolverImpl resolver, Map attrs) {
Context c = AbstractDataImportHandlerTestCase.getContext(null,
Context c = getContext(null,
resolver, null, Context.FULL_DUMP, Collections.EMPTY_LIST, attrs);
FileListEntityProcessor fileListEntityProcessor = new FileListEntityProcessor();
fileListEntityProcessor.init(c);
@ -141,31 +138,31 @@ public class TestFileListEntityProcessor extends SolrTestCaseJ4 {
createFile(tmpdir, "a.xml", "a.xml".getBytes(), true);
createFile(tmpdir, "b.xml", "b.xml".getBytes(), true);
createFile(tmpdir, "c.props", "c.props".getBytes(), true);
Map attrs = AbstractDataImportHandlerTestCase.createMap(
Map attrs = createMap(
FileListEntityProcessor.FILE_NAME, "xml$",
FileListEntityProcessor.BASE_DIR, tmpdir.getAbsolutePath(),
FileListEntityProcessor.OLDER_THAN, "'NOW'");
List<String> fList = getFiles(null, attrs);
Assert.assertEquals(2, fList.size());
attrs = AbstractDataImportHandlerTestCase.createMap(
assertEquals(2, fList.size());
attrs = createMap(
FileListEntityProcessor.FILE_NAME, ".xml$",
FileListEntityProcessor.BASE_DIR, tmpdir.getAbsolutePath(),
FileListEntityProcessor.NEWER_THAN, "'NOW-2HOURS'");
fList = getFiles(null, attrs);
Assert.assertEquals(2, fList.size());
assertEquals(2, fList.size());
// Use a variable for newerThan
attrs = AbstractDataImportHandlerTestCase.createMap(
attrs = createMap(
FileListEntityProcessor.FILE_NAME, ".xml$",
FileListEntityProcessor.BASE_DIR, tmpdir.getAbsolutePath(),
FileListEntityProcessor.NEWER_THAN, "${a.x}");
VariableResolverImpl resolver = new VariableResolverImpl();
String lastMod = DataImporter.DATE_TIME_FORMAT.get().format(new Date(System.currentTimeMillis() - 50000));
resolver.addNamespace("a", AbstractDataImportHandlerTestCase.createMap("x", lastMod));
resolver.addNamespace("a", createMap("x", lastMod));
createFile(tmpdir, "t.xml", "t.xml".getBytes(), false);
fList = getFiles(resolver, attrs);
Assert.assertEquals(1, fList.size());
Assert.assertEquals("File name must be t.xml", new File(tmpdir, "t.xml").getAbsolutePath(), fList.get(0));
assertEquals(1, fList.size());
assertEquals("File name must be t.xml", new File(tmpdir, "t.xml").getAbsolutePath(), fList.get(0));
}
@Test
@ -180,23 +177,11 @@ public class TestFileListEntityProcessor extends SolrTestCaseJ4 {
createFile(childdir, "a.xml", "a.xml".getBytes(), true);
createFile(childdir, "b.xml", "b.xml".getBytes(), true);
createFile(childdir, "c.props", "c.props".getBytes(), true);
Map attrs = AbstractDataImportHandlerTestCase.createMap(
Map attrs = createMap(
FileListEntityProcessor.FILE_NAME, "^.*\\.xml$",
FileListEntityProcessor.BASE_DIR, childdir.getAbsolutePath(),
FileListEntityProcessor.RECURSIVE, "true");
List<String> fList = getFiles(null, attrs);
Assert.assertEquals(2, fList.size());
}
public static File createFile(File tmpdir, String name, byte[] content,
boolean changeModifiedTime) throws IOException {
File file = new File(tmpdir.getAbsolutePath() + File.separator + name);
file.deleteOnExit();
FileOutputStream f = new FileOutputStream(file);
f.write(content);
f.close();
if (changeModifiedTime)
file.setLastModified(System.currentTimeMillis() - 3600000);
return file;
assertEquals(2, fList.size());
}
}

30
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestJdbcDataSource.java
View File

@ -23,10 +23,12 @@ import java.util.*;
import javax.sql.DataSource;
import org.apache.solr.SolrTestCaseJ4;
import org.easymock.EasyMock;
import org.easymock.IMocksControl;
import org.junit.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
/**
* <p>
@ -40,7 +42,7 @@ import org.junit.*;
* @version $Id$
* @since solr 1.3
*/
public class TestJdbcDataSource extends SolrTestCaseJ4 {
public class TestJdbcDataSource extends AbstractDataImportHandlerTestCase {
Driver driver;
DataSource dataSource;
Connection connection;
@ -78,7 +80,7 @@ public class TestJdbcDataSource extends SolrTestCaseJ4 {
}
@Test
public void retrieveFromJndi() throws Exception {
public void testRetrieveFromJndi() throws Exception {
MockInitialContextFactory.bind("java:comp/env/jdbc/JndiDB", dataSource);
props.put(JdbcDataSource.JNDI_NAME, "java:comp/env/jdbc/JndiDB");
@ -94,11 +96,11 @@ public class TestJdbcDataSource extends SolrTestCaseJ4 {
mockControl.verify();
Assert.assertSame("connection", conn, connection);
assertSame("connection", conn, connection);
}
@Test
public void retrieveFromJndiWithCredentials() throws Exception {
public void testRetrieveFromJndiWithCredentials() throws Exception {
MockInitialContextFactory.bind("java:comp/env/jdbc/JndiDB", dataSource);
props.put(JdbcDataSource.JNDI_NAME, "java:comp/env/jdbc/JndiDB");
@ -118,11 +120,11 @@ public class TestJdbcDataSource extends SolrTestCaseJ4 {
mockControl.verify();
Assert.assertSame("connection", conn, connection);
assertSame("connection", conn, connection);
}
@Test
public void retrieveFromDriverManager() throws Exception {
public void testRetrieveFromDriverManager() throws Exception {
DriverManager.registerDriver(driver);
EasyMock.expect(
@ -141,12 +143,12 @@ public class TestJdbcDataSource extends SolrTestCaseJ4 {
mockControl.verify();
Assert.assertSame("connection", conn, connection);
assertSame("connection", conn, connection);
}
@Test
@Ignore
public void basic() throws Exception {
public void testBasic() throws Exception {
JdbcDataSource dataSource = new JdbcDataSource();
Properties p = new Properties();
p.put("driver", "com.mysql.jdbc.Driver");
@ -164,7 +166,7 @@ public class TestJdbcDataSource extends SolrTestCaseJ4 {
f.put("type", "float");
flds.add(f);
Context c = AbstractDataImportHandlerTestCase.getContext(null, null,
Context c = getContext(null, null,
dataSource, Context.FULL_DUMP, flds, null);
dataSource.init(c, p);
Iterator<Map<String, Object>> i = dataSource
@ -178,8 +180,8 @@ public class TestJdbcDataSource extends SolrTestCaseJ4 {
trim_id = map.get("trim_id");
count++;
}
Assert.assertEquals(5, count);
Assert.assertEquals(Float.class, msrp.getClass());
Assert.assertEquals(Long.class, trim_id.getClass());
assertEquals(5, count);
assertEquals(Float.class, msrp.getClass());
assertEquals(Long.class, trim_id.getClass());
}
}

40
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestLineEntityProcessor.java
View File

@ -16,8 +16,6 @@ package org.apache.solr.handler.dataimport;
* limitations under the License.
*/
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Test;
import java.io.IOException;
@ -32,11 +30,11 @@ import java.util.*;
* @version $Id$
* @since solr 1.4
*/
public class TestLineEntityProcessor extends SolrTestCaseJ4 {
public class TestLineEntityProcessor extends AbstractDataImportHandlerTestCase {
@Test
/************************************************************************/
public void simple() throws IOException {
public void testSimple() throws IOException {
/* we want to create the equiv of :-
* <entity name="list_all_files"
@ -45,13 +43,13 @@ public class TestLineEntityProcessor extends SolrTestCaseJ4 {
* />
*/
Map attrs = AbstractDataImportHandlerTestCase.createMap(
Map attrs = createMap(
LineEntityProcessor.URL, "dummy.lis",
LineEntityProcessor.ACCEPT_LINE_REGEX, null,
LineEntityProcessor.SKIP_LINE_REGEX, null
);
Context c = AbstractDataImportHandlerTestCase.getContext(
Context c = getContext(
null, //parentEntity
new VariableResolverImpl(), //resolver
getDataSource(filecontents), //parentDataSource
@ -63,20 +61,20 @@ public class TestLineEntityProcessor extends SolrTestCaseJ4 {
ep.init(c);
/// call the entity processor to the list of lines
System.out.print("\n");
if (VERBOSE) System.out.print("\n");
List<String> fList = new ArrayList<String>();
while (true) {
Map<String, Object> f = ep.nextRow();
if (f == null) break;
fList.add((String) f.get("rawLine"));
System.out.print(" rawLine='" + f.get("rawLine") + "'\n");
if (VERBOSE) System.out.print(" rawLine='" + f.get("rawLine") + "'\n");
}
Assert.assertEquals(24, fList.size());
assertEquals(24, fList.size());
}
@Test
/************************************************************************/
public void only_xml_files() throws IOException {
public void testOnly_xml_files() throws IOException {
/* we want to create the equiv of :-
* <entity name="list_all_files"
@ -85,13 +83,13 @@ public class TestLineEntityProcessor extends SolrTestCaseJ4 {
* acceptLineRegex="xml"
* />
*/
Map attrs = AbstractDataImportHandlerTestCase.createMap(
Map attrs = createMap(
LineEntityProcessor.URL, "dummy.lis",
LineEntityProcessor.ACCEPT_LINE_REGEX, "xml",
LineEntityProcessor.SKIP_LINE_REGEX, null
);
Context c = AbstractDataImportHandlerTestCase.getContext(
Context c = getContext(
null, //parentEntity
new VariableResolverImpl(), //resolver
getDataSource(filecontents), //parentDataSource
@ -109,12 +107,12 @@ public class TestLineEntityProcessor extends SolrTestCaseJ4 {
if (f == null) break;
fList.add((String) f.get("rawLine"));
}
Assert.assertEquals(5, fList.size());
assertEquals(5, fList.size());
}
@Test
/************************************************************************/
public void only_xml_files_no_xsd() throws IOException {
public void testOnly_xml_files_no_xsd() throws IOException {
/* we want to create the equiv of :-
* <entity name="list_all_files"
* processor="LineEntityProcessor"
@ -123,13 +121,13 @@ public class TestLineEntityProcessor extends SolrTestCaseJ4 {
* omitLineRegex="\\.xsd"
* />
*/
Map attrs = AbstractDataImportHandlerTestCase.createMap(
Map attrs = createMap(
LineEntityProcessor.URL, "dummy.lis",
LineEntityProcessor.ACCEPT_LINE_REGEX, "\\.xml",
LineEntityProcessor.SKIP_LINE_REGEX, "\\.xsd"
);
Context c = AbstractDataImportHandlerTestCase.getContext(
Context c = getContext(
null, //parentEntity
new VariableResolverImpl(), //resolver
getDataSource(filecontents), //parentDataSource
@ -147,12 +145,12 @@ public class TestLineEntityProcessor extends SolrTestCaseJ4 {
if (f == null) break;
fList.add((String) f.get("rawLine"));
}
Assert.assertEquals(4, fList.size());
assertEquals(4, fList.size());
}
@Test
/************************************************************************/
public void no_xsd_files() throws IOException {
public void testNo_xsd_files() throws IOException {
/* we want to create the equiv of :-
* <entity name="list_all_files"
* processor="LineEntityProcessor"
@ -160,12 +158,12 @@ public class TestLineEntityProcessor extends SolrTestCaseJ4 {
* omitLineRegex="\\.xsd"
* />
*/
Map attrs = AbstractDataImportHandlerTestCase.createMap(
Map attrs = createMap(
LineEntityProcessor.URL, "dummy.lis",
LineEntityProcessor.SKIP_LINE_REGEX, "\\.xsd"
);
Context c = AbstractDataImportHandlerTestCase.getContext(
Context c = getContext(
null, //parentEntity
new VariableResolverImpl(), //resolver
getDataSource(filecontents), //parentDataSource
@ -183,7 +181,7 @@ public class TestLineEntityProcessor extends SolrTestCaseJ4 {
if (f == null) break;
fList.add((String) f.get("rawLine"));
}
Assert.assertEquals(18, fList.size());
assertEquals(18, fList.size());
}
/**

77
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestNumberFormatTransformer.java
View File

@ -16,8 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Test;
import java.text.DecimalFormatSymbols;
@ -34,7 +32,7 @@ import java.util.Map;
* @version $Id$
* @since solr 1.3
*/
public class TestNumberFormatTransformer extends SolrTestCaseJ4 {
public class TestNumberFormatTransformer extends AbstractDataImportHandlerTestCase {
private char GROUPING_SEP = new DecimalFormatSymbols().getGroupingSeparator();
private char DECIMAL_SEP = new DecimalFormatSymbols().getDecimalSeparator();
@ -43,55 +41,53 @@ public class TestNumberFormatTransformer extends SolrTestCaseJ4 {
public void testTransformRow_SingleNumber() {
char GERMAN_GROUPING_SEP = new DecimalFormatSymbols(Locale.GERMANY).getGroupingSeparator();
List l = new ArrayList();
l.add(AbstractDataImportHandlerTestCase.createMap("column", "num",
l.add(createMap("column", "num",
NumberFormatTransformer.FORMAT_STYLE, NumberFormatTransformer.NUMBER));
l.add(AbstractDataImportHandlerTestCase.createMap("column", "localizedNum",
l.add(createMap("column", "localizedNum",
NumberFormatTransformer.FORMAT_STYLE, NumberFormatTransformer.NUMBER, NumberFormatTransformer.LOCALE, "de-DE"));
Context c = AbstractDataImportHandlerTestCase.getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = AbstractDataImportHandlerTestCase.createMap("num", "123" + GROUPING_SEP + "567", "localizedNum", "123" + GERMAN_GROUPING_SEP + "567");
Context c = getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = createMap("num", "123" + GROUPING_SEP + "567", "localizedNum", "123" + GERMAN_GROUPING_SEP + "567");
new NumberFormatTransformer().transformRow(m, c);
Assert.assertEquals(new Long(123567), m.get("num"));
Assert.assertEquals(new Long(123567), m.get("localizedNum"));
assertEquals(new Long(123567), m.get("num"));
assertEquals(new Long(123567), m.get("localizedNum"));
}
@Test
@SuppressWarnings("unchecked")
public void testTransformRow_MultipleNumbers() throws Exception {
List fields = new ArrayList();
fields.add(AbstractDataImportHandlerTestCase.createMap(DataImporter.COLUMN,
"inputs"));
fields.add(AbstractDataImportHandlerTestCase.createMap(DataImporter.COLUMN,
fields.add(createMap(DataImporter.COLUMN, "inputs"));
fields.add(createMap(DataImporter.COLUMN,
"outputs", RegexTransformer.SRC_COL_NAME, "inputs",
NumberFormatTransformer.FORMAT_STYLE, NumberFormatTransformer.NUMBER));
List inputs = new ArrayList();
inputs.add("123" + GROUPING_SEP + "567");
inputs.add("245" + GROUPING_SEP + "678");
Map row = AbstractDataImportHandlerTestCase.createMap("inputs", inputs);
Map row = createMap("inputs", inputs);
VariableResolverImpl resolver = new VariableResolverImpl();
resolver.addNamespace("e", row);
Context context = AbstractDataImportHandlerTestCase.getContext(null, resolver, null, Context.FULL_DUMP, fields, null);
Context context = getContext(null, resolver, null, Context.FULL_DUMP, fields, null);
new NumberFormatTransformer().transformRow(row, context);
List output = new ArrayList();
output.add(new Long(123567));
output.add(new Long(245678));
Map outputRow = AbstractDataImportHandlerTestCase.createMap("inputs", inputs,
"outputs", output);
Map outputRow = createMap("inputs", inputs, "outputs", output);
Assert.assertEquals(outputRow, row);
assertEquals(outputRow, row);
}
@Test(expected = DataImportHandlerException.class)
@SuppressWarnings("unchecked")
public void testTransformRow_InvalidInput1_Number() {
List l = new ArrayList();
l.add(AbstractDataImportHandlerTestCase.createMap("column", "num",
l.add(createMap("column", "num",
NumberFormatTransformer.FORMAT_STYLE, NumberFormatTransformer.NUMBER));
Context c = AbstractDataImportHandlerTestCase.getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = AbstractDataImportHandlerTestCase.createMap("num", "123" + GROUPING_SEP + "5a67");
Context c = getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = createMap("num", "123" + GROUPING_SEP + "5a67");
new NumberFormatTransformer().transformRow(m, c);
}
@ -99,10 +95,10 @@ public class TestNumberFormatTransformer extends SolrTestCaseJ4 {
@SuppressWarnings("unchecked")
public void testTransformRow_InvalidInput2_Number() {
List l = new ArrayList();
l.add(AbstractDataImportHandlerTestCase.createMap("column", "num",
l.add(createMap("column", "num",
NumberFormatTransformer.FORMAT_STYLE, NumberFormatTransformer.NUMBER));
Context c = AbstractDataImportHandlerTestCase.getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = AbstractDataImportHandlerTestCase.createMap("num", "123" + GROUPING_SEP + "567b");
Context c = getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = createMap("num", "123" + GROUPING_SEP + "567b");
new NumberFormatTransformer().transformRow(m, c);
}
@ -110,10 +106,10 @@ public class TestNumberFormatTransformer extends SolrTestCaseJ4 {
@SuppressWarnings("unchecked")
public void testTransformRow_InvalidInput2_Currency() {
List l = new ArrayList();
l.add(AbstractDataImportHandlerTestCase.createMap("column", "num",
l.add(createMap("column", "num",
NumberFormatTransformer.FORMAT_STYLE, NumberFormatTransformer.CURRENCY));
Context c = AbstractDataImportHandlerTestCase.getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = AbstractDataImportHandlerTestCase.createMap("num", "123" + GROUPING_SEP + "567b");
Context c = getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = createMap("num", "123" + GROUPING_SEP + "567b");
new NumberFormatTransformer().transformRow(m, c);
}
@ -121,10 +117,10 @@ public class TestNumberFormatTransformer extends SolrTestCaseJ4 {
@SuppressWarnings("unchecked")
public void testTransformRow_InvalidInput1_Percent() {
List l = new ArrayList();
l.add(AbstractDataImportHandlerTestCase.createMap("column", "num",
l.add(createMap("column", "num",
NumberFormatTransformer.FORMAT_STYLE, NumberFormatTransformer.PERCENT));
Context c = AbstractDataImportHandlerTestCase.getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = AbstractDataImportHandlerTestCase.createMap("num", "123" + GROUPING_SEP + "5a67");
Context c = getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = createMap("num", "123" + GROUPING_SEP + "5a67");
new NumberFormatTransformer().transformRow(m, c);
}
@ -132,11 +128,10 @@ public class TestNumberFormatTransformer extends SolrTestCaseJ4 {
@SuppressWarnings("unchecked")
public void testTransformRow_InvalidInput3_Currency() {
List l = new ArrayList();
l.add(AbstractDataImportHandlerTestCase.createMap("column", "num",
l.add(createMap("column", "num",
NumberFormatTransformer.FORMAT_STYLE, NumberFormatTransformer.CURRENCY));
Context c = AbstractDataImportHandlerTestCase.getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = AbstractDataImportHandlerTestCase.createMap(
"num", "123" + DECIMAL_SEP + "456" + DECIMAL_SEP + "789");
Context c = getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = createMap("num", "123" + DECIMAL_SEP + "456" + DECIMAL_SEP + "789");
new NumberFormatTransformer().transformRow(m, c);
}
@ -144,11 +139,10 @@ public class TestNumberFormatTransformer extends SolrTestCaseJ4 {
@SuppressWarnings("unchecked")
public void testTransformRow_InvalidInput3_Number() {
List l = new ArrayList();
l.add(AbstractDataImportHandlerTestCase.createMap("column", "num",
l.add(createMap("column", "num",
NumberFormatTransformer.FORMAT_STYLE, NumberFormatTransformer.NUMBER));
Context c = AbstractDataImportHandlerTestCase.getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = AbstractDataImportHandlerTestCase.createMap(
"num", "123" + DECIMAL_SEP + "456" + DECIMAL_SEP + "789");
Context c = getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = createMap("num", "123" + DECIMAL_SEP + "456" + DECIMAL_SEP + "789");
new NumberFormatTransformer().transformRow(m, c);
}
@ -156,12 +150,11 @@ public class TestNumberFormatTransformer extends SolrTestCaseJ4 {
@SuppressWarnings("unchecked")
public void testTransformRow_MalformedInput_Number() {
List l = new ArrayList();
l.add(AbstractDataImportHandlerTestCase.createMap("column", "num",
l.add(createMap("column", "num",
NumberFormatTransformer.FORMAT_STYLE, NumberFormatTransformer.NUMBER));
Context c = AbstractDataImportHandlerTestCase.getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = AbstractDataImportHandlerTestCase.createMap(
"num", "123" + GROUPING_SEP + GROUPING_SEP + "789");
Context c = getContext(null, null, null, Context.FULL_DUMP, l, null);
Map m = createMap("num", "123" + GROUPING_SEP + GROUPING_SEP + "789");
new NumberFormatTransformer().transformRow(m, c);
Assert.assertEquals(new Long(123789), m.get("num"));
assertEquals(new Long(123789), m.get("num"));
}
}

11
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestPlainTextEntityProcessor.java
View File

@ -16,10 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import junit.framework.Assert;
import static org.apache.solr.handler.dataimport.AbstractDataImportHandlerTestCase.createMap;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Test;
import java.io.StringReader;
@ -32,16 +28,15 @@ import java.util.Properties;
* @see org.apache.solr.handler.dataimport.PlainTextEntityProcessor
* @since solr 1.4
*/
public class TestPlainTextEntityProcessor extends SolrTestCaseJ4 {
public class TestPlainTextEntityProcessor extends AbstractDataImportHandlerTestCase {
@Test
public void simple() {
public void testSimple() {
DataImporter di = new DataImporter();
di.loadAndInit(DATA_CONFIG);
TestDocBuilder.SolrWriterImpl sw = new TestDocBuilder.SolrWriterImpl();
DataImporter.RequestParams rp = new DataImporter.RequestParams(createMap("command", "full-import"));
di.runCmd(rp, sw);
Assert.assertEquals(DS.s, sw.docs.get(0).getFieldValue("x"));
assertEquals(DS.s, sw.docs.get(0).getFieldValue("x"));
}
public static class DS extends DataSource {

70
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestRegexTransformer.java
View File

@ -20,11 +20,7 @@ import static org.apache.solr.handler.dataimport.RegexTransformer.REGEX;
import static org.apache.solr.handler.dataimport.RegexTransformer.GROUP_NAMES;
import static org.apache.solr.handler.dataimport.RegexTransformer.REPLACE_WITH;
import static org.apache.solr.handler.dataimport.DataImporter.COLUMN;
import static org.apache.solr.handler.dataimport.AbstractDataImportHandlerTestCase.createMap;
import static org.apache.solr.handler.dataimport.AbstractDataImportHandlerTestCase.getContext;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Test;
import java.util.ArrayList;
@ -38,26 +34,26 @@ import java.util.Map;
* @version $Id$
* @since solr 1.3
*/
public class TestRegexTransformer extends SolrTestCaseJ4 {
public class TestRegexTransformer extends AbstractDataImportHandlerTestCase {
@Test
public void commaSeparated() {
public void testCommaSeparated() {
List<Map<String, String>> fields = new ArrayList<Map<String, String>>();
// <field column="col1" sourceColName="a" splitBy="," />
fields.add(getField("col1", "string", null, "a", ","));
Context context = AbstractDataImportHandlerTestCase.getContext(null, null, null, Context.FULL_DUMP, fields, null);
Context context = getContext(null, null, null, Context.FULL_DUMP, fields, null);
Map<String, Object> src = new HashMap<String, Object>();
src.put("a", "a,bb,cc,d");
Map<String, Object> result = new RegexTransformer().transformRow(src, context);
Assert.assertEquals(2, result.size());
Assert.assertEquals(4, ((List) result.get("col1")).size());
assertEquals(2, result.size());
assertEquals(4, ((List) result.get("col1")).size());
}
@Test
public void groupNames() {
public void testGroupNames() {
List<Map<String, String>> fields = new ArrayList<Map<String, String>>();
// <field column="col1" regex="(\w*)(\w*) (\w*)" groupNames=",firstName,lastName"/>
Map<String ,String > m = new HashMap<String, String>();
@ -65,13 +61,13 @@ public class TestRegexTransformer extends SolrTestCaseJ4 {
m.put(GROUP_NAMES,",firstName,lastName");
m.put(REGEX,"(\\w*) (\\w*) (\\w*)");
fields.add(m);
Context context = AbstractDataImportHandlerTestCase.getContext(null, null, null, Context.FULL_DUMP, fields, null);
Context context = getContext(null, null, null, Context.FULL_DUMP, fields, null);
Map<String, Object> src = new HashMap<String, Object>();
src.put("fullName", "Mr Noble Paul");
Map<String, Object> result = new RegexTransformer().transformRow(src, context);
Assert.assertEquals("Noble", result.get("firstName"));
Assert.assertEquals("Paul", result.get("lastName"));
assertEquals("Noble", result.get("firstName"));
assertEquals("Paul", result.get("lastName"));
src= new HashMap<String, Object>();
List<String> l= new ArrayList();
l.add("Mr Noble Paul") ;
@ -80,21 +76,20 @@ public class TestRegexTransformer extends SolrTestCaseJ4 {
result = new RegexTransformer().transformRow(src, context);
List l1 = (List) result.get("firstName");
List l2 = (List) result.get("lastName");
Assert.assertEquals("Noble", l1.get(0));
Assert.assertEquals("Shalin", l1.get(1));
Assert.assertEquals("Paul", l2.get(0));
Assert.assertEquals("Mangar", l2.get(1));
assertEquals("Noble", l1.get(0));
assertEquals("Shalin", l1.get(1));
assertEquals("Paul", l2.get(0));
assertEquals("Mangar", l2.get(1));
}
@Test
public void replaceWith() {
public void testReplaceWith() {
List<Map<String, String>> fields = new ArrayList<Map<String, String>>();
// <field column="name" regexp="'" replaceWith="''" />
Map<String, String> fld = getField("name", "string", "'", null, null);
fld.put(REPLACE_WITH, "''");
fields.add(fld);
Context context = AbstractDataImportHandlerTestCase.getContext(null, null,
null, Context.FULL_DUMP, fields, null);
Context context = getContext(null, null, null, Context.FULL_DUMP, fields, null);
Map<String, Object> src = new HashMap<String, Object>();
String s = "D'souza";
@ -102,11 +97,11 @@ public class TestRegexTransformer extends SolrTestCaseJ4 {
Map<String, Object> result = new RegexTransformer().transformRow(src,
context);
Assert.assertEquals("D''souza", result.get("name"));
assertEquals("D''souza", result.get("name"));
}
@Test
public void mileage() {
public void testMileage() {
// init a whole pile of fields
List<Map<String, String>> fields = getFields();
@ -141,16 +136,16 @@ public class TestRegexTransformer extends SolrTestCaseJ4 {
VariableResolverImpl resolver = new VariableResolverImpl();
resolver.addNamespace("e", row);
Map<String, String> eAttrs = AbstractDataImportHandlerTestCase.createMap("name", "e");
Context context = AbstractDataImportHandlerTestCase.getContext(null, resolver, null, Context.FULL_DUMP, fields, eAttrs);
Map<String, String> eAttrs = createMap("name", "e");
Context context = getContext(null, resolver, null, Context.FULL_DUMP, fields, eAttrs);
Map<String, Object> result = new RegexTransformer().transformRow(row, context);
Assert.assertEquals(5, result.size());
Assert.assertEquals(s, result.get("rowdata"));
Assert.assertEquals("26", result.get("highway_mileage"));
Assert.assertEquals("19", result.get("city_mileage"));
Assert.assertEquals("*** 19 *** mpg City", result.get("hltCityMPG"));
Assert.assertEquals("Fuel Economy range: 26 mpg Hwy, 19 mpg City", result.get("t3"));
assertEquals(5, result.size());
assertEquals(s, result.get("rowdata"));
assertEquals("26", result.get("highway_mileage"));
assertEquals("19", result.get("city_mileage"));
assertEquals("*** 19 *** mpg City", result.get("hltCityMPG"));
assertEquals("Fuel Economy range: 26 mpg Hwy, 19 mpg City", result.get("t3"));
}
@Test
@ -166,9 +161,7 @@ public class TestRegexTransformer extends SolrTestCaseJ4 {
strings.add("hello");
strings.add("world");
Map<String, Object> result = new RegexTransformer().transformRow(createMap("person", strings), context);
Assert.assertEquals(strings,result.get("participant"));
assertEquals(strings,result.get("participant"));
}
public static List<Map<String, String>> getFields() {
@ -197,15 +190,4 @@ public class TestRegexTransformer extends SolrTestCaseJ4 {
fields.add(getField("rowdata", "string", null, "rowdata", null));
return fields;
}
public static Map<String, String> getField(String col, String type,
String re, String srcCol, String splitBy) {
HashMap<String, String> vals = new HashMap<String, String>();
vals.put("column", col);
vals.put("type", type);
vals.put("regex", re);
vals.put("sourceColName", srcCol);
vals.put("splitBy", splitBy);
return vals;
}
}

27
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestScriptTransformer.java
View File

@ -16,8 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import org.w3c.dom.Document;
@ -43,11 +41,11 @@ import java.util.Map;
* @version $Id$
* @since solr 1.3
*/
public class TestScriptTransformer extends SolrTestCaseJ4 {
public class TestScriptTransformer extends AbstractDataImportHandlerTestCase {
@Test
@Ignore
public void basic() {
public void testBasic() {
String script = "function f1(row,context){"
+ "row.put('name','Hello ' + row.get('name'));" + "return row;\n" + "}";
Context context = getContext("f1", script);
@ -56,8 +54,7 @@ public class TestScriptTransformer extends SolrTestCaseJ4 {
EntityProcessorWrapper sep = new EntityProcessorWrapper(new SqlEntityProcessor(), null);
sep.init(context);
sep.applyTransformer(map);
Assert.assertEquals(map.get("name"), "Hello Scott");
assertEquals(map.get("name"), "Hello Scott");
}
private Context getContext(String funcName, String script) {
@ -66,7 +63,7 @@ public class TestScriptTransformer extends SolrTestCaseJ4 {
entity.put("name", "hello");
entity.put("transformer", "script:" + funcName);
AbstractDataImportHandlerTestCase.TestContext context = AbstractDataImportHandlerTestCase.getContext(null, null, null,
TestContext context = getContext(null, null, null,
Context.FULL_DUMP, fields, entity);
context.script = script;
context.scriptlang = "JavaScript";
@ -75,7 +72,7 @@ public class TestScriptTransformer extends SolrTestCaseJ4 {
@Test
@Ignore
public void oneparam() {
public void testOneparam() {
String script = "function f1(row){"
+ "row.put('name','Hello ' + row.get('name'));" + "return row;\n" + "}";
@ -86,25 +83,24 @@ public class TestScriptTransformer extends SolrTestCaseJ4 {
EntityProcessorWrapper sep = new EntityProcessorWrapper(new SqlEntityProcessor(), null);
sep.init(context);
sep.applyTransformer(map);
Assert.assertEquals(map.get("name"), "Hello Scott");
assertEquals(map.get("name"), "Hello Scott");
}
@Test
@Ignore
public void readScriptTag() throws Exception {
public void testReadScriptTag() throws Exception {
DocumentBuilder builder = DocumentBuilderFactory.newInstance()
.newDocumentBuilder();
Document document = builder.parse(new InputSource(new StringReader(xml)));
DataConfig config = new DataConfig();
config.readFromXml((Element) document.getElementsByTagName("dataConfig")
.item(0));
Assert.assertTrue(config.script.text.indexOf("checkNextToken") > -1);
assertTrue(config.script.text.indexOf("checkNextToken") > -1);
}
@Test
@Ignore
public void checkScript() throws Exception {
public void testCheckScript() throws Exception {
DocumentBuilder builder = DocumentBuilderFactory.newInstance()
.newDocumentBuilder();
Document document = builder.parse(new InputSource(new StringReader(xml)));
@ -119,12 +115,11 @@ public class TestScriptTransformer extends SolrTestCaseJ4 {
EntityProcessorWrapper sep = new EntityProcessorWrapper(new SqlEntityProcessor(), null);
sep.init(c);
sep.applyTransformer(map);
Assert.assertEquals("true", map.get("$hasMore"));
assertEquals("true", map.get("$hasMore"));
map = new HashMap();
map.put("nextToken", "");
sep.applyTransformer(map);
Assert.assertNull(map.get("$hasMore"));
assertNull(map.get("$hasMore"));
}
static String xml = "<dataConfig>\n"

38
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestSqlEntityProcessor.java
View File

@ -16,8 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Test;
import java.util.*;
@ -30,18 +28,17 @@ import java.util.*;
* @version $Id$
* @since solr 1.3
*/
public class TestSqlEntityProcessor extends SolrTestCaseJ4 {
public class TestSqlEntityProcessor extends AbstractDataImportHandlerTestCase {
private static ThreadLocal<Integer> local = new ThreadLocal<Integer>();
@Test
public void singleBatch() {
public void testSingleBatch() {
SqlEntityProcessor sep = new SqlEntityProcessor();
List<Map<String, Object>> rows = getRows(3);
VariableResolverImpl vr = new VariableResolverImpl();
HashMap<String, String> ea = new HashMap<String, String>();
ea.put("query", "SELECT * FROM A");
Context c = AbstractDataImportHandlerTestCase.getContext(null, vr, getDs(rows),
Context.FULL_DUMP, null, ea);
Context c = getContext(null, vr, getDs(rows), Context.FULL_DUMP, null, ea);
sep.init(c);
int count = 0;
while (true) {
@ -51,11 +48,11 @@ public class TestSqlEntityProcessor extends SolrTestCaseJ4 {
count++;
}
Assert.assertEquals(3, count);
assertEquals(3, count);
}
@Test
public void tranformer() {
public void testTranformer() {
EntityProcessor sep = new EntityProcessorWrapper( new SqlEntityProcessor(), null);
List<Map<String, Object>> rows = getRows(2);
VariableResolverImpl vr = new VariableResolverImpl();
@ -63,8 +60,7 @@ public class TestSqlEntityProcessor extends SolrTestCaseJ4 {
ea.put("query", "SELECT * FROM A");
ea.put("transformer", T.class.getName());
sep.init(AbstractDataImportHandlerTestCase.getContext(null, vr, getDs(rows),
Context.FULL_DUMP, null, ea));
sep.init(getContext(null, vr, getDs(rows), Context.FULL_DUMP, null, ea));
List<Map<String, Object>> rs = new ArrayList<Map<String, Object>>();
Map<String, Object> r = null;
while (true) {
@ -74,12 +70,12 @@ public class TestSqlEntityProcessor extends SolrTestCaseJ4 {
rs.add(r);
}
Assert.assertEquals(2, rs.size());
Assert.assertNotNull(rs.get(0).get("T"));
assertEquals(2, rs.size());
assertNotNull(rs.get(0).get("T"));
}
@Test
public void tranformerWithReflection() {
public void testTranformerWithReflection() {
EntityProcessor sep = new EntityProcessorWrapper(new SqlEntityProcessor(), null);
List<Map<String, Object>> rows = getRows(2);
VariableResolverImpl vr = new VariableResolverImpl();
@ -87,8 +83,7 @@ public class TestSqlEntityProcessor extends SolrTestCaseJ4 {
ea.put("query", "SELECT * FROM A");
ea.put("transformer", T3.class.getName());
sep.init(AbstractDataImportHandlerTestCase.getContext(null, vr, getDs(rows),
Context.FULL_DUMP, null, ea));
sep.init(getContext(null, vr, getDs(rows), Context.FULL_DUMP, null, ea));
List<Map<String, Object>> rs = new ArrayList<Map<String, Object>>();
Map<String, Object> r = null;
while (true) {
@ -98,12 +93,12 @@ public class TestSqlEntityProcessor extends SolrTestCaseJ4 {
rs.add(r);
}
Assert.assertEquals(2, rs.size());
Assert.assertNotNull(rs.get(0).get("T3"));
assertEquals(2, rs.size());
assertNotNull(rs.get(0).get("T3"));
}
@Test
public void tranformerList() {
public void testTranformerList() {
EntityProcessor sep = new EntityProcessorWrapper(new SqlEntityProcessor(),null);
List<Map<String, Object>> rows = getRows(2);
VariableResolverImpl vr = new VariableResolverImpl();
@ -111,8 +106,7 @@ public class TestSqlEntityProcessor extends SolrTestCaseJ4 {
HashMap<String, String> ea = new HashMap<String, String>();
ea.put("query", "SELECT * FROM A");
ea.put("transformer", T2.class.getName());
sep.init(AbstractDataImportHandlerTestCase.getContext(null, vr, getDs(rows),
Context.FULL_DUMP, null, ea));
sep.init(getContext(null, vr, getDs(rows), Context.FULL_DUMP, null, ea));
local.set(0);
Map<String, Object> r = null;
@ -123,8 +117,8 @@ public class TestSqlEntityProcessor extends SolrTestCaseJ4 {
break;
count++;
}
Assert.assertEquals(2, (int) local.get());
Assert.assertEquals(4, count);
assertEquals(2, (int) local.get());
assertEquals(4, count);
}
private List<Map<String, Object>> getRows(int count) {

43
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestSqlEntityProcessor2.java
View File

@ -16,6 +16,8 @@
*/
package org.apache.solr.handler.dataimport;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import java.util.ArrayList;
@ -33,26 +35,18 @@ import java.text.ParseException;
* @since solr 1.3
*/
public class TestSqlEntityProcessor2 extends AbstractDataImportHandlerTestCase {
@Override
public String getSchemaFile() {
return "dataimport-schema.xml";
@BeforeClass
public static void beforeClass() throws Exception {
initCore("dataimport-solrconfig.xml", "dataimport-schema.xml");
}
@Override
public String getSolrConfigFile() {
return "dataimport-solrconfig.xml";
}
@Override
@Before @Override
public void setUp() throws Exception {
super.setUp();
clearIndex();
assertU(commit());
}
@Override
public void tearDown() throws Exception {
super.tearDown();
}
@Test
@SuppressWarnings("unchecked")
public void testCompositePk_FullImport() throws Exception {
@ -66,11 +60,12 @@ public class TestSqlEntityProcessor2 extends AbstractDataImportHandlerTestCase {
MockDataSource.setIterator("select * from y where y.A=1", childRow
.iterator());
super.runFullImport(dataConfig);
runFullImport(dataConfig);
assertQ(req("id:1"), "//*[@numFound='1']");
assertQ(req("desc:hello"), "//*[@numFound='1']");
}
@Test
@SuppressWarnings("unchecked")
public void testCompositePk_FullImport_MT() throws Exception {
@ -85,7 +80,7 @@ public class TestSqlEntityProcessor2 extends AbstractDataImportHandlerTestCase {
MockDataSource.setIterator("select * from y where y.A=1", childRow.iterator());
MockDataSource.setIterator("select * from y where y.A=2", childRow.iterator());
super.runFullImport(dataConfig_2threads);
runFullImport(dataConfig_2threads);
assertQ(req("id:1"), "//*[@numFound='1']");
assertQ(req("id:2"), "//*[@numFound='1']");
@ -106,7 +101,7 @@ public class TestSqlEntityProcessor2 extends AbstractDataImportHandlerTestCase {
.iterator());
super.runFullImport(dataConfig,createMap("commit","false"));
runFullImport(dataConfig,createMap("commit","false"));
assertQ(req("id:10"), "//*[@numFound='0']");
}
@ -128,7 +123,7 @@ public class TestSqlEntityProcessor2 extends AbstractDataImportHandlerTestCase {
MockDataSource.setIterator("select * from y where y.A=5", childRow
.iterator());
super.runDeltaImport(dataConfig);
runDeltaImport(dataConfig);
assertQ(req("id:5"), "//*[@numFound='1']");
assertQ(req("desc:hello"), "//*[@numFound='1']");
@ -147,7 +142,7 @@ public class TestSqlEntityProcessor2 extends AbstractDataImportHandlerTestCase {
MockDataSource.setIterator("select * from y where y.A=11", childRow
.iterator());
super.runFullImport(dataConfig);
runFullImport(dataConfig);
assertQ(req("id:11"), "//*[@numFound='1']");
@ -175,13 +170,11 @@ public class TestSqlEntityProcessor2 extends AbstractDataImportHandlerTestCase {
MockDataSource.setIterator("select * from x where id = '17'", parentRow
.iterator());
super.runDeltaImport(dataConfig);
runDeltaImport(dataConfig);
assertQ(req("id:15"), "//*[@numFound='1']");
assertQ(req("id:11"), "//*[@numFound='0']");
assertQ(req("id:17"), "//*[@numFound='0']");
}
@Test
@ -202,7 +195,7 @@ public class TestSqlEntityProcessor2 extends AbstractDataImportHandlerTestCase {
MockDataSource.setIterator("select * from y where y.A=5", childRow
.iterator());
super.runDeltaImport(dataConfig_deltaimportquery);
runDeltaImport(dataConfig_deltaimportquery);
assertQ(req("id:5"), "//*[@numFound='1']");
assertQ(req("desc:hello"), "//*[@numFound='1']");
@ -214,7 +207,7 @@ public class TestSqlEntityProcessor2 extends AbstractDataImportHandlerTestCase {
List row = new ArrayList();
row.add(createMap("id", 5));
MockDataSource.setIterator("select * from x where last_modified > OK", row.iterator());
super.runFullImport(dataConfig_LastIndexTime);
runFullImport(dataConfig_LastIndexTime);
assertQ(req("id:5"), "//*[@numFound='1']");
}

42
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestSqlEntityProcessorDelta.java
View File

@ -16,10 +16,11 @@
*/
package org.apache.solr.handler.dataimport;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
@ -39,27 +40,18 @@ public class TestSqlEntityProcessorDelta extends AbstractDataImportHandlerTestCa
private static final String DELETED_PK_QUERY = "select id from x where last_modified > NOW AND deleted='true'";
@Override
public String getSchemaFile() {
return "dataimport-schema.xml";
@BeforeClass
public static void beforeClass() throws Exception {
initCore("dataimport-solrconfig.xml", "dataimport-schema.xml");
}
@Override
public String getSolrConfigFile() {
return "dataimport-solrconfig.xml";
}
@Override
@Before @Override
public void setUp() throws Exception {
super.setUp();
clearIndex();
assertU(commit());
}
@Override
public void tearDown() throws Exception {
super.tearDown();
}
@SuppressWarnings("unchecked")
private void add1document() throws Exception {
List parentRow = new ArrayList();
@ -71,7 +63,7 @@ public class TestSqlEntityProcessorDelta extends AbstractDataImportHandlerTestCa
MockDataSource.setIterator("select * from y where y.A='1'", childRow
.iterator());
super.runFullImport(dataConfig_delta);
runFullImport(dataConfig_delta);
assertQ(req("*:* OR add1document"), "//*[@numFound='1']");
assertQ(req("id:1"), "//*[@numFound='1']");
@ -102,7 +94,7 @@ public class TestSqlEntityProcessorDelta extends AbstractDataImportHandlerTestCa
MockDataSource.setIterator("select * from y where y.A='1'", childRow
.iterator());
super.runDeltaImport(dataConfig_delta);
runDeltaImport(dataConfig_delta);
assertQ(req("*:* OR testCompositePk_DeltaImport_delete"), "//*[@numFound='0']");
}
@ -126,7 +118,7 @@ public class TestSqlEntityProcessorDelta extends AbstractDataImportHandlerTestCa
MockDataSource.setIterator("select * from y where y.A='1'", childRow
.iterator());
super.runDeltaImport(dataConfig_delta);
runDeltaImport(dataConfig_delta);
assertQ(req("*:* OR testCompositePk_DeltaImport_empty"), "//*[@numFound='1']");
assertQ(req("id:1"), "//*[@numFound='1']");
@ -137,7 +129,7 @@ public class TestSqlEntityProcessorDelta extends AbstractDataImportHandlerTestCa
@Test
@SuppressWarnings("unchecked")
public void XtestCompositePk_DeltaImport_replace_delete() throws Exception {
public void testCompositePk_DeltaImport_replace_delete() throws Exception {
add1document();
MockDataSource.clearCache();
@ -161,7 +153,7 @@ public class TestSqlEntityProcessorDelta extends AbstractDataImportHandlerTestCa
MockDataSource.setIterator("select * from y where y.A='1'", childRow
.iterator());
super.runDeltaImport(dataConfig_delta);
runDeltaImport(dataConfig_delta);
assertQ(req("*:* OR testCompositePk_DeltaImport_replace_delete"), "//*[@numFound='0']");
}
@ -191,7 +183,7 @@ public class TestSqlEntityProcessorDelta extends AbstractDataImportHandlerTestCa
MockDataSource.setIterator("select * from y where y.A='1'", childRow
.iterator());
super.runDeltaImport(dataConfig_delta);
runDeltaImport(dataConfig_delta);
assertQ(req("*:* OR XtestCompositePk_DeltaImport_replace_nodelete"), "//*[@numFound='1']");
assertQ(req("id:1"), "//*[@numFound='1']");
@ -220,7 +212,7 @@ public class TestSqlEntityProcessorDelta extends AbstractDataImportHandlerTestCa
MockDataSource.setIterator("select * from y where y.A='2'", childRow
.iterator());
super.runDeltaImport(dataConfig_delta);
runDeltaImport(dataConfig_delta);
assertQ(req("*:* OR testCompositePk_DeltaImport_add"), "//*[@numFound='2']");
assertQ(req("id:1"), "//*[@numFound='1']");
@ -238,7 +230,7 @@ public class TestSqlEntityProcessorDelta extends AbstractDataImportHandlerTestCa
MockDataSource.setIterator(DELTA_QUERY,
Collections.EMPTY_LIST.iterator());
super.runDeltaImport(dataConfig_delta);
runDeltaImport(dataConfig_delta);
assertQ(req("*:* OR testCompositePk_DeltaImport_nodelta"), "//*[@numFound='1']");
assertQ(req("id:1 OR testCompositePk_DeltaImport_nodelta"), "//*[@numFound='1']");
@ -271,7 +263,7 @@ public class TestSqlEntityProcessorDelta extends AbstractDataImportHandlerTestCa
MockDataSource.setIterator("select * from y where y.A='2'", childRow
.iterator());
super.runDeltaImport(dataConfig_delta);
runDeltaImport(dataConfig_delta);
assertQ(req("*:* OR XtestCompositePk_DeltaImport_add_delete"), "//*[@numFound='1']");
assertQ(req("id:2"), "//*[@numFound='1']");

44
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestSqlEntityProcessorDelta2.java
View File

@ -16,10 +16,11 @@
*/
package org.apache.solr.handler.dataimport;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
@ -39,27 +40,18 @@ public class TestSqlEntityProcessorDelta2 extends AbstractDataImportHandlerTestC
private static final String DELETED_PK_QUERY = "select id from x where last_modified > NOW AND deleted='true'";
@Override
public String getSchemaFile() {
return "dataimport-solr_id-schema.xml";
@BeforeClass
public static void beforeClass() throws Exception {
initCore("dataimport-solrconfig.xml", "dataimport-solr_id-schema.xml");
}
@Override
public String getSolrConfigFile() {
return "dataimport-solrconfig.xml";
}
@Override
@Before @Override
public void setUp() throws Exception {
super.setUp();
clearIndex();
assertU(commit());
}
@Override
public void tearDown() throws Exception {
super.tearDown();
}
@SuppressWarnings("unchecked")
private void add1document() throws Exception {
List parentRow = new ArrayList();
@ -71,7 +63,7 @@ public class TestSqlEntityProcessorDelta2 extends AbstractDataImportHandlerTestC
MockDataSource.setIterator("select * from y where y.A='1'", childRow
.iterator());
super.runFullImport(dataConfig_delta2);
runFullImport(dataConfig_delta2);
assertQ(req("*:* OR add1document"), "//*[@numFound='1']");
assertQ(req("solr_id:prefix-1"), "//*[@numFound='1']");
@ -100,7 +92,7 @@ public class TestSqlEntityProcessorDelta2 extends AbstractDataImportHandlerTestC
MockDataSource.setIterator("select * from y where y.A='1'", childRow
.iterator());
super.runDeltaImport(dataConfig_delta2);
runDeltaImport(dataConfig_delta2);
assertQ(req("*:* OR testCompositePk_DeltaImport_delete"), "//*[@numFound='0']");
}
@ -124,7 +116,7 @@ public class TestSqlEntityProcessorDelta2 extends AbstractDataImportHandlerTestC
MockDataSource.setIterator("select * from y where y.A='1'", childRow
.iterator());
super.runDeltaImport(dataConfig_delta2);
runDeltaImport(dataConfig_delta2);
assertQ(req("*:* OR testCompositePk_DeltaImport_empty"), "//*[@numFound='1']");
assertQ(req("solr_id:prefix-1"), "//*[@numFound='1']");
@ -133,7 +125,7 @@ public class TestSqlEntityProcessorDelta2 extends AbstractDataImportHandlerTestC
@Test
@SuppressWarnings("unchecked")
public void XtestCompositePk_DeltaImport_replace_delete() throws Exception {
public void testCompositePk_DeltaImport_replace_delete() throws Exception {
add1document();
MockDataSource.clearCache();
@ -157,7 +149,7 @@ public class TestSqlEntityProcessorDelta2 extends AbstractDataImportHandlerTestC
MockDataSource.setIterator("select * from y where y.A='1'", childRow
.iterator());
super.runDeltaImport(dataConfig_delta2);
runDeltaImport(dataConfig_delta2);
assertQ(req("*:* OR testCompositePk_DeltaImport_replace_delete"), "//*[@numFound='0']");
}
@ -187,7 +179,7 @@ public class TestSqlEntityProcessorDelta2 extends AbstractDataImportHandlerTestC
MockDataSource.setIterator("select * from y where y.A='1'", childRow
.iterator());
super.runDeltaImport(dataConfig_delta2);
runDeltaImport(dataConfig_delta2);
assertQ(req("*:* OR XtestCompositePk_DeltaImport_replace_nodelete"), "//*[@numFound='1']");
assertQ(req("solr_id:prefix-1"), "//*[@numFound='1']");
@ -216,7 +208,7 @@ public class TestSqlEntityProcessorDelta2 extends AbstractDataImportHandlerTestC
MockDataSource.setIterator("select * from y where y.A='2'", childRow
.iterator());
super.runDeltaImport(dataConfig_delta2);
runDeltaImport(dataConfig_delta2);
assertQ(req("*:* OR testCompositePk_DeltaImport_add"), "//*[@numFound='2']");
assertQ(req("solr_id:prefix-1"), "//*[@numFound='1']");
@ -234,7 +226,7 @@ public class TestSqlEntityProcessorDelta2 extends AbstractDataImportHandlerTestC
MockDataSource.setIterator(DELTA_QUERY,
Collections.EMPTY_LIST.iterator());
super.runDeltaImport(dataConfig_delta2);
runDeltaImport(dataConfig_delta2);
assertQ(req("*:* OR testCompositePk_DeltaImport_nodelta"), "//*[@numFound='1']");
assertQ(req("solr_id:prefix-1 OR testCompositePk_DeltaImport_nodelta"), "//*[@numFound='1']");
@ -267,7 +259,7 @@ public class TestSqlEntityProcessorDelta2 extends AbstractDataImportHandlerTestC
MockDataSource.setIterator("select * from y where y.A='2'", childRow
.iterator());
super.runDeltaImport(dataConfig_delta2);
runDeltaImport(dataConfig_delta2);
assertQ(req("*:* OR XtestCompositePk_DeltaImport_add_delete"), "//*[@numFound='1']");
assertQ(req("solr_id:prefix-2"), "//*[@numFound='1']");

15
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestTemplateString.java
View File

@ -16,8 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Test;
import java.util.HashMap;
@ -33,20 +31,17 @@ import java.util.regex.Pattern;
* @version $Id$
* @since solr 1.3
*/
public class TestTemplateString extends SolrTestCaseJ4 {
public class TestTemplateString extends AbstractDataImportHandlerTestCase {
@Test
public void testSimple() {
VariableResolverImpl vri = new VariableResolverImpl();
Map<String, Object> ns = new HashMap<String, Object>();
ns.put("last_index_time", Long.valueOf(1199429363730l));
vri.addNamespace("indexer", ns);
Assert
.assertEquals(
"select id from subject where last_modified > 1199429363730",
new TemplateString()
.replaceTokens(
"select id from subject where last_modified > ${indexer.last_index_time}",
vri));
assertEquals("select id from subject where last_modified > 1199429363730",
new TemplateString().replaceTokens(
"select id from subject where last_modified > ${indexer.last_index_time}",
vri));
}
private static Properties EMPTY_PROPS = new Properties();

29
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestTemplateTransformer.java
View File

@ -16,8 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Test;
import java.util.ArrayList;
@ -33,28 +31,28 @@ import java.util.Arrays;
* @version $Id$
* @since solr 1.3
*/
public class TestTemplateTransformer extends SolrTestCaseJ4 {
public class TestTemplateTransformer extends AbstractDataImportHandlerTestCase {
@Test
@SuppressWarnings("unchecked")
public void testTransformRow() {
List fields = new ArrayList();
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "firstName"));
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "lastName"));
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "middleName"));
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "name",
fields.add(createMap("column", "firstName"));
fields.add(createMap("column", "lastName"));
fields.add(createMap("column", "middleName"));
fields.add(createMap("column", "name",
TemplateTransformer.TEMPLATE,
"${e.lastName}, ${e.firstName} ${e.middleName}"));
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "emails",
fields.add(createMap("column", "emails",
TemplateTransformer.TEMPLATE,
"${e.mail}"));
// test reuse of template output in another template
fields.add(AbstractDataImportHandlerTestCase.createMap("column", "mrname",
fields.add(createMap("column", "mrname",
TemplateTransformer.TEMPLATE,"Mr ${e.name}"));
List<String> mails = Arrays.asList(new String[]{"a@b.com", "c@d.com"});
Map row = AbstractDataImportHandlerTestCase.createMap(
Map row = createMap(
"firstName", "Shalin",
"middleName", "Shekhar",
"lastName", "Mangar",
@ -62,15 +60,14 @@ public class TestTemplateTransformer extends SolrTestCaseJ4 {
VariableResolverImpl resolver = new VariableResolverImpl();
resolver.addNamespace("e", row);
Map<String, String> entityAttrs = AbstractDataImportHandlerTestCase.createMap(
"name", "e");
Map<String, String> entityAttrs = createMap("name", "e");
Context context = AbstractDataImportHandlerTestCase.getContext(null, resolver,
Context context = getContext(null, resolver,
null, Context.FULL_DUMP, fields, entityAttrs);
new TemplateTransformer().transformRow(row, context);
Assert.assertEquals("Mangar, Shalin Shekhar", row.get("name"));
Assert.assertEquals("Mr Mangar, Shalin Shekhar", row.get("mrname"));
Assert.assertEquals(mails,row.get("emails"));
assertEquals("Mangar, Shalin Shekhar", row.get("name"));
assertEquals("Mr Mangar, Shalin Shekhar", row.get("mrname"));
assertEquals(mails,row.get("emails"));
}
}

19
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestThreaded.java
View File

@ -16,6 +16,7 @@
*/
package org.apache.solr.handler.dataimport;
import org.junit.BeforeClass;
import org.junit.Test;
import java.util.List;
@ -24,6 +25,11 @@ import java.util.Map;
public class TestThreaded extends AbstractDataImportHandlerTestCase {
@BeforeClass
public static void beforeClass() throws Exception {
initCore("dataimport-solrconfig.xml", "dataimport-schema.xml");
}
@Test
@SuppressWarnings("unchecked")
public void testCompositePk_FullImport() throws Exception {
@ -44,23 +50,14 @@ public class TestThreaded extends AbstractDataImportHandlerTestCase {
MockDataSource.setIterator("select * from y where y.A=3", childRow.iterator());
MockDataSource.setIterator("select * from y where y.A=4", childRow.iterator());
super.runFullImport(dataConfig);
runFullImport(dataConfig);
assertQ(req("id:1"), "//*[@numFound='1']");
assertQ(req("*:*"), "//*[@numFound='4']");
assertQ(req("desc:hello"), "//*[@numFound='4']");
}
@Override
public String getSchemaFile() {
return "dataimport-schema.xml";
}
@Override
public String getSolrConfigFile() {
return "dataimport-solrconfig.xml";
}
private static String dataConfig = "<dataConfig>\n"
private static String dataConfig = "<dataConfig>\n"
+"<dataSource type=\"MockDataSource\"/>\n"
+ " <document>\n"
+ " <entity name=\"x\" threads=\"2\" query=\"select * from x\" deletedPkQuery=\"select id from x where last_modified > NOW AND deleted='true'\" deltaQuery=\"select id from x where last_modified > NOW\">\n"

7
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestURLDataSource.java
View File

@ -22,12 +22,9 @@ import java.util.List;
import java.util.Map;
import java.util.Properties;
import junit.framework.Assert;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Test;
public class TestURLDataSource extends SolrTestCaseJ4 {
public class TestURLDataSource extends AbstractDataImportHandlerTestCase {
private List<Map<String, String>> fields = new ArrayList<Map<String, String>>();
private URLDataSource dataSource = new URLDataSource();
private VariableResolverImpl variableResolver = new VariableResolverImpl();
@ -43,6 +40,6 @@ public class TestURLDataSource extends SolrTestCaseJ4 {
initProps.setProperty(URLDataSource.BASE_URL, "${dataimporter.request.baseurl}");
dataSource.init(context, initProps);
Assert.assertEquals(url, dataSource.getBaseUrl());
assertEquals(url, dataSource.getBaseUrl());
}
}

27
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestVariableResolver.java
View File

@ -16,9 +16,7 @@
*/
package org.apache.solr.handler.dataimport;
import org.junit.Assert;
import org.junit.Test;
import org.apache.solr.SolrTestCaseJ4;
import org.apache.solr.util.DateMathParser;
import java.text.SimpleDateFormat;
@ -32,7 +30,7 @@ import java.util.*;
* @version $Id$
* @since solr 1.3
*/
public class TestVariableResolver extends SolrTestCaseJ4 {
public class TestVariableResolver extends AbstractDataImportHandlerTestCase {
@Test
public void testSimpleNamespace() {
@ -40,7 +38,7 @@ public class TestVariableResolver extends SolrTestCaseJ4 {
Map<String, Object> ns = new HashMap<String, Object>();
ns.put("world", "WORLD");
vri.addNamespace("hello", ns);
Assert.assertEquals("WORLD", vri.resolve("hello.world"));
assertEquals("WORLD", vri.resolve("hello.world"));
}
@Test
@ -54,9 +52,8 @@ public class TestVariableResolver extends SolrTestCaseJ4 {
VariableResolverImpl vri = new VariableResolverImpl(m);
Object val = vri.resolve(TestVariableResolver.class.getName());
// System.out.println("val = " + val);
Assert.assertEquals("hello", val);
Assert.assertEquals("world",vri.resolve("hello"));
assertEquals("hello", val);
assertEquals("world",vri.resolve("hello"));
}
@Test
@ -68,7 +65,7 @@ public class TestVariableResolver extends SolrTestCaseJ4 {
ns = new HashMap<String, Object>();
ns.put("world1", "WORLD1");
vri.addNamespace("hello.my", ns);
Assert.assertEquals("WORLD1", vri.resolve("hello.my.world1"));
assertEquals("WORLD1", vri.resolve("hello.my.world1"));
}
@Test
@ -80,7 +77,7 @@ public class TestVariableResolver extends SolrTestCaseJ4 {
ns = new HashMap<String, Object>();
ns.put("world1", "WORLD1");
vri.addNamespace("hello.my.new", ns);
Assert.assertEquals("WORLD1", vri.resolve("hello.my.new.world1"));
assertEquals("WORLD1", vri.resolve("hello.my.new.world1"));
}
@Test
@ -95,7 +92,7 @@ public class TestVariableResolver extends SolrTestCaseJ4 {
Date d = new Date();
ns.put("dt", d);
vri.addNamespace("A", ns);
Assert.assertEquals(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(d),
assertEquals(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(d),
vri.replaceTokens("${dataimporter.functions.formatDate(A.dt,'yyyy-MM-dd HH:mm:ss')}"));
} finally {
Context.CURRENT_CONTEXT.remove();
@ -117,7 +114,7 @@ public class TestVariableResolver extends SolrTestCaseJ4 {
DateMathParser dmp = new DateMathParser(TimeZone.getDefault(), Locale.getDefault());
String s = vri.replaceTokens("${dataimporter.functions.formatDate('NOW/DAY','yyyy-MM-dd HH:mm')}");
Assert.assertEquals(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(dmp.parseMath("/DAY")), s);
assertEquals(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(dmp.parseMath("/DAY")), s);
} finally {
Context.CURRENT_CONTEXT.remove();
}
@ -129,7 +126,7 @@ public class TestVariableResolver extends SolrTestCaseJ4 {
Map<String, Object> ns = new HashMap<String, Object>();
ns.put("world", "WORLD");
vri.addNamespace(null, ns);
Assert.assertEquals("WORLD", vri.resolve("world"));
assertEquals("WORLD", vri.resolve("world"));
}
@Test
@ -138,7 +135,7 @@ public class TestVariableResolver extends SolrTestCaseJ4 {
Map<String, Object> ns = new HashMap<String, Object>();
ns.put("world", "WORLD");
vri.addNamespace(null, ns);
Assert.assertEquals("WORLD", vri.resolve("world"));
assertEquals("WORLD", vri.resolve("world"));
}
@Test
@ -162,9 +159,9 @@ public class TestVariableResolver extends SolrTestCaseJ4 {
.getFunctionsNamespace(l,null));
String s = resolver
.replaceTokens("${dataimporter.functions.formatDate('NOW/DAY','yyyy-MM-dd HH:mm')}");
Assert.assertEquals(new SimpleDateFormat("yyyy-MM-dd HH:mm")
assertEquals(new SimpleDateFormat("yyyy-MM-dd HH:mm")
.format(dmp.parseMath("/DAY")), s);
Assert.assertEquals("Hello World", resolver
assertEquals("Hello World", resolver
.replaceTokens("${dataimporter.functions.test('TEST')}"));
} finally {
Context.CURRENT_CONTEXT.remove();

46
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestXPathEntityProcessor.java
View File

@ -16,10 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import static org.apache.solr.handler.dataimport.AbstractDataImportHandlerTestCase.createMap;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Test;
import java.io.File;
@ -39,7 +35,7 @@ import java.util.concurrent.TimeUnit;
* @version $Id$
* @since solr 1.3
*/
public class TestXPathEntityProcessor extends SolrTestCaseJ4 {
public class TestXPathEntityProcessor extends AbstractDataImportHandlerTestCase {
boolean simulateSlowReader;
boolean simulateSlowResultProcessor;
int rowsToRead = -1;
@ -58,7 +54,7 @@ public class TestXPathEntityProcessor extends SolrTestCaseJ4 {
fields.add(createMap("column", "title", "xpath", "/catalog/cd/title"));
fields.add(createMap("column", "artist", "xpath", "/catalog/cd/artist"));
fields.add(createMap("column", "year", "xpath", "/catalog/cd/year"));
Context c = AbstractDataImportHandlerTestCase.getContext(null,
Context c = getContext(null,
new VariableResolverImpl(), getDataSource(cdData), Context.FULL_DUMP, fields, entityAttrs);
XPathEntityProcessor xPathEntityProcessor = new XPathEntityProcessor();
xPathEntityProcessor.init(c);
@ -69,10 +65,10 @@ public class TestXPathEntityProcessor extends SolrTestCaseJ4 {
break;
result.add(row);
}
Assert.assertEquals(3, result.size());
Assert.assertEquals("Empire Burlesque", result.get(0).get("title"));
Assert.assertEquals("Bonnie Tyler", result.get(1).get("artist"));
Assert.assertEquals("1982", result.get(2).get("year"));
assertEquals(3, result.size());
assertEquals("Empire Burlesque", result.get(0).get("title"));
assertEquals("Bonnie Tyler", result.get(1).get("artist"));
assertEquals("1982", result.get(2).get("year"));
}
@Test
@ -81,7 +77,7 @@ public class TestXPathEntityProcessor extends SolrTestCaseJ4 {
XPathEntityProcessor.FOR_EACH, "/root");
List fields = new ArrayList();
fields.add(createMap("column", "a", "xpath", "/root/a", DataImporter.MULTI_VALUED, "true"));
Context c = AbstractDataImportHandlerTestCase.getContext(null,
Context c = getContext(null,
new VariableResolverImpl(), getDataSource(testXml), Context.FULL_DUMP, fields, entityAttrs);
XPathEntityProcessor xPathEntityProcessor = new XPathEntityProcessor();
xPathEntityProcessor.init(c);
@ -92,7 +88,7 @@ public class TestXPathEntityProcessor extends SolrTestCaseJ4 {
break;
result.add(row);
}
Assert.assertEquals(2, ((List)result.get(0).get("a")).size());
assertEquals(2, ((List)result.get(0).get("a")).size());
}
@Test
@ -101,7 +97,7 @@ public class TestXPathEntityProcessor extends SolrTestCaseJ4 {
XPathEntityProcessor.FOR_EACH, "/root");
List fields = new ArrayList();
fields.add(createMap("column", "a", "xpath", "/root/a" ,"flatten","true"));
Context c = AbstractDataImportHandlerTestCase.getContext(null,
Context c = getContext(null,
new VariableResolverImpl(), getDataSource(testXmlFlatten), Context.FULL_DUMP, fields, entityAttrs);
XPathEntityProcessor xPathEntityProcessor = new XPathEntityProcessor();
xPathEntityProcessor.init(c);
@ -112,7 +108,7 @@ public class TestXPathEntityProcessor extends SolrTestCaseJ4 {
break;
result = row;
}
Assert.assertEquals("1B2", result.get("a"));
assertEquals("1B2", result.get("a"));
}
@Test
@ -126,7 +122,7 @@ public class TestXPathEntityProcessor extends SolrTestCaseJ4 {
fields.add(createMap("column", "title", "xpath", "/catalog/cd/title"));
fields.add(createMap("column", "artist", "xpath", "/catalog/cd/artist"));
fields.add(createMap("column", "year", "xpath", "/catalog/cd/year"));
Context c = AbstractDataImportHandlerTestCase.getContext(null,
Context c = getContext(null,
new VariableResolverImpl(), getDataSource(cdData), Context.FULL_DUMP, fields, entityAttrs);
XPathEntityProcessor xPathEntityProcessor = new XPathEntityProcessor() {
private int count;
@ -180,14 +176,14 @@ public class TestXPathEntityProcessor extends SolrTestCaseJ4 {
// confirm that publisher thread stops.
xPathEntityProcessor.publisherThread.join(1000);
Assert.assertEquals("Expected thread to stop", false, xPathEntityProcessor.publisherThread.isAlive());
assertEquals("Expected thread to stop", false, xPathEntityProcessor.publisherThread.isAlive());
Assert.assertEquals(rowsToRead < 0 ? 3 : rowsToRead, result.size());
assertEquals(rowsToRead < 0 ? 3 : rowsToRead, result.size());
if (rowsToRead < 0) {
Assert.assertEquals("Empire Burlesque", result.get(0).get("title"));
Assert.assertEquals("Bonnie Tyler", result.get(1).get("artist"));
Assert.assertEquals("1982", result.get(2).get("year"));
assertEquals("Empire Burlesque", result.get(0).get("title"));
assertEquals("Bonnie Tyler", result.get(1).get("artist"));
assertEquals("1982", result.get(2).get("year"));
}
}
@ -221,7 +217,7 @@ public class TestXPathEntityProcessor extends SolrTestCaseJ4 {
Map entityAttrs = createMap("name", "e",
XPathEntityProcessor.USE_SOLR_ADD_SCHEMA, "true", "xsl", ""
+ new File(tmpdir, "x.xsl").getAbsolutePath(), "url", "cd.xml");
Context c = AbstractDataImportHandlerTestCase.getContext(null,
Context c = getContext(null,
new VariableResolverImpl(), getDataSource(cdData), Context.FULL_DUMP, null, entityAttrs);
XPathEntityProcessor xPathEntityProcessor = new XPathEntityProcessor();
xPathEntityProcessor.init(c);
@ -232,10 +228,10 @@ public class TestXPathEntityProcessor extends SolrTestCaseJ4 {
break;
result.add(row);
}
Assert.assertEquals(3, result.size());
Assert.assertEquals("Empire Burlesque", result.get(0).get("title"));
Assert.assertEquals("Bonnie Tyler", result.get(1).get("artist"));
Assert.assertEquals("1982", result.get(2).get("year"));
assertEquals(3, result.size());
assertEquals("Empire Burlesque", result.get(0).get("title"));
assertEquals("Bonnie Tyler", result.get(1).get("artist"));
assertEquals("1982", result.get(2).get("year"));
}
private DataSource<Reader> getDataSource(final String xml) {

239
solr/contrib/dataimporthandler/src/test/java/org/apache/solr/handler/dataimport/TestXPathRecordReader.java
View File

@ -16,8 +16,6 @@
*/
package org.apache.solr.handler.dataimport;
import org.apache.solr.SolrTestCaseJ4;
import org.junit.Assert;
import org.junit.Test;
import java.io.StringReader;
@ -31,9 +29,9 @@ import java.util.Map;
* @version $Id$
* @since solr 1.3
*/
public class TestXPathRecordReader extends SolrTestCaseJ4 {
public class TestXPathRecordReader extends AbstractDataImportHandlerTestCase {
@Test
public void basic() {
public void testBasic() {
String xml="<root>\n"
+ " <b><c>Hello C1</c>\n"
+ " <c>Hello C1</c>\n"
@ -44,13 +42,13 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
XPathRecordReader rr = new XPathRecordReader("/root/b");
rr.addField("c", "/root/b/c", true);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(2, l.size());
Assert.assertEquals(2, ((List) l.get(0).get("c")).size());
Assert.assertEquals(1, ((List) l.get(1).get("c")).size());
assertEquals(2, l.size());
assertEquals(2, ((List) l.get(0).get("c")).size());
assertEquals(1, ((List) l.get(1).get("c")).size());
}
@Test
public void attributes() {
public void testAttributes() {
String xml="<root>\n"
+ " <b a=\"x0\" b=\"y0\" />\n"
+ " <b a=\"x1\" b=\"y1\" />\n"
@ -60,17 +58,17 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
rr.addField("a", "/root/b/@a", false);
rr.addField("b", "/root/b/@b", false);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(3, l.size());
Assert.assertEquals("x0", l.get(0).get("a"));
Assert.assertEquals("x1", l.get(1).get("a"));
Assert.assertEquals("x2", l.get(2).get("a"));
Assert.assertEquals("y0", l.get(0).get("b"));
Assert.assertEquals("y1", l.get(1).get("b"));
Assert.assertEquals("y2", l.get(2).get("b"));
assertEquals(3, l.size());
assertEquals("x0", l.get(0).get("a"));
assertEquals("x1", l.get(1).get("a"));
assertEquals("x2", l.get(2).get("a"));
assertEquals("y0", l.get(0).get("b"));
assertEquals("y1", l.get(1).get("b"));
assertEquals("y2", l.get(2).get("b"));
}
@Test
public void attrInRoot(){
public void testAttrInRoot(){
String xml="<r>\n" +
"<merchantProduct id=\"814636051\" mid=\"189973\">\n" +
" <in_stock type=\"stock-4\" />\n" +
@ -91,20 +89,20 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
rr.addField("conditionType", "/r/merchantProduct/condition/@type", false);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Map<String, Object> m = l.get(0);
Assert.assertEquals("814636051", m.get("id"));
Assert.assertEquals("189973", m.get("mid"));
Assert.assertEquals("301.46", m.get("price"));
Assert.assertEquals("cond-0", m.get("conditionType"));
assertEquals("814636051", m.get("id"));
assertEquals("189973", m.get("mid"));
assertEquals("301.46", m.get("price"));
assertEquals("cond-0", m.get("conditionType"));
m = l.get(1);
Assert.assertEquals("814636052", m.get("id"));
Assert.assertEquals("189974", m.get("mid"));
Assert.assertEquals("302.46", m.get("price"));
Assert.assertEquals("cond-1", m.get("conditionType"));
assertEquals("814636052", m.get("id"));
assertEquals("189974", m.get("mid"));
assertEquals("302.46", m.get("price"));
assertEquals("cond-1", m.get("conditionType"));
}
@Test
public void attributes2Level() {
public void testAttributes2Level() {
String xml="<root>\n"
+ "<a>\n <b a=\"x0\" b=\"y0\" />\n"
+ " <b a=\"x1\" b=\"y1\" />\n"
@ -115,13 +113,13 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
rr.addField("a", "/root/a/b/@a", false);
rr.addField("b", "/root/a/b/@b", false);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(3, l.size());
Assert.assertEquals("x0", l.get(0).get("a"));
Assert.assertEquals("y1", l.get(1).get("b"));
assertEquals(3, l.size());
assertEquals("x0", l.get(0).get("a"));
assertEquals("y1", l.get(1).get("b"));
}
@Test
public void attributes2LevelHetero() {
public void testAttributes2LevelHetero() {
String xml="<root>\n"
+ "<a>\n <b a=\"x0\" b=\"y0\" />\n"
+ " <b a=\"x1\" b=\"y1\" />\n"
@ -148,12 +146,12 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
}
});
Assert.assertEquals(1, a.size());
Assert.assertEquals(1, x.size());
assertEquals(1, a.size());
assertEquals(1, x.size());
}
@Test
public void attributes2LevelMissingAttrVal() {
public void testAttributes2LevelMissingAttrVal() {
String xml="<root>\n"
+ "<a>\n <b a=\"x0\" b=\"y0\" />\n"
+ " <b a=\"x1\" b=\"y1\" />\n"
@ -166,13 +164,13 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
rr.addField("a", "/root/a/b/@a", true);
rr.addField("b", "/root/a/b/@b", true);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(2, l.size());
Assert.assertNull(((List) l.get(1).get("a")).get(1));
Assert.assertNull(((List) l.get(1).get("b")).get(0));
assertEquals(2, l.size());
assertNull(((List) l.get(1).get("a")).get(1));
assertNull(((List) l.get(1).get("b")).get(0));
}
@Test
public void elems2LevelMissing() {
public void testElems2LevelMissing() {
String xml="<root>\n"
+ "\t<a>\n"
+ "\t <b>\n\t <x>x0</x>\n"
@ -191,13 +189,13 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
rr.addField("a", "/root/a/b/x", true);
rr.addField("b", "/root/a/b/y", true);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(2, l.size());
Assert.assertNull(((List) l.get(1).get("a")).get(1));
Assert.assertNull(((List) l.get(1).get("b")).get(0));
assertEquals(2, l.size());
assertNull(((List) l.get(1).get("a")).get(1));
assertNull(((List) l.get(1).get("b")).get(0));
}
@Test
public void mixedContent() {
public void testMixedContent() {
String xml = "<xhtml:p xmlns:xhtml=\"http://xhtml.com/\" >This text is \n" +
" <xhtml:b>bold</xhtml:b> and this text is \n" +
" <xhtml:u>underlined</xhtml:u>!\n" +
@ -209,18 +207,18 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Map<String, Object> row = l.get(0);
Assert.assertEquals("bold", ((List) row.get("b")).get(0));
Assert.assertEquals("underlined", ((List) row.get("u")).get(0));
assertEquals("bold", ((List) row.get("b")).get(0));
assertEquals("underlined", ((List) row.get("u")).get(0));
String p = (String) ((List) row.get("p")).get(0);
Assert.assertTrue(p.contains("This text is"));
Assert.assertTrue(p.contains("and this text is"));
Assert.assertTrue(p.contains("!"));
assertTrue(p.contains("This text is"));
assertTrue(p.contains("and this text is"));
assertTrue(p.contains("!"));
// Should not contain content from child elements
Assert.assertFalse(p.contains("bold"));
assertFalse(p.contains("bold"));
}
@Test
public void mixedContentFlattened() {
public void testMixedContentFlattened() {
String xml = "<xhtml:p xmlns:xhtml=\"http://xhtml.com/\" >This text is \n" +
" <xhtml:b>bold</xhtml:b> and this text is \n" +
" <xhtml:u>underlined</xhtml:u>!\n" +
@ -229,13 +227,13 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
rr.addField("p", "/p", false, XPathRecordReader.FLATTEN);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Map<String, Object> row = l.get(0);
Assert.assertEquals("This text is \n" +
assertEquals("This text is \n" +
" bold and this text is \n" +
" underlined!", ((String)row.get("p")).trim() );
}
@Test
public void elems2LevelWithAttrib() {
public void testElems2LevelWithAttrib() {
String xml = "<root>\n\t<a>\n\t <b k=\"x\">\n"
+ "\t <x>x0</x>\n"
+ "\t <y>y0</y>\n"
@ -257,14 +255,14 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
rr.addField("x", "/root/a/b[@k]/x", true);
rr.addField("y", "/root/a/b[@k]/y", true);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(2, l.size());
Assert.assertEquals(2, ((List) l.get(0).get("x")).size());
Assert.assertEquals(2, ((List) l.get(0).get("y")).size());
Assert.assertEquals(0, l.get(1).size());
assertEquals(2, l.size());
assertEquals(2, ((List) l.get(0).get("x")).size());
assertEquals(2, ((List) l.get(0).get("y")).size());
assertEquals(0, l.get(1).size());
}
@Test
public void elems2LevelWithAttribMultiple() {
public void testElems2LevelWithAttribMultiple() {
String xml="<root>\n"
+ "\t<a>\n\t <b k=\"x\" m=\"n\" >\n"
+ "\t <x>x0</x>\n"
@ -287,14 +285,14 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
rr.addField("x", "/root/a/b[@k][@m='n']/x", true);
rr.addField("y", "/root/a/b[@k][@m='n']/y", true);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(2, l.size());
Assert.assertEquals(1, ((List) l.get(0).get("x")).size());
Assert.assertEquals(1, ((List) l.get(0).get("y")).size());
Assert.assertEquals(0, l.get(1).size());
assertEquals(2, l.size());
assertEquals(1, ((List) l.get(0).get("x")).size());
assertEquals(1, ((List) l.get(0).get("y")).size());
assertEquals(0, l.get(1).size());
}
@Test
public void elems2LevelWithAttribVal() {
public void testElems2LevelWithAttribVal() {
String xml="<root>\n\t<a>\n <b k=\"x\">\n"
+ "\t <x>x0</x>\n"
+ "\t <y>y0</y>\n"
@ -311,44 +309,43 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
rr.addField("x", "/root/a/b[@k='x']/x", true);
rr.addField("y", "/root/a/b[@k='x']/y", true);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(2, l.size());
Assert.assertEquals(1, ((List) l.get(0).get("x")).size());
Assert.assertEquals(1, ((List) l.get(0).get("y")).size());
Assert.assertEquals(0, l.get(1).size());
assertEquals(2, l.size());
assertEquals(1, ((List) l.get(0).get("x")).size());
assertEquals(1, ((List) l.get(0).get("y")).size());
assertEquals(0, l.get(1).size());
}
@Test
public void attribValWithSlash() {
public void testAttribValWithSlash() {
String xml = "<root><b>\n" +
" <a x=\"a/b\" h=\"hello-A\"/> \n" +
"</b></root>";
XPathRecordReader rr = new XPathRecordReader("/root/b");
rr.addField("x", "/root/b/a[@x='a/b']/@h", false);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(1, l.size());
assertEquals(1, l.size());
Map<String, Object> m = l.get(0);
Assert.assertEquals("hello-A", m.get("x"));
assertEquals("hello-A", m.get("x"));
}
@Test
public void unsupported_Xpaths() {
public void testUnsupported_Xpaths() {
String xml = "<root><b><a x=\"a/b\" h=\"hello-A\"/> </b></root>";
XPathRecordReader rr=null;
try {
rr = new XPathRecordReader("//b");
Assert.fail("A RuntimeException was expected: //b forEach cannot begin with '//'.");
fail("A RuntimeException was expected: //b forEach cannot begin with '//'.");
}
catch (RuntimeException ex) { }
try {
rr.addField("bold" ,"b", false);
Assert.fail("A RuntimeException was expected: 'b' xpaths must begin with '/'.");
fail("A RuntimeException was expected: 'b' xpaths must begin with '/'.");
}
catch (RuntimeException ex) { }
}
@Test
public void any_decendent_from_root() {
public void testAny_decendent_from_root() {
XPathRecordReader rr = new XPathRecordReader("/anyd/contenido");
rr.addField("descdend", "//boo", true);
rr.addField("inr_descd","//boo/i", false);
@ -373,22 +370,22 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
+ "</anyd>";
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(1, l.size());
assertEquals(1, l.size());
Map<String, Object> m = l.get(0);
Assert.assertEquals("This one is inside a forEach", m.get("cont").toString().trim());
Assert.assertEquals("10097" ,m.get("id"));
Assert.assertEquals("My flattened title",m.get("title").toString().trim());
Assert.assertEquals("My summary" ,m.get("resume").toString().trim());
Assert.assertEquals("My text" ,m.get("text").toString().trim());
Assert.assertEquals("not ignored as its",(String) ((List) m.get("descdend")).get(0) );
Assert.assertEquals("antler" ,(String) ((List) m.get("descdend")).get(1) );
Assert.assertEquals("Within the body of",(String) ((List) m.get("descdend")).get(2) );
Assert.assertEquals("inner as well" ,(String) ((List) m.get("descdend")).get(3) );
Assert.assertEquals("sub clauses" ,m.get("inr_descd").toString().trim());
assertEquals("This one is inside a forEach", m.get("cont").toString().trim());
assertEquals("10097" ,m.get("id"));
assertEquals("My flattened title",m.get("title").toString().trim());
assertEquals("My summary" ,m.get("resume").toString().trim());
assertEquals("My text" ,m.get("text").toString().trim());
assertEquals("not ignored as its",(String) ((List) m.get("descdend")).get(0) );
assertEquals("antler" ,(String) ((List) m.get("descdend")).get(1) );
assertEquals("Within the body of",(String) ((List) m.get("descdend")).get(2) );
assertEquals("inner as well" ,(String) ((List) m.get("descdend")).get(3) );
assertEquals("sub clauses" ,m.get("inr_descd").toString().trim());
}
@Test
public void any_decendent_of_a_child1() {
public void testAny_decendent_of_a_child1() {
XPathRecordReader rr = new XPathRecordReader("/anycd");
rr.addField("descdend", "/anycd//boo", true);
@ -407,19 +404,19 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
+ "</anycd>";
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(1, l.size());
assertEquals(1, l.size());
Map<String, Object> m = l.get(0);
Assert.assertEquals("top level" ,(String) ((List) m.get("descdend")).get(0) );
Assert.assertEquals("this element" ,(String) ((List) m.get("descdend")).get(1) );
Assert.assertEquals("not ignored as its",(String) ((List) m.get("descdend")).get(2) );
Assert.assertEquals("antler" ,(String) ((List) m.get("descdend")).get(3) );
Assert.assertEquals("title" ,(String) ((List) m.get("descdend")).get(4) );
Assert.assertEquals("Within the body of",(String) ((List) m.get("descdend")).get(5) );
Assert.assertEquals("inner as well" ,(String) ((List) m.get("descdend")).get(6) );
assertEquals("top level" ,(String) ((List) m.get("descdend")).get(0) );
assertEquals("this element" ,(String) ((List) m.get("descdend")).get(1) );
assertEquals("not ignored as its",(String) ((List) m.get("descdend")).get(2) );
assertEquals("antler" ,(String) ((List) m.get("descdend")).get(3) );
assertEquals("title" ,(String) ((List) m.get("descdend")).get(4) );
assertEquals("Within the body of",(String) ((List) m.get("descdend")).get(5) );
assertEquals("inner as well" ,(String) ((List) m.get("descdend")).get(6) );
}
@Test
public void any_decendent_of_a_child2() {
public void testAny_decendent_of_a_child2() {
XPathRecordReader rr = new XPathRecordReader("/anycd");
rr.addField("descdend", "/anycd/contenido//boo", true);
@ -438,17 +435,17 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
+ "</anycd>";
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(1, l.size());
assertEquals(1, l.size());
Map<String, Object> m = l.get(0);
Assert.assertEquals("not ignored as its",((List) m.get("descdend")).get(0) );
Assert.assertEquals("antler" ,((List) m.get("descdend")).get(1) );
Assert.assertEquals("title" ,((List) m.get("descdend")).get(2) );
Assert.assertEquals("Within the body of",((List) m.get("descdend")).get(3) );
Assert.assertEquals("inner as well" ,((List) m.get("descdend")).get(4) );
assertEquals("not ignored as its",((List) m.get("descdend")).get(0) );
assertEquals("antler" ,((List) m.get("descdend")).get(1) );
assertEquals("title" ,((List) m.get("descdend")).get(2) );
assertEquals("Within the body of",((List) m.get("descdend")).get(3) );
assertEquals("inner as well" ,((List) m.get("descdend")).get(4) );
}
@Test
public void another() {
public void testAnother() {
String xml="<root>\n"
+ " <contenido id=\"10097\" idioma=\"cat\">\n"
+ " <antetitulo></antetitulo>\n"
@ -464,17 +461,17 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
rr.addField("text", "/root/contenido/texto", false);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals(1, l.size());
assertEquals(1, l.size());
Map<String, Object> m = l.get(0);
Assert.assertEquals("10097", m.get("id"));
Assert.assertEquals("This is my title", m.get("title").toString().trim());
Assert.assertEquals("This is my summary", m.get("resume").toString().trim());
Assert.assertEquals("This is the body of my text", m.get("text").toString()
assertEquals("10097", m.get("id"));
assertEquals("This is my title", m.get("title").toString().trim());
assertEquals("This is my summary", m.get("resume").toString().trim());
assertEquals("This is the body of my text", m.get("text").toString()
.trim());
}
@Test
public void sameForEachAndXpath(){
public void testSameForEachAndXpath(){
String xml="<root>\n" +
" <cat>\n" +
" <name>hello</name>\n" +
@ -484,11 +481,11 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
XPathRecordReader rr = new XPathRecordReader("/root/cat/name");
rr.addField("catName", "/root/cat/name",false);
List<Map<String, Object>> l = rr.getAllRecords(new StringReader(xml));
Assert.assertEquals("hello",l.get(0).get("catName"));
assertEquals("hello",l.get(0).get("catName"));
}
@Test
public void putNullTest(){
public void testPutNullTest(){
String xml = "<root>\n" +
" <i>\n" +
" <x>\n" +
@ -521,29 +518,29 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
List<String> b = (List<String>) map.get("b");
List<String> c = (List<String>) map.get("c");
Assert.assertEquals("A.1.1",a.get(0));
Assert.assertEquals("B.1.1",b.get(0));
Assert.assertNull(c.get(0));
assertEquals("A.1.1",a.get(0));
assertEquals("B.1.1",b.get(0));
assertNull(c.get(0));
Assert.assertNull(a.get(1));
Assert.assertEquals("B.1.2",b.get(1));
Assert.assertEquals("C.1.2",c.get(1));
assertNull(a.get(1));
assertEquals("B.1.2",b.get(1));
assertEquals("C.1.2",c.get(1));
map = l.get(1);
a = (List<String>) map.get("a");
b = (List<String>) map.get("b");
c = (List<String>) map.get("c");
Assert.assertEquals("A.2.1",a.get(0));
Assert.assertNull(b.get(0));
Assert.assertEquals("C.2.1",c.get(0));
assertEquals("A.2.1",a.get(0));
assertNull(b.get(0));
assertEquals("C.2.1",c.get(0));
Assert.assertNull(a.get(1));
Assert.assertEquals("B.2.2",b.get(1));
Assert.assertEquals("C.2.2",c.get(1));
assertNull(a.get(1));
assertEquals("B.2.2",b.get(1));
assertEquals("C.2.2",c.get(1));
}
@Test
@Test
public void testError(){
String malformedXml = "<root>\n" +
" <node>\n" +
@ -564,7 +561,7 @@ public class TestXPathRecordReader extends SolrTestCaseJ4 {
rr.addField("desc", "/root/node/desc", true);
try {
rr.getAllRecords(new StringReader(malformedXml));
Assert.fail("A RuntimeException was expected: the input XML is invalid.");
fail("A RuntimeException was expected: the input XML is invalid.");
} catch (Exception e) { }
}
}