public FunctionDef build() { return new FunctionDef(functionName, params); } }
public static FunctionDefBuilder newFunction(String functionName) { return new FunctionDefBuilder(functionName); }
public FunctionDefBuilder withParam(String paramName, String type) { params.add(new ParamDef(paramName, type)); return this; }
private void testGenerateConditionSuccessful(String function) { for (int i = 0; i < variableParams.size(); i++) { Condition condition = new Condition(function); condition.addParam(variableParams.get(i)); condition.addParam(stringParams.get(i)); GenerateConditionResult result = service.generateCondition(condition); assertFalse(result.hasError()); String expectedScript = buildBinaryConditionScript(function, variableParams.get(i), stringParams.get(i)); assertEquals(expectedScript, result.getExpression()); } } }
@Test public void testGenerateConditionUnSuccessful() { GenerateConditionResult result = service.generateCondition(null); assertTrue(result.hasError()); assertEquals("A condition must be provided", result.getError()); Condition condition = new Condition("SomeNonExistingFunction"); result = service.generateCondition(condition); assertTrue(result.hasError()); assertEquals("Function SomeNonExistingFunction was not found in current functions definitions", result.getError()); condition = new Condition("startsWith"); condition.addParam("variable"); condition.addParam(null); result = service.generateCondition(condition); assertTrue(result.hasError()); assertEquals("Parameter can not be null nor empty", result.getError()); }
private void testParseConditionSuccessful(String function) { List<String> conditions = buildBinaryConditionScripts(function); for (int i = 0; i < conditions.size(); i++) { ParseConditionResult result = service.parseCondition(conditions.get(i)); assertFalse(result.hasError()); assertEquals(function, result.getCondition().getFunction()); assertEquals(2, result.getCondition().getParams().size()); assertEquals(variableParams.get(i), result.getCondition().getParams().get(0)); assertEquals(stringParams.get(i), result.getCondition().getParams().get(1)); } }
private Condition parse(FunctionDef functionDef) throws ParseException { parseReturnSentence(); functionName = parseFunctionName(); functionName = functionName.substring(KIE_FUNCTIONS.length()); parseFunctionOpen(); Condition condition = new Condition(functionName); String param; String[] variableParam; boolean first = true; for (ParamDef ignored : functionDef.getParams()) { if (first) { variableParam = parseVariableParam(); param = variableParam[0] + (variableParam[1] != null ? ("." + variableParam[1]) : ""); first = false; } else { parseParamDelimiter(); param = parseStringParameter(); } condition.addParam(param); } //all parameters were consumed parseFunctionClose(); parseSentenceClose(); return condition; }
private void assertHasField(TypeMetadata typeMetadata, String fieldName, String type, String accessor, String mutator) { FieldMetadata fieldMetadata = typeMetadata.getFieldMetadata().stream().filter(fieldMetadata1 -> fieldMetadata1.getName().equals(fieldName)).findFirst().orElse(null); assertNotNull(fieldMetadata); assertEquals(type, fieldMetadata.getType()); assertEquals(accessor, fieldMetadata.getAccessor()); assertEquals(mutator, fieldMetadata.getMutator()); }
@Test public void testParamIsNullError() throws Exception { ConditionGenerator generator = new ConditionGenerator(); Condition condition = new Condition("startsWith"); condition.addParam("variable"); condition.addParam(null); expectedException.expectMessage("Parameter can not be null nor empty"); generator.generateScript(condition); }
private void onSimpleConditionChange(GenerateConditionResult result) { clearError(); if (!result.hasError()) { ScriptTypeValue oldValue = value; value = new ScriptTypeValue(DEFAULT_LANGUAGE, result.getExpression()); notifyChange(oldValue, value); } else { showError(result.getError()); } }
@Test public void testParseConditionResultEqualsAndHashCode() { TestCaseBuilder.newTestCase() .addTrueCase(new ParseConditionResult(null, null), new ParseConditionResult(null, null)) .addTrueCase(new ParseConditionResult(new Condition(null, null)), new ParseConditionResult(new Condition(null, null))) .addTrueCase(new ParseConditionResult(new Condition("function", Arrays.asList("param1"))), new ParseConditionResult(new Condition("function", Arrays.asList("param1")))) .addTrueCase(new ParseConditionResult(new Condition("function", Arrays.asList("param1")), "error"), new ParseConditionResult(new Condition("function", Arrays.asList("param1")), "error")) .addFalseCase(new ParseConditionResult(new Condition(null, null), "error"), new ParseConditionResult(new Condition(null, null), null)) .addFalseCase(new ParseConditionResult(new Condition("function", Arrays.asList("param1"))), new ParseConditionResult(new Condition("function", null))) .addFalseCase(new ParseConditionResult(new Condition("function", Arrays.asList("param1")), "error"), new ParseConditionResult(new Condition("function1", Arrays.asList("param1")), "error")) .addFalseCase(new ParseConditionResult(new Condition("function", Arrays.asList("param1")), "error"), new ParseConditionResult(new Condition("function", Arrays.asList("param2")), "error")) .addFalseCase(new ParseConditionResult(new Condition("function", Arrays.asList("param1")), "error"), new ParseConditionResult(new Condition("function", Arrays.asList("param1")), "error1")) .test(); }
private void testFindAvailableFunctions(String clazz, String[] expectedFunctions) { List<FunctionDef> functionDefs = service.findAvailableFunctions(path, clazz); assertEquals(functionDefs.size(), expectedFunctions.length); for (String expectedFunction : expectedFunctions) { assertTrue(functionDefs.stream() .anyMatch(functionDef -> expectedFunction.equals(functionDef.getName()))); } }
private void onSetValue(ParseConditionResult result) { if (!result.hasError()) { simpleConditionEditor.setValue(result.getCondition()); showSimpleConditionEditor(); } else { showScriptEditor(); } }
private void testParseConditionUnsuccessful(String function) { failingBinaryFunctionExpressions.forEach(binaryFunctionExpression -> { String expression = String.format(binaryFunctionExpression, "KieFunctions." + function); ParseConditionResult result = service.parseCondition(expression); assertTrue(result.hasError()); }); }
protected TypeMetadataQueryResult findMetadata(TypeMetadataQuery query, ClassLoader classLoader) { Set<TypeMetadata> typeMetadatas = new HashSet<>(); Set<String> missingTypes = new HashSet<>(); for (String type : query.getTypes()) { try { TypeMetadata typeMetadata = buildTypeMetadata(type, classLoader); typeMetadatas.add(typeMetadata); } catch (ClassNotFoundException e) { missingTypes.add(type); } } return new TypeMetadataQueryResult(typeMetadatas, missingTypes); }
@Override public GenerateConditionResult generateCondition(Condition condition) { ConditionGenerator generator = new ConditionGenerator(); try { return new GenerateConditionResult(generator.generateScript(condition)); } catch (GenerateConditionException e) { return new GenerateConditionResult(null, e.getMessage()); } }
@Override public ParseConditionResult parseCondition(String conditionStr) { try { ConditionParser parser = new ConditionParser(conditionStr); return new ParseConditionResult(parser.parse()); } catch (ParseException e) { return new ParseConditionResult(e.getMessage()); } }
@Override public TypeMetadataQueryResult findMetadata(TypeMetadataQuery query) { return findMetadata(query, resolveClassLoader(query.getPath())); }
@Test public void testParamDefEqualsAndHashCode() { TestCaseBuilder.newTestCase() .addTrueCase(new ParamDef(null, null), new ParamDef(null, null)) .addTrueCase(new ParamDef("name", null), new ParamDef("name", null)) .addTrueCase(new ParamDef("name", "type"), new ParamDef("name", "type")) .addFalseCase(new ParamDef("name", "type"), new ParamDef("name", null)) .addFalseCase(new ParamDef("name", "type"), new ParamDef(null, "type")) .addFalseCase(new ParamDef("name", null), new ParamDef("name1", null)) .addFalseCase(new ParamDef("name", "type"), new ParamDef("name", "type1")) .addFalseCase(new ParamDef("name", "type"), new ParamDef("name1", "type1")) .test(); }
@Test public void testGenerateConditionResultEqualsAndHashCode() { TestCaseBuilder.newTestCase() .addTrueCase(new GenerateConditionResult(null), new GenerateConditionResult(null)) .addTrueCase(new GenerateConditionResult(null, null), new GenerateConditionResult(null, null)) .addTrueCase(new GenerateConditionResult("expr"), new GenerateConditionResult("expr")) .addTrueCase(new GenerateConditionResult("expr", "error"), new GenerateConditionResult("expr", "error")) .addFalseCase(new GenerateConditionResult("expr"), new GenerateConditionResult(null)) .addFalseCase(new GenerateConditionResult("expr", "error"), new GenerateConditionResult("expr", null)) .addFalseCase(new GenerateConditionResult("expr"), new GenerateConditionResult("expr1")) .addFalseCase(new GenerateConditionResult("expr", "error"), new GenerateConditionResult("expr", "error1")) .addFalseCase(new GenerateConditionResult("expr", "error"), new GenerateConditionResult("expr1", "error1")) .test(); }