diff --git a/modules/core/src/main/java/org/apache/synapse/config/xml/LogMediatorFactory.java b/modules/core/src/main/java/org/apache/synapse/config/xml/LogMediatorFactory.java index 77609db7a4..db495e45aa 100644 --- a/modules/core/src/main/java/org/apache/synapse/config/xml/LogMediatorFactory.java +++ b/modules/core/src/main/java/org/apache/synapse/config/xml/LogMediatorFactory.java @@ -22,7 +22,9 @@ import org.apache.axiom.om.OMAttribute; import org.apache.axiom.om.OMElement; import org.apache.synapse.Mediator; +import org.apache.synapse.SynapseException; import org.apache.synapse.mediators.builtin.LogMediator; +import org.jaxen.JaxenException; import javax.xml.namespace.QName; import java.util.Properties; @@ -71,8 +73,15 @@ public Mediator createSpecificMediator(OMElement elem, Properties properties) { boolean containMessageTemplate = false; OMElement messageElement = elem.getFirstChildWithName(ELEMENT_MESSAGE_Q); if (messageElement != null && messageElement.getText() != null) { - logMediator.setMessageTemplate(messageElement.getText()); - containMessageTemplate = true; + try { + containMessageTemplate = true; + logMediator.setMessageTemplate(messageElement.getText()); + logMediator.processTemplateAndSetContentAware(); + } catch (JaxenException e) { + String msg = "Invalid message template : " + e.getMessage(); + log.error(msg); + throw new SynapseException(msg); + } } // Set the high level set of properties to be logged (i.e. log level) @@ -126,7 +135,6 @@ public Mediator createSpecificMediator(OMElement elem, Properties properties) { } logMediator.addAllProperties(MediatorPropertyFactory.getMediatorProperties(elem)); - logMediator.processTemplateAndSetContentAware(); addAllCommentChildrenToList(elem, logMediator.getCommentsList()); return logMediator; diff --git a/modules/core/src/main/java/org/apache/synapse/mediators/builtin/LogMediator.java b/modules/core/src/main/java/org/apache/synapse/mediators/builtin/LogMediator.java index 3f4f67c1c8..e9cbc9f915 100644 --- a/modules/core/src/main/java/org/apache/synapse/mediators/builtin/LogMediator.java +++ b/modules/core/src/main/java/org/apache/synapse/mediators/builtin/LogMediator.java @@ -33,11 +33,14 @@ import org.apache.synapse.mediators.AbstractMediator; import org.apache.synapse.mediators.MediatorProperty; import org.apache.synapse.util.InlineExpressionUtil; +import org.apache.synapse.util.xpath.SynapseExpression; import org.jaxen.JaxenException; import java.util.ArrayList; import java.util.Iterator; import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; /** * Logs the specified message into the configured logger. The log levels specify @@ -80,6 +83,7 @@ public class LogMediator extends AbstractMediator { private String messageTemplate = ""; private boolean isContentAware = false; + private final Map inlineExpressionCache = new ConcurrentHashMap<>(); /** * Logs the current message according to the supplied semantics @@ -285,6 +289,12 @@ public void addProperty(MediatorProperty p) { public void addAllProperties(List list) { properties.addAll(list); + for (MediatorProperty property : properties) { + if (property.getExpression() != null && property.getExpression().isContentAware()) { + isContentAware = true; + return; + } + } } public List getProperties() { @@ -324,7 +334,8 @@ private String trimLeadingSeparator(StringBuffer sb) { private void processMessageTemplate(StringBuffer stringBuffer, MessageContext synCtx, String template) { try { - stringBuffer.append(InlineExpressionUtil.processInLineSynapseExpressionTemplate(synCtx, template)); + stringBuffer.append(InlineExpressionUtil.processInLineSynapseExpressionTemplate(synCtx, template, + inlineExpressionCache)); } catch (JaxenException e) { handleException("Failed to process the message template : " + template, e, synCtx); } @@ -333,21 +344,14 @@ private void processMessageTemplate(StringBuffer stringBuffer, MessageContext sy @Override public boolean isContentAware() { - return isContentAware; + if (logLevel == MESSAGE_TEMPLATE || logLevel == CUSTOM) { + return isContentAware; + } + return true; } - public void processTemplateAndSetContentAware() { + public void processTemplateAndSetContentAware() throws JaxenException { - if (logLevel == MESSAGE_TEMPLATE || logLevel == CUSTOM) { - for (MediatorProperty property : properties) { - if (property.getExpression() != null && property.getExpression().isContentAware()) { - isContentAware = true; - return; - } - } - isContentAware = InlineExpressionUtil.isInlineSynapseExpressionsContentAware(messageTemplate); - } else { - isContentAware = true; - } + isContentAware = InlineExpressionUtil.initInlineSynapseExpressions(messageTemplate, inlineExpressionCache); } } diff --git a/modules/core/src/main/java/org/apache/synapse/mediators/transform/pfutils/Constants.java b/modules/core/src/main/java/org/apache/synapse/mediators/transform/pfutils/Constants.java index d359c82352..565c480e32 100644 --- a/modules/core/src/main/java/org/apache/synapse/mediators/transform/pfutils/Constants.java +++ b/modules/core/src/main/java/org/apache/synapse/mediators/transform/pfutils/Constants.java @@ -40,7 +40,7 @@ private Constants() { public static final String CTX_PROPERTY_INJECTING_NAME = "ctx"; public static final String AXIS2_PROPERTY_INJECTING_NAME = "axis2"; public static final String TRANSPORT_PROPERTY_INJECTING_NAME = "trp"; - public static final String VARIABLE_INJECTING_NAME = "var"; + public static final String VARIABLE_INJECTING_NAME = "vars"; public static final String JSON_TYPE = "json"; public static final String XML_TYPE = "xml"; public static final String TEXT_TYPE = "text"; diff --git a/modules/core/src/main/java/org/apache/synapse/mediators/transform/pfutils/RegexTemplateProcessor.java b/modules/core/src/main/java/org/apache/synapse/mediators/transform/pfutils/RegexTemplateProcessor.java index ab3184a00c..80d4263dcf 100644 --- a/modules/core/src/main/java/org/apache/synapse/mediators/transform/pfutils/RegexTemplateProcessor.java +++ b/modules/core/src/main/java/org/apache/synapse/mediators/transform/pfutils/RegexTemplateProcessor.java @@ -33,12 +33,14 @@ import org.apache.synapse.SynapseException; import org.apache.synapse.commons.json.JsonUtil; import org.apache.synapse.mediators.transform.ArgumentDetails; +import org.apache.synapse.util.InlineExpressionUtil; import org.apache.synapse.util.xpath.SynapseExpression; import org.jaxen.JaxenException; import java.util.HashMap; import java.util.Iterator; import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.xml.stream.XMLStreamException; @@ -50,9 +52,10 @@ public class RegexTemplateProcessor extends TemplateProcessor { private static final Log log = LogFactory.getLog(RegexTemplateProcessor.class); // Pattern matches "${...}" (quoted), ${...} (unquoted), and $n - private final Pattern pattern = Pattern.compile("\"\\$\\{(.+?)\\}\"|\\$\\{(.+?)\\}|\\$(\\d+)"); + private final Pattern pattern = Pattern.compile("\"\\$\\{([^}]+)\\}\"|\\$\\{([^}]+)\\}|\\$(\\d+)"); private final Gson gson = new Gson(); + private final Map inlineExpressionCache = new ConcurrentHashMap<>(); @Override public String processTemplate(String template, String mediaType, MessageContext synCtx) { @@ -63,7 +66,16 @@ public String processTemplate(String template, String mediaType, MessageContext } @Override - public void init() { + public void init() throws SynapseException { + String format = getFormat(); + if (format != null) { + try { + InlineExpressionUtil.initInlineSynapseExpressions(format, inlineExpressionCache); + } catch (JaxenException e) { + String msg = "Invalid Payload format : " + e.getMessage(); + throw new SynapseException(msg); + } + } this.readInputFactoryProperties(); } @@ -76,6 +88,7 @@ public void init() { */ private void replace(String format, StringBuffer result, String mediaType, MessageContext synCtx) { + Map inlineExpressionResults = new ConcurrentHashMap<>(); HashMap[] argValues = getArgValues(mediaType, synCtx); HashMap replacement; Map.Entry replacementEntry; @@ -92,7 +105,7 @@ private void replace(String format, StringBuffer result, String mediaType, Messa if (matcher.group(1) != null) { // Handle "${...}" pattern (with quotes) String expression = matcher.group(1); - Object expressionResult = evaluateExpression(expression, synCtx); + Object expressionResult = evaluateExpression(expression, synCtx, inlineExpressionResults); if (expressionResult instanceof JsonPrimitive) { replacementValue = prepareJSONPrimitiveReplacementValue(expressionResult, mediaType); } else if (expressionResult instanceof JsonElement) { @@ -118,7 +131,7 @@ private void replace(String format, StringBuffer result, String mediaType, Messa } else if (matcher.group(2) != null) { // Handle ${...} pattern (without quotes) String expression = matcher.group(2); - Object expressionResult = evaluateExpression(expression, synCtx); + Object expressionResult = evaluateExpression(expression, synCtx, inlineExpressionResults); replacementValue = expressionResult.toString(); if (expressionResult instanceof JsonPrimitive) { replacementValue = prepareJSONPrimitiveReplacementValue(expressionResult, mediaType); @@ -176,12 +189,26 @@ private String prepareJSONPrimitiveReplacementValue(Object expressionResult, Str * @return evaluated result * @throws JaxenException if an error occurs while evaluating the expression */ - private Object evaluateExpression(String expression, MessageContext synCtx) throws JaxenException { + private Object evaluateExpression(String expression, MessageContext synCtx, + Map inlineExpressionResults) throws JaxenException { - if (expression.contains("xpath(")) { - return new SynapseExpression(expression).stringValueOf(synCtx); + SynapseExpression expressionObj = inlineExpressionCache.get(expression); + if (expressionObj == null) { + expressionObj = new SynapseExpression(expression); + inlineExpressionCache.put(expression, expressionObj); + } + if (inlineExpressionResults.containsKey(expression)) { + return inlineExpressionResults.get(expression); + } else { + Object result; + if (expression.contains("xpath(")) { + result = expressionObj.stringValueOf(synCtx); + } else { + result = expressionObj.objectValueOf(synCtx); + } + inlineExpressionResults.put(expression, result); + return result; } - return new SynapseExpression(expression).objectValueOf(synCtx); } private String escapeJson(String value) { diff --git a/modules/core/src/main/java/org/apache/synapse/mediators/transform/pfutils/TemplateProcessor.java b/modules/core/src/main/java/org/apache/synapse/mediators/transform/pfutils/TemplateProcessor.java index 097063a4f1..4a55c47c22 100644 --- a/modules/core/src/main/java/org/apache/synapse/mediators/transform/pfutils/TemplateProcessor.java +++ b/modules/core/src/main/java/org/apache/synapse/mediators/transform/pfutils/TemplateProcessor.java @@ -31,6 +31,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.synapse.MessageContext; +import org.apache.synapse.SynapseException; import org.apache.synapse.commons.json.JsonUtil; import org.apache.synapse.config.xml.SynapsePath; import org.apache.synapse.mediators.transform.Argument; @@ -90,7 +91,7 @@ public abstract class TemplateProcessor { /** * Execute pre-processing steps if needed */ - public abstract void init(); + public abstract void init() throws SynapseException; /** * Goes through SynapsePath argument list, evaluating each by calling stringValueOf and returns a HashMap String, String diff --git a/modules/core/src/main/java/org/apache/synapse/mediators/v2/ForEachMediatorV2.java b/modules/core/src/main/java/org/apache/synapse/mediators/v2/ForEachMediatorV2.java index bbf7dd225e..b83e91517c 100644 --- a/modules/core/src/main/java/org/apache/synapse/mediators/v2/ForEachMediatorV2.java +++ b/modules/core/src/main/java/org/apache/synapse/mediators/v2/ForEachMediatorV2.java @@ -63,6 +63,7 @@ import org.apache.synapse.mediators.eip.aggregator.ForEachAggregate; import org.apache.synapse.transport.passthru.util.RelayUtils; import org.apache.synapse.util.MessageHelper; +import org.apache.synapse.util.synapse.expression.constants.ExpressionConstants; import org.apache.synapse.util.xpath.SynapseExpression; import org.apache.synapse.util.xpath.SynapseExpressionUtils; import org.apache.synapse.util.xpath.SynapseXPath; @@ -81,6 +82,7 @@ public class ForEachMediatorV2 extends AbstractMediator implements ManagedLifecycle, FlowContinuableMediator { + public static final String VARIABLE_DOT = ExpressionConstants.VARIABLES + "."; public static final String JSON_TYPE = "JSON"; public static final String XML_TYPE = "XML"; private final Object lock = new Object(); @@ -479,7 +481,7 @@ private void setJSONResultToVariable(JsonArray variable, ForEachAggregate aggreg String[] msgSequence = prop.toString().split(EIPConstants.MESSAGE_SEQUENCE_DELEMITER); JsonElement jsonElement = null; try { - Object result = new SynapseExpression("payload").objectValueOf(synCtx); + Object result = new SynapseExpression(ExpressionConstants.PAYLOAD).objectValueOf(synCtx); if (result instanceof JsonElement) { jsonElement = (JsonElement) result; } @@ -513,7 +515,7 @@ private void updateOriginalPayload(MessageContext originalMessageContext, ForEac Object prop = synCtx.getProperty(EIPConstants.MESSAGE_SEQUENCE + "." + id); String[] msgSequence = prop.toString().split(EIPConstants.MESSAGE_SEQUENCE_DELEMITER); JsonElement jsonElement = null; - Object result = new SynapseExpression("payload").objectValueOf(synCtx); + Object result = new SynapseExpression(ExpressionConstants.PAYLOAD).objectValueOf(synCtx); if (result instanceof JsonElement) { jsonElement = (JsonElement) result; } @@ -705,24 +707,26 @@ private String getVariableName(SynapsePath expression) { private boolean isCollectionReferencedByVariable(SynapsePath expression) { - return expression.getExpression().startsWith("var."); + return expression.getExpression().startsWith(VARIABLE_DOT); } private JsonPath getJsonPathFromExpression(String expression) { String jsonPath = expression; - if (jsonPath.startsWith("payload")) { - jsonPath = jsonPath.replace("payload", "$"); - } else if (jsonPath.startsWith("var.")) { - // Remove the "var." prefix and variable name and replace it with "$" for JSON path - jsonPath = expression.replaceAll("var\\.\\w+\\.(\\w+)", "\\$.$1").replaceAll("var\\.\\w+", "\\$"); + if (jsonPath.startsWith(ExpressionConstants.PAYLOAD)) { + jsonPath = jsonPath.replace(ExpressionConstants.PAYLOAD, ExpressionConstants.PAYLOAD_$); + } else if (jsonPath.startsWith(VARIABLE_DOT)) { + // Remove the "vars." prefix and variable name and replace it with "$" for JSON path + jsonPath = expression.replaceAll(ExpressionConstants.VARIABLES + "\\.\\w+\\.(\\w+)", "\\$.$1") + .replaceAll(ExpressionConstants.VARIABLES + "\\.\\w+", "\\$"); } return JsonPath.compile(jsonPath); } private boolean isWholeContent(JsonPath jsonPath) { - return "$".equals(jsonPath.getPath().trim()) || "$.".equals(jsonPath.getPath().trim()); + return ExpressionConstants.PAYLOAD_$.equals(jsonPath.getPath().trim()) + || ExpressionConstants.PAYLOAD_$.equals(jsonPath.getPath().trim()); } public String getCounterVariable() { diff --git a/modules/core/src/main/java/org/apache/synapse/util/InlineExpressionUtil.java b/modules/core/src/main/java/org/apache/synapse/util/InlineExpressionUtil.java index ff2301e5bc..667c47186a 100644 --- a/modules/core/src/main/java/org/apache/synapse/util/InlineExpressionUtil.java +++ b/modules/core/src/main/java/org/apache/synapse/util/InlineExpressionUtil.java @@ -35,6 +35,7 @@ import org.apache.synapse.util.xpath.SynapseXPath; import org.jaxen.JaxenException; +import java.util.Map; import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.xml.stream.XMLStreamException; @@ -203,34 +204,41 @@ private static boolean isValidXML(String stringToValidate) { } /** - * Checks whether inline template contains content aware synapse expressions. + * Initialize the inline synapse expressions in the inline text and return whether the inline text is content aware * Inline expressions will be denoted inside ${} * e.g.: ${var.var1}, ${payload.element.id} * - * @param inlineText Inline text string + * @param inlineText Inline text string + * @param expressionCache Cache to store the synapse expressions * @return true if the string contains content aware inline synapse expressions, false otherwise */ - public static boolean isInlineSynapseExpressionsContentAware(String inlineText) { + public static boolean initInlineSynapseExpressions(String inlineText, Map expressionCache) + throws JaxenException { + boolean isContentAware = false; Matcher matcher = SYNAPSE_EXPRESSION_PLACEHOLDER_PATTERN.matcher(inlineText); while (matcher.find()) { - // Extract the expression inside ${...} - String expression = matcher.group(1); - if (SynapseExpressionUtils.isSynapseExpressionContentAware(expression)) { - return true; + // Extract the expression inside ${...} and add it to the cache + String placeholder = matcher.group(1); + SynapseExpression expression = new SynapseExpression(placeholder); + if (expression.isContentAware()) { + isContentAware = true; } + expressionCache.put(placeholder, expression); } - return false; + return isContentAware; } /** * Process the inline template and replace the synapse expressions with the resolved values * - * @param synCtx Message Context - * @param template Inline template + * @param synCtx Message Context + * @param template Inline template + * @param expressionCache Cache to store the synapse expressions * @return Processed inline template */ - public static String processInLineSynapseExpressionTemplate(MessageContext synCtx, String template) + public static String processInLineSynapseExpressionTemplate(MessageContext synCtx, String template, + Map expressionCache) throws JaxenException { Matcher matcher = SYNAPSE_EXPRESSION_PLACEHOLDER_PATTERN.matcher(template); @@ -238,7 +246,11 @@ public static String processInLineSynapseExpressionTemplate(MessageContext synCt while (matcher.find()) { // Extract the expression inside ${...} String placeholder = matcher.group(1); - SynapseExpression expression = new SynapseExpression(placeholder); + SynapseExpression expression = expressionCache.get(placeholder); + if (expression == null) { + expression = new SynapseExpression(placeholder); + expressionCache.put(placeholder, expression); + } String replacement = expression.stringValueOf(synCtx); matcher.appendReplacement(result, Matcher.quoteReplacement(replacement)); } diff --git a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/constants/ExpressionConstants.java b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/constants/ExpressionConstants.java index e7077120a9..a55aa2a648 100644 --- a/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/constants/ExpressionConstants.java +++ b/modules/core/src/main/java/org/apache/synapse/util/synapse/expression/constants/ExpressionConstants.java @@ -80,4 +80,5 @@ public class ExpressionConstants { public static final String VAULT_LOOKUP = "wso2:vault-lookup('"; public static final String HEADERS = "headers"; public static final String ATTRIBUTES = "attributes"; + public static final String VARIABLES = "vars"; } diff --git a/modules/core/src/test/java/org/apache/synapse/util/InlineExpressionUtilTest.java b/modules/core/src/test/java/org/apache/synapse/util/InlineExpressionUtilTest.java index 059a41d942..893a7526b5 100644 --- a/modules/core/src/test/java/org/apache/synapse/util/InlineExpressionUtilTest.java +++ b/modules/core/src/test/java/org/apache/synapse/util/InlineExpressionUtilTest.java @@ -24,6 +24,8 @@ import org.apache.synapse.mediators.TestUtils; import org.junit.Assert; +import java.util.HashMap; + public class InlineExpressionUtilTest extends TestCase { private static String payload = "{\n" + @@ -83,10 +85,10 @@ public void testsInLineSynapseExpressionTemplate1() throws Exception { MessageContext mc = TestUtils.getTestContextJson(payload, null); String inlineExpression = "Processing payload : ${payload.team[0]}"; - boolean isContentAware = InlineExpressionUtil.isInlineSynapseExpressionsContentAware(inlineExpression); + boolean isContentAware = InlineExpressionUtil.initInlineSynapseExpressions(inlineExpression, new HashMap<>()); Assert.assertTrue("Inline expression content aware should be true", isContentAware); - String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression); + String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression, new HashMap<>()); Assert.assertEquals("Inline expression result mismatch", expected, result); } @@ -100,10 +102,10 @@ public void testsInLineSynapseExpressionTemplate2() throws Exception { MessageContext mc = TestUtils.getTestContextJson(payload, null); String inlineExpression = "Processing user : ${payload.team[0].name}"; - boolean isContentAware = InlineExpressionUtil.isInlineSynapseExpressionsContentAware(inlineExpression); + boolean isContentAware = InlineExpressionUtil.initInlineSynapseExpressions(inlineExpression, new HashMap<>()); Assert.assertTrue("Inline expression content aware should be true", isContentAware); - String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression); + String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression, new HashMap<>()); Assert.assertEquals("Inline expression result mismatch", expected, result); } @@ -117,10 +119,10 @@ public void testsInLineSynapseExpressionTemplate3() throws Exception { MessageContext mc = TestUtils.getTestContextJson(payload, null); String inlineExpression = "Processing user : ${payload.team[0].age}"; - boolean isContentAware = InlineExpressionUtil.isInlineSynapseExpressionsContentAware(inlineExpression); + boolean isContentAware = InlineExpressionUtil.initInlineSynapseExpressions(inlineExpression, new HashMap<>()); Assert.assertTrue("Inline expression content aware should be true", isContentAware); - String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression); + String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression, new HashMap<>()); Assert.assertEquals("Inline expression result mismatch", expected, result); } @@ -140,10 +142,10 @@ public void testsInLineSynapseExpressionTemplate4() throws Exception { mc.setVariable("address", jsonObject); String inlineExpression = "Processing user with age : ${vars.age} lives at ${vars.address}"; - boolean isContentAware = InlineExpressionUtil.isInlineSynapseExpressionsContentAware(inlineExpression); + boolean isContentAware = InlineExpressionUtil.initInlineSynapseExpressions(inlineExpression, new HashMap<>()); Assert.assertFalse("Inline expression content aware should be false", isContentAware); - String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression); + String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression, new HashMap<>()); Assert.assertEquals("Inline expression result mismatch", expected, result); } @@ -163,10 +165,10 @@ public void testsInLineSynapseExpressionTemplate5() throws Exception { String inlineExpression = "Processing user : ${payload.team[0].name}, role : ${vars.role}, " + "experience : ${vars.experience.level} ${properties.synapse.duration}"; - boolean isContentAware = InlineExpressionUtil.isInlineSynapseExpressionsContentAware(inlineExpression); + boolean isContentAware = InlineExpressionUtil.initInlineSynapseExpressions(inlineExpression, new HashMap<>()); Assert.assertTrue("Inline expression content aware should be true", isContentAware); - String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression); + String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression, new HashMap<>()); Assert.assertEquals("Inline expression result mismatch", expected, result); } @@ -182,10 +184,10 @@ public void testsInLineSynapseExpressionTemplate6() throws Exception { mc.setProperty("method", "get"); String inlineExpression = "Processing using endpoint : ${vars.endpoint}, method : ${properties.synapse.method}, role : ${payload.team[2].role}"; - boolean isContentAware = InlineExpressionUtil.isInlineSynapseExpressionsContentAware(inlineExpression); + boolean isContentAware = InlineExpressionUtil.initInlineSynapseExpressions(inlineExpression, new HashMap<>()); Assert.assertTrue("Inline expression content aware should be true", isContentAware); - String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression); + String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression, new HashMap<>()); Assert.assertEquals("Inline expression result mismatch", expected, result); } @@ -207,10 +209,30 @@ public void testsInLineSynapseExpressionTemplate7() throws Exception { mc.setVariable("endpoint", "https://test.wso2.com/"); String inlineExpression = "Using endpoint : ${vars.endpoint} to process book : ${xpath('//catalog/book[1]')}"; - boolean isContentAware = InlineExpressionUtil.isInlineSynapseExpressionsContentAware(inlineExpression); + boolean isContentAware = InlineExpressionUtil.initInlineSynapseExpressions(inlineExpression, new HashMap<>()); + Assert.assertTrue("Inline expression content aware should be true", isContentAware); + + String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression, new HashMap<>()); + Assert.assertEquals("Inline expression result mismatch", expected, result); + } + + /** + * Test inline synapse expression template processing with multiple expressions. + */ + public void testsInLineSynapseExpressionTemplate8() throws Exception { + + String expected = "Using endpoint : https://test.wso2.com/integration to process sum = 15 and status = true"; + + MessageContext mc = TestUtils.getTestContextJson(payload, null); + mc.setVariable("endpoint", "https://test.wso2.com/"); + mc.setVariable("completed", true); + String inlineExpression = "Using endpoint : ${vars.endpoint + 'integration'} to process sum = " + + "${payload.team[0].experience + 12} and status = ${(payload.team[0].experience > 2) && (vars.completed)}"; + + boolean isContentAware = InlineExpressionUtil.initInlineSynapseExpressions(inlineExpression, new HashMap<>()); Assert.assertTrue("Inline expression content aware should be true", isContentAware); - String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression); + String result = InlineExpressionUtil.processInLineSynapseExpressionTemplate(mc, inlineExpression, new HashMap<>()); Assert.assertEquals("Inline expression result mismatch", expected, result); } }