From 224f02f429d595fba894fc5dc9119be85aa6ae19 Mon Sep 17 00:00:00 2001 From: msmock Date: Wed, 13 Dec 2017 17:08:50 +0100 Subject: [PATCH] added request and response classes with tests --- .../strolch/soql/core/CompiledStatement.java | 3 + .../li/strolch/soql/core/QueryRequest.java | 79 +++++++++++ .../li/strolch/soql/core/QueryResponse.java | 45 +++++++ .../soql/core/SOQLEvaluationException.java | 3 + .../strolch/soql/core/SOQLParseException.java | 3 + .../java/li/strolch/soql/core/BaseTest.java | 125 ++++++++++++++++++ .../ComparisonExpressionTest.java | 7 +- .../soql/core/MethodExpressionTest.java | 114 ++++++++++++++++ .../java/li/strolch/soql/core/QueryTest.java | 79 +++++++++++ .../strolch/soql/core/SerialisationTest.java | 94 +++++++++++++ .../li/strolch/soql/core/StatementTest.java | 116 +++------------- .../li/strolch/soql/core/VerboseListener.java | 3 + .../ChainedMethodExpressionTest.java | 118 ----------------- .../core/expression/MethodExpressionTest.java | 67 ---------- 14 files changed, 575 insertions(+), 281 deletions(-) create mode 100644 li.strolch.soql/src/main/java/li/strolch/soql/core/QueryRequest.java create mode 100644 li.strolch.soql/src/main/java/li/strolch/soql/core/QueryResponse.java create mode 100644 li.strolch.soql/src/test/java/li/strolch/soql/core/BaseTest.java rename li.strolch.soql/src/test/java/li/strolch/soql/core/{expression => }/ComparisonExpressionTest.java (98%) create mode 100644 li.strolch.soql/src/test/java/li/strolch/soql/core/MethodExpressionTest.java create mode 100644 li.strolch.soql/src/test/java/li/strolch/soql/core/QueryTest.java create mode 100644 li.strolch.soql/src/test/java/li/strolch/soql/core/SerialisationTest.java delete mode 100644 li.strolch.soql/src/test/java/li/strolch/soql/core/expression/ChainedMethodExpressionTest.java delete mode 100644 li.strolch.soql/src/test/java/li/strolch/soql/core/expression/MethodExpressionTest.java diff --git a/li.strolch.soql/src/main/java/li/strolch/soql/core/CompiledStatement.java b/li.strolch.soql/src/main/java/li/strolch/soql/core/CompiledStatement.java index 5a9d3d233..158ba5ece 100644 --- a/li.strolch.soql/src/main/java/li/strolch/soql/core/CompiledStatement.java +++ b/li.strolch.soql/src/main/java/li/strolch/soql/core/CompiledStatement.java @@ -8,6 +8,9 @@ import java.util.Map; import li.strolch.soql.core.expresssion.SelectClause; import li.strolch.soql.core.expresssion.WhereExpression; +/** + * @author msmock + */ public class CompiledStatement { // the map of entities declared in the FROM clause with their nicknames as keys diff --git a/li.strolch.soql/src/main/java/li/strolch/soql/core/QueryRequest.java b/li.strolch.soql/src/main/java/li/strolch/soql/core/QueryRequest.java new file mode 100644 index 000000000..d4bc8cc4b --- /dev/null +++ b/li.strolch.soql/src/main/java/li/strolch/soql/core/QueryRequest.java @@ -0,0 +1,79 @@ +package li.strolch.soql.core; + +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import li.strolch.model.Tags; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; + +/** + * @author msmock + */ +public class QueryRequest { + + public static final String STATEMENT = "statement"; + public static final String PARAMETER = "parameter"; + + // the SOQL query string + private String statement; + + // the parameter of the SOQL query + private Map parameter = new HashMap<>(); + + public String getStatement() { + return statement; + } + + public void setStatement(String statement) { + this.statement = statement; + } + + public Map getParameter() { + return parameter; + } + + /** + * @return the query as JsonObject + */ + public JsonObject toJson() { + + final JsonObject rootJ = new JsonObject(); + rootJ.addProperty(Tags.Json.OBJECT_TYPE, "QueryRequest"); + rootJ.addProperty(STATEMENT, statement); + + final JsonObject parameterJ = new JsonObject(); + rootJ.add(PARAMETER, parameterJ); + + final Set keys = parameter.keySet(); + for (Iterator iterator = keys.iterator(); iterator.hasNext(); ) { + final String key = iterator.next(); + final Object param = parameter.get(key); + parameterJ.addProperty(key, param.toString()); + } + + return rootJ; + } + + /** + * build request from Json object + * + * @return + */ + public QueryRequest fromJson(JsonObject jsonObject) { + + final String statement = jsonObject.get(STATEMENT).getAsString(); + setStatement(statement); + + final JsonObject params = jsonObject.getAsJsonObject(PARAMETER); + final Set> entrySet = params.entrySet(); + for (final Map.Entry entry : entrySet) { + parameter.put(entry.getKey(), entry.getValue().getAsString()); + } + + return this; + } + +} diff --git a/li.strolch.soql/src/main/java/li/strolch/soql/core/QueryResponse.java b/li.strolch.soql/src/main/java/li/strolch/soql/core/QueryResponse.java new file mode 100644 index 000000000..67ee26725 --- /dev/null +++ b/li.strolch.soql/src/main/java/li/strolch/soql/core/QueryResponse.java @@ -0,0 +1,45 @@ +package li.strolch.soql.core; + +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import li.strolch.model.StrolchRootElement; +import li.strolch.model.Tags; +import li.strolch.model.json.StrolchElementToJsonVisitor; + +import java.util.*; + +/** + * @author msmock + */ +public class QueryResponse extends QueryRequest { + + // the returned objects + static final String RESULT_SET = "resultSet"; + public List resultSet = new ArrayList<>(); + + // an exception or error message in case of error + public String message; + + /** + * @return the query as JsonObject + */ + public JsonObject toJson(final StrolchElementToJsonVisitor visitor) { + + final JsonObject rootJ = super.toJson(); + + if (message != null && !message.isEmpty()) { + rootJ.addProperty("Message", message); + } + + final JsonArray resultSetJ = new JsonArray(); + rootJ.add(RESULT_SET, resultSetJ); + + for (Iterator iter = resultSet.iterator(); iter.hasNext(); ) { + resultSetJ.add(iter.next().accept(visitor)); + } + + return rootJ; + } + +} diff --git a/li.strolch.soql/src/main/java/li/strolch/soql/core/SOQLEvaluationException.java b/li.strolch.soql/src/main/java/li/strolch/soql/core/SOQLEvaluationException.java index b71cf75cb..e1316d0e7 100644 --- a/li.strolch.soql/src/main/java/li/strolch/soql/core/SOQLEvaluationException.java +++ b/li.strolch.soql/src/main/java/li/strolch/soql/core/SOQLEvaluationException.java @@ -1,5 +1,8 @@ package li.strolch.soql.core; +/** + * @author msmock + */ public class SOQLEvaluationException extends RuntimeException { private static final long serialVersionUID = 1L; diff --git a/li.strolch.soql/src/main/java/li/strolch/soql/core/SOQLParseException.java b/li.strolch.soql/src/main/java/li/strolch/soql/core/SOQLParseException.java index 9c6a8114f..a71162fd2 100644 --- a/li.strolch.soql/src/main/java/li/strolch/soql/core/SOQLParseException.java +++ b/li.strolch.soql/src/main/java/li/strolch/soql/core/SOQLParseException.java @@ -1,5 +1,8 @@ package li.strolch.soql.core; +/** + * @author msmock + */ public class SOQLParseException extends RuntimeException { private static final long serialVersionUID = 1L; diff --git a/li.strolch.soql/src/test/java/li/strolch/soql/core/BaseTest.java b/li.strolch.soql/src/test/java/li/strolch/soql/core/BaseTest.java new file mode 100644 index 000000000..617e71fc7 --- /dev/null +++ b/li.strolch.soql/src/test/java/li/strolch/soql/core/BaseTest.java @@ -0,0 +1,125 @@ +package li.strolch.soql.core; + +import li.strolch.model.*; +import li.strolch.model.parameter.FloatParameter; +import li.strolch.model.parameter.Parameter; +import li.strolch.model.query.ActivityQuery; +import li.strolch.model.query.OrderQuery; +import li.strolch.model.query.ResourceQuery; +import li.strolch.model.query.StrolchElementQuery; +import li.strolch.soql.antlr4.generated.SOQLLexer; +import li.strolch.soql.antlr4.generated.SOQLParser; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.CharStreams; +import org.antlr.v4.runtime.CommonTokenStream; +import org.antlr.v4.runtime.tree.ParseTree; +import org.antlr.v4.runtime.tree.ParseTreeWalker; +import org.junit.Test; + +import java.util.*; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +/** + * @author msmock + */ +public abstract class BaseTest { + + /** + * parse the string and return the antlr tree + * + * @throws Exception + */ + ParseTree parseString(final String s) throws Exception { + + final CharStream input = CharStreams.fromString(s); + final SOQLLexer lexer = new SOQLLexer(input); // create a buffer of tokens pulled from the lexer + + final CommonTokenStream tokens = new CommonTokenStream(lexer); // create a parser that feeds off the tokens buffer + final SOQLParser parser = new SOQLParser(tokens); + parser.addErrorListener(new VerboseListener()); + + final ParseTree tree = parser.select_statement(); // begin parsing at block + + // System.out.println(tree.toStringTree(parser)); // print LISP-style tree + + return tree; + } + + /** + * compile the antlr tree to executable + * + * @param tree + * @return CompiledSOQLStatement + * @throws Exception + */ + CompiledStatement compile(final ParseTree tree) throws Exception { + + final ParseTreeWalker walker = new ParseTreeWalker(); + final SOQLListener listener = new SOQLListener(); + walker.walk(listener, tree); + + final CompiledStatement soqlStatement = new CompiledStatement(); + soqlStatement.entities = listener.getEntities(); + soqlStatement.whereExpression = listener.getWhereExpression(); + soqlStatement.selectClause = listener.getSelectClause(); + + return soqlStatement; + } + + /** + * @return a test resource + */ + StrolchRootElement getTestResource(final String id) { + final Resource resource = new Resource(); + resource.setId(id); + + final ParameterBag bag = new ParameterBag(); + bag.setId("testBag"); + resource.addParameterBag(bag); + + final Parameter parameter = new FloatParameter(); + parameter.setId("testId"); + parameter.setValue(100d); + + resource.addParameter("testBag", parameter); + return resource; + } + + /** + * @return a test order + */ + StrolchRootElement getTestOrder(final String id) { + final Order order = new Order(); + order.setId("testId"); + + final ParameterBag bag = new ParameterBag(); + bag.setId("testBag"); + order.addParameterBag(bag); + + final Parameter parameter = new FloatParameter(); + parameter.setId("testId"); + parameter.setValue(100d); + + order.addParameter("testBag", parameter); + return order; + } + + List getTestRessources(int n) { + final List result = new ArrayList<>(n); + for (int i = 0; i < n; i++) { + result.add(getTestResource(String.valueOf(n))); + } + return result; + } + + List getTestOrders(int n) { + final List result = new ArrayList<>(n); + for (int i = 0; i < n; i++) { + result.add(getTestOrder(String.valueOf(n))); + } + return result; + } + +} diff --git a/li.strolch.soql/src/test/java/li/strolch/soql/core/expression/ComparisonExpressionTest.java b/li.strolch.soql/src/test/java/li/strolch/soql/core/ComparisonExpressionTest.java similarity index 98% rename from li.strolch.soql/src/test/java/li/strolch/soql/core/expression/ComparisonExpressionTest.java rename to li.strolch.soql/src/test/java/li/strolch/soql/core/ComparisonExpressionTest.java index 4a3cbcbc3..1ef9120ca 100644 --- a/li.strolch.soql/src/test/java/li/strolch/soql/core/expression/ComparisonExpressionTest.java +++ b/li.strolch.soql/src/test/java/li/strolch/soql/core/ComparisonExpressionTest.java @@ -1,4 +1,4 @@ -package li.strolch.soql.core.expression; +package li.strolch.soql.core; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; @@ -12,6 +12,9 @@ import li.strolch.soql.core.expresssion.ComparisonExpression; import li.strolch.soql.core.expresssion.ParameterReference; import li.strolch.soql.core.expresssion.ValueDeclaration; +/** + * @author msmock + */ public class ComparisonExpressionTest { @Test @@ -130,7 +133,7 @@ public class ComparisonExpressionTest { } @Test - public void testNumericLessEuals() { + public void testNumericLessEquals() { ParameterReference vd_1 = new ParameterReference(); vd_1.varName = "a"; diff --git a/li.strolch.soql/src/test/java/li/strolch/soql/core/MethodExpressionTest.java b/li.strolch.soql/src/test/java/li/strolch/soql/core/MethodExpressionTest.java new file mode 100644 index 000000000..b09d9c92f --- /dev/null +++ b/li.strolch.soql/src/test/java/li/strolch/soql/core/MethodExpressionTest.java @@ -0,0 +1,114 @@ +package li.strolch.soql.core; + +import com.google.gson.JsonObject; +import li.strolch.model.ParameterBag; +import li.strolch.model.Resource; +import li.strolch.model.StrolchElement; +import li.strolch.model.StrolchRootElement; +import li.strolch.model.json.StrolchElementToJsonVisitor; +import li.strolch.model.parameter.Parameter; +import li.strolch.model.parameter.StringParameter; +import li.strolch.soql.core.expresssion.ChainedMethodExpression; +import li.strolch.soql.core.expresssion.MethodArgumentDeclaration; +import li.strolch.soql.core.expresssion.MethodExpression; +import li.strolch.soql.core.expresssion.ParameterReference; +import org.junit.Test; + +import java.util.HashMap; +import java.util.Map; + +import static org.junit.Assert.assertEquals; + +/** + * @author msmock + */ +public class MethodExpressionTest { + + public StrolchRootElement getTestElement() { + final Resource resource = new Resource(); + resource.setId("testId"); + + final ParameterBag bag = new ParameterBag(); + bag.setId("testBag"); + resource.addParameterBag(bag); + + final Parameter parameter = new StringParameter(); + parameter.setId("testId"); + parameter.setValue("testValue"); + + resource.addParameter("testBag", parameter); + return resource; + } + + @Test + public void testMethod() { + + MethodExpression methodExpression = new MethodExpression(); + methodExpression.setMethodName("getParameter"); + methodExpression.setObject(getTestElement()); + + MethodArgumentDeclaration argument = new MethodArgumentDeclaration(); + + ParameterReference parameterReference = new ParameterReference(); + parameterReference.varName = "p_1"; + argument.addParameterReference(parameterReference); + + parameterReference = new ParameterReference(); + parameterReference.varName = "p_2"; + argument.addParameterReference(parameterReference); + + methodExpression.setMethodArguments(argument); + + Map queryParameter = new HashMap<>(); + queryParameter.put("p_1", "testBag"); + queryParameter.put("p_2", "testId"); + + Object result = methodExpression.evaluate(null, queryParameter); + + assertEquals(StringParameter.class, result.getClass()); + + } + + @Test + public void testChained() { + + MethodArgumentDeclaration argument = new MethodArgumentDeclaration(); + + ParameterReference parameterReference = new ParameterReference(); + parameterReference.varName = "p_1"; + argument.addParameterReference(parameterReference); + + parameterReference = new ParameterReference(); + parameterReference.varName = "p_2"; + argument.addParameterReference(parameterReference); + + MethodExpression methodExpression_1 = new MethodExpression(); + methodExpression_1.setMethodName("getParameter"); + methodExpression_1.setMethodArguments(argument); + + MethodExpression methodExpression_2 = new MethodExpression(); + methodExpression_2.setMethodName("getType"); + methodExpression_2.setMethodArguments(new MethodArgumentDeclaration()); + + // build the chained expression + ChainedMethodExpression chainedMethodExpression = new ChainedMethodExpression(); + chainedMethodExpression.setObjectKey("a"); + chainedMethodExpression.addMethodExpression(methodExpression_1); + chainedMethodExpression.addMethodExpression(methodExpression_2); + + // prepare the runtime objects + + Map inputObjects = new HashMap<>(); + inputObjects.put("a", getTestElement()); + + Map queryParameter = new HashMap<>(); + queryParameter.put("p_1", "testBag"); + queryParameter.put("p_2", "testId"); + + // evaluate the chained expression + Object result = chainedMethodExpression.evaluate(inputObjects, queryParameter); + + assertEquals("String", result); + } + +} diff --git a/li.strolch.soql/src/test/java/li/strolch/soql/core/QueryTest.java b/li.strolch.soql/src/test/java/li/strolch/soql/core/QueryTest.java new file mode 100644 index 000000000..4bddfe4ee --- /dev/null +++ b/li.strolch.soql/src/test/java/li/strolch/soql/core/QueryTest.java @@ -0,0 +1,79 @@ +package li.strolch.soql.core; + +import li.strolch.model.Order; +import li.strolch.model.ParameterBag; +import li.strolch.model.Resource; +import li.strolch.model.StrolchElement; +import li.strolch.model.parameter.FloatParameter; +import li.strolch.model.parameter.Parameter; +import li.strolch.model.query.ActivityQuery; +import li.strolch.model.query.OrderQuery; +import li.strolch.model.query.ResourceQuery; +import li.strolch.model.query.StrolchElementQuery; +import li.strolch.soql.antlr4.generated.SOQLLexer; +import li.strolch.soql.antlr4.generated.SOQLParser; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.CharStreams; +import org.antlr.v4.runtime.CommonTokenStream; +import org.antlr.v4.runtime.tree.ParseTree; +import org.antlr.v4.runtime.tree.ParseTreeWalker; +import org.junit.Test; + +import java.util.*; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +/** + * @author msmock + */ +public class QueryTest extends BaseTest { + + /** + * @param entities + * @return Map of queries for the entities + */ + public Map resolveEntities(final Map entities) { + + final Map result = new HashMap<>(); + + final Set keys = entities.keySet(); + for (Iterator iterator = keys.iterator(); iterator.hasNext(); ) { + + final String key = iterator.next(); + final String clazzKey = entities.get(key); + + // System.out.println("key = " + key + ", class = " + clazzKey); + + switch (clazzKey) { + case "Resource": + result.put(key, new ResourceQuery()); + break; + case "Order": + result.put(key, new OrderQuery()); + break; + case "Activity": + result.put(key, new ActivityQuery()); + break; + } + } + return result; + } + + @Test + public void testQuery() throws Exception { + + final String s = "SELECT a, r, o FROM Activity a, Resource r, Order o"; + + final ParseTree tree = parseString(s); + final CompiledStatement compiledStatement = compile(tree); + final Map entities = compiledStatement.entities; + + final Map queries = resolveEntities(entities); + + assertEquals(ActivityQuery.class, queries.get("a").getClass()); + assertEquals(ResourceQuery.class, queries.get("r").getClass()); + assertEquals(OrderQuery.class, queries.get("o").getClass()); + } + +} diff --git a/li.strolch.soql/src/test/java/li/strolch/soql/core/SerialisationTest.java b/li.strolch.soql/src/test/java/li/strolch/soql/core/SerialisationTest.java new file mode 100644 index 000000000..4bd1880e5 --- /dev/null +++ b/li.strolch.soql/src/test/java/li/strolch/soql/core/SerialisationTest.java @@ -0,0 +1,94 @@ +package li.strolch.soql.core; + +import com.google.gson.JsonObject; +import li.strolch.model.StrolchRootElement; +import li.strolch.model.json.StrolchElementToJsonVisitor; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.Assert.assertEquals; + +/** + * @author msmock + */ +public class SerialisationTest extends BaseTest { + + final StrolchElementToJsonVisitor visitor = new StrolchElementToJsonVisitor(); + + private QueryRequest buildTestRequest() { + String s = "SELECT a FROM Activity a WHERE a.getId() = :p"; + final QueryRequest request = new QueryRequest(); + request.setStatement(s); + request.getParameter().put("r", "Just a string!"); + return request; + } + + private QueryResponse buildTestResponse() { + String s = "SELECT a FROM Activity a WHERE a.getId() = :p"; + final QueryResponse response = new QueryResponse(); + response.setStatement(s); + response.getParameter().put("r", "Just a string!"); + return response; + } + + @Test + public void testSerialization() { + final StrolchRootElement element = getTestResource("testId"); + final JsonObject jsonObject = element.accept(visitor); + // System.out.println(jsonObject); + + String expected = "{\"objectType\":\"Resource\",\"id\":\"testId\",\"name\":null,\"type\":null,\"parameterBags\"" + + ":{\"testBag\":{\"id\":\"testBag\",\"name\":null,\"type\":null,\"parameters\":{\"testId\":" + + "{\"id\":\"testId\",\"name\":null,\"type\":\"Float\",\"value\":\"100.0\"}}}}}\n"; + + assertEquals(expected.trim(), jsonObject.toString()); + } + + @Test + public void testQuery2JSON() { + final QueryRequest query = buildTestRequest(); + JsonObject jsonObject = query.toJson(); + + String expected = "{\"objectType\":\"QueryRequest\",\"statement\":\"SELECT a FROM Activity a WHERE a.getId() " + + "= :p\",\"parameter\":{\"r\":\"Just a string!\"}}"; + assertEquals(expected.trim(), jsonObject.toString()); + } + + @Test + public void testJSON2Query() { + + String s = "SELECT a FROM Activity a WHERE a.getId() = :p"; + + final QueryRequest initial = new QueryRequest(); + initial.setStatement(s); + initial.getParameter().put("p", "10010"); + final JsonObject jsonObject = initial.toJson(); + + final QueryRequest query = new QueryRequest(); + query.fromJson(jsonObject); + + assertEquals(s, query.getStatement()); + assertEquals("10010", query.getParameter().get("p")); + } + + @Test + public void testResponse2JSON() { + final QueryResponse response = buildTestResponse(); + response.resultSet = getTestRessources(2); + + String expected = "{\"objectType\":\"QueryRequest\",\"statement\":\"SELECT a FROM Activity a WHERE a.getId() " + + "= :p\",\"parameter\":{\"r\":\"Just a string!\"},\"resultSet\":[{\"objectType\":" + + "\"Resource\",\"id\":\"2\",\"name\":null,\"type\":null,\"parameterBags\":" + + "{\"testBag\":{\"id\":\"testBag\",\"name\":null,\"type\":null,\"parameters\":{\"testId\":{\"id\":" + + "\"testId\",\"name\":null,\"type\":\"Float\",\"value\":\"100.0\"}}}}},{\"objectType\":\"Resource\"," + + "\"id\":\"2\",\"name\":null,\"type\":null,\"parameterBags\":{\"testBag\":{\"id\":\"testBag\",\"name\"" + + ":null,\"type\":null,\"parameters\":{\"testId\":{\"id\":\"testId\",\"name\":null,\"type\":\"Float\"," + + "\"value\":\"100.0\"}}}}}]}\n"; + + final JsonObject jsonObject = response.toJson(visitor); + assertEquals(expected.trim(), jsonObject.toString()); + } + +} diff --git a/li.strolch.soql/src/test/java/li/strolch/soql/core/StatementTest.java b/li.strolch.soql/src/test/java/li/strolch/soql/core/StatementTest.java index 4ee0514df..bf4c3675e 100644 --- a/li.strolch.soql/src/test/java/li/strolch/soql/core/StatementTest.java +++ b/li.strolch.soql/src/test/java/li/strolch/soql/core/StatementTest.java @@ -1,84 +1,17 @@ package li.strolch.soql.core; -import li.strolch.model.ParameterBag; -import li.strolch.model.Resource; -import li.strolch.model.StrolchElement; -import li.strolch.model.parameter.FloatParameter; -import li.strolch.model.parameter.Parameter; -import li.strolch.soql.antlr4.generated.SOQLLexer; -import li.strolch.soql.antlr4.generated.SOQLParser; -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.CharStreams; -import org.antlr.v4.runtime.CommonTokenStream; import org.antlr.v4.runtime.tree.ParseTree; -import org.antlr.v4.runtime.tree.ParseTreeWalker; import org.junit.Test; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; -public class StatementTest { - - /** - * @throws Exception - */ - private ParseTree parseString(final String s) throws Exception { - - CharStream input = CharStreams.fromString(s); - SOQLLexer lexer = new SOQLLexer(input); // create a buffer of tokens pulled from the lexer - - CommonTokenStream tokens = new CommonTokenStream(lexer); // create a parser that feeds off the tokens buffer - SOQLParser parser = new SOQLParser(tokens); - parser.addErrorListener(new VerboseListener()); - - ParseTree tree = parser.select_statement(); // begin parsing at block - - System.out.println(tree.toStringTree(parser)); // print LISP-style tree - - return tree; - } - - /** - * @param tree - * @return CompiledSOQLStatement the compiled SOQL statement - * @throws Exception - */ - private CompiledStatement compile(final ParseTree tree) throws Exception { - - final ParseTreeWalker walker = new ParseTreeWalker(); - final SOQLListener listener = new SOQLListener(); - walker.walk(listener, tree); - - final CompiledStatement soqlStatement = new CompiledStatement(); - soqlStatement.entities = listener.getEntities(); - soqlStatement.whereExpression = listener.getWhereExpression(); - soqlStatement.selectClause = listener.getSelectClause(); - - return soqlStatement; - } - - /** - * @return a test parameter with String value - */ - public StrolchElement getTestElement() { - final Resource resource = new Resource(); - resource.setId("testId"); - - final ParameterBag bag = new ParameterBag(); - bag.setId("testBag"); - resource.addParameterBag(bag); - - final Parameter parameter = new FloatParameter(); - parameter.setId("testId"); - parameter.setValue(100d); - - resource.addParameter("testBag", parameter); - return resource; - } +/** + * @author msmock + */ +public class StatementTest extends BaseTest{ @Test public void test0() throws Exception { @@ -91,14 +24,13 @@ public class StatementTest { // System.out.println(compiledStatement); final Map inputObjects = new HashMap<>(); - inputObjects.put("r", getTestElement()); + inputObjects.put("r", getTestResource("testId")); final Map queryParameter = new HashMap<>(); final List result = compiledStatement.evaluate(inputObjects, queryParameter); assertEquals(1, result.size()); - } @Test @@ -112,15 +44,14 @@ public class StatementTest { // System.out.println(compiledStatement); final Map inputObjects = new HashMap<>(); - inputObjects.put("r", getTestElement()); - inputObjects.put("a", getTestElement()); + inputObjects.put("r", getTestResource("testId")); + inputObjects.put("a", getTestResource("testId")); final Map queryParameter = new HashMap<>(); final List result = compiledStatement.evaluate(inputObjects, queryParameter); assertEquals(3, result.size()); - } /** @@ -136,7 +67,7 @@ public class StatementTest { final CompiledStatement compiledStatement = compile(tree); final Map inputObjects = new HashMap<>(); - inputObjects.put("r", getTestElement()); + inputObjects.put("r", getTestResource("testId")); final Map queryParameter = new HashMap<>(); @@ -158,14 +89,13 @@ public class StatementTest { final CompiledStatement compiledStatement = compile(tree); final Map inputObjects = new HashMap<>(); - inputObjects.put("r", getTestElement()); + inputObjects.put("r", getTestResource("testId")); final Map queryParameter = new HashMap<>(); final List result = compiledStatement.evaluate(inputObjects, queryParameter); assertTrue(result.isEmpty()); - } /** @@ -180,8 +110,8 @@ public class StatementTest { final CompiledStatement compiledStatement = compile(tree); final Map inputObjects = new HashMap<>(); - inputObjects.put("r", getTestElement()); - inputObjects.put("a", getTestElement()); + inputObjects.put("r", getTestResource("testId")); + inputObjects.put("a", getTestResource("testId")); final Map parameter = new HashMap<>(); @@ -205,7 +135,7 @@ public class StatementTest { queryParameter.put("outer_var", "testId"); final Map inputObjects = new HashMap<>(); - inputObjects.put("a", getTestElement()); + inputObjects.put("a", getTestResource("testId")); final List result = compiledStatement.evaluate(inputObjects, queryParameter); @@ -224,7 +154,7 @@ public class StatementTest { final CompiledStatement compiledStatement = compile(tree); final Map inputObjects = new HashMap<>(); - inputObjects.put("a", getTestElement()); + inputObjects.put("a", getTestResource("testId")); final Map queryParameter = new HashMap<>(); queryParameter.put("p_1", "testBag"); @@ -248,7 +178,7 @@ public class StatementTest { final CompiledStatement compiledStatement = compile(tree); final Map inputObjects = new HashMap<>(); - inputObjects.put("a", getTestElement()); + inputObjects.put("a", getTestResource("testId")); final Map queryParameter = new HashMap<>(); queryParameter.put("p_1", "testBag"); @@ -273,7 +203,7 @@ public class StatementTest { final Map inputObjects = new HashMap<>(); - inputObjects.put("a", getTestElement()); + inputObjects.put("a", getTestResource("testId")); Map queryParameter = new HashMap<>(); queryParameter.put("param_1", "testBag"); @@ -305,7 +235,7 @@ public class StatementTest { final Map inputObjects = new HashMap<>(); - inputObjects.put("a", getTestElement()); + inputObjects.put("a", getTestResource("testId")); Map queryParameter = new HashMap<>(); queryParameter.put("param_1", "testBag"); @@ -337,7 +267,7 @@ public class StatementTest { final Map inputObjects = new HashMap<>(); - inputObjects.put("a", getTestElement()); + inputObjects.put("a", getTestResource("testId")); final Map queryParameter = new HashMap<>(); queryParameter.put("param_1", "testBag"); @@ -362,7 +292,7 @@ public class StatementTest { final Map inputObjects = new HashMap<>(); - inputObjects.put("a", getTestElement()); + inputObjects.put("a", getTestResource("testId")); final Map queryParameter = new HashMap<>(); queryParameter.put("p_1", "testBag"); @@ -371,7 +301,6 @@ public class StatementTest { List result = compiledStatement.evaluate(inputObjects, queryParameter); assertEquals(1, result.size()); - } /** @@ -387,7 +316,7 @@ public class StatementTest { final Map inputObjects = new HashMap<>(); - inputObjects.put("a", getTestElement()); + inputObjects.put("a", getTestResource("testId")); final Map queryParameter = new HashMap<>(); queryParameter.put("p_1", "testBag"); @@ -412,7 +341,7 @@ public class StatementTest { final Map inputObjects = new HashMap<>(); - inputObjects.put("a", getTestElement()); + inputObjects.put("a", getTestResource("testId")); final Map queryParameter = new HashMap<>(); queryParameter.put("p_1", "testBag"); @@ -436,8 +365,7 @@ public class StatementTest { final CompiledStatement compiledStatement = compile(tree); final Map inputObjects = new HashMap<>(); - - inputObjects.put("a", getTestElement()); + inputObjects.put("a", getTestResource("testId")); final Map queryParameter = new HashMap<>(); queryParameter.put("p_1", "testBag"); diff --git a/li.strolch.soql/src/test/java/li/strolch/soql/core/VerboseListener.java b/li.strolch.soql/src/test/java/li/strolch/soql/core/VerboseListener.java index 37e703878..ea75d48ee 100644 --- a/li.strolch.soql/src/test/java/li/strolch/soql/core/VerboseListener.java +++ b/li.strolch.soql/src/test/java/li/strolch/soql/core/VerboseListener.java @@ -9,6 +9,9 @@ import org.antlr.v4.runtime.Parser; import org.antlr.v4.runtime.RecognitionException; import org.antlr.v4.runtime.Recognizer; +/** + * @author msmock + */ public class VerboseListener extends BaseErrorListener implements ANTLRErrorListener { @Override diff --git a/li.strolch.soql/src/test/java/li/strolch/soql/core/expression/ChainedMethodExpressionTest.java b/li.strolch.soql/src/test/java/li/strolch/soql/core/expression/ChainedMethodExpressionTest.java deleted file mode 100644 index ad9b3639a..000000000 --- a/li.strolch.soql/src/test/java/li/strolch/soql/core/expression/ChainedMethodExpressionTest.java +++ /dev/null @@ -1,118 +0,0 @@ -package li.strolch.soql.core.expression; - -import static org.junit.Assert.assertEquals; - -import java.util.HashMap; -import java.util.Map; - -import li.strolch.model.ParameterBag; -import li.strolch.model.Resource; -import li.strolch.model.StrolchElement; -import li.strolch.model.parameter.Parameter; -import li.strolch.model.parameter.StringParameter; -import org.junit.Test; - -import li.strolch.soql.core.expresssion.ChainedMethodExpression; -import li.strolch.soql.core.expresssion.MethodArgumentDeclaration; -import li.strolch.soql.core.expresssion.MethodExpression; -import li.strolch.soql.core.expresssion.ParameterReference; - -public class ChainedMethodExpressionTest { - - /** - * @return a test parameter with String value - */ - public StrolchElement getTestElement() { - final Resource resource = new Resource(); - resource.setId("testId"); - - final ParameterBag bag = new ParameterBag(); - bag.setId("testBag"); - resource.addParameterBag(bag); - - final Parameter parameter = new StringParameter(); - parameter.setId("testId"); - parameter.setValue("testValue"); - - resource.addParameter("testBag", parameter); - return resource; - } - - @Test - public void test() { - - String matchingKey = "testString"; - - // build the message expression - ParameterReference parameterReference = new ParameterReference(); - parameterReference.varName = "param_1"; - - MethodArgumentDeclaration argument = new MethodArgumentDeclaration(); - argument.addParameterReference(parameterReference); - - MethodExpression methodExpression = new MethodExpression(); - methodExpression.setMethodName("getParameter"); - methodExpression.setMethodArguments(argument); - - // build the chained expression - ChainedMethodExpression chainedMethodExpression = new ChainedMethodExpression(); - chainedMethodExpression.setObjectKey("a"); - chainedMethodExpression.addMethodExpression(methodExpression); - - // prepare the runtime objects - - Map inputObjects = new HashMap<>(); - inputObjects.put("a", getTestElement()); - - Map queryParameter = new HashMap<>(); - queryParameter.put("param_1", matchingKey); - - // evaluate the chained expression - Object result = chainedMethodExpression.evaluate(inputObjects, queryParameter); - - assertEquals(StringParameter.class, result.getClass()); - - } - - @Test - public void testChained() { - - String matchingKey = "testString"; - - // build the message expression - ParameterReference parameterReference = new ParameterReference(); - parameterReference.varName = "param_1"; - - MethodArgumentDeclaration argument = new MethodArgumentDeclaration(); - argument.addParameterReference(parameterReference); - - MethodExpression methodExpression_1 = new MethodExpression(); - methodExpression_1.setMethodName("getParameter"); - methodExpression_1.setMethodArguments(argument); - - MethodExpression methodExpression_2 = new MethodExpression(); - methodExpression_2.setMethodName("getType"); - methodExpression_2.setMethodArguments(new MethodArgumentDeclaration()); - - // build the chained expression - ChainedMethodExpression chainedMethodExpression = new ChainedMethodExpression(); - chainedMethodExpression.setObjectKey("a"); - chainedMethodExpression.addMethodExpression(methodExpression_1); - chainedMethodExpression.addMethodExpression(methodExpression_2); - - // prepare the runtime objects - - Map inputObjects = new HashMap<>(); - inputObjects.put("a", getTestElement()); - - Map queryParameter = new HashMap<>(); - queryParameter.put("param_1", matchingKey); - - // evaluate the chained expression - Object result = chainedMethodExpression.evaluate(inputObjects, queryParameter); - - assertEquals("testType", result); - - } - -} diff --git a/li.strolch.soql/src/test/java/li/strolch/soql/core/expression/MethodExpressionTest.java b/li.strolch.soql/src/test/java/li/strolch/soql/core/expression/MethodExpressionTest.java deleted file mode 100644 index da3b59409..000000000 --- a/li.strolch.soql/src/test/java/li/strolch/soql/core/expression/MethodExpressionTest.java +++ /dev/null @@ -1,67 +0,0 @@ -package li.strolch.soql.core.expression; - -import static org.junit.Assert.assertEquals; - -import java.util.HashMap; -import java.util.Map; - -import li.strolch.model.ParameterBag; -import li.strolch.model.Resource; -import li.strolch.model.StrolchElement; -import li.strolch.model.parameter.Parameter; -import li.strolch.model.parameter.StringListParameter; -import li.strolch.model.parameter.StringParameter; -import org.junit.Test; - -import li.strolch.soql.core.expresssion.MethodArgumentDeclaration; -import li.strolch.soql.core.expresssion.MethodExpression; -import li.strolch.soql.core.expresssion.ParameterReference; - -public class MethodExpressionTest { - - /** - * @return a test parameter with String value - */ - public StrolchElement getTestElement() { - final Resource resource = new Resource(); - resource.setId("testId"); - - final ParameterBag bag = new ParameterBag(); - bag.setId("testBag"); - resource.addParameterBag(bag); - - final Parameter parameter = new StringParameter(); - parameter.setId("testId"); - parameter.setValue("testValue"); - - resource.addParameter("testBag", parameter); - return resource; - } - - @Test - public void test() { - - String matchingKey = "testString"; - - MethodExpression methodExpression = new MethodExpression(); - methodExpression.setMethodName("getParameter"); - methodExpression.setObject(getTestElement()); - - ParameterReference parameterReference = new ParameterReference(); - parameterReference.varName = "param_1"; - - MethodArgumentDeclaration argument = new MethodArgumentDeclaration(); - argument.addParameterReference(parameterReference); - - methodExpression.setMethodArguments(argument); - - Map queryParameter = new HashMap<>(); - queryParameter.put("param_1", matchingKey); - - Object result = methodExpression.evaluate(null, queryParameter); - - assertEquals(StringParameter.class, result.getClass()); - - } - -}