public/liteFlow
1
0
Fork 0
mirror of https://gitee.com/dromara/liteFlow.git synced 2026-06-15 14:21:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

!315 #IAWJG1 调整 ELBus 构建普通节点和降级节点逻辑

Browse Source 
Merge pull request !315 from luoyi/issues/IAWJG1
This commit is contained in:
铂赛东
2024-11-02 10:38:32 +00:00
committed by Gitee
parent e20604a14d 6faf51ac6d
commit 2317b6b0c4
18 changed files with 561 additions and 595 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/CommonNodeELWrapper.java
View File

@@ -1,25 +1,129 @@
package com.yomahub.liteflow.builder.el;
import cn.hutool.core.util.StrUtil;
import com.yomahub.liteflow.util.JsonUtil;
import java.util.Map;
/**
* 普通节点表示
*
* @author luo yi
* @since 2.12.3
*/
public class CommonNodeELWrapper extends NodeELWrapper {
public class CommonNodeELWrapper extends ELWrapper {
private String nodeId;
private String tag;
public CommonNodeELWrapper(String nodeId) {
super(nodeId);
this.nodeId = nodeId;
this.setNodeWrapper(this);
}
private void setNodeWrapper(ELWrapper elWrapper){
this.addWrapper(elWrapper, 0);
}
private CommonNodeELWrapper getNodeWrapper(){
return (CommonNodeELWrapper) this.getFirstWrapper();
}
protected String getNodeId() {
return nodeId;
}
protected void setNodeId(String nodeId) {
this.nodeId = nodeId;
}
@Override
public CommonNodeELWrapper tag(String tag) {
this.setTag(tag);
return this;
}
/**
* 单节点不允许定义 id，重载为protected修饰
*
* @param id 节点id
* @return {@link CommonNodeELWrapper}
*/
@Override
public CommonNodeELWrapper id(String id) {
this.setId(id);
return this;
}
@Override
public CommonNodeELWrapper data(String dataName, Object object) {
setData("'" + JsonUtil.toJsonString(object) + "'");
setDataName(dataName);
return this;
}
@Override
public CommonNodeELWrapper data(String dataName, String jsonString) {
setData("'" + jsonString + "'");
setDataName(dataName);
return this;
}
@Override
public CommonNodeELWrapper data(String dataName, Map<String, Object> jsonMap) {
setData("'" + JsonUtil.toJsonString(jsonMap) + "'");
setDataName(dataName);
return this;
}
@Override
public CommonNodeELWrapper maxWaitSeconds(Integer maxWaitSeconds){
setMaxWaitSeconds(maxWaitSeconds);
return this;
}
public CommonNodeELWrapper retry(Integer count){
super.retry(count);
return this;
}
public CommonNodeELWrapper retry(Integer count, String... exceptions){
super.retry(count, exceptions);
return this;
}
@Override
protected String toEL(Integer depth, StringBuilder paramContext) {
CommonNodeELWrapper nodeElWrapper = (CommonNodeELWrapper) this.getFirstWrapper();
CommonNodeELWrapper commonNodeElWrapper = this.getNodeWrapper();
StringBuilder sb = new StringBuilder();
processWrapperTabs(sb, depth);
sb.append(nodeElWrapper.getNodeId());
sb.append(commonNodeElWrapper.getNodeId());
processWrapperProperty(sb, paramContext);
return sb.toString();
}
/**
* Node的公共属性不包括id，对父类方法重载。
*
* @param elContext EL 上下文
* @param paramContext 参数上下文
*/
@Override
protected void processWrapperProperty(StringBuilder elContext, StringBuilder paramContext){
if(this.getTag() != null){
elContext.append(StrUtil.format(".tag(\"{}\")", this.getTag()));
}
if(this.getData() != null){
elContext.append(StrUtil.format(".data({})", this.getDataName()));
paramContext.append(StrUtil.format("{} = {}", this.getDataName(), this.getData())).append(";\n");
}
if(this.getMaxWaitSeconds() != null){
elContext.append(StrUtil.format(".maxWaitSeconds({})", String.valueOf(this.getMaxWaitSeconds())));
}
if (this.getRetry() != null){
elContext.append(StrUtil.format(".retry({})", this.getRetry().toString()));
}
}
}

71
liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/ELBus.java
View File

@@ -13,8 +13,6 @@ public class ELBus {
public static final String TAB = "\t";
private static boolean nodeWrapper = true;
/**
* 创建 then 串行组件
*
@@ -82,12 +80,12 @@ public class ELBus {
* @param falseElWrapper 判断节点返回false时执行的组件
* @return {@link IfELWrapper}
*/
public static IfELWrapper ifOpt(NodeELWrapper ifElWrapper, Object trueElWrapper, Object falseElWrapper){
public static IfELWrapper ifOpt(CommonNodeELWrapper ifElWrapper, Object trueElWrapper, Object falseElWrapper){
return new IfELWrapper(ifElWrapper, convertToNonBooleanOpt(trueElWrapper), convertToNonBooleanOpt(falseElWrapper));
}
public static IfELWrapper ifOpt(String ifElWrapper, Object trueElWrapper, Object falseElWrapper){
return new IfELWrapper((NodeELWrapper) convertToBooleanOpt(ifElWrapper), convertToNonBooleanOpt(trueElWrapper), convertToNonBooleanOpt(falseElWrapper));
return new IfELWrapper((CommonNodeELWrapper) convertToBooleanOpt(ifElWrapper), convertToNonBooleanOpt(trueElWrapper), convertToNonBooleanOpt(falseElWrapper));
}
public static IfELWrapper ifOpt(AndELWrapper ifElWrapper, Object trueElWrapper, Object falseElWrapper){
@@ -102,12 +100,12 @@ public class ELBus {
return new IfELWrapper(ifElWrapper, convertToNonBooleanOpt(trueElWrapper), convertToNonBooleanOpt(falseElWrapper));
}
public static IfELWrapper ifOpt(NodeELWrapper ifElWrapper, Object trueElWrapper){
public static IfELWrapper ifOpt(CommonNodeELWrapper ifElWrapper, Object trueElWrapper){
return new IfELWrapper(ifElWrapper, convertToNonBooleanOpt(trueElWrapper));
}
public static IfELWrapper ifOpt(String ifElWrapper, Object trueElWrapper){
return new IfELWrapper((NodeELWrapper) convertToBooleanOpt(ifElWrapper), convertToNonBooleanOpt(trueElWrapper));
return new IfELWrapper((CommonNodeELWrapper) convertToBooleanOpt(ifElWrapper), convertToNonBooleanOpt(trueElWrapper));
}
public static IfELWrapper ifOpt(AndELWrapper ifElWrapper, Object trueElWrapper){
@@ -123,33 +121,33 @@ public class ELBus {
}
/**
* 创建 node 单节点表达式
* 创建 commonNode 单节点表达式
*
* @param nodeId 节点id
* @return {@link NodeELWrapper}
*/
public static NodeELWrapper node(String nodeId){
return new NodeELWrapper(nodeId);
}
/**
* 创建普通 node 单节点表达式
*
* @param nodeId 节点 id
* @return {@link CommonNodeELWrapper}
*/
public static CommonNodeELWrapper commonNode(String nodeId){
return new CommonNodeELWrapper(nodeId);
}
/**
* 创建降级 commonNode 单节点表达式
*
* @param nodeId 节点 id
* @return {@link NodeELWrapper}
*/
public static NodeELWrapper node(String nodeId){
return new NodeELWrapper(nodeId);
}
/**
* 创建 switch 选择表达式
*
* @param nodeElWrapper 选择节点
* @param commonNodeElWrapper 选择节点
* @return {@link SwitchELWrapper}
*/
public static SwitchELWrapper switchOpt(NodeELWrapper nodeElWrapper){
return new SwitchELWrapper(nodeElWrapper);
public static SwitchELWrapper switchOpt(CommonNodeELWrapper commonNodeElWrapper){
return new SwitchELWrapper(commonNodeElWrapper);
}
public static SwitchELWrapper switchOpt(String nodeElWrapper){
@@ -169,11 +167,11 @@ public class ELBus {
/**
* 创建 for 次数循环表达式
*
* @param nodeElWrapper 返回循环次数的节点
* @param commonNodeElWrapper 返回循环次数的节点
* @return {@link LoopELWrapper}
*/
public static LoopELWrapper forOpt(NodeELWrapper nodeElWrapper){
return new LoopELWrapper(nodeElWrapper, LoopELWrapper.FOR);
public static LoopELWrapper forOpt(CommonNodeELWrapper commonNodeElWrapper){
return new LoopELWrapper(commonNodeElWrapper, LoopELWrapper.FOR);
}
/**
@@ -189,11 +187,11 @@ public class ELBus {
/**
* 创建 while 条件循环表达式
*
* @param nodeElWrapper 返回布尔值的节点
* @param commonNodeElWrapper 返回布尔值的节点
* @return {@link LoopELWrapper}
*/
public static LoopELWrapper whileOpt(NodeELWrapper nodeElWrapper){
return new LoopELWrapper(nodeElWrapper, LoopELWrapper.WHILE);
public static LoopELWrapper whileOpt(CommonNodeELWrapper commonNodeElWrapper){
return new LoopELWrapper(commonNodeElWrapper, LoopELWrapper.WHILE);
}
public static LoopELWrapper whileOpt(String nodeElWrapper){
@@ -215,11 +213,11 @@ public class ELBus {
/**
* 创建迭代循环表达式
*
* @param nodeElWrapper 迭代节点
* @param commonNodeElWrapper 迭代节点
* @return {@link LoopELWrapper}
*/
public static LoopELWrapper iteratorOpt(NodeELWrapper nodeElWrapper){
return new LoopELWrapper(nodeElWrapper, LoopELWrapper.ITERATOR);
public static LoopELWrapper iteratorOpt(CommonNodeELWrapper commonNodeElWrapper){
return new LoopELWrapper(commonNodeElWrapper, LoopELWrapper.ITERATOR);
}
public static LoopELWrapper iteratorOpt(String nodeElWrapper){
@@ -264,7 +262,7 @@ public class ELBus {
* @param notElWrapper 返回布尔值的表达式
* @return {@link NotELWrapper}
*/
public static NotELWrapper not(NodeELWrapper notElWrapper){
public static NotELWrapper not(CommonNodeELWrapper notElWrapper){
return new NotELWrapper(notElWrapper);
}
@@ -294,7 +292,7 @@ public class ELBus {
public static ELWrapper[] convert(Object... objects){
return Arrays.stream(objects).map(o -> {
if (o instanceof String) {
return new NodeELWrapper(o.toString());
return new CommonNodeELWrapper(o.toString());
} else if (o instanceof ELWrapper) {
return (ELWrapper) o;
} else {
@@ -305,7 +303,7 @@ public class ELBus {
public static ELWrapper convert(Object object){
if (object instanceof String) {
return new NodeELWrapper(object.toString());
return new CommonNodeELWrapper(object.toString());
} else if (object instanceof ELWrapper) {
return (ELWrapper) object;
} else {
@@ -376,17 +374,10 @@ public class ELBus {
if(!(elWrapper instanceof AndELWrapper)
&& !(elWrapper instanceof OrELWrapper)
&& !(elWrapper instanceof NotELWrapper)
&& !(elWrapper instanceof NodeELWrapper)){
&& !(elWrapper instanceof CommonNodeELWrapper)){
throw new RuntimeException("param is error");
}
}
}
public static boolean isNodeWrapper() {
return nodeWrapper;
}
public static void setNodeWrapper(boolean nodeWrapper) {
ELBus.nodeWrapper = nodeWrapper;
}
}

8
liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/IfELWrapper.java
View File

@@ -32,14 +32,14 @@ public class IfELWrapper extends ELWrapper {
* @param trueWrapper 判断节点返回true时执行的表达式
* @param falseWrapper 判断节点返回false时执行的表达式
*/
public IfELWrapper(NodeELWrapper ifWrapper, ELWrapper trueWrapper, ELWrapper falseWrapper) {
public IfELWrapper(CommonNodeELWrapper ifWrapper, ELWrapper trueWrapper, ELWrapper falseWrapper) {
this.setIfWrapper(ifWrapper);
this.setTrueWrapper(trueWrapper);
this.setFalseWrapper(falseWrapper);
this.format = IF_FORMAT;
}
public IfELWrapper(NodeELWrapper ifWrapper, ELWrapper trueWrapper) {
public IfELWrapper(CommonNodeELWrapper ifWrapper, ELWrapper trueWrapper) {
this.setIfWrapper(ifWrapper);
this.setTrueWrapper(trueWrapper);
this.format = IF_ELSE_FORMAT;
@@ -139,8 +139,8 @@ public class IfELWrapper extends ELWrapper {
ELWrapper ifWrapper = ELBus.convertToBooleanOpt(ifObject);
ELWrapper trueWrapper = ELBus.convertToNonBooleanOpt(trueObject);
IfELWrapper elIfWrapper;
if(ifWrapper instanceof NodeELWrapper){
elIfWrapper = new IfELWrapper((NodeELWrapper) ifWrapper, trueWrapper);
if(ifWrapper instanceof CommonNodeELWrapper){
elIfWrapper = new IfELWrapper((CommonNodeELWrapper) ifWrapper, trueWrapper);
} else if (ifWrapper instanceof AndELWrapper){
elIfWrapper = new IfELWrapper((AndELWrapper) ifWrapper, trueWrapper);
} else if (ifWrapper instanceof OrELWrapper){

114
liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/NodeELWrapper.java
View File

@@ -1,9 +1,6 @@
package com.yomahub.liteflow.builder.el;
import cn.hutool.core.util.StrUtil;
import com.yomahub.liteflow.util.JsonUtil;
import java.util.Map;
/**
* 单节点表达式
@@ -11,124 +8,23 @@ import java.util.Map;
* 支持设置 tag data maxWaitSeconds 属性
*
* @author gezuao
* @author luo yi
* @since 2.11.1
*/
public class NodeELWrapper extends ELWrapper {
private String nodeId;
private String tag;
public class NodeELWrapper extends CommonNodeELWrapper {
public NodeELWrapper(String nodeId) {
this.nodeId = nodeId;
this.setNodeWrapper(this);
}
private void setNodeWrapper(ELWrapper elWrapper){
this.addWrapper(elWrapper, 0);
}
private NodeELWrapper getNodeWrapper(){
return (NodeELWrapper) this.getFirstWrapper();
}
protected String getNodeId() {
return nodeId;
}
protected void setNodeId(String nodeId) {
this.nodeId = nodeId;
}
@Override
public NodeELWrapper tag(String tag) {
this.setTag(tag);
return this;
}
/**
* 单节点不允许定义 id，重载为protected修饰
*
* @param id 节点id
* @return {@link NodeELWrapper}
*/
@Override
public NodeELWrapper id(String id) {
this.setId(id);
return this;
}
@Override
public NodeELWrapper data(String dataName, Object object) {
setData("'" + JsonUtil.toJsonString(object) + "'");
setDataName(dataName);
return this;
}
@Override
public NodeELWrapper data(String dataName, String jsonString) {
setData("'" + jsonString + "'");
setDataName(dataName);
return this;
}
@Override
public NodeELWrapper data(String dataName, Map<String, Object> jsonMap) {
setData("'" + JsonUtil.toJsonString(jsonMap) + "'");
setDataName(dataName);
return this;
}
@Override
public NodeELWrapper maxWaitSeconds(Integer maxWaitSeconds){
setMaxWaitSeconds(maxWaitSeconds);
return this;
}
public NodeELWrapper retry(Integer count){
super.retry(count);
return this;
}
public NodeELWrapper retry(Integer count, String... exceptions){
super.retry(count, exceptions);
return this;
super(nodeId);
}
@Override
protected String toEL(Integer depth, StringBuilder paramContext) {
NodeELWrapper nodeElWrapper = this.getNodeWrapper();
NodeELWrapper nodeElWrapper = (NodeELWrapper) this.getFirstWrapper();
StringBuilder sb = new StringBuilder();
processWrapperTabs(sb, depth);
if (ELBus.isNodeWrapper()){
sb.append(StrUtil.format("node(\"{}\")", nodeElWrapper.getNodeId()));
}else{
sb.append(StrUtil.format("{}", nodeElWrapper.getNodeId()));
}
sb.append(StrUtil.format("node(\"{}\")", nodeElWrapper.getNodeId()));
processWrapperProperty(sb, paramContext);
return sb.toString();
}
/**
* Node的公共属性不包括id，对父类方法重载。
*
* @param elContext EL 上下文
* @param paramContext 参数上下文
*/
@Override
protected void processWrapperProperty(StringBuilder elContext, StringBuilder paramContext){
if(this.getTag() != null){
elContext.append(StrUtil.format(".tag(\"{}\")", this.getTag()));
}
if(this.getData() != null){
elContext.append(StrUtil.format(".data({})", this.getDataName()));
paramContext.append(StrUtil.format("{} = {}", this.getDataName(), this.getData())).append(";\n");
}
if(this.getMaxWaitSeconds() != null){
elContext.append(StrUtil.format(".maxWaitSeconds({})", String.valueOf(this.getMaxWaitSeconds())));
}
if (this.getRetry() != null){
elContext.append(StrUtil.format(".retry({})", this.getRetry().toString()));
}
}
}

40
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/CatchELBuilderTest.java
View File

@@ -25,51 +25,51 @@ public class CatchELBuilderTest extends BaseTest {
public void testCatch1(){
String expectedStr = "CATCH(THEN(node(\"a\"),node(\"b\"))).DO(node(\"c\"));";
Assertions.assertEquals(expectedStr,
ELBus.catchException(ELBus.then("a", "b")).doOpt("c").toEL());
ELBus.catchException(ELBus.then(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.then("a", "b")).doOpt("c").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.then(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).toEL()));
}
@Test
public void testCatch2(){
String expectedStr = "CATCH(\n\tTHEN(\n\t\tnode(\"a\"),\n\t\tnode(\"b\")\n\t)\n).DO(\n\tnode(\"c\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.catchException(ELBus.then("a", "b")).doOpt("c").toEL(true));
ELBus.catchException(ELBus.then(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.then("a", "b")).doOpt("c").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.then(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).toEL(true)));
}
// 属性设置测试
@Test
public void testCatch3(){
String expectedStr = "CATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(3);";
Assertions.assertEquals(expectedStr,
ELBus.catchException("a").doOpt(ELBus.then("b", "c")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL());
ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", "c")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL()));
}
@Test
public void testCatch4(){
String expectedStr = "CATCH(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(3);";
Assertions.assertEquals(expectedStr,
ELBus.catchException("a").doOpt(ELBus.then("b", "c")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true));
ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", "c")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true)));
}
// data 设置 jsonStr
@Test
public void testCatch5(){
String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(catchData)));";
Assertions.assertEquals(expectedStr,
ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL());
ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL()));
}
@Test
public void testCatch6(){
String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(catchData)\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL(true));
ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL(true)));
}
// data 设置 map
@Test
@@ -79,9 +79,9 @@ public class CatchELBuilderTest extends BaseTest {
name2Value.put("age", 18);
String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(catchData)));";
Assertions.assertEquals(expectedStr,
ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL());
ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL()));
}
@Test
public void testCatch8(){
@@ -90,9 +90,9 @@ public class CatchELBuilderTest extends BaseTest {
name2Value.put("age", 18);
String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(catchData)\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL(true));
ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL(true)));
}
private static class ParamClass{
private String name;
@@ -112,9 +112,9 @@ public class CatchELBuilderTest extends BaseTest {
name2Value.age = 18;
String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(catchData)));";
Assertions.assertEquals(expectedStr,
ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL());
ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL()));
}
@Test
public void testCatch10(){
@@ -123,8 +123,8 @@ public class CatchELBuilderTest extends BaseTest {
name2Value.age = 18;
String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(catchData)\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL(true));
ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL(true)));
}
}

28
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/ComplexELBuilderTest.java
View File

@@ -8,7 +8,6 @@ import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder;
import com.yomahub.liteflow.builder.el.ThenELWrapper;
import com.yomahub.liteflow.core.FlowExecutor;
import com.yomahub.liteflow.enums.NodeTypeEnum;
import com.yomahub.liteflow.flow.FlowBus;
import com.yomahub.liteflow.flow.LiteflowResponse;
import com.yomahub.liteflow.slot.DefaultContext;
import com.yomahub.liteflow.test.BaseTest;
@@ -22,7 +21,6 @@ import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.ComponentScan;
import javax.annotation.Resource;
import java.util.Date;
/**
* 复杂编排例子测试
@@ -61,17 +59,17 @@ public class ComplexELBuilderTest extends BaseTest {
ThenELWrapper complexEl1 = ELBus.then(
ELBus.node("A"),
ELBus.when(
ELBus.then("B", "C"),
ELBus.then(ELBus.node("D")).then("E").then("F"),
ELBus.then(ELBus.node("B"), ELBus.node("C")),
ELBus.then(ELBus.node("D")).then(ELBus.node("E")).then(ELBus.node("F")),
ELBus.then(
ELBus.switchOpt("G").to(
ELBus.then("H", ELBus.node("I"), ELBus.when("J").when("K")).id("t1"),
ELBus.then("L", "M").id("t2")
ELBus.switchOpt(ELBus.node("G")).to(
ELBus.then(ELBus.node("H"), ELBus.node("I"), ELBus.when(ELBus.node("J")).when(ELBus.node("K"))).id("t1"),
ELBus.then(ELBus.node("L"), ELBus.node("M")).id("t2")
),
"N"
ELBus.node("N")
)
),
"Z"
ELBus.node("Z")
);
String expectedStr = "THEN(node(\"A\"),WHEN(THEN(node(\"B\"),node(\"C\")),THEN(node(\"D\"),node(\"E\"),node(\"F\")),THEN(SWITCH(node(\"G\")).TO(THEN(node(\"H\"),node(\"I\"),WHEN(node(\"J\"),node(\"K\"))).id(\"t1\"),THEN(node(\"L\"),node(\"M\")).id(\"t2\")),node(\"N\"))),node(\"Z\"));";
Assertions.assertEquals(expectedStr,
@@ -110,18 +108,18 @@ public class ComplexELBuilderTest extends BaseTest {
ThenELWrapper complexEl2 = ELBus.then(
ELBus.node("A"),
ELBus.switchOpt(ELBus.node("B")).to(
ELBus.then("D","E").then(ELBus.node("F")).id("t1"),
ELBus.then(ELBus.node("D"),ELBus.node("E")).then(ELBus.node("F")).id("t1"),
ELBus.then(
ELBus.node("C"),
ELBus.when(
ELBus.then(
ELBus.switchOpt("G").to(
ELBus.then("H", "I").id("t2"),
"J"
ELBus.switchOpt(ELBus.node("G")).to(
ELBus.then(ELBus.node("H"), ELBus.node("I")).id("t2"),
ELBus.node("J")
),
"K"
ELBus.node("K")
),
ELBus.then("L", "M")
ELBus.then(ELBus.node("L"), ELBus.node("M"))
)
).id("t3")
),

144
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/IfELBuilderTest.java
View File

@@ -25,222 +25,222 @@ public class IfELBuilderTest extends BaseTest {
public void testIf1(){
String expectedStr = "IF(node(\"a\"),THEN(node(\"c\"),node(\"d\")),WHEN(node(\"e\"),node(\"f\")));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", ELBus.then("c", "d"), ELBus.when("e", "f")).toEL());
ELBus.ifOpt(ELBus.node("a"), ELBus.then(ELBus.node("c"), ELBus.node("d")), ELBus.when(ELBus.node("e"), ELBus.node("f"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", ELBus.then("c", "d"), ELBus.when("e", "f")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.then(ELBus.node("c"), ELBus.node("d")), ELBus.when(ELBus.node("e"), ELBus.node("f"))).toEL()));
}
// 格式化输出测试
@Test
public void testIf2(){
String expectedStr = "IF(\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t),\n\tWHEN(\n\t\tnode(\"e\"),\n\t\tnode(\"f\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.node("a"), ELBus.then("c", "d"), ELBus.when("e", "f")).toEL(true));
ELBus.ifOpt(ELBus.node("a"), ELBus.then(ELBus.node("c"), ELBus.node("d")), ELBus.when(ELBus.node("e"), ELBus.node("f"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.then("c", "d"), ELBus.when("e", "f")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.then(ELBus.node("c"), ELBus.node("d")), ELBus.when(ELBus.node("e"), ELBus.node("f"))).toEL(true)));
}
// If二元函数测试
@Test
public void testIf3(){
String expectedStr = "IF(node(\"a\"),THEN(node(\"b\"),node(\"c\"))).ELSE(WHEN(node(\"c\"),node(\"d\")));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.node("a"), ELBus.then("b", "c")).elseOpt(ELBus.when("c", "d")).toEL());
ELBus.ifOpt(ELBus.node("a"), ELBus.then(ELBus.node("b"), ELBus.node("c"))).elseOpt(ELBus.when(ELBus.node("c"), ELBus.node("d"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.then("b", "c")).elseOpt(ELBus.when("c", "d")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.then(ELBus.node("b"), ELBus.node("c"))).elseOpt(ELBus.when(ELBus.node("c"), ELBus.node("d"))).toEL()));
}
// 格式化输出测试
@Test
public void testIf4(){
String expectedStr = "IF(\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).ELSE(\n\tWHEN(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", ELBus.then("b", "c")).elseOpt(ELBus.when("c", "d")).toEL(true));
ELBus.ifOpt(ELBus.node("a"), ELBus.then(ELBus.node("b"), ELBus.node("c"))).elseOpt(ELBus.when(ELBus.node("c"), ELBus.node("d"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", ELBus.then("b", "c")).elseOpt(ELBus.when("c", "d")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.then(ELBus.node("b"), ELBus.node("c"))).elseOpt(ELBus.when(ELBus.node("c"), ELBus.node("d"))).toEL(true)));
}
// ELIF调用测试
@Test
public void testIf5(){
String expectedStr = "IF(node(\"a\"),node(\"b\")).ELIF(node(\"f1\"),node(\"c\")).ELIF(node(\"f2\"),node(\"d\")).ELSE(node(\"e\"));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b").elIfOpt("f1", "c").elIfOpt("f2","d").elseOpt("e").toEL());
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b")).elIfOpt(ELBus.node("f1"), ELBus.node("c")).elIfOpt(ELBus.node("f2"),ELBus.node("d")).elseOpt(ELBus.node("e")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b").elIfOpt("f1", "c").elIfOpt("f2","d").elseOpt("e").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b")).elIfOpt(ELBus.node("f1"), ELBus.node("c")).elIfOpt(ELBus.node("f2"),ELBus.node("d")).elseOpt(ELBus.node("e")).toEL()));
}
// 格式化输出测试
@Test
public void testIf6(){
String expectedStr = "IF(\n\tnode(\"a\"),\n\tnode(\"b\")\n).ELIF(\n\tnode(\"f1\"),\n\tnode(\"c\")\n).ELIF(\n\tnode(\"f2\"),\n\tnode(\"d\")\n).ELSE(\n\tnode(\"e\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b").elIfOpt("f1", "c").elIfOpt("f2","d").elseOpt("e").toEL(true));
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b")).elIfOpt(ELBus.node("f1"), ELBus.node("c")).elIfOpt(ELBus.node("f2"),ELBus.node("d")).elseOpt(ELBus.node("e")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b").elIfOpt("f1", "c").elIfOpt("f2","d").elseOpt("e").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b")).elIfOpt(ELBus.node("f1"), ELBus.node("c")).elIfOpt(ELBus.node("f2"),ELBus.node("d")).elseOpt(ELBus.node("e")).toEL(true)));
}
// IF嵌套调用测试
@Test
public void testIf7(){
String expectedStr = "IF(node(\"a\"),node(\"b\"),IF(node(\"c\"),node(\"d\")).ELSE(node(\"e\")));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b", ELBus.ifOpt("c", "d").elseOpt("e")).toEL());
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.ifOpt(ELBus.node("c"), ELBus.node("d")).elseOpt(ELBus.node("e"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.ifOpt("c", "d").elseOpt("e")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.ifOpt(ELBus.node("c"), ELBus.node("d")).elseOpt(ELBus.node("e"))).toEL()));
}
// 格式化输出测试
@Test
public void testIf8(){
String expectedStr = "IF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tIF(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t).ELSE(\n\t\tnode(\"e\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b", ELBus.ifOpt("c", "d").elseOpt("e")).toEL(true));
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.ifOpt(ELBus.node("c"), ELBus.node("d")).elseOpt(ELBus.node("e"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.ifOpt("c", "d").elseOpt("e")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.ifOpt(ELBus.node("c"), ELBus.node("d")).elseOpt(ELBus.node("e"))).toEL(true)));
}
// IF嵌套调用测试
@Test
public void testIf9(){
String expectedStr = "IF(node(\"a\"),node(\"b\")).ELSE(IF(node(\"c\"),node(\"d\"),node(\"e\")));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b").elseOpt(ELBus.ifOpt("c", "d", "e")).toEL());
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b")).elseOpt(ELBus.ifOpt(ELBus.node("c"), ELBus.node("d"), ELBus.node("e"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b").elseOpt(ELBus.ifOpt("c", "d", "e")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b")).elseOpt(ELBus.ifOpt(ELBus.node("c"), ELBus.node("d"), ELBus.node("e"))).toEL()));
}
// 格式化输出测试
@Test
public void testIf10(){
String expectedStr = "IF(\n\tnode(\"a\"),\n\tnode(\"b\")\n).ELSE(\n\tIF(\n\t\tnode(\"c\"),\n\t\tnode(\"d\"),\n\t\tnode(\"e\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b").elseOpt(ELBus.ifOpt("c", "d", "e")).toEL(true));
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b")).elseOpt(ELBus.ifOpt(ELBus.node("c"), ELBus.node("d"), ELBus.node("e"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b").elseOpt(ELBus.ifOpt("c", "d", "e")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b")).elseOpt(ELBus.ifOpt(ELBus.node("c"), ELBus.node("d"), ELBus.node("e"))).toEL(true)));
}
// 与表达式输出测试
@Test
public void testIf11(){
String expectedStr = "IF(AND(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\"),node(\"e\"));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.and("a", "b", "c"), "d", "e").toEL());
ELBus.ifOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d"), ELBus.node("e")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and("a", "b", "c"), "d", "e").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d"), ELBus.node("e")).toEL()));
expectedStr = "IF(AND(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\")).ELSE(node(\"e\"));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elseOpt("e").toEL());
ELBus.ifOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elseOpt(ELBus.node("e")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elseOpt("e").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elseOpt(ELBus.node("e")).toEL()));
expectedStr = "IF(AND(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\")).ELIF(AND(node(\"f1\"),node(\"f2\")),node(\"e\"));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elIfOpt(ELBus.and("f1", "f2"), "e").toEL());
ELBus.ifOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elIfOpt(ELBus.and(ELBus.node("f1"), ELBus.node("f2")), ELBus.node("e")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elIfOpt(ELBus.and("f1", "f2"), "e").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elIfOpt(ELBus.and(ELBus.node("f1"), ELBus.node("f2")), ELBus.node("e")).toEL()));
}
// 格式化输出测试
@Test
public void testIf12(){
String expectedStr = "IF(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tnode(\"e\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.and("a", "b", "c"), "d", "e").toEL(true));
ELBus.ifOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d"), ELBus.node("e")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and("a", "b", "c"), "d", "e").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d"), ELBus.node("e")).toEL(true)));
expectedStr = "IF(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n).ELSE(\n\tnode(\"e\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elseOpt("e").toEL(true));
ELBus.ifOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elseOpt(ELBus.node("e")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elseOpt("e").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elseOpt(ELBus.node("e")).toEL(true)));
expectedStr = "IF(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n).ELIF(\n\tAND(\n\t\tnode(\"f1\"),\n\t\tnode(\"f2\")\n\t),\n\tnode(\"e\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elIfOpt(ELBus.and("f1", "f2"), "e").toEL(true));
ELBus.ifOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elIfOpt(ELBus.and(ELBus.node("f1"), ELBus.node("f2")), ELBus.node("e")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elIfOpt(ELBus.and("f1", "f2"), "e").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elIfOpt(ELBus.and(ELBus.node("f1"), ELBus.node("f2")), ELBus.node("e")).toEL(true)));
}
// 或表达式测试
@Test
public void testIf13(){
String expectedStr = "IF(OR(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\"),node(\"e\"));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.or("a", "b", "c"), "d", "e").toEL());
ELBus.ifOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d"), ELBus.node("e")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or("a", "b", "c"), "d", "e").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d"), ELBus.node("e")).toEL()));
expectedStr = "IF(OR(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\")).ELSE(node(\"e\"));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elseOpt("e").toEL());
ELBus.ifOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elseOpt(ELBus.node("e")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elseOpt("e").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elseOpt(ELBus.node("e")).toEL()));
expectedStr = "IF(OR(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\")).ELIF(OR(node(\"f1\"),node(\"f2\")),node(\"e\"));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elIfOpt(ELBus.or("f1", "f2"), "e").toEL());
ELBus.ifOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elIfOpt(ELBus.or(ELBus.node("f1"), ELBus.node("f2")), ELBus.node("e")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elIfOpt(ELBus.or("f1", "f2"), "e").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elIfOpt(ELBus.or(ELBus.node("f1"), ELBus.node("f2")), ELBus.node("e")).toEL()));
}
// 格式化输出测试
@Test
public void testIf14(){
String expectedStr = "IF(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tnode(\"e\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.or("a", "b", "c"), "d", "e").toEL(true));
ELBus.ifOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d"), ELBus.node("e")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or("a", "b", "c"), "d", "e").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d"), ELBus.node("e")).toEL(true)));
expectedStr = "IF(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n).ELSE(\n\tnode(\"e\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elseOpt("e").toEL(true));
ELBus.ifOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elseOpt(ELBus.node("e")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elseOpt("e").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elseOpt(ELBus.node("e")).toEL(true)));
expectedStr = "IF(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n).ELIF(\n\tOR(\n\t\tnode(\"f1\"),\n\t\tnode(\"f2\")\n\t),\n\tnode(\"e\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elIfOpt(ELBus.or("f1", "f2"), "e").toEL(true));
ELBus.ifOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elIfOpt(ELBus.or(ELBus.node("f1"), ELBus.node("f2")), ELBus.node("e")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elIfOpt(ELBus.or("f1", "f2"), "e").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")), ELBus.node("d")).elIfOpt(ELBus.or(ELBus.node("f1"), ELBus.node("f2")), ELBus.node("e")).toEL(true)));
}
// 非表达式测试
@Test
public void testIf15(){
String expectedStr = "IF(NOT(node(\"a\")),node(\"b\"),node(\"c\"));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.not("a"), "b", "c").toEL());
ELBus.ifOpt(ELBus.not(ELBus.node("a")), ELBus.node("b"), ELBus.node("c")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not("a"), "b", "c").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not(ELBus.node("a")), ELBus.node("b"), ELBus.node("c")).toEL()));
expectedStr = "IF(NOT(node(\"a\")),node(\"b\")).ELSE(node(\"c\"));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.not("a"), "b").elseOpt("c").toEL());
ELBus.ifOpt(ELBus.not(ELBus.node("a")), ELBus.node("b")).elseOpt(ELBus.node("c")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not("a"), "b").elseOpt("c").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not(ELBus.node("a")), ELBus.node("b")).elseOpt(ELBus.node("c")).toEL()));
expectedStr = "IF(NOT(node(\"a\")),node(\"b\")).ELIF(NOT(node(\"f\")),node(\"c\"));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.not("a"), "b").elIfOpt(ELBus.not("f"), "c").toEL());
ELBus.ifOpt(ELBus.not(ELBus.node("a")), ELBus.node("b")).elIfOpt(ELBus.not(ELBus.node("f")), ELBus.node("c")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not("a"), "b").elIfOpt(ELBus.not("f"), "c").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not(ELBus.node("a")), ELBus.node("b")).elIfOpt(ELBus.not(ELBus.node("f")), ELBus.node("c")).toEL()));
}
// 格式化输出测试
@Test
public void testIf16(){
String expectedStr = "IF(\n\tNOT(\n\t\tnode(\"a\")\n\t),\n\tnode(\"b\"),\n\tnode(\"c\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.not("a"), "b", "c").toEL(true));
ELBus.ifOpt(ELBus.not(ELBus.node("a")), ELBus.node("b"), ELBus.node("c")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not("a"), "b", "c").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not(ELBus.node("a")), ELBus.node("b"), ELBus.node("c")).toEL(true)));
expectedStr = "IF(\n\tNOT(\n\t\tnode(\"a\")\n\t),\n\tnode(\"b\")\n).ELSE(\n\tnode(\"c\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.not("a"), "b").elseOpt("c").toEL(true));
ELBus.ifOpt(ELBus.not(ELBus.node("a")), ELBus.node("b")).elseOpt(ELBus.node("c")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not("a"), "b").elseOpt("c").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not(ELBus.node("a")), ELBus.node("b")).elseOpt(ELBus.node("c")).toEL(true)));
expectedStr = "IF(\n\tNOT(\n\t\tnode(\"a\")\n\t),\n\tnode(\"b\")\n).ELIF(\n\tNOT(\n\t\tnode(\"f\")\n\t),\n\tnode(\"c\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt(ELBus.not("a"), "b").elIfOpt(ELBus.not("f"), "c").toEL(true));
ELBus.ifOpt(ELBus.not(ELBus.node("a")), ELBus.node("b")).elIfOpt(ELBus.not(ELBus.node("f")), ELBus.node("c")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not("a"), "b").elIfOpt(ELBus.not("f"), "c").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not(ELBus.node("a")), ELBus.node("b")).elIfOpt(ELBus.not(ELBus.node("f")), ELBus.node("c")).toEL(true)));
}
// 属性测试
@Test
public void testIf17(){
String expectedStr = "IF(node(\"a\"),node(\"b\"),node(\"c\")).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(6);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b", "c").id("this is a id").tag("this is a tag").maxWaitSeconds(6).toEL());
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")).id("this is a id").tag("this is a tag").maxWaitSeconds(6).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", "c").id("this is a id").tag("this is a tag").maxWaitSeconds(6).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")).id("this is a id").tag("this is a tag").maxWaitSeconds(6).toEL()));
}
// 格式化输出
@Test
public void testIf18(){
String expectedStr = "IF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\")\n).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(6);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b", "c").id("this is a id").tag("this is a tag").maxWaitSeconds(6).toEL(true));
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")).id("this is a id").tag("this is a tag").maxWaitSeconds(6).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", "c").id("this is a id").tag("this is a tag").maxWaitSeconds(6).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")).id("this is a id").tag("this is a tag").maxWaitSeconds(6).toEL(true)));
}
// data map 测试
@Test
@@ -250,9 +250,9 @@ public class IfELBuilderTest extends BaseTest {
name2Value.put("age", 18);
String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(node(\"a\"),node(\"b\"),node(\"c\").data(ifData));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL());
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", name2Value)).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", name2Value)).toEL()));
}
// 格式化输出
@Test
@@ -262,27 +262,27 @@ public class IfELBuilderTest extends BaseTest {
name2Value.put("age", 18);
String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\").data(ifData)\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL(true));
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", name2Value)).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", name2Value)).toEL(true)));
}
// data JsonStr 测试
@Test
public void testIf21(){
String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(node(\"a\"),node(\"b\"),node(\"c\").data(ifData));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", "{\"name\":\"zhangsan\",\"age\":18}")).toEL());
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", "{\"name\":\"zhangsan\",\"age\":18}")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", "{\"name\":\"zhangsan\",\"age\":18}")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", "{\"name\":\"zhangsan\",\"age\":18}")).toEL()));
}
// 格式化输出
@Test
public void testIf22(){
String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\").data(ifData)\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", "{\"name\":\"zhangsan\",\"age\":18}")).toEL(true));
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", "{\"name\":\"zhangsan\",\"age\":18}")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", "{\"name\":\"zhangsan\",\"age\":18}")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", "{\"name\":\"zhangsan\",\"age\":18}")).toEL(true)));
}
private static class ParamClass{
private String name;
@@ -302,9 +302,9 @@ public class IfELBuilderTest extends BaseTest {
name2Value.age = 18;
String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(node(\"a\"),node(\"b\"),node(\"c\").data(ifData));";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL());
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", name2Value)).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", name2Value)).toEL()));
}
// 格式化输出
@Test
@@ -314,9 +314,9 @@ public class IfELBuilderTest extends BaseTest {
name2Value.age = 18;
String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\").data(ifData)\n);";
Assertions.assertEquals(expectedStr,
ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL(true));
ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", name2Value)).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", name2Value)).toEL(true)));
}
}

70
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/LogicELBuilderTest.java
View File

@@ -24,68 +24,68 @@ public class LogicELBuilderTest extends BaseTest {
public void testlogic1(){
String expectedStr = "AND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\")));";
Assertions.assertEquals(expectedStr,
ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d")).toEL());
ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d"))).toEL()));
}
@Test
public void testlogic2(){
String expectedStr = "AND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d")).toEL(true));
ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d"))).toEL(true)));
}
@Test
public void testlogic3(){
String expectedStr = "AND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\")));";
Assertions.assertEquals(expectedStr,
ELBus.and("a").and(ELBus.or("b").or("c")).and(ELBus.not("d")).toEL());
ELBus.and(ELBus.node("a")).and(ELBus.or(ELBus.node("b")).or(ELBus.node("c"))).and(ELBus.not(ELBus.node("d"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a").and(ELBus.or("b").or("c")).and(ELBus.not("d")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and(ELBus.node("a")).and(ELBus.or(ELBus.node("b")).or(ELBus.node("c"))).and(ELBus.not(ELBus.node("d"))).toEL()));
}
@Test
public void testlogic4(){
String expectedStr = "AND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.and("a").and(ELBus.or("b").or("c")).and(ELBus.not("d")).toEL(true));
ELBus.and(ELBus.node("a")).and(ELBus.or(ELBus.node("b")).or(ELBus.node("c"))).and(ELBus.not(ELBus.node("d"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a").and(ELBus.or("b").or("c")).and(ELBus.not("d")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and(ELBus.node("a")).and(ELBus.or(ELBus.node("b")).or(ELBus.node("c"))).and(ELBus.not(ELBus.node("d"))).toEL(true)));
}
// 属性设置
@Test
public void testlogic5(){
String expectedStr = "AND(node(\"a\"),OR(node(\"b\"),node(\"c\")).id(\"this is a id\"),NOT(node(\"d\")).tag(\"this is a tag\"));";
Assertions.assertEquals(expectedStr,
ELBus.and("a", ELBus.or("b", "c").id("this is a id"), ELBus.not("d").tag("this is a tag")).toEL());
ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")).id("this is a id"), ELBus.not(ELBus.node("d")).tag("this is a tag")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c").id("this is a id"), ELBus.not("d").tag("this is a tag")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")).id("this is a id"), ELBus.not(ELBus.node("d")).tag("this is a tag")).toEL()));
}
@Test
public void testlogic6(){
String expectedStr = "AND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tNOT(\n\t\tnode(\"d\")\n\t).tag(\"this is a tag\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.and("a", ELBus.or("b", "c").id("this is a id"), ELBus.not("d").tag("this is a tag")).toEL(true));
ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")).id("this is a id"), ELBus.not(ELBus.node("d")).tag("this is a tag")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c").id("this is a id"), ELBus.not("d").tag("this is a tag")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")).id("this is a id"), ELBus.not(ELBus.node("d")).tag("this is a tag")).toEL(true)));
}
@Test
public void testlogic7(){
String expectedStr = "andData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\").data(andData)));";
Assertions.assertEquals(expectedStr,
ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("andData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL());
ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("andData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("andData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("andData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL()));
}
@Test
public void testlogic8(){
String expectedStr = "andData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\").data(andData)\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("andData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL(true));
ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("andData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("andData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("andData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL(true)));
}
@Test
public void testlogic9(){
@@ -94,9 +94,9 @@ public class LogicELBuilderTest extends BaseTest {
name2Value.put("age", 18);
String expectedStr = "orData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\").data(orData)));";
Assertions.assertEquals(expectedStr,
ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL());
ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL()));
}
@Test
public void testlogic10(){
@@ -105,9 +105,9 @@ public class LogicELBuilderTest extends BaseTest {
name2Value.put("age", 18);
String expectedStr = "orData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\").data(orData)\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL(true));
ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL(true)));
}
private static class ParamClass{
private String name;
@@ -126,9 +126,9 @@ public class LogicELBuilderTest extends BaseTest {
name2Value.age = 18;
String expectedStr = "notData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\").data(notData)));";
Assertions.assertEquals(expectedStr,
ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL());
ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL()));
}
@Test
public void testlogic12(){
@@ -137,9 +137,9 @@ public class LogicELBuilderTest extends BaseTest {
name2Value.age = 18;
String expectedStr = "notData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\").data(notData)\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL(true));
ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL(true)));
}
// NOT调用方法补充测试
@Test
@@ -151,14 +151,14 @@ public class LogicELBuilderTest extends BaseTest {
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.node("a")).toEL()));
expectedStr = "NOT(AND(node(\"a\"),node(\"b\"),node(\"c\")));";
Assertions.assertEquals(expectedStr,
ELBus.not(ELBus.and("a", "b", "c")).toEL());
ELBus.not(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.and("a", "b", "c")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c"))).toEL()));
expectedStr = "NOT(OR(node(\"a\"),node(\"b\"),node(\"c\")));";
Assertions.assertEquals(expectedStr,
ELBus.not(ELBus.or("a", "b", "c")).toEL());
ELBus.not(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.or("a", "b", "c")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c"))).toEL()));
expectedStr = "NOT(NOT(node(\"a\")));";
Assertions.assertEquals(expectedStr,
ELBus.not(ELBus.not(ELBus.node("a"))).toEL());
@@ -174,14 +174,14 @@ public class LogicELBuilderTest extends BaseTest {
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.node("a")).toEL(true)));
expectedStr = "NOT(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.not(ELBus.and("a", "b", "c")).toEL(true));
ELBus.not(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.and("a", "b", "c")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.and(ELBus.node("a"), ELBus.node("b"), ELBus.node("c"))).toEL(true)));
expectedStr = "NOT(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.not(ELBus.or("a", "b", "c")).toEL(true));
ELBus.not(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.or("a", "b", "c")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.or(ELBus.node("a"), ELBus.node("b"), ELBus.node("c"))).toEL(true)));
expectedStr = "NOT(\n\tNOT(\n\t\tnode(\"a\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.not(ELBus.not(ELBus.node("a"))).toEL(true));
@@ -191,11 +191,11 @@ public class LogicELBuilderTest extends BaseTest {
@Test
public void testLogic(){
AndELWrapper andEl = ELBus.and("a", "b").id("this is a id").tag("this is a tag");
AndELWrapper andEl = ELBus.and(ELBus.node("a"), ELBus.node("b")).id("this is a id").tag("this is a tag");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(andEl.toEL()));
OrELWrapper orEl = ELBus.or("a", "b");
OrELWrapper orEl = ELBus.or(ELBus.node("a"), ELBus.node("b"));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(orEl.toEL()));
NotELWrapper notEl = ELBus.not("a");
NotELWrapper notEl = ELBus.not(ELBus.node("a"));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(notEl.toEL()));
}
}

148
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/LoopELBuilderTest.java
View File

@@ -25,187 +25,187 @@ public class LoopELBuilderTest extends BaseTest {
public void testLoop1(){
String expectedStr = "FOR(3).DO(THEN(node(\"a\"),node(\"b\"),node(\"c\"))).BREAK(node(\"d\"));";
Assertions.assertEquals(expectedStr,
ELBus.forOpt(3).doOpt(ELBus.then("a", "b", "c")).breakOpt("d").toEL());
ELBus.forOpt(3).doOpt(ELBus.then(ELBus.node("a"), ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("d")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(3).doOpt(ELBus.then("a", "b", "c")).breakOpt("d").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(3).doOpt(ELBus.then(ELBus.node("a"), ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("d")).toEL()));
}
// 格式化输出
@Test
public void testLoop2(){
String expectedStr = "FOR(3).DO(\n\tTHEN(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).BREAK(\n\tnode(\"d\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.forOpt(3).doOpt(ELBus.then("a", "b", "c")).breakOpt("d").toEL(true));
ELBus.forOpt(3).doOpt(ELBus.then(ELBus.node("a"), ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("d")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(3).doOpt(ELBus.then("a", "b", "c")).breakOpt("d").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(3).doOpt(ELBus.then(ELBus.node("a"), ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("d")).toEL(true)));
}
// for 单节点循环测试
@Test
public void testLoop3(){
String expectedStr = "FOR(node(\"a\")).DO(WHEN(node(\"b\"),node(\"c\"),node(\"d\"))).BREAK(AND(node(\"e\"),node(\"f\")));";
Assertions.assertEquals(expectedStr,
ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.and("e", "f")).toEL());
ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("d"))).breakOpt(ELBus.and(ELBus.node("e"), ELBus.node("f"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.and("e", "f")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("d"))).breakOpt(ELBus.and(ELBus.node("e"), ELBus.node("f"))).toEL()));
}
@Test
public void testLoop4(){
String expectedStr = "FOR(\n\tnode(\"a\")\n).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t)\n).BREAK(\n\tAND(\n\t\tnode(\"e\"),\n\t\tnode(\"f\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.and("e", "f")).toEL(true));
ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("d"))).breakOpt(ELBus.and(ELBus.node("e"), ELBus.node("f"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.and("e", "f")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("d"))).breakOpt(ELBus.and(ELBus.node("e"), ELBus.node("f"))).toEL(true)));
}
// parallel语句测试
@Test
public void testLoop5(){
String expectedStr = "FOR(node(\"a\")).parallel(true).DO(WHEN(node(\"b\"),node(\"c\"),node(\"d\"))).BREAK(node(\"e\"));";
Assertions.assertEquals(expectedStr,
ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt("e").parallel(true).toEL());
ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("d"))).breakOpt(ELBus.node("e")).parallel(true).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt("e").parallel(true).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("d"))).breakOpt(ELBus.node("e")).parallel(true).toEL()));
}
@Test
public void testLoop6(){
String expectedStr = "FOR(\n\tnode(\"a\")\n).parallel(true).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t)\n).BREAK(\n\tnode(\"e\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt("e").parallel(true).toEL(true));
ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("d"))).breakOpt(ELBus.node("e")).parallel(true).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt("e").parallel(true).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("d"))).breakOpt(ELBus.node("e")).parallel(true).toEL(true)));
}
// 属性测试
@Test
public void testLoop7(){
String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\nFOR(node(\"a\")).DO(WHEN(node(\"b\"),node(\"c\"),node(\"d\"))).BREAK(node(\"e\").data(forData)).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(3);";
Assertions.assertEquals(expectedStr,
ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.node("e").data("forData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL());
ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("d"))).breakOpt(ELBus.node("e").data("forData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.node("e").data("forData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("d"))).breakOpt(ELBus.node("e").data("forData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL()));
}
@Test
public void testLoop8(){
String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\nFOR(\n\tnode(\"a\")\n).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t)\n).BREAK(\n\tnode(\"e\").data(forData)\n).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(3);";
Assertions.assertEquals(expectedStr,
ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.node("e").data("forData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true));
ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("d"))).breakOpt(ELBus.node("e").data("forData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.node("e").data("forData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("d"))).breakOpt(ELBus.node("e").data("forData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true)));
}
// while调用测试
@Test
public void testLoop9(){
String expectedStr = "WHILE(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).BREAK(node(\"f\"));";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt("f").toEL());
ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("f")).toEL());
Assertions.assertEquals(expectedStr,
ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then("b", "c")).breakOpt("f").toEL());
ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("f")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt("f").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("f")).toEL()));
expectedStr = "WHILE(AND(node(\"a\"),node(\"b\"))).DO(node(\"c\")).BREAK(node(\"d\"));";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt(ELBus.and("a", "b")).doOpt("c").breakOpt("d").toEL());
ELBus.whileOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).breakOpt(ELBus.node("d")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.and("a", "b")).doOpt("c").breakOpt("d").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).breakOpt(ELBus.node("d")).toEL()));
expectedStr = "WHILE(OR(node(\"a\"),node(\"b\"))).DO(node(\"c\")).BREAK(node(\"d\"));";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt(ELBus.or("a", "b")).doOpt("c").breakOpt("d").toEL());
ELBus.whileOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).breakOpt(ELBus.node("d")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.or("a", "b")).doOpt("c").breakOpt("d").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).breakOpt(ELBus.node("d")).toEL()));
expectedStr = "WHILE(NOT(node(\"a\"))).DO(node(\"c\")).BREAK(node(\"d\"));";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt(ELBus.not("a")).doOpt("c").breakOpt("d").toEL());
ELBus.whileOpt(ELBus.not(ELBus.node("a"))).doOpt(ELBus.node("c")).breakOpt(ELBus.node("d")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.not("a")).doOpt("c").breakOpt("d").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.not(ELBus.node("a"))).doOpt(ELBus.node("c")).breakOpt(ELBus.node("d")).toEL()));
}
@Test
public void testLoop10(){
String expectedStr = "WHILE(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).BREAK(\n\tnode(\"f\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt("f").toEL(true));
ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("f")).toEL(true));
Assertions.assertEquals(expectedStr,
ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then("b", "c")).breakOpt("f").toEL(true));
ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("f")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt("f").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("f")).toEL(true)));
expectedStr = "WHILE(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\")\n\t)\n).DO(\n\tnode(\"c\")\n).BREAK(\n\tnode(\"d\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt(ELBus.and("a", "b")).doOpt("c").breakOpt("d").toEL(true));
ELBus.whileOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).breakOpt(ELBus.node("d")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.and("a", "b")).doOpt("c").breakOpt("d").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.and(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).breakOpt(ELBus.node("d")).toEL(true)));
expectedStr = "WHILE(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\")\n\t)\n).DO(\n\tnode(\"c\")\n).BREAK(\n\tnode(\"d\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt(ELBus.or("a", "b")).doOpt("c").breakOpt("d").toEL(true));
ELBus.whileOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).breakOpt(ELBus.node("d")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.or("a", "b")).doOpt("c").breakOpt("d").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.or(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).breakOpt(ELBus.node("d")).toEL(true)));
expectedStr = "WHILE(\n\tNOT(\n\t\tnode(\"a\")\n\t)\n).DO(\n\tnode(\"c\")\n).BREAK(\n\tnode(\"d\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt(ELBus.not("a")).doOpt("c").breakOpt("d").toEL(true));
ELBus.whileOpt(ELBus.not(ELBus.node("a"))).doOpt(ELBus.node("c")).breakOpt(ELBus.node("d")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.not("a")).doOpt("c").breakOpt("d").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.not(ELBus.node("a"))).doOpt(ELBus.node("c")).breakOpt(ELBus.node("d")).toEL(true)));
}
// while属性调用测试
@Test
public void testLoop11(){
String expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHILE(node(\"a\")).parallel(true).DO(THEN(node(\"b\"),node(\"c\"))).BREAK(node(\"d\").data(whileData)).id(\"this is a ig\").tag(\"this is a tag\").maxWaitSeconds(3);";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt(ELBus.node("d").data("whileData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL());
ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("d").data("whileData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt(ELBus.node("d").data("whileData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("d").data("whileData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL()));
}
@Test
public void testLoop12(){
String expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHILE(\n\tnode(\"a\")\n).parallel(true).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).BREAK(\n\tnode(\"d\").data(whileData)\n).id(\"this is a ig\").tag(\"this is a tag\").maxWaitSeconds(3);";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt(ELBus.node("d").data("whileData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL(true));
ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("d").data("whileData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt(ELBus.node("d").data("whileData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).breakOpt(ELBus.node("d").data("whileData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL(true)));
}
// Iterator 调用测试
@Test
public void testLoop13(){
String expectedStr = "ITERATOR(node(\"a\")).DO(WHEN(node(\"b\"),node(\"c\")));";
Assertions.assertEquals(expectedStr,
ELBus.iteratorOpt("a").doOpt(ELBus.when("b", "c")).toEL());
ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.when("b", "c")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"))).toEL()));
expectedStr = "ITERATOR(node(\"a\")).DO(WHEN(node(\"b\"),node(\"c\")));";
Assertions.assertEquals(expectedStr,
ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c")).toEL());
ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"))).toEL()));
}
@Test
public void testLoop14(){
String expectedStr = "ITERATOR(\n\tnode(\"a\")\n).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.iteratorOpt("a").doOpt(ELBus.when("b", "c")).toEL(true));
ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.when("b", "c")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"))).toEL(true)));
expectedStr = "ITERATOR(\n\tnode(\"a\")\n).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c")).toEL(true));
ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"))).toEL(true)));
}
// iterator 属性测试
@Test
public void testLoop15(){
String expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\nITERATOR(node(\"a\")).parallel(true).DO(THEN(node(\"b\"),node(\"c\").data(iteratorData))).id(\"this is a ig\").tag(\"this is a tag\").maxWaitSeconds(3);";
Assertions.assertEquals(expectedStr,
ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", "{\"name\":\"zhangsan\",\"age\":18}"))).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL());
ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", "{\"name\":\"zhangsan\",\"age\":18}"))).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", "{\"name\":\"zhangsan\",\"age\":18}"))).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", "{\"name\":\"zhangsan\",\"age\":18}"))).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL()));
}
@Test
public void testLoop16(){
String expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\nITERATOR(\n\tnode(\"a\")\n).parallel(true).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(iteratorData)\n\t)\n).id(\"this is a ig\").tag(\"this is a tag\").maxWaitSeconds(3);";
Assertions.assertEquals(expectedStr,
ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", "{\"name\":\"zhangsan\",\"age\":18}"))).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL(true));
ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", "{\"name\":\"zhangsan\",\"age\":18}"))).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", "{\"name\":\"zhangsan\",\"age\":18}"))).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", "{\"name\":\"zhangsan\",\"age\":18}"))).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL(true)));
}
// data Map 参数 测试
@Test
@@ -216,21 +216,21 @@ public class LoopELBuilderTest extends BaseTest {
String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"FOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(forData)));";
Assertions.assertEquals(expectedStr,
ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL());
ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL()));
expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"WHILE(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(whileData)));";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL());
ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL()));
expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"ITERATOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(iteratorData)));";
Assertions.assertEquals(expectedStr,
ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL());
ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", name2Value))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", name2Value))).toEL()));
}
@Test
@@ -241,21 +241,21 @@ public class LoopELBuilderTest extends BaseTest {
String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"FOR(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(forData)\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL(true));
ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL(true)));
expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"WHILE(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whileData)\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL(true));
ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL(true)));
expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"ITERATOR(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(iteratorData)\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL(true));
ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", name2Value))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", name2Value))).toEL(true)));
}
private static class ParamClass{
private String name;
@@ -276,21 +276,21 @@ public class LoopELBuilderTest extends BaseTest {
String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"FOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(forData)));";
Assertions.assertEquals(expectedStr,
ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL());
ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL()));
expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"WHILE(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(whileData)));";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL());
ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL()));
expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"ITERATOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(iteratorData)));";
Assertions.assertEquals(expectedStr,
ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL());
ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", name2Value))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", name2Value))).toEL()));
}
@Test
@@ -301,21 +301,21 @@ public class LoopELBuilderTest extends BaseTest {
String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"FOR(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(forData)\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL(true));
ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL(true)));
expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"WHILE(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whileData)\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL(true));
ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL(true)));
expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"ITERATOR(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(iteratorData)\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL(true));
ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", name2Value))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", name2Value))).toEL(true)));
}
}

16
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/MaxWaitSecondBuilderTest.java
View File

@@ -2,9 +2,7 @@ package com.yomahub.liteflow.test.builder;
import com.yomahub.liteflow.builder.el.*;
import com.yomahub.liteflow.test.BaseTest;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
@@ -13,17 +11,11 @@ import org.springframework.boot.test.context.SpringBootTest;
@EnableAutoConfiguration
public class MaxWaitSecondBuilderTest extends BaseTest {
@BeforeAll
public static void init(){
ELBus.setNodeWrapper(false);
}
// node层面
@Test
public void testMaxWaitSecond1(){
NodeELWrapper nodeA = ELBus.node("a").maxWaitSeconds(4);
NodeELWrapper nodeB = ELBus.node("b").maxWaitSeconds(4);
CommonNodeELWrapper nodeA = ELBus.commonNode("a").maxWaitSeconds(4);
CommonNodeELWrapper nodeB = ELBus.commonNode("b").maxWaitSeconds(4);
WhenELWrapper whenELWrapper = ELBus.when(nodeA, nodeB);
Assertions.assertEquals("WHEN(a.maxWaitSeconds(4),b.maxWaitSeconds(4));", whenELWrapper.toEL());
}
@@ -71,8 +63,4 @@ public class MaxWaitSecondBuilderTest extends BaseTest {
Assertions.assertEquals("ITERATOR(i).DO(a).maxWaitSeconds(5);", iteratorELWrapper.toEL());
}
@AfterAll
public static void after(){
ELBus.setNodeWrapper(true);
}
}

15
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/NodeELBuilderTest.java
View File

@@ -2,9 +2,9 @@ package com.yomahub.liteflow.test.builder;
import cn.hutool.core.date.DateUtil;
import com.yomahub.liteflow.builder.LiteFlowNodeBuilder;
import com.yomahub.liteflow.builder.el.CommonNodeELWrapper;
import com.yomahub.liteflow.builder.el.ELBus;
import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder;
import com.yomahub.liteflow.builder.el.NodeELWrapper;
import com.yomahub.liteflow.builder.el.ThenELWrapper;
import com.yomahub.liteflow.core.FlowExecutor;
import com.yomahub.liteflow.enums.NodeTypeEnum;
@@ -14,7 +14,6 @@ import com.yomahub.liteflow.test.BaseTest;
import com.yomahub.liteflow.test.builder.cmp.ACmp;
import com.yomahub.liteflow.test.builder.cmp.BCmp;
import com.yomahub.liteflow.test.builder.vo.User;
import com.yomahub.liteflow.util.JsonUtil;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
@@ -41,7 +40,7 @@ public class NodeELBuilderTest extends BaseTest {
String jsonStr = "{\"name\":\"zhangsan\",\"age\":18}";
String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
NodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", jsonStr);
CommonNodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", jsonStr);
Assertions.assertEquals(expectedStr,
node.toEL());
System.out.println(expectedStr);
@@ -52,7 +51,7 @@ public class NodeELBuilderTest extends BaseTest {
String jsonStr = "{\"name\":\"zhangsan\",\"age\":18}";
String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
NodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", jsonStr);
CommonNodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", jsonStr);
Assertions.assertEquals(expectedStr,
node.toEL(true));
System.out.println(expectedStr);
@@ -65,7 +64,7 @@ public class NodeELBuilderTest extends BaseTest {
name2Value.put("age", 18);
String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
NodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
CommonNodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
Assertions.assertEquals(expectedStr,
node.toEL());
System.out.println(expectedStr);
@@ -78,7 +77,7 @@ public class NodeELBuilderTest extends BaseTest {
name2Value.put("age", 18);
String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
NodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
CommonNodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
Assertions.assertEquals(expectedStr,
node.toEL(true));
System.out.println(expectedStr);
@@ -101,7 +100,7 @@ public class NodeELBuilderTest extends BaseTest {
name2Value.name = "zhangsan";
String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
NodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
CommonNodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
Assertions.assertEquals(expectedStr,
node.toEL());
System.out.println(expectedStr);
@@ -114,7 +113,7 @@ public class NodeELBuilderTest extends BaseTest {
name2Value.name = "zhangsan";
String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
"node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
NodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
CommonNodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
Assertions.assertEquals(expectedStr,
node.toEL(true));
System.out.println(expectedStr);

75
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/ParELBuilderTest.java
View File

@@ -3,7 +3,6 @@ package com.yomahub.liteflow.test.builder;
import com.yomahub.liteflow.builder.el.ELBus;
import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder;
import com.yomahub.liteflow.builder.el.ParELWrapper;
import com.yomahub.liteflow.builder.el.WhenELWrapper;
import com.yomahub.liteflow.test.BaseTest;
import com.yomahub.liteflow.util.JsonUtil;
import org.junit.jupiter.api.Assertions;
@@ -28,105 +27,105 @@ public class ParELBuilderTest extends BaseTest {
public void testPar1(){
String expectedStr = "PAR(node(\"a\"),node(\"b\"));";
Assertions.assertEquals(expectedStr,
ELBus.par("a", "b").toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", "b").toEL()));
ELBus.par(ELBus.node("a"), ELBus.node("b")).toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.node("b")).toEL()));
}
// 格式化输出测试
@Test
public void testPar2(){
String expectedStr = "PAR(\n\tnode(\"a\"),\n\tnode(\"b\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.par("a", "b").toEL(true));
ELBus.par(ELBus.node("a"), ELBus.node("b")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", "b").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.node("b")).toEL(true)));
}
// then组件then方法调用测试
@Test
public void testPar3(){
String expectedStr = "PAR(node(\"a\"),node(\"b\"),node(\"c\"));";
Assertions.assertEquals(expectedStr,
ELBus.par("a", "b").par("c").toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", "b").par("c").toEL()));
ELBus.par(ELBus.node("a"), ELBus.node("b")).par(ELBus.node("c")).toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.node("b")).par(ELBus.node("c")).toEL()));
}
// 格式化输出测试
@Test
public void testPar4(){
String expectedStr = "PAR(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.par("a", "b").par("c").toEL(true));
ELBus.par(ELBus.node("a"), ELBus.node("b")).par(ELBus.node("c")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", "b").par("c").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.node("b")).par(ELBus.node("c")).toEL(true)));
}
// then组件嵌套调用测试
@Test
public void testPar5(){
String expectedStr = "PAR(node(\"a\"),PAR(node(\"b\"),node(\"c\")),node(\"d\"));";
Assertions.assertEquals(expectedStr,
ELBus.par("a", ELBus.par("b").par("c")).par("d").toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", ELBus.par("b").par("c")).par("d").toEL()));
ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c"))).par(ELBus.node("d")).toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c"))).par(ELBus.node("d")).toEL()));
}
// 格式化输出测试
@Test
public void testPar6(){
String expectedStr = "PAR(\n\tnode(\"a\"),\n\tPAR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.par("a", ELBus.par("b").par("c")).par("d").toEL(true));
ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c"))).par(ELBus.node("d")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", ELBus.par("b").par("c")).par("d").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c"))).par(ELBus.node("d")).toEL(true)));
}
// PAR特有属性测试 any ignoreError customThreadExecutor must
@Test
public void testPar7(){
String expectedStr = "PAR(node(\"a\"),node(\"b\"),PAR(node(\"c\"),node(\"d\")).any(true).threadPool(\"com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1\").id(\"node1\")).ignoreError(true).must(\"a\", \"task1\", \"node1\");";
Assertions.assertEquals(expectedStr,
ELBus.par("a", "b", ELBus.par("c").par("d").id("node1").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL());
ELBus.par(ELBus.node("a"), ELBus.node("b"), ELBus.par(ELBus.node("c")).par(ELBus.node("d")).id("node1").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").any(true)).ignoreError(true).must("a","task1","node1").toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", "b", ELBus.par("c").par("d").id("node1").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.node("b"), ELBus.par(ELBus.node("c")).par(ELBus.node("d")).id("node1").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").any(true)).ignoreError(true).must("a","task1","node1").toEL()));
}
// 格式化输出测试
@Test
public void testPar8(){
String expectedStr = "PAR(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tPAR(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t).any(true).threadPool(\"com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1\").id(\"node1\")\n).ignoreError(true).must(\"a\", \"task1\", \"node1\");";
Assertions.assertEquals(expectedStr,
ELBus.par("a", "b", ELBus.par("c").par("d").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").id("node1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL(true));
ELBus.par(ELBus.node("a"), ELBus.node("b"), ELBus.par(ELBus.node("c")).par(ELBus.node("d")).customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").id("node1").any(true)).ignoreError(true).must("a","task1","node1").toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", "b", ELBus.par("c").par("d").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").id("node1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.node("b"), ELBus.par(ELBus.node("c")).par(ELBus.node("d")).customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").id("node1").any(true)).ignoreError(true).must("a","task1","node1").toEL(true)));
}
// maxWaitSeconds 属性测试
@Test
public void testPar9(){
String expectedStr = "PAR(node(\"a\"),node(\"b\")).maxWaitSeconds(5);";
Assertions.assertEquals(expectedStr,
ELBus.par("a", "b").maxWaitSeconds(5).toEL());
ELBus.par(ELBus.node("a"), ELBus.node("b")).maxWaitSeconds(5).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", "b").maxWaitSeconds(5).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.node("b")).maxWaitSeconds(5).toEL()));
}
// 格式化输出测试
@Test
public void testPar10(){
String expectedStr = "PAR(\n\tnode(\"a\"),\n\tnode(\"b\")\n).maxWaitSeconds(5);";
Assertions.assertEquals(expectedStr,
ELBus.par("a", "b").maxWaitSeconds(5).toEL(true));
ELBus.par(ELBus.node("a"), ELBus.node("b")).maxWaitSeconds(5).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", "b").maxWaitSeconds(5).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.node("b")).maxWaitSeconds(5).toEL(true)));
}
// 属性设置测试
@Test
public void testPar11(){
String expectedStr = "PAR(node(\"a\"),PAR(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.par("a", ELBus.par("b").par("c").id("this is a id")).par("d").tag("this is a tag").toEL());
ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c")).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", ELBus.par("b").par("c").id("this is a id")).par("d").tag("this is a tag").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c")).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL()));
}
// 格式化输出测试
@Test
public void testPar12(){
String expectedStr = "PAR(\n\tnode(\"a\"),\n\tPAR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.par("a", ELBus.par("b").par("c").id("this is a id")).par("d").tag("this is a tag").toEL(true));
ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c")).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", ELBus.par("b").par("c").id("this is a id")).par("d").tag("this is a tag").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c")).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(true)));
}
// data属性测试
@Test
@@ -137,9 +136,9 @@ public class ParELBuilderTest extends BaseTest {
System.out.println(JsonUtil.toJsonString(name2Value));
String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nPAR(node(\"a\"),PAR(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.par("a", ELBus.par("b").par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par("d").tag("this is a tag").toEL(false));
ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(false));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", ELBus.par("b").par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par("d").tag("this is a tag").toEL(false)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(false)));
}
// 格式化输出测试
@Test
@@ -149,27 +148,27 @@ public class ParELBuilderTest extends BaseTest {
name2Value.put("age", 18);
String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nPAR(\n\tnode(\"a\"),\n\tPAR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whenData)\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.par("a", ELBus.par("b").par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par("d").tag("this is a tag").toEL(true));
ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", ELBus.par("b").par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par("d").tag("this is a tag").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(true)));
}
// data属性测试 Json字符串赋值data
@Test
public void testPar15(){
String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nPAR(node(\"a\"),PAR(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.par("a", ELBus.par("b").par(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).par("d").tag("this is a tag").toEL());
ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", ELBus.par("b").par(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).par("d").tag("this is a tag").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL()));
}
// 格式化输出测试 Json字符串赋值data
@Test
public void testPar16(){
String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nPAR(\n\tnode(\"a\"),\n\tPAR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whenData)\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.par("a", ELBus.par("b").par(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).par("d").tag("this is a tag").toEL(true));
ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", ELBus.par("b").par(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).par("d").tag("this is a tag").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(true)));
}
private static class ParamClass{
private String name;
@@ -189,9 +188,9 @@ public class ParELBuilderTest extends BaseTest {
name2Value.age = 18;
String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nPAR(node(\"a\"),PAR(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.par("a", ELBus.par("b").par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par("d").tag("this is a tag").toEL());
ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", ELBus.par("b").par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par("d").tag("this is a tag").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL()));
}
// 格式化输出测试
@Test
@@ -201,14 +200,14 @@ public class ParELBuilderTest extends BaseTest {
name2Value.age = 18;
String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nPAR(\n\tnode(\"a\"),\n\tPAR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whenData)\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.par("a", ELBus.par("b").par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par("d").tag("this is a tag").toEL(true));
ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par("a", ELBus.par("b").par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par("d").tag("this is a tag").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(true)));
}
@Test
public void testPAR(){
ParELWrapper el = ELBus.par("a", "b", "c").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1");
ParELWrapper el = ELBus.par(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")).customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(el.toEL()));
}
}

23
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/RetryBuilderTest.java
View File

@@ -1,10 +1,10 @@
package com.yomahub.liteflow.test.builder;
import com.yomahub.liteflow.builder.el.*;
import com.yomahub.liteflow.builder.el.CommonNodeELWrapper;
import com.yomahub.liteflow.builder.el.ELBus;
import com.yomahub.liteflow.builder.el.WhenELWrapper;
import com.yomahub.liteflow.test.BaseTest;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
@@ -13,16 +13,11 @@ import org.springframework.boot.test.context.SpringBootTest;
@EnableAutoConfiguration
public class RetryBuilderTest extends BaseTest {
@BeforeAll
public static void init(){
ELBus.setNodeWrapper(false);
}
// node上进行retry
@Test
public void testRetry1(){
NodeELWrapper nodeA = ELBus.node("a").retry(2);
NodeELWrapper nodeB = ELBus.node("b").retry(3);
CommonNodeELWrapper nodeA = ELBus.commonNode("a").retry(2);
CommonNodeELWrapper nodeB = ELBus.commonNode("b").retry(3);
WhenELWrapper whenELWrapper = ELBus.when(nodeA, nodeB);
Assertions.assertEquals("WHEN(a.retry(2),b.retry(3));", whenELWrapper.toEL());
}
@@ -30,8 +25,8 @@ public class RetryBuilderTest extends BaseTest {
// node上进行retry，带exception
@Test
public void testRetry2(){
NodeELWrapper nodeA = ELBus.node("a").retry(2, "java.lang.NullPointerException");
NodeELWrapper nodeB = ELBus.node("b").retry(3, "java.lang.NullPointerException", "java.lang.ArrayIndexOutOfBoundsException");
CommonNodeELWrapper nodeA = ELBus.commonNode("a").retry(2, "java.lang.NullPointerException");
CommonNodeELWrapper nodeB = ELBus.commonNode("b").retry(3, "java.lang.NullPointerException", "java.lang.ArrayIndexOutOfBoundsException");
WhenELWrapper whenELWrapper = ELBus.when(nodeA, nodeB);
Assertions.assertEquals("WHEN(a.retry(2,\"java.lang.NullPointerException\"),b.retry(3,\"java.lang.NullPointerException\",\"java.lang.ArrayIndexOutOfBoundsException\"));",
whenELWrapper.toEL());
@@ -52,8 +47,4 @@ public class RetryBuilderTest extends BaseTest {
whenELWrapper.toEL());
}
@AfterAll
public static void after(){
ELBus.setNodeWrapper(true);
}
}

81
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/SerELBuilderTest.java
View File

@@ -16,6 +16,7 @@ import java.util.Map;
* 串行组件测试
*
* @author gezuao
* @author luo yi
* @since 2.11.1
*/
@SpringBootTest(classes = SerELBuilderTest.class)
@@ -26,98 +27,98 @@ public class SerELBuilderTest extends BaseTest {
@Test
public void testSer1(){
Assertions.assertEquals("SER(node(\"a\"),node(\"b\"));",
ELBus.ser("a", "b").toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", "b").toEL()));
ELBus.ser(ELBus.node("a"), ELBus.node("b")).toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.node("b")).toEL()));
}
// 格式化输出测试
@Test
public void testSer2(){
Assertions.assertEquals("SER(\n\tnode(\"a\")," +
"\n\tnode(\"b\")\n);",
ELBus.ser("a", "b").toEL(true));
ELBus.ser(ELBus.node("a"), ELBus.node("b")).toEL(true));
System.out.println("SER(\n\tnode(\"a\")," +
"\n\tnode(\"b\")\n);");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", "b").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.node("b")).toEL(true)));
}
// then组件then方法调用测试
@Test
public void testSer3(){
Assertions.assertEquals("SER(node(\"a\"),node(\"b\"),node(\"c\"));",
ELBus.ser("a", "b").ser("c").toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", "b").ser("c").toEL()));
ELBus.ser(ELBus.node("a"), ELBus.node("b")).ser(ELBus.node("c")).toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.node("b")).ser(ELBus.node("c")).toEL()));
}
// 格式化输出测试
@Test
public void testSer4(){
Assertions.assertEquals("SER(\n\tnode(\"a\"),\n\tnode(\"b\")," +
"\n\tnode(\"c\")\n);",
ELBus.ser("a", "b").ser("c").toEL(true));
ELBus.ser(ELBus.node("a"), ELBus.node("b")).ser(ELBus.node("c")).toEL(true));
System.out.println("SER(\n\tnode(\"a\"),\n\tnode(\"b\")," +
"\n\tnode(\"c\")\n);");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", "b").ser("c").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.node("b")).ser(ELBus.node("c")).toEL(true)));
}
// then组件嵌套调用测试
@Test
public void testSer5(){
Assertions.assertEquals("SER(node(\"a\"),SER(node(\"b\"),node(\"c\")),node(\"d\"));",
ELBus.ser("a", ELBus.ser("b").ser("c")).ser("d").toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c")).ser("d").toEL()));
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).toEL()));
}
// 格式化输出测试
@Test
public void testSer6(){
Assertions.assertEquals("SER(\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);",
ELBus.ser("a", ELBus.ser("b").ser("c")).ser("d").toEL(true));
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).toEL(true));
System.out.println("SER(\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c")).ser("d").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).toEL(true)));
}
// pre组件测试
@Test
public void testSer7(){
Assertions.assertEquals("SER(PRE(node(\"p\")),PRE(node(\"pp\")),node(\"a\"),SER(node(\"b\"),node(\"c\")),node(\"d\"));",
ELBus.ser("a", ELBus.ser("b").ser("c")).ser("d").pre("p").pre("pp").toEL());
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL());
System.out.println("SER(PRE(node(\"p\")),PRE(node(\"pp\")),node(\"a\"),SER(node(\"b\"),node(\"c\")),node(\"d\"));");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c")).ser("d").pre("p").pre("pp").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL()));
}
// 格式化输出测试
@Test
public void testSer8(){
Assertions.assertEquals("SER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tPRE(\n\t\tnode(\"pp\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);",
ELBus.ser("a", ELBus.ser("b").ser("c")).ser("d").pre("p").pre("pp").toEL(true));
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL(true));
System.out.println("SER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tPRE(\n\t\tnode(\"pp\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c")).ser("d").pre("p").pre("pp").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL(true)));
}
// pre finally 格式测试
@Test
public void testSer9(){
Assertions.assertEquals("SER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")),node(\"d\"),FINALLY(node(\"f\")));",
ELBus.ser("a", ELBus.ser("b").ser("c")).ser("d").pre("p").finallyOpt("f").toEL());
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
System.out.println("SER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")),node(\"d\"),FINALLY(node(\"f\")));");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c")).ser("d").pre("p").finallyOpt("f").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
}
// 格式化输出测试
@Test
public void testSer10(){
Assertions.assertEquals("SER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n);",
ELBus.ser("a", ELBus.ser("b").ser("c")).ser("d").pre("p").finallyOpt("f").toEL(true));
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
System.out.println("SER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n);");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c")).ser("d").pre("p").finallyOpt("f").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
}
// 属性设置测试
@Test
public void testSer11(){
Assertions.assertEquals("SER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser("d").pre("p").finallyOpt("f").toEL());
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
System.out.println("SER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser("d").pre("p").finallyOpt("f").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
}
// 格式化输出测试
@Test
public void testSer12(){
Assertions.assertEquals("SER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser("d").pre("p").finallyOpt("f").toEL(true));
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
System.out.println("SER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser("d").pre("p").finallyOpt("f").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
}
// data属性测试
@Test
@@ -127,9 +128,9 @@ public class SerELBuilderTest extends BaseTest {
name2Value.put("age", 18);
System.out.println(JsonUtil.toJsonString(name2Value));
Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL());
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
}
// 格式化输出测试
@Test
@@ -138,25 +139,25 @@ public class SerELBuilderTest extends BaseTest {
name2Value.put("name", "zhangsan");
name2Value.put("age", 18);
Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL(true));
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
}
// data属性测试 Json字符串赋值data
@Test
public void testSer15(){
Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre("p").finallyOpt("f").toEL());
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
// System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre("p").finallyOpt("f").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
}
// 格式化输出测试 Json字符串赋值data
@Test
public void testSer16(){
Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre("p").finallyOpt("f").toEL(true));
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
// System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre("p").finallyOpt("f").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
}
private static class ParamClass{
private String name;
@@ -175,9 +176,9 @@ public class SerELBuilderTest extends BaseTest {
name2Value.name = "zhangsan";
name2Value.age = 18;
Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL());
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
}
// 格式化输出测试
@Test
@@ -186,26 +187,26 @@ public class SerELBuilderTest extends BaseTest {
name2Value.name = "zhangsan";
name2Value.age = 18;
Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL(true));
ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a", ELBus.ser("b").ser("c").id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
}
// maxWaitSecond测试
@Test
public void testSer19(){
String expectedStr = "SER(node(\"a\"),node(\"b\")).maxWaitSeconds(5);";
Assertions.assertEquals(expectedStr,
ELBus.ser("a").ser("b").maxWaitSeconds(5).toEL());
ELBus.ser(ELBus.node("a")).ser(ELBus.node("b")).maxWaitSeconds(5).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a").ser("b").maxWaitSeconds(5).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a")).ser(ELBus.node("b")).maxWaitSeconds(5).toEL()));
}
// 格式化输出测试
@Test
public void testSer20(){
String expectedStr = "SER(\n\tnode(\"a\"),\n\tnode(\"b\")\n).maxWaitSeconds(5);";
Assertions.assertEquals(expectedStr,
ELBus.ser("a").ser("b").maxWaitSeconds(5).toEL(true));
ELBus.ser(ELBus.node("a")).ser(ELBus.node("b")).maxWaitSeconds(5).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser("a").ser("b").maxWaitSeconds(5).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a")).ser(ELBus.node("b")).maxWaitSeconds(5).toEL(true)));
}
}

48
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/SwitchELBuilderTest.java
View File

@@ -26,9 +26,9 @@ public class SwitchELBuilderTest extends BaseTest {
public void testSwitch1(){
String expectedStr = "SWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\")).DEFAULT(node(\"f\"));";
Assertions.assertEquals(expectedStr,
ELBus.switchOpt("a").to("b", "c", "d").defaultOpt("f").toEL());
ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d")).defaultOpt(ELBus.node("f")).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", "d").defaultOpt("f").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d")).defaultOpt(ELBus.node("f")).toEL()));
}
// 格式化输出测试
@@ -36,9 +36,9 @@ public class SwitchELBuilderTest extends BaseTest {
public void testSwitch2(){
String expectedStr = "SWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\")\n).DEFAULT(\n\tnode(\"f\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.switchOpt("a").to("b", "c", "d").defaultOpt("f").toEL(true));
ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d")).defaultOpt(ELBus.node("f")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", "d").defaultOpt("f").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d")).defaultOpt(ELBus.node("f")).toEL(true)));
}
// switch和THEN when嵌套调用测试
@@ -46,9 +46,9 @@ public class SwitchELBuilderTest extends BaseTest {
public void testSwitch3(){
String expectedStr = "SWITCH(node(\"a\")).TO(node(\"b\"),THEN(node(\"c\"),node(\"d\")),WHEN(node(\"e\"),node(\"f\"))).DEFAULT(THEN(node(\"g\"),node(\"h\")));";
Assertions.assertEquals(expectedStr,
ELBus.switchOpt("a").to("b", ELBus.then("c", "d"), ELBus.when("e", "f")).defaultOpt(ELBus.then("g", "h")).toEL());
ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.then(ELBus.node("c"), ELBus.node("d")), ELBus.when(ELBus.node("e"), ELBus.node("f"))).defaultOpt(ELBus.then(ELBus.node("g"), ELBus.node("h"))).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", ELBus.then("c", "d"), ELBus.when("e", "f")).defaultOpt(ELBus.then("g", "h")).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.then(ELBus.node("c"), ELBus.node("d")), ELBus.when(ELBus.node("e"), ELBus.node("f"))).defaultOpt(ELBus.then(ELBus.node("g"), ELBus.node("h"))).toEL()));
}
// 格式化输出测试
@@ -56,9 +56,9 @@ public class SwitchELBuilderTest extends BaseTest {
public void testSwitch4(){
String expectedStr = "SWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tTHEN(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t),\n\tWHEN(\n\t\tnode(\"e\"),\n\t\tnode(\"f\")\n\t)\n).DEFAULT(\n\tTHEN(\n\t\tnode(\"g\"),\n\t\tnode(\"h\")\n\t)\n);";
Assertions.assertEquals(expectedStr,
ELBus.switchOpt("a").to("b", ELBus.then("c", "d"), ELBus.when("e", "f")).defaultOpt(ELBus.then("g", "h")).toEL(true));
ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.then(ELBus.node("c"), ELBus.node("d")), ELBus.when(ELBus.node("e"), ELBus.node("f"))).defaultOpt(ELBus.then(ELBus.node("g"), ELBus.node("h"))).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", ELBus.then("c", "d"), ELBus.when("e", "f")).defaultOpt(ELBus.then("g", "h")).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.then(ELBus.node("c"), ELBus.node("d")), ELBus.when(ELBus.node("e"), ELBus.node("f"))).defaultOpt(ELBus.then(ELBus.node("g"), ELBus.node("h"))).toEL(true)));
}
// 属性设置测试
@@ -66,9 +66,9 @@ public class SwitchELBuilderTest extends BaseTest {
public void testSwitch5(){
String expectedStr = "SWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\")).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(5);";
Assertions.assertEquals(expectedStr,
ELBus.switchOpt("a").to("b", "c", "d").id("this is a id").tag("this is a tag").maxWaitSeconds(5).toEL());
ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d")).id("this is a id").tag("this is a tag").maxWaitSeconds(5).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", "d").id("this is a id").tag("this is a tag").maxWaitSeconds(5).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d")).id("this is a id").tag("this is a tag").maxWaitSeconds(5).toEL()));
}
// 格式化输出测试
@@ -76,9 +76,9 @@ public class SwitchELBuilderTest extends BaseTest {
public void testSwitch6(){
String expectedStr = "SWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\")\n).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(5);";
Assertions.assertEquals(expectedStr,
ELBus.switchOpt("a").to("b", "c", "d").id("this is a id").tag("this is a tag").maxWaitSeconds(5).toEL(true));
ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d")).id("this is a id").tag("this is a tag").maxWaitSeconds(5).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", "d").id("this is a id").tag("this is a tag").maxWaitSeconds(5).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d")).id("this is a id").tag("this is a tag").maxWaitSeconds(5).toEL(true)));
}
// data属性测试
@@ -89,9 +89,9 @@ public class SwitchELBuilderTest extends BaseTest {
name2Value.put("age", 18);
String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\").data(switchData));";
Assertions.assertEquals(expectedStr,
ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL());
ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", name2Value)).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c",ELBus.node("d").data("switchData", name2Value)).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"),ELBus.node("d").data("switchData", name2Value)).toEL()));
}
@Test
@@ -101,9 +101,9 @@ public class SwitchELBuilderTest extends BaseTest {
name2Value.put("age", 18);
String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\").data(switchData)\n);";
Assertions.assertEquals(expectedStr,
ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL(true));
ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", name2Value)).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", name2Value)).toEL(true)));
}
@Test
@@ -111,9 +111,9 @@ public class SwitchELBuilderTest extends BaseTest {
String jsonStr = "{\"name\":\"zhangsan\",\"age\":18}";
String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\").data(switchData));";
Assertions.assertEquals(expectedStr,
ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", jsonStr)).toEL());
ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", jsonStr)).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", jsonStr)).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", jsonStr)).toEL()));
}
@Test
@@ -121,9 +121,9 @@ public class SwitchELBuilderTest extends BaseTest {
String jsonStr = "{\"name\":\"zhangsan\",\"age\":18}";
String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\").data(switchData)\n);";
Assertions.assertEquals(expectedStr,
ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", jsonStr)).toEL(true));
ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", jsonStr)).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", jsonStr)).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", jsonStr)).toEL(true)));
}
private static class ParamClass{
@@ -144,9 +144,9 @@ public class SwitchELBuilderTest extends BaseTest {
name2Value.age = 18;
String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\").data(switchData));";
Assertions.assertEquals(expectedStr,
ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL());
ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", name2Value)).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", name2Value)).toEL()));
}
@Test
@@ -156,9 +156,9 @@ public class SwitchELBuilderTest extends BaseTest {
name2Value.age = 18;
String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\").data(switchData)\n);";
Assertions.assertEquals(expectedStr,
ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL(true));
ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", name2Value)).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", name2Value)).toEL(true)));
}
}

86
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/ThenELBuilderTest.java
View File

@@ -27,108 +27,108 @@ public class ThenELBuilderTest extends BaseTest {
Map<String, Object> name2Value = new HashMap<String, Object>();
name2Value.put("name", "zhangsan");
name2Value.put("age", 18);
System.out.println(ELBus.then(ELBus.commonNode("a").data("nodeData", name2Value).tag("tagA").maxWaitSeconds(10).retry(2), ELBus.node("b")).toEL(true));
String expected = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\ta.tag(\"tagA\").data(nodeData).maxWaitSeconds(10).retry(2),\n\tnode(\"b\")\n);";
Assertions.assertEquals(expected,
ELBus.then(ELBus.commonNode("a").data("nodeData", name2Value).tag("tagA").maxWaitSeconds(10).retry(2), ELBus.node("b")).toEL(true));
String actualEl = ELBus.then(ELBus.commonNode("a").data("nodeData", name2Value).tag("tagA").maxWaitSeconds(10).retry(2), ELBus.node("b")).toEL(true);
System.out.println(actualEl);
Assertions.assertEquals(expected, actualEl);
}
// then组件测试
@Test
public void testThen1(){
Assertions.assertEquals("THEN(node(\"a\"),node(\"b\"));",
ELBus.then("a", "b").toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", "b").toEL()));
ELBus.then(ELBus.node("a"), ELBus.node("b")).toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.node("b")).toEL()));
}
// 格式化输出测试
@Test
public void testThen2(){
Assertions.assertEquals("THEN(\n\tnode(\"a\")," +
"\n\tnode(\"b\")\n);",
ELBus.then("a", "b").toEL(true));
ELBus.then(ELBus.node("a"), ELBus.node("b")).toEL(true));
System.out.println("THEN(\n\tnode(\"a\")," +
"\n\tnode(\"b\")\n);");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", "b").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.node("b")).toEL(true)));
}
// then组件then方法调用测试
@Test
public void testThen3(){
Assertions.assertEquals("THEN(node(\"a\"),node(\"b\"),node(\"c\"));",
ELBus.then("a", "b").then("c").toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", "b").then("c").toEL()));
ELBus.then(ELBus.node("a"), ELBus.node("b")).then(ELBus.node("c")).toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.node("b")).then(ELBus.node("c")).toEL()));
}
// 格式化输出测试
@Test
public void testThen4(){
Assertions.assertEquals("THEN(\n\tnode(\"a\"),\n\tnode(\"b\")," +
"\n\tnode(\"c\")\n);",
ELBus.then("a", "b").then("c").toEL(true));
ELBus.then(ELBus.node("a"), ELBus.node("b")).then(ELBus.node("c")).toEL(true));
System.out.println("THEN(\n\tnode(\"a\"),\n\tnode(\"b\")," +
"\n\tnode(\"c\")\n);");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", "b").then("c").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.node("b")).then(ELBus.node("c")).toEL(true)));
}
// then组件嵌套调用测试
@Test
public void testThen5(){
Assertions.assertEquals("THEN(node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"));",
ELBus.then("a", ELBus.then("b").then("c")).then("d").toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c")).then("d").toEL()));
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).toEL()));
}
// 格式化输出测试
@Test
public void testThen6(){
Assertions.assertEquals("THEN(\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);",
ELBus.then("a", ELBus.then("b").then("c")).then("d").toEL(true));
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).toEL(true));
System.out.println("THEN(\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c")).then("d").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).toEL(true)));
}
// pre组件测试
@Test
public void testThen7(){
Assertions.assertEquals("THEN(PRE(node(\"p\")),PRE(node(\"pp\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"));",
ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").pre("pp").toEL());
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL());
System.out.println("THEN(PRE(node(\"p\")),PRE(node(\"pp\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"));");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").pre("pp").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL()));
}
// 格式化输出测试
@Test
public void testThen8(){
Assertions.assertEquals("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tPRE(\n\t\tnode(\"pp\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);",
ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").pre("pp").toEL(true));
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL(true));
System.out.println("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tPRE(\n\t\tnode(\"pp\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").pre("pp").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL(true)));
}
// pre finally 格式测试
@Test
public void testThen9(){
Assertions.assertEquals("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"),FINALLY(node(\"f\")));",
ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").finallyOpt("f").toEL());
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
System.out.println("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"),FINALLY(node(\"f\")));");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").finallyOpt("f").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
}
// 格式化输出测试
@Test
public void testThen10(){
Assertions.assertEquals("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n);",
ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").finallyOpt("f").toEL(true));
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
System.out.println("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n);");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").finallyOpt("f").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
}
// 属性设置测试
@Test
public void testThen11(){
Assertions.assertEquals("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").pre("p").finallyOpt("f").toEL());
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
System.out.println("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").pre("p").finallyOpt("f").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
}
// 格式化输出测试
@Test
public void testThen12(){
Assertions.assertEquals("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").pre("p").finallyOpt("f").toEL(true));
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
System.out.println("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").pre("p").finallyOpt("f").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
}
// data属性测试
@Test
@@ -138,9 +138,9 @@ public class ThenELBuilderTest extends BaseTest {
name2Value.put("age", 18);
System.out.println(JsonUtil.toJsonString(name2Value));
Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL());
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
}
// 格式化输出测试
@Test
@@ -149,25 +149,25 @@ public class ThenELBuilderTest extends BaseTest {
name2Value.put("name", "zhangsan");
name2Value.put("age", 18);
Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL(true));
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
}
// data属性测试 Json字符串赋值data
@Test
public void testThen15(){
Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre("p").finallyOpt("f").toEL());
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
// System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre("p").finallyOpt("f").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
}
// 格式化输出测试 Json字符串赋值data
@Test
public void testThen16(){
Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre("p").finallyOpt("f").toEL(true));
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
// System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre("p").finallyOpt("f").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
}
private static class ParamClass{
private String name;
@@ -186,9 +186,9 @@ public class ThenELBuilderTest extends BaseTest {
name2Value.name = "zhangsan";
name2Value.age = 18;
Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL());
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
}
// 格式化输出测试
@Test
@@ -197,26 +197,26 @@ public class ThenELBuilderTest extends BaseTest {
name2Value.name = "zhangsan";
name2Value.age = 18;
Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL(true));
ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
}
// maxWaitSecond测试
@Test
public void testThen19(){
String expectedStr = "THEN(node(\"a\"),node(\"b\")).maxWaitSeconds(5);";
Assertions.assertEquals(expectedStr,
ELBus.then("a").then("b").maxWaitSeconds(5).toEL());
ELBus.then(ELBus.node("a")).then(ELBus.node("b")).maxWaitSeconds(5).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a").then("b").maxWaitSeconds(5).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a")).then(ELBus.node("b")).maxWaitSeconds(5).toEL()));
}
// 格式化输出测试
@Test
public void testThen20(){
String expectedStr = "THEN(\n\tnode(\"a\"),\n\tnode(\"b\")\n).maxWaitSeconds(5);";
Assertions.assertEquals(expectedStr,
ELBus.then("a").then("b").maxWaitSeconds(5).toEL(true));
ELBus.then(ELBus.node("a")).then(ELBus.node("b")).maxWaitSeconds(5).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a").then("b").maxWaitSeconds(5).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a")).then(ELBus.node("b")).maxWaitSeconds(5).toEL(true)));
}
}

75
liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/WhenELBuilderTest.java
View File

@@ -10,7 +10,6 @@ import org.junit.jupiter.api.Test;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.meta.When;
import java.util.HashMap;
import java.util.Map;
@@ -28,105 +27,105 @@ public class WhenELBuilderTest extends BaseTest {
public void testWhen1(){
String expectedStr = "WHEN(node(\"a\"),node(\"b\"));";
Assertions.assertEquals(expectedStr,
ELBus.when("a", "b").toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b").toEL()));
ELBus.when(ELBus.node("a"), ELBus.node("b")).toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.node("b")).toEL()));
}
// 格式化输出测试
@Test
public void testWhen2(){
String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tnode(\"b\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.when("a", "b").toEL(true));
ELBus.when(ELBus.node("a"), ELBus.node("b")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.node("b")).toEL(true)));
}
// then组件then方法调用测试
@Test
public void testWhen3(){
String expectedStr = "WHEN(node(\"a\"),node(\"b\"),node(\"c\"));";
Assertions.assertEquals(expectedStr,
ELBus.when("a", "b").when("c").toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b").when("c").toEL()));
ELBus.when(ELBus.node("a"), ELBus.node("b")).when(ELBus.node("c")).toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.node("b")).when(ELBus.node("c")).toEL()));
}
// 格式化输出测试
@Test
public void testWhen4(){
String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.when("a", "b").when("c").toEL(true));
ELBus.when(ELBus.node("a"), ELBus.node("b")).when(ELBus.node("c")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b").when("c").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.node("b")).when(ELBus.node("c")).toEL(true)));
}
// then组件嵌套调用测试
@Test
public void testWhen5(){
String expectedStr = "WHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\")),node(\"d\"));";
Assertions.assertEquals(expectedStr,
ELBus.when("a", ELBus.when("b").when("c")).when("d").toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when("c")).when("d").toEL()));
ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c"))).when(ELBus.node("d")).toEL());
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c"))).when(ELBus.node("d")).toEL()));
}
// 格式化输出测试
@Test
public void testWhen6(){
String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);";
Assertions.assertEquals(expectedStr,
ELBus.when("a", ELBus.when("b").when("c")).when("d").toEL(true));
ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c"))).when(ELBus.node("d")).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when("c")).when("d").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c"))).when(ELBus.node("d")).toEL(true)));
}
// WHEN特有属性测试 any ignoreError customThreadExecutor must
@Test
public void testWhen7(){
String expectedStr = "WHEN(node(\"a\"),node(\"b\"),WHEN(node(\"c\"),node(\"d\")).any(true).threadPool(\"com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1\").id(\"node1\")).ignoreError(true).must(\"a\", \"task1\", \"node1\");";
Assertions.assertEquals(expectedStr,
ELBus.when("a", "b", ELBus.when("c").when("d").id("node1").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL());
ELBus.when(ELBus.node("a"), ELBus.node("b"), ELBus.when(ELBus.node("c")).when(ELBus.node("d")).id("node1").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b", ELBus.when("c").when("d").id("node1").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.node("b"), ELBus.when(ELBus.node("c")).when(ELBus.node("d")).id("node1").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL()));
}
// 格式化输出测试
@Test
public void testWhen8(){
String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tWHEN(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t).any(true).threadPool(\"com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1\").id(\"node1\")\n).ignoreError(true).must(\"a\", \"task1\", \"node1\");";
Assertions.assertEquals(expectedStr,
ELBus.when("a", "b", ELBus.when("c").when("d").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").id("node1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL(true));
ELBus.when(ELBus.node("a"), ELBus.node("b"), ELBus.when(ELBus.node("c")).when(ELBus.node("d")).customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").id("node1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b", ELBus.when("c").when("d").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").id("node1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.node("b"), ELBus.when(ELBus.node("c")).when(ELBus.node("d")).customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").id("node1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL(true)));
}
// maxWaitSeconds 属性测试
@Test
public void testWhen9(){
String expectedStr = "WHEN(node(\"a\"),node(\"b\")).maxWaitSeconds(5);";
Assertions.assertEquals(expectedStr,
ELBus.when("a", "b").maxWaitSeconds(5).toEL());
ELBus.when(ELBus.node("a"), ELBus.node("b")).maxWaitSeconds(5).toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b").maxWaitSeconds(5).toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.node("b")).maxWaitSeconds(5).toEL()));
}
// 格式化输出测试
@Test
public void testWhen10(){
String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tnode(\"b\")\n).maxWaitSeconds(5);";
Assertions.assertEquals(expectedStr,
ELBus.when("a", "b").maxWaitSeconds(5).toEL(true));
ELBus.when(ELBus.node("a"), ELBus.node("b")).maxWaitSeconds(5).toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b").maxWaitSeconds(5).toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.node("b")).maxWaitSeconds(5).toEL(true)));
}
// 属性设置测试
@Test
public void testWhen11(){
String expectedStr = "WHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.when("a", ELBus.when("b").when("c").id("this is a id")).when("d").tag("this is a tag").toEL());
ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c")).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when("c").id("this is a id")).when("d").tag("this is a tag").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c")).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL()));
}
// 格式化输出测试
@Test
public void testWhen12(){
String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.when("a", ELBus.when("b").when("c").id("this is a id")).when("d").tag("this is a tag").toEL(true));
ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c")).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when("c").id("this is a id")).when("d").tag("this is a tag").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c")).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(true)));
}
// data属性测试
@Test
@@ -137,9 +136,9 @@ public class WhenELBuilderTest extends BaseTest {
System.out.println(JsonUtil.toJsonString(name2Value));
String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL(false));
ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(false));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL(false)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(false)));
}
// 格式化输出测试
@Test
@@ -149,27 +148,27 @@ public class WhenELBuilderTest extends BaseTest {
name2Value.put("age", 18);
String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whenData)\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL(true));
ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(true)));
}
// data属性测试 Json字符串赋值data
@Test
public void testWhen15(){
String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).when("d").tag("this is a tag").toEL());
ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).when("d").tag("this is a tag").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL()));
}
// 格式化输出测试 Json字符串赋值data
@Test
public void testWhen16(){
String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whenData)\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).when("d").tag("this is a tag").toEL(true));
ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).when("d").tag("this is a tag").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(true)));
}
private static class ParamClass{
private String name;
@@ -189,9 +188,9 @@ public class WhenELBuilderTest extends BaseTest {
name2Value.age = 18;
String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL());
ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL());
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL()));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL()));
}
// 格式化输出测试
@Test
@@ -201,14 +200,14 @@ public class WhenELBuilderTest extends BaseTest {
name2Value.age = 18;
String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whenData)\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\");";
Assertions.assertEquals(expectedStr,
ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL(true));
ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(true));
System.out.println(expectedStr);
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL(true)));
Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(true)));
}
@Test
public void testWHEN(){
WhenELWrapper el = ELBus.when("a", "b", "c").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1");
WhenELWrapper el = ELBus.when(ELBus.node("a"), ELBus.node("b"), ELBus.node("c")).customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1");
Assertions.assertTrue(LiteFlowChainELBuilder.validate(el.toEL()));
}
}

2
liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/fallback/FallbackELSpringbootTest.java
View File

@@ -193,7 +193,7 @@ public class FallbackELSpringbootTest extends BaseTest {
@Test
public void testWithElBuild(){
ELWrapper el = ELBus.then("a", "b", "az");
ELWrapper el = ELBus.then("a", "b", ELBus.node("az"));
LiteFlowChainELBuilder.createChain().setChainId("elBuilder").setEL(el.toEL()).build();
LiteflowResponse response = flowExecutor.execute2Resp("elBuilder");
Assertions.assertTrue(response.isSuccess());