From 9f5f8959fbb372d3dd002c192f0995ebbf99d25d Mon Sep 17 00:00:00 2001 From: Dale Lee <1658850308@qq.com> Date: Fri, 7 Jul 2023 09:49:57 +0800 Subject: [PATCH 01/11] =?UTF-8?q?feature=20#I7I3LL=20=E5=A2=9E=E5=8A=A0max?= =?UTF-8?q?WaitSeconds=E5=85=B3=E9=94=AE=E5=AD=97,=E5=85=81=E8=AE=B8?= =?UTF-8?q?=E5=AF=B9EL=E4=B8=AD=E7=9A=84=E6=AF=8F=E4=B8=80=E4=B8=AA?= =?UTF-8?q?=E7=BB=84=E4=BB=B6=E8=BF=9B=E8=A1=8C=E8=B6=85=E6=97=B6=E6=8E=A7?= =?UTF-8?q?=E5=88=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../builder/el/LiteFlowChainELBuilder.java | 1 + .../el/operator/MaxWaitSecondsOperator.java | 89 +++++++++ .../liteflow/common/ChainConstant.java | 2 + .../flow/element/condition/WhenCondition.java | 44 ++++- .../MaxWaitSecondsELSpringBootTest.java | 184 ++++++++++++++++++ .../test/maxWaitSeconds/cmp/ACmp.java | 20 ++ .../test/maxWaitSeconds/cmp/BCmp.java | 18 ++ .../test/maxWaitSeconds/cmp/CCmp.java | 18 ++ .../test/maxWaitSeconds/cmp/DCmp.java | 24 +++ .../test/maxWaitSeconds/cmp/FCmp.java | 12 ++ .../test/maxWaitSeconds/cmp/SCmp.java | 13 ++ .../test/maxWaitSeconds/cmp/WCmp.java | 14 ++ .../test/maxWaitSeconds/cmp/XCmp.java | 17 ++ .../maxWaitSeconds/application.properties | 1 + .../test/resources/maxWaitSeconds/flow.el.xml | 98 ++++++++++ 15 files changed, 546 insertions(+), 9 deletions(-) create mode 100644 liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/MaxWaitSecondsOperator.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringBootTest.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/resources/maxWaitSeconds/application.properties create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/resources/maxWaitSeconds/flow.el.xml diff --git a/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/LiteFlowChainELBuilder.java b/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/LiteFlowChainELBuilder.java index cc1e3d4db..53a98df0b 100644 --- a/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/LiteFlowChainELBuilder.java +++ b/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/LiteFlowChainELBuilder.java @@ -78,6 +78,7 @@ public class LiteFlowChainELBuilder { EXPRESS_RUNNER.addFunctionAndClassMethod(ChainConstant.DO, Object.class, new DoOperator()); EXPRESS_RUNNER.addFunctionAndClassMethod(ChainConstant.BREAK, Object.class, new BreakOperator()); EXPRESS_RUNNER.addFunctionAndClassMethod(ChainConstant.DATA, Object.class, new DataOperator()); + EXPRESS_RUNNER.addFunctionAndClassMethod(ChainConstant.MAX_WAIT_SECONDS, Object.class, new MaxWaitSecondsOperator()); } public static LiteFlowChainELBuilder createChain() { diff --git a/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/MaxWaitSecondsOperator.java b/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/MaxWaitSecondsOperator.java new file mode 100644 index 000000000..a6b1d5bdc --- /dev/null +++ b/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/MaxWaitSecondsOperator.java @@ -0,0 +1,89 @@ +package com.yomahub.liteflow.builder.el.operator; + +import cn.hutool.core.collection.CollUtil; +import com.ql.util.express.exception.QLException; +import com.yomahub.liteflow.builder.el.operator.base.BaseOperator; +import com.yomahub.liteflow.builder.el.operator.base.OperatorHelper; +import com.yomahub.liteflow.flow.element.Condition; +import com.yomahub.liteflow.flow.element.Executable; +import com.yomahub.liteflow.flow.element.condition.ConditionKey; +import com.yomahub.liteflow.flow.element.condition.FinallyCondition; +import com.yomahub.liteflow.flow.element.condition.ThenCondition; +import com.yomahub.liteflow.flow.element.condition.WhenCondition; + +import java.util.List; +import java.util.concurrent.TimeUnit; + +/** + * EL 规则中的 maxWaitSeconds 的操作符 + * + * @author DaleLee + * @since 2.11.0 + */ +public class MaxWaitSecondsOperator extends BaseOperator { + @Override + public Condition build(Object[] objects) throws Exception { + OperatorHelper.checkObjectSizeEqTwo(objects); + Executable executable = OperatorHelper.convert(objects[0], Executable.class); + // 获取传入的时间参数 + Integer maxWaitSeconds = OperatorHelper.convert(objects[1], Integer.class); + if (executable instanceof WhenCondition) { + // WhenCondition，直接设置等待时间 + WhenCondition whenCondition = OperatorHelper.convert(executable, WhenCondition.class); + whenCondition.setMaxWaitTime(maxWaitSeconds); + whenCondition.setMaxWaitTimeUnit(TimeUnit.SECONDS); + return whenCondition; + } else if (executable instanceof FinallyCondition) { + // FINALLY，报错 + String errorMsg = "The caller cannot be FinallyCondition item"; + throw new QLException(errorMsg); + } else if (containsFinally(executable)) { + // 处理 THEN 中的 FINALLY + ThenCondition thenCondition = OperatorHelper.convert(executable, ThenCondition.class); + return handleFinally(thenCondition, maxWaitSeconds); + } else { + // 其他情况，被 WHEN 包装 + return wrappedByWhen(executable, maxWaitSeconds); + } + } + + // 将一个 Executable 包装为带有单独超时控制的 WhenCondition + private WhenCondition wrappedByWhen(Executable executable, Integer maxWaitSeconds) { + WhenCondition whenCondition = new WhenCondition(); + whenCondition.addExecutable(executable); + whenCondition.setMaxWaitTime(maxWaitSeconds); + whenCondition.setMaxWaitTimeUnit(TimeUnit.SECONDS); + return whenCondition; + } + + // 判断 THEN 中是否含有 FINALLY 组件 + private boolean containsFinally(Executable executable) { + return executable instanceof ThenCondition + && CollUtil.isNotEmpty(((ThenCondition) executable).getFinallyConditionList()); + } + + // 将 FINALLY 排除在超时控制之外 + private ThenCondition handleFinally(ThenCondition thenCondition, Integer maxWaitSeconds) { + // 进行如下转换 + // THEN(PRE(a),b,FINALLY(c)) + // => THEN( + // WHEN(THEN(PRE(a),b)), + // FINALLY(c)) + + // 定义外层 THEN + ThenCondition outerThenCondition = new ThenCondition(); + + // 把 FINALLY 转移到外层 THEN + List finallyList = thenCondition.getExecutableList(ConditionKey.FINALLY_KEY); + finallyList.forEach(executable + -> outerThenCondition + .addFinallyCondition((FinallyCondition) executable)); + finallyList.clear(); + + // 包装内部 THEN + WhenCondition whenCondition = wrappedByWhen(thenCondition, maxWaitSeconds); + outerThenCondition.addExecutable(whenCondition); + + return outerThenCondition; + } +} diff --git a/liteflow-core/src/main/java/com/yomahub/liteflow/common/ChainConstant.java b/liteflow-core/src/main/java/com/yomahub/liteflow/common/ChainConstant.java index 0cdbdce99..5be9dc6fc 100644 --- a/liteflow-core/src/main/java/com/yomahub/liteflow/common/ChainConstant.java +++ b/liteflow-core/src/main/java/com/yomahub/liteflow/common/ChainConstant.java @@ -81,4 +81,6 @@ public interface ChainConstant { String NOT = "NOT"; + String MAX_WAIT_SECONDS = "maxWaitSeconds"; + } diff --git a/liteflow-core/src/main/java/com/yomahub/liteflow/flow/element/condition/WhenCondition.java b/liteflow-core/src/main/java/com/yomahub/liteflow/flow/element/condition/WhenCondition.java index f18c59d57..830aee652 100644 --- a/liteflow-core/src/main/java/com/yomahub/liteflow/flow/element/condition/WhenCondition.java +++ b/liteflow-core/src/main/java/com/yomahub/liteflow/flow/element/condition/WhenCondition.java @@ -52,6 +52,12 @@ public class WhenCondition extends Condition { // when单独的线程池名称 private String threadExecutorClass; + // 异步线程最⻓的等待时间 + private Integer maxWaitTime; + + // 等待时间单位 + private TimeUnit maxWaitTimeUnit; + @Override public void executeCondition(Integer slotIndex) throws Exception { executeAsyncCondition(slotIndex); @@ -86,15 +92,20 @@ public class WhenCondition extends Condition { // 3.根据condition.getNodeList()的集合进行流处理，用map进行把executable对象转换成List> // 4.在转的过程中，套入CompletableFutureTimeout方法进行超时判断，如果超时则用WhenFutureObj.timeOut返回超时的对象 // 5.第2个参数是主要的本体CompletableFuture，传入了ParallelSupplier和线程池对象 - Integer whenMaxWaitTime; - TimeUnit whenMaxWaitTimeUnit; + if (ObjectUtil.isNull(this.getMaxWaitTime())) { + if (ObjectUtil.isNotNull(liteflowConfig.getWhenMaxWaitSeconds())) { + // 获取全局异步线程最长等待秒数 + this.setMaxWaitTime(liteflowConfig.getWhenMaxWaitSeconds()); + this.setMaxWaitTimeUnit(TimeUnit.SECONDS); + } else { + // 获取全局异步线程最⻓的等待时间 + this.setMaxWaitTime(liteflowConfig.getWhenMaxWaitTime()); + } + } - if (ObjectUtil.isNotNull(liteflowConfig.getWhenMaxWaitSeconds())){ - whenMaxWaitTime = liteflowConfig.getWhenMaxWaitSeconds(); - whenMaxWaitTimeUnit = TimeUnit.SECONDS; - }else{ - whenMaxWaitTime = liteflowConfig.getWhenMaxWaitTime(); - whenMaxWaitTimeUnit = liteflowConfig.getWhenMaxWaitTimeUnit(); + if (ObjectUtil.isNull(this.getMaxWaitTimeUnit())) { + // 获取全局异步线程最⻓的等待时间单位 + this.setMaxWaitTimeUnit(liteflowConfig.getWhenMaxWaitTimeUnit()); } List> completableFutureList = this.getExecutableList() @@ -112,7 +123,7 @@ public class WhenCondition extends Condition { WhenFutureObj.timeOut(executable.getId()), CompletableFuture.supplyAsync(new ParallelSupplier(executable, currChainName, slotIndex), parallelExecutor), - whenMaxWaitTime, whenMaxWaitTimeUnit)) + this.getMaxWaitTime(), this.getMaxWaitTimeUnit())) .collect(Collectors.toList()); CompletableFuture resultCompletableFuture; @@ -221,4 +232,19 @@ public class WhenCondition extends Condition { this.threadExecutorClass = threadExecutorClass; } + public Integer getMaxWaitTime() { + return maxWaitTime; + } + + public void setMaxWaitTime(Integer maxWaitTime) { + this.maxWaitTime = maxWaitTime; + } + + public TimeUnit getMaxWaitTimeUnit() { + return maxWaitTimeUnit; + } + + public void setMaxWaitTimeUnit(TimeUnit maxWaitTimeUnit) { + this.maxWaitTimeUnit = maxWaitTimeUnit; + } } diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringBootTest.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringBootTest.java new file mode 100644 index 000000000..931671042 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringBootTest.java @@ -0,0 +1,184 @@ +package com.yomahub.liteflow.test.maxWaitSeconds; + +import com.yomahub.liteflow.builder.LiteFlowNodeBuilder; +import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder; +import com.yomahub.liteflow.core.FlowExecutor; +import com.yomahub.liteflow.enums.NodeTypeEnum; +import com.yomahub.liteflow.exception.WhenTimeoutException; +import com.yomahub.liteflow.flow.LiteflowResponse; +import com.yomahub.liteflow.slot.DefaultContext; +import com.yomahub.liteflow.test.BaseTest; +import com.yomahub.liteflow.test.validateRule.cmp.ACmp; +import com.yomahub.liteflow.test.validateRule.cmp.BCmp; +import com.yomahub.liteflow.test.validateRule.cmp.CCmp; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.test.context.TestPropertySource; +import org.springframework.test.context.junit4.SpringRunner; + +import javax.annotation.Resource; + +/** + * springboot环境下超时控制测试 + * + * @author DaleLee + * @since 2.11.0 + */ +@RunWith(SpringRunner.class) +@TestPropertySource(value = "classpath:/maxWaitSeconds/application.properties") +@SpringBootTest(classes = MaxWaitSecondsELSpringBootTest.class) +@EnableAutoConfiguration +@ComponentScan({ "com.yomahub.liteflow.test.maxWaitSeconds.cmp" }) +public class MaxWaitSecondsELSpringBootTest extends BaseTest { + @Resource + private FlowExecutor flowExecutor; + + public static final String CONTENT_KEY = "testKey"; + + // 测试 THEN 的超时情况 + @Test + public void testThen1() { + assertTimeout("then1"); + } + + // 测试 THEN 的非超时情况 + @Test + public void testThen2() { + assertNotTimeout("then2"); + } + + // 测试 When 的超时情况 + @Test + public void testWhen1() { + assertTimeout("when1"); + } + + // 测试 WHEN 的非超时情况 + @Test + public void testWhen2() { + assertNotTimeout("when2"); + } + + // 测试 FOR 的超时情况 + @Test + public void testFor1() { + assertTimeout("for1"); + } + + // 测试 FOR 的非超时情况 + @Test + public void testFor2() { + assertNotTimeout("for2"); + } + + // 测试 WHILE 的超时情况 + @Test + public void testWhile1() { + assertTimeout("while1"); + } + + // 测试 WHILE 的非超时情况 + @Test + public void testWhile2() { + assertNotTimeout("while2"); + } + + // 测试 ITERATOR 的超时情况 + @Test + public void testIterator1() { + assertTimeout("iterator1"); + } + + // 测试 ITERATOR 的非超时情况 + @Test + public void testIterator2() { + assertNotTimeout("iterator2"); + } + + // 测试 SWITCH 的超时情况 + @Test + public void testSwitch1() { + assertTimeout("switch1"); + } + + // 测试 SWITCH 的非超时情况 + @Test + public void testSwitch2() { + assertNotTimeout("switch2"); + } + + // 测试 IF 的超时情况 + @Test + public void testIf1() { + assertTimeout("if1"); + } + + // 测试 SWITCH 的非超时情况 + @Test + public void testIf2() { + assertNotTimeout("if2"); + } + + // 测试单个组件的超时情况 + @Test + public void testComponent1() { + assertTimeout("component1"); + } + + // 测试单个组件的非超时情况 + @Test + public void testComponent2() { + assertNotTimeout("component2"); + } + + // 测试 FINALLY，虽然超时，但 FINALLY 仍会执行 + @Test + public void testFinally1() { + LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY + DefaultContext contextBean = response.getFirstContextBean(); + Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); + + } + + // 测试 maxWaitSeconds 关键字不能作用于 Finally + @Test + public void testFinally2() { + LiteFlowNodeBuilder.createNode() + .setId("a") + .setName("组件A") + .setType(NodeTypeEnum.COMMON) + .setClazz(ACmp.class) + .build(); + LiteFlowNodeBuilder.createNode() + .setId("b") + .setName("组件B") + .setType(NodeTypeEnum.COMMON) + .setClazz(BCmp.class) + .build(); + LiteFlowNodeBuilder.createNode() + .setId("c") + .setName("组件C") + .setType(NodeTypeEnum.COMMON) + .setClazz(CCmp.class) + .build(); + Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); + } + + private void assertTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + } + + private void assertNotTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertTrue(response.isSuccess()); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java new file mode 100644 index 000000000..28a669d83 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java @@ -0,0 +1,20 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeComponent; + +import java.util.Random; + +@LiteflowComponent("a") +public class ACmp extends NodeComponent { + @Override + public void process() { + try { + Thread.sleep(1000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("ACmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java new file mode 100644 index 000000000..08bd6d21c --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java @@ -0,0 +1,18 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeComponent; + +@LiteflowComponent("b") +public class BCmp extends NodeComponent { + @Override + public void process() { + try { + Thread.sleep(2000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("BCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java new file mode 100644 index 000000000..e991188fd --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java @@ -0,0 +1,18 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeComponent; + +@LiteflowComponent("c") +public class CCmp extends NodeComponent { + @Override + public void process() { + try { + Thread.sleep(5000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("CCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java new file mode 100644 index 000000000..6e5801334 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java @@ -0,0 +1,24 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.slot.DefaultContext; + +import static com.yomahub.liteflow.test.maxWaitSeconds.MaxWaitSecondsELSpringBootTest.CONTENT_KEY; + +@LiteflowComponent("d") +public class DCmp extends NodeComponent { + + @Override + public void process() { + try { + Thread.sleep(500); + DefaultContext contextBean = this.getFirstContextBean(); + contextBean.setData(CONTENT_KEY,"value"); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("DCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java new file mode 100644 index 000000000..89ef9f92d --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java @@ -0,0 +1,12 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeIfComponent; + +@LiteflowComponent("f") +public class FCmp extends NodeIfComponent { + @Override + public boolean processIf() throws Exception { + return true; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java new file mode 100644 index 000000000..e0e138ef0 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java @@ -0,0 +1,13 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeSwitchComponent; + +@LiteflowComponent("s") +public class SCmp extends NodeSwitchComponent { + + @Override + public String processSwitch() throws Exception { + return "b"; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java new file mode 100644 index 000000000..5cb8dac0c --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java @@ -0,0 +1,14 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeWhileComponent; + +@LiteflowComponent("w") +public class WCmp extends NodeWhileComponent { + private int count = 0; + @Override + public boolean processWhile() throws Exception { + count++; + return count <= 2; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java new file mode 100644 index 000000000..c8bf8b6df --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java @@ -0,0 +1,17 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import cn.hutool.core.collection.ListUtil; +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeIteratorComponent; + +import java.util.Iterator; +import java.util.List; + +@LiteflowComponent("x") +public class XCmp extends NodeIteratorComponent { + @Override + public Iterator processIterator() throws Exception { + List list = ListUtil.toList("one", "two"); + return list.iterator(); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/resources/maxWaitSeconds/application.properties b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/resources/maxWaitSeconds/application.properties new file mode 100644 index 000000000..4dae0deff --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/resources/maxWaitSeconds/application.properties @@ -0,0 +1 @@ +liteflow.rule-source=maxWaitSeconds/flow.el.xml \ No newline at end of file diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/resources/maxWaitSeconds/flow.el.xml b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/resources/maxWaitSeconds/flow.el.xml new file mode 100644 index 000000000..e32dc3203 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/resources/maxWaitSeconds/flow.el.xml @@ -0,0 +1,98 @@ + + + + + + + THEN(a,b).maxWaitSeconds(2); + + + + THEN(a,b).maxWaitSeconds(5); + + + + + + WHEN(a,c).maxWaitSeconds(3); + + + + WHEN(a,b).maxWaitSeconds(3); + + + + + + FOR(2).DO(a).maxWaitSeconds(1); + + + + FOR(2).DO(a).maxWaitSeconds(3); + + + + + WHILE(w).DO(a).maxWaitSeconds(1); + + + + WHILE(w).DO(a).maxWaitSeconds(3); + + + + + ITERATOR(x).DO(a).maxWaitSeconds(1); + + + + ITERATOR(x).DO(a).maxWaitSeconds(3); + + + + + + + SWITCH(s).TO(a, b).maxWaitSeconds(1); + + + + SWITCH(s).TO(a, b).maxWaitSeconds(3); + + + + + + + IF(f, b, c).maxWaitSeconds(1); + + + + IF(f, b, c).maxWaitSeconds(3); + + + + + + WHEN( + a.maxWaitSeconds(2), + c.maxWaitSeconds(3) + ); + + + + WHEN( + a.maxWaitSeconds(2), + b.maxWaitSeconds(3) + ); + + + + + + THEN(PRE(a), b, FINALLY(d)).maxWaitSeconds(2); + + + \ No newline at end of file From 2ae59b8a3f8d9662bbb68dc30021042e399bc225 Mon Sep 17 00:00:00 2001 From: Dale Lee <1658850308@qq.com> Date: Sat, 8 Jul 2023 19:04:39 +0800 Subject: [PATCH 02/11] =?UTF-8?q?feature=20#I7I3LL=20=E5=A2=9E=E5=8A=A0spr?= =?UTF-8?q?ingnative=E4=B8=8B=E7=9A=84=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../MaxWaitSecondsELSpringTest.java | 172 ++++++++++++++++++ .../test/maxWaitSeconds/cmp/ACmp.java | 18 ++ .../test/maxWaitSeconds/cmp/BCmp.java | 18 ++ .../test/maxWaitSeconds/cmp/CCmp.java | 18 ++ .../test/maxWaitSeconds/cmp/DCmp.java | 25 +++ .../test/maxWaitSeconds/cmp/FCmp.java | 12 ++ .../test/maxWaitSeconds/cmp/SCmp.java | 13 ++ .../test/maxWaitSeconds/cmp/WCmp.java | 14 ++ .../test/maxWaitSeconds/cmp/XCmp.java | 17 ++ .../resources/maxWaitSeconds/application.xml | 23 +++ .../test/resources/maxWaitSeconds/flow.el.xml | 98 ++++++++++ 11 files changed, 428 insertions(+) create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/maxWaitSeconds/application.xml create mode 100644 liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/maxWaitSeconds/flow.el.xml diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java new file mode 100644 index 000000000..bc2dbd790 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java @@ -0,0 +1,172 @@ +package com.yomahub.liteflow.test.maxWaitSeconds; + +import com.yomahub.liteflow.builder.LiteFlowNodeBuilder; +import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder; +import com.yomahub.liteflow.core.FlowExecutor; +import com.yomahub.liteflow.enums.NodeTypeEnum; +import com.yomahub.liteflow.exception.WhenTimeoutException; +import com.yomahub.liteflow.flow.LiteflowResponse; +import com.yomahub.liteflow.slot.DefaultContext; +import com.yomahub.liteflow.test.BaseTest; +import com.yomahub.liteflow.test.maxWaitSeconds.cmp.ACmp; +import com.yomahub.liteflow.test.maxWaitSeconds.cmp.BCmp; +import com.yomahub.liteflow.test.maxWaitSeconds.cmp.CCmp; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringRunner; + +import javax.annotation.Resource; + +import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; + +@RunWith(SpringRunner.class) +@ContextConfiguration("classpath:/maxWaitSeconds/application.xml") +public class MaxWaitSecondsELSpringTest extends BaseTest { + @Resource + private FlowExecutor flowExecutor; + + // 测试 THEN 的超时情况 + @Test + public void testThen1() { + assertTimeout("then1"); + } + + // 测试 THEN 的非超时情况 + @Test + public void testThen2() { + assertNotTimeout("then2"); + } + + // 测试 When 的超时情况 + @Test + public void testWhen1() { + assertTimeout("when1"); + } + + // 测试 WHEN 的非超时情况 + @Test + public void testWhen2() { + assertNotTimeout("when2"); + } + + // 测试 FOR 的超时情况 + @Test + public void testFor1() { + assertTimeout("for1"); + } + + // 测试 FOR 的非超时情况 + @Test + public void testFor2() { + assertNotTimeout("for2"); + } + + // 测试 WHILE 的超时情况 + @Test + public void testWhile1() { + assertTimeout("while1"); + } + + // 测试 WHILE 的非超时情况 + @Test + public void testWhile2() { + assertNotTimeout("while2"); + } + + // 测试 ITERATOR 的超时情况 + @Test + public void testIterator1() { + assertTimeout("iterator1"); + } + + // 测试 ITERATOR 的非超时情况 + @Test + public void testIterator2() { + assertNotTimeout("iterator2"); + } + + // 测试 SWITCH 的超时情况 + @Test + public void testSwitch1() { + assertTimeout("switch1"); + } + + // 测试 SWITCH 的非超时情况 + @Test + public void testSwitch2() { + assertNotTimeout("switch2"); + } + + // 测试 IF 的超时情况 + @Test + public void testIf1() { + assertTimeout("if1"); + } + + // 测试 SWITCH 的非超时情况 + @Test + public void testIf2() { + assertNotTimeout("if2"); + } + + // 测试单个组件的超时情况 + @Test + public void testComponent1() { + assertTimeout("component1"); + } + + // 测试单个组件的非超时情况 + @Test + public void testComponent2() { + assertNotTimeout("component2"); + } + + // 测试 FINALLY，虽然超时，但 FINALLY 仍会执行 + @Test + public void testFinally1() { + LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY + DefaultContext contextBean = response.getFirstContextBean(); + Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); + + } + + // 测试 maxWaitSeconds 关键字不能作用于 Finally + @Test + public void testFinally2() { + LiteFlowNodeBuilder.createNode() + .setId("a") + .setName("组件A") + .setType(NodeTypeEnum.COMMON) + .setClazz(ACmp.class) + .build(); + LiteFlowNodeBuilder.createNode() + .setId("b") + .setName("组件B") + .setType(NodeTypeEnum.COMMON) + .setClazz(BCmp.class) + .build(); + LiteFlowNodeBuilder.createNode() + .setId("c") + .setName("组件C") + .setType(NodeTypeEnum.COMMON) + .setClazz(CCmp.class) + .build(); + Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); + } + + private void assertTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + } + + private void assertNotTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertTrue(response.isSuccess()); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java new file mode 100644 index 000000000..1b76405be --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java @@ -0,0 +1,18 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeComponent; + +@LiteflowComponent("a") +public class ACmp extends NodeComponent { + @Override + public void process() { + try { + Thread.sleep(1000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("ACmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java new file mode 100644 index 000000000..08bd6d21c --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java @@ -0,0 +1,18 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeComponent; + +@LiteflowComponent("b") +public class BCmp extends NodeComponent { + @Override + public void process() { + try { + Thread.sleep(2000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("BCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java new file mode 100644 index 000000000..e991188fd --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java @@ -0,0 +1,18 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeComponent; + +@LiteflowComponent("c") +public class CCmp extends NodeComponent { + @Override + public void process() { + try { + Thread.sleep(5000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("CCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java new file mode 100644 index 000000000..c502d7c31 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java @@ -0,0 +1,25 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.slot.DefaultContext; + + +@LiteflowComponent("d") +public class DCmp extends NodeComponent { + + public static final String CONTENT_KEY = "testKey"; + + @Override + public void process() { + try { + Thread.sleep(500); + DefaultContext contextBean = this.getFirstContextBean(); + contextBean.setData(CONTENT_KEY, "value"); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("DCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java new file mode 100644 index 000000000..89ef9f92d --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java @@ -0,0 +1,12 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeIfComponent; + +@LiteflowComponent("f") +public class FCmp extends NodeIfComponent { + @Override + public boolean processIf() throws Exception { + return true; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java new file mode 100644 index 000000000..e0e138ef0 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java @@ -0,0 +1,13 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeSwitchComponent; + +@LiteflowComponent("s") +public class SCmp extends NodeSwitchComponent { + + @Override + public String processSwitch() throws Exception { + return "b"; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java new file mode 100644 index 000000000..5cb8dac0c --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java @@ -0,0 +1,14 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeWhileComponent; + +@LiteflowComponent("w") +public class WCmp extends NodeWhileComponent { + private int count = 0; + @Override + public boolean processWhile() throws Exception { + count++; + return count <= 2; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java new file mode 100644 index 000000000..c8bf8b6df --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java @@ -0,0 +1,17 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import cn.hutool.core.collection.ListUtil; +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeIteratorComponent; + +import java.util.Iterator; +import java.util.List; + +@LiteflowComponent("x") +public class XCmp extends NodeIteratorComponent { + @Override + public Iterator processIterator() throws Exception { + List list = ListUtil.toList("one", "two"); + return list.iterator(); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/maxWaitSeconds/application.xml b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/maxWaitSeconds/application.xml new file mode 100644 index 000000000..3d968adea --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/maxWaitSeconds/application.xml @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/maxWaitSeconds/flow.el.xml b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/maxWaitSeconds/flow.el.xml new file mode 100644 index 000000000..e32dc3203 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/maxWaitSeconds/flow.el.xml @@ -0,0 +1,98 @@ + + + + + + + THEN(a,b).maxWaitSeconds(2); + + + + THEN(a,b).maxWaitSeconds(5); + + + + + + WHEN(a,c).maxWaitSeconds(3); + + + + WHEN(a,b).maxWaitSeconds(3); + + + + + + FOR(2).DO(a).maxWaitSeconds(1); + + + + FOR(2).DO(a).maxWaitSeconds(3); + + + + + WHILE(w).DO(a).maxWaitSeconds(1); + + + + WHILE(w).DO(a).maxWaitSeconds(3); + + + + + ITERATOR(x).DO(a).maxWaitSeconds(1); + + + + ITERATOR(x).DO(a).maxWaitSeconds(3); + + + + + + + SWITCH(s).TO(a, b).maxWaitSeconds(1); + + + + SWITCH(s).TO(a, b).maxWaitSeconds(3); + + + + + + + IF(f, b, c).maxWaitSeconds(1); + + + + IF(f, b, c).maxWaitSeconds(3); + + + + + + WHEN( + a.maxWaitSeconds(2), + c.maxWaitSeconds(3) + ); + + + + WHEN( + a.maxWaitSeconds(2), + b.maxWaitSeconds(3) + ); + + + + + + THEN(PRE(a), b, FINALLY(d)).maxWaitSeconds(2); + + + \ No newline at end of file From c9ed2337d2f0d85e4335786939e5846f86fa180a Mon Sep 17 00:00:00 2001 From: Dale Lee <1658850308@qq.com> Date: Sat, 8 Jul 2023 19:24:13 +0800 Subject: [PATCH 03/11] =?UTF-8?q?feature=20#I7I3LL=20=E5=A2=9E=E5=8A=A0nos?= =?UTF-8?q?pring=E4=B8=8B=E7=9A=84=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../maxWaitSeconds/MaxWaitSecondsTest.java | 176 ++++++++++++++++++ .../test/maxWaitSeconds/cmp/ACmp.java | 16 ++ .../test/maxWaitSeconds/cmp/BCmp.java | 16 ++ .../test/maxWaitSeconds/cmp/CCmp.java | 16 ++ .../test/maxWaitSeconds/cmp/DCmp.java | 23 +++ .../test/maxWaitSeconds/cmp/FCmp.java | 10 + .../test/maxWaitSeconds/cmp/SCmp.java | 11 ++ .../test/maxWaitSeconds/cmp/WCmp.java | 12 ++ .../test/maxWaitSeconds/cmp/XCmp.java | 15 ++ .../test/resources/maxWaitSeconds/flow.el.xml | 108 +++++++++++ 10 files changed, 403 insertions(+) create mode 100644 liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/resources/maxWaitSeconds/flow.el.xml diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java new file mode 100644 index 000000000..7746dcaa2 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java @@ -0,0 +1,176 @@ +package com.yomahub.liteflow.test.maxWaitSeconds; + +import com.yomahub.liteflow.builder.LiteFlowNodeBuilder; +import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder; +import com.yomahub.liteflow.core.FlowExecutor; +import com.yomahub.liteflow.core.FlowExecutorHolder; +import com.yomahub.liteflow.enums.NodeTypeEnum; +import com.yomahub.liteflow.exception.WhenTimeoutException; +import com.yomahub.liteflow.flow.LiteflowResponse; +import com.yomahub.liteflow.property.LiteflowConfig; +import com.yomahub.liteflow.slot.DefaultContext; +import com.yomahub.liteflow.test.BaseTest; +import com.yomahub.liteflow.test.maxWaitSeconds.cmp.ACmp; +import com.yomahub.liteflow.test.maxWaitSeconds.cmp.BCmp; +import com.yomahub.liteflow.test.maxWaitSeconds.cmp.CCmp; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; + +import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; + +public class MaxWaitSecondsTest extends BaseTest { + + private static FlowExecutor flowExecutor; + + @BeforeClass + public static void init() { + LiteflowConfig config = new LiteflowConfig(); + config.setRuleSource("maxWaitSeconds/flow.el.xml"); + flowExecutor = FlowExecutorHolder.loadInstance(config); + } + + // 测试 THEN 的超时情况 + @Test + public void testThen1() { + assertTimeout("then1"); + } + + // 测试 THEN 的非超时情况 + @Test + public void testThen2() { + assertNotTimeout("then2"); + } + + // 测试 When 的超时情况 + @Test + public void testWhen1() { + assertTimeout("when1"); + } + + // 测试 WHEN 的非超时情况 + @Test + public void testWhen2() { + assertNotTimeout("when2"); + } + + // 测试 FOR 的超时情况 + @Test + public void testFor1() { + assertTimeout("for1"); + } + + // 测试 FOR 的非超时情况 + @Test + public void testFor2() { + assertNotTimeout("for2"); + } + + // 测试 WHILE 的超时情况 + @Test + public void testWhile1() { + assertTimeout("while1"); + } + + // 测试 WHILE 的非超时情况 + @Test + public void testWhile2() { + assertNotTimeout("while2"); + } + + // 测试 ITERATOR 的超时情况 + @Test + public void testIterator1() { + assertTimeout("iterator1"); + } + + // 测试 ITERATOR 的非超时情况 + @Test + public void testIterator2() { + assertNotTimeout("iterator2"); + } + + // 测试 SWITCH 的超时情况 + @Test + public void testSwitch1() { + assertTimeout("switch1"); + } + + // 测试 SWITCH 的非超时情况 + @Test + public void testSwitch2() { + assertNotTimeout("switch2"); + } + + // 测试 IF 的超时情况 + @Test + public void testIf1() { + assertTimeout("if1"); + } + + // 测试 SWITCH 的非超时情况 + @Test + public void testIf2() { + assertNotTimeout("if2"); + } + + // 测试单个组件的超时情况 + @Test + public void testComponent1() { + assertTimeout("component1"); + } + + // 测试单个组件的非超时情况 + @Test + public void testComponent2() { + assertNotTimeout("component2"); + } + + // 测试 FINALLY，虽然超时，但 FINALLY 仍会执行 + @Test + public void testFinally1() { + LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY + DefaultContext contextBean = response.getFirstContextBean(); + Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); + + } + + // 测试 maxWaitSeconds 关键字不能作用于 Finally + @Test + public void testFinally2() { + LiteFlowNodeBuilder.createNode() + .setId("a") + .setName("组件A") + .setType(NodeTypeEnum.COMMON) + .setClazz(ACmp.class) + .build(); + LiteFlowNodeBuilder.createNode() + .setId("b") + .setName("组件B") + .setType(NodeTypeEnum.COMMON) + .setClazz(BCmp.class) + .build(); + LiteFlowNodeBuilder.createNode() + .setId("c") + .setName("组件C") + .setType(NodeTypeEnum.COMMON) + .setClazz(CCmp.class) + .build(); + Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); + } + + private void assertTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + } + + private void assertNotTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertTrue(response.isSuccess()); + } + +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java new file mode 100644 index 000000000..9973aafbc --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java @@ -0,0 +1,16 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.core.NodeComponent; + +public class ACmp extends NodeComponent { + @Override + public void process() { + try { + Thread.sleep(1000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("ACmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java new file mode 100644 index 000000000..318ee981a --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java @@ -0,0 +1,16 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.core.NodeComponent; + +public class BCmp extends NodeComponent { + @Override + public void process() { + try { + Thread.sleep(2000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("BCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java new file mode 100644 index 000000000..ae8d7df50 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java @@ -0,0 +1,16 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.core.NodeComponent; + +public class CCmp extends NodeComponent { + @Override + public void process() { + try { + Thread.sleep(5000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("CCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java new file mode 100644 index 000000000..0a018819a --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java @@ -0,0 +1,23 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.slot.DefaultContext; + + +public class DCmp extends NodeComponent { + + public static final String CONTENT_KEY = "testKey"; + + @Override + public void process() { + try { + Thread.sleep(500); + DefaultContext contextBean = this.getFirstContextBean(); + contextBean.setData(CONTENT_KEY, "value"); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("DCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java new file mode 100644 index 000000000..d22ecdf4f --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java @@ -0,0 +1,10 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.core.NodeIfComponent; + +public class FCmp extends NodeIfComponent { + @Override + public boolean processIf() throws Exception { + return true; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java new file mode 100644 index 000000000..fef1f06c0 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java @@ -0,0 +1,11 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.core.NodeSwitchComponent; + +public class SCmp extends NodeSwitchComponent { + + @Override + public String processSwitch() throws Exception { + return "b"; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java new file mode 100644 index 000000000..42f9ca172 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java @@ -0,0 +1,12 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.core.NodeWhileComponent; + +public class WCmp extends NodeWhileComponent { + private int count = 0; + @Override + public boolean processWhile() throws Exception { + count++; + return count <= 2; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java new file mode 100644 index 000000000..0a637bde0 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java @@ -0,0 +1,15 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import cn.hutool.core.collection.ListUtil; +import com.yomahub.liteflow.core.NodeIteratorComponent; + +import java.util.Iterator; +import java.util.List; + +public class XCmp extends NodeIteratorComponent { + @Override + public Iterator processIterator() throws Exception { + List list = ListUtil.toList("one", "two"); + return list.iterator(); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/resources/maxWaitSeconds/flow.el.xml b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/resources/maxWaitSeconds/flow.el.xml new file mode 100644 index 000000000..14bb4d482 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/resources/maxWaitSeconds/flow.el.xml @@ -0,0 +1,108 @@ + + + + + + + + + + + + + + + + + THEN(a,b).maxWaitSeconds(2); + + + + THEN(a,b).maxWaitSeconds(5); + + + + + + WHEN(a,c).maxWaitSeconds(3); + + + + WHEN(a,b).maxWaitSeconds(3); + + + + + + FOR(2).DO(a).maxWaitSeconds(1); + + + + FOR(2).DO(a).maxWaitSeconds(3); + + + + + WHILE(w).DO(a).maxWaitSeconds(1); + + + + WHILE(w).DO(a).maxWaitSeconds(3); + + + + + ITERATOR(x).DO(a).maxWaitSeconds(1); + + + + ITERATOR(x).DO(a).maxWaitSeconds(3); + + + + + + + SWITCH(s).TO(a, b).maxWaitSeconds(1); + + + + SWITCH(s).TO(a, b).maxWaitSeconds(3); + + + + + + + IF(f, b, c).maxWaitSeconds(1); + + + + IF(f, b, c).maxWaitSeconds(3); + + + + + + WHEN( + a.maxWaitSeconds(2), + c.maxWaitSeconds(3) + ); + + + + WHEN( + a.maxWaitSeconds(2), + b.maxWaitSeconds(3) + ); + + + + + + THEN(PRE(a), b, FINALLY(d)).maxWaitSeconds(2); + + + \ No newline at end of file From 2d1e5b4ede47048cef92c0312011f7459c890d32 Mon Sep 17 00:00:00 2001 From: Dale Lee <1658850308@qq.com> Date: Sat, 8 Jul 2023 20:20:36 +0800 Subject: [PATCH 04/11] =?UTF-8?q?feature=20#I7I3LL=20=E5=A2=9E=E5=8A=A0dec?= =?UTF-8?q?lare-springboot=E4=B8=8B=E7=9A=84=E6=B5=8B=E8=AF=95=E7=94=A8?= =?UTF-8?q?=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../MaxWaitSecondsELDeclSpringBootTest.java | 184 ++++++++++++++++++ .../test/maxWaitSeconds/cmp/ACmp.java | 21 ++ .../test/maxWaitSeconds/cmp/BCmp.java | 21 ++ .../test/maxWaitSeconds/cmp/CCmp.java | 21 ++ .../test/maxWaitSeconds/cmp/DCmp.java | 26 +++ .../test/maxWaitSeconds/cmp/FCmp.java | 18 ++ .../test/maxWaitSeconds/cmp/SCmp.java | 18 ++ .../test/maxWaitSeconds/cmp/WCmp.java | 20 ++ .../test/maxWaitSeconds/cmp/XCmp.java | 23 +++ .../maxWaitSeconds/application.properties | 1 + .../test/resources/maxWaitSeconds/flow.el.xml | 98 ++++++++++ 11 files changed, 451 insertions(+) create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringBootTest.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/resources/maxWaitSeconds/application.properties create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/resources/maxWaitSeconds/flow.el.xml diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringBootTest.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringBootTest.java new file mode 100644 index 000000000..c74ee5796 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringBootTest.java @@ -0,0 +1,184 @@ +package com.yomahub.liteflow.test.maxWaitSeconds; + +import com.yomahub.liteflow.builder.LiteFlowNodeBuilder; +import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder; +import com.yomahub.liteflow.core.FlowExecutor; +import com.yomahub.liteflow.enums.NodeTypeEnum; +import com.yomahub.liteflow.exception.WhenTimeoutException; +import com.yomahub.liteflow.flow.LiteflowResponse; +import com.yomahub.liteflow.slot.DefaultContext; +import com.yomahub.liteflow.test.BaseTest; +import com.yomahub.liteflow.test.loop.LoopELDeclSpringbootTest; +import com.yomahub.liteflow.test.maxWaitSeconds.cmp.ACmp; +import com.yomahub.liteflow.test.maxWaitSeconds.cmp.BCmp; +import com.yomahub.liteflow.test.maxWaitSeconds.cmp.CCmp; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.test.context.TestPropertySource; +import org.springframework.test.context.junit4.SpringRunner; + +import javax.annotation.Resource; + +import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; + +/** + * springboot环境下超时控制测试 + * + * @author DaleLee + * @since 2.11.0 + */ +@RunWith(SpringRunner.class) +@TestPropertySource(value = "classpath:/maxWaitSeconds/application.properties") +@SpringBootTest(classes = MaxWaitSecondsELDeclSpringBootTest.class) +@EnableAutoConfiguration +@ComponentScan({ "com.yomahub.liteflow.test.maxWaitSeconds.cmp" }) +public class MaxWaitSecondsELDeclSpringBootTest extends BaseTest { + @Resource + private FlowExecutor flowExecutor; + + // 测试 THEN 的超时情况 + @Test + public void testThen1() { + assertTimeout("then1"); + } + + // 测试 THEN 的非超时情况 + @Test + public void testThen2() { + assertNotTimeout("then2"); + } + + // 测试 When 的超时情况 + @Test + public void testWhen1() { + assertTimeout("when1"); + } + + // 测试 WHEN 的非超时情况 + @Test + public void testWhen2() { + assertNotTimeout("when2"); + } + + // 测试 FOR 的超时情况 + @Test + public void testFor1() { + assertTimeout("for1"); + } + + // 测试 FOR 的非超时情况 + @Test + public void testFor2() { + assertNotTimeout("for2"); + } + + // 测试 WHILE 的超时情况 + @Test + public void testWhile1() { + assertTimeout("while1"); + } + + // 测试 WHILE 的非超时情况 + @Test + public void testWhile2() { + assertNotTimeout("while2"); + } + + // 测试 ITERATOR 的超时情况 + @Test + public void testIterator1() { + assertTimeout("iterator1"); + } + + // 测试 ITERATOR 的非超时情况 + @Test + public void testIterator2() { + assertNotTimeout("iterator2"); + } + + // 测试 SWITCH 的超时情况 + @Test + public void testSwitch1() { + assertTimeout("switch1"); + } + + // 测试 SWITCH 的非超时情况 + @Test + public void testSwitch2() { + assertNotTimeout("switch2"); + } + + // 测试 IF 的超时情况 + @Test + public void testIf1() { + assertTimeout("if1"); + } + + // 测试 SWITCH 的非超时情况 + @Test + public void testIf2() { + assertNotTimeout("if2"); + } + + // 测试单个组件的超时情况 + @Test + public void testComponent1() { + assertTimeout("component1"); + } + + // 测试单个组件的非超时情况 + @Test + public void testComponent2() { + assertNotTimeout("component2"); + } + + // 测试 FINALLY，虽然超时，但 FINALLY 仍会执行 + @Test + public void testFinally1() { + LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY + DefaultContext contextBean = response.getFirstContextBean(); + Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); + } + + // 测试 maxWaitSeconds 关键字不能作用于 Finally + @Test + public void testFinally2() { + LiteFlowNodeBuilder.createNode() + .setId("a") + .setName("组件A") + .setType(NodeTypeEnum.COMMON) + .setClazz(ACmp.class) + .build(); + LiteFlowNodeBuilder.createNode() + .setId("b") + .setName("组件B") + .setType(NodeTypeEnum.COMMON) + .setClazz(BCmp.class) + .build(); + LiteFlowNodeBuilder.createNode() + .setId("c") + .setName("组件C") + .setType(NodeTypeEnum.COMMON) + .setClazz(CCmp.class) + .build(); + Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); + } + + private void assertTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + } + + private void assertNotTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertTrue(response.isSuccess()); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java new file mode 100644 index 000000000..9afb4ff80 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java @@ -0,0 +1,21 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.annotation.LiteflowMethod; +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.enums.LiteFlowMethodEnum; + +@LiteflowComponent("a") +public class ACmp { + + @LiteflowMethod(LiteFlowMethodEnum.PROCESS) + public void process(NodeComponent bindCmp) { + try { + Thread.sleep(1000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("ACmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java new file mode 100644 index 000000000..aefcba9ea --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java @@ -0,0 +1,21 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.annotation.LiteflowMethod; +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.enums.LiteFlowMethodEnum; + +@LiteflowComponent("b") +public class BCmp { + + @LiteflowMethod(LiteFlowMethodEnum.PROCESS) + public void process(NodeComponent bindCmp) { + try { + Thread.sleep(2000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("BCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java new file mode 100644 index 000000000..4127c8bb6 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java @@ -0,0 +1,21 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.annotation.LiteflowMethod; +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.enums.LiteFlowMethodEnum; + +@LiteflowComponent("c") +public class CCmp { + + @LiteflowMethod(LiteFlowMethodEnum.PROCESS) + public void process(NodeComponent bindCmp) { + try { + Thread.sleep(5000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("CCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java new file mode 100644 index 000000000..248f31471 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java @@ -0,0 +1,26 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.annotation.LiteflowMethod; +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.enums.LiteFlowMethodEnum; +import com.yomahub.liteflow.slot.DefaultContext; + +@LiteflowComponent("d") +public class DCmp { + + public static final String CONTENT_KEY = "testKey"; + + @LiteflowMethod(LiteFlowMethodEnum.PROCESS) + public void process(NodeComponent bindCmp) { + try { + Thread.sleep(500); + DefaultContext contextBean = bindCmp.getFirstContextBean(); + contextBean.setData(CONTENT_KEY, "value"); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("DCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java new file mode 100644 index 000000000..f2b3bd1c3 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java @@ -0,0 +1,18 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowCmpDefine; +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.annotation.LiteflowMethod; +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.enums.LiteFlowMethodEnum; +import com.yomahub.liteflow.enums.NodeTypeEnum; + +@LiteflowComponent("f") +@LiteflowCmpDefine(NodeTypeEnum.IF) +public class FCmp { + + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS_IF, nodeType = NodeTypeEnum.IF) + public boolean processIf(NodeComponent bindCmp) throws Exception { + return true; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java new file mode 100644 index 000000000..d81b5d471 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java @@ -0,0 +1,18 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowCmpDefine; +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.annotation.LiteflowMethod; +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.enums.LiteFlowMethodEnum; +import com.yomahub.liteflow.enums.NodeTypeEnum; + +@LiteflowComponent("s") +@LiteflowCmpDefine(NodeTypeEnum.SWITCH) +public class SCmp { + + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS_SWITCH, nodeType = NodeTypeEnum.SWITCH) + public String processSwitch(NodeComponent bindCmp) throws Exception { + return "b"; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java new file mode 100644 index 000000000..3f1dbcdd3 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java @@ -0,0 +1,20 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowCmpDefine; +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.annotation.LiteflowMethod; +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.enums.LiteFlowMethodEnum; +import com.yomahub.liteflow.enums.NodeTypeEnum; + +@LiteflowComponent("w") +@LiteflowCmpDefine(NodeTypeEnum.WHILE) +public class WCmp { + private int count = 0; + + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS_WHILE, nodeType = NodeTypeEnum.WHILE) + public boolean processWhile(NodeComponent bindCmp) throws Exception { + count++; + return count <= 2; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java new file mode 100644 index 000000000..b1c06ade4 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java @@ -0,0 +1,23 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import cn.hutool.core.collection.ListUtil; +import com.yomahub.liteflow.annotation.LiteflowCmpDefine; +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.annotation.LiteflowMethod; +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.enums.LiteFlowMethodEnum; +import com.yomahub.liteflow.enums.NodeTypeEnum; + +import java.util.Iterator; +import java.util.List; + +@LiteflowComponent("x") +@LiteflowCmpDefine(NodeTypeEnum.ITERATOR) +public class XCmp { + + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS_ITERATOR, nodeType = NodeTypeEnum.ITERATOR) + public Iterator processIterator(NodeComponent bindCmp) throws Exception { + List list = ListUtil.toList("one", "two"); + return list.iterator(); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/resources/maxWaitSeconds/application.properties b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/resources/maxWaitSeconds/application.properties new file mode 100644 index 000000000..4dae0deff --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/resources/maxWaitSeconds/application.properties @@ -0,0 +1 @@ +liteflow.rule-source=maxWaitSeconds/flow.el.xml \ No newline at end of file diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/resources/maxWaitSeconds/flow.el.xml b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/resources/maxWaitSeconds/flow.el.xml new file mode 100644 index 000000000..e32dc3203 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/resources/maxWaitSeconds/flow.el.xml @@ -0,0 +1,98 @@ + + + + + + + THEN(a,b).maxWaitSeconds(2); + + + + THEN(a,b).maxWaitSeconds(5); + + + + + + WHEN(a,c).maxWaitSeconds(3); + + + + WHEN(a,b).maxWaitSeconds(3); + + + + + + FOR(2).DO(a).maxWaitSeconds(1); + + + + FOR(2).DO(a).maxWaitSeconds(3); + + + + + WHILE(w).DO(a).maxWaitSeconds(1); + + + + WHILE(w).DO(a).maxWaitSeconds(3); + + + + + ITERATOR(x).DO(a).maxWaitSeconds(1); + + + + ITERATOR(x).DO(a).maxWaitSeconds(3); + + + + + + + SWITCH(s).TO(a, b).maxWaitSeconds(1); + + + + SWITCH(s).TO(a, b).maxWaitSeconds(3); + + + + + + + IF(f, b, c).maxWaitSeconds(1); + + + + IF(f, b, c).maxWaitSeconds(3); + + + + + + WHEN( + a.maxWaitSeconds(2), + c.maxWaitSeconds(3) + ); + + + + WHEN( + a.maxWaitSeconds(2), + b.maxWaitSeconds(3) + ); + + + + + + THEN(PRE(a), b, FINALLY(d)).maxWaitSeconds(2); + + + \ No newline at end of file From 8d6ae38bf3b06fc937743fe8e4b0cda863b5a7dd Mon Sep 17 00:00:00 2001 From: Dale Lee <1658850308@qq.com> Date: Sat, 8 Jul 2023 21:50:55 +0800 Subject: [PATCH 05/11] =?UTF-8?q?feature=20#I7I3LL=20=E5=A2=9E=E5=8A=A0dec?= =?UTF-8?q?lare-multi-springboot=E4=B8=8B=E7=9A=84=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...xWaitSecondsELDeclMultiSpringbootTest.java | 160 ++++++++++++++++++ .../test/maxWaitSeconds/cmp/CmpConfig.java | 95 +++++++++++ .../maxWaitSeconds/application.properties | 1 + .../test/resources/maxWaitSeconds/flow.el.xml | 98 +++++++++++ 4 files changed, 354 insertions(+) create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CmpConfig.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/resources/maxWaitSeconds/application.properties create mode 100644 liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/resources/maxWaitSeconds/flow.el.xml diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java new file mode 100644 index 000000000..c853b3458 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java @@ -0,0 +1,160 @@ +package com.yomahub.liteflow.test.maxWaitSeconds; + +import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder; +import com.yomahub.liteflow.core.FlowExecutor; +import com.yomahub.liteflow.exception.WhenTimeoutException; +import com.yomahub.liteflow.flow.LiteflowResponse; +import com.yomahub.liteflow.slot.DefaultContext; +import com.yomahub.liteflow.test.BaseTest; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.test.context.TestPropertySource; +import org.springframework.test.context.junit4.SpringRunner; + +import javax.annotation.Resource; + +import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.CmpConfig.CONTENT_KEY; + +/** + * springboot环境下超时控制测试 + * + * @author DaleLee + * @since 2.11.0 + */ +@RunWith(SpringRunner.class) +@TestPropertySource(value = "classpath:/maxWaitSeconds/application.properties") +@SpringBootTest(classes = MaxWaitSecondsELDeclMultiSpringbootTest.class) +@EnableAutoConfiguration +@ComponentScan({ "com.yomahub.liteflow.test.maxWaitSeconds.cmp" }) +public class MaxWaitSecondsELDeclMultiSpringbootTest extends BaseTest { + @Resource + private FlowExecutor flowExecutor; + + // 测试 THEN 的超时情况 + @Test + public void testThen1() { + assertTimeout("then1"); + } + + // 测试 THEN 的非超时情况 + @Test + public void testThen2() { + assertNotTimeout("then2"); + } + + // 测试 When 的超时情况 + @Test + public void testWhen1() { + assertTimeout("when1"); + } + + // 测试 WHEN 的非超时情况 + @Test + public void testWhen2() { + assertNotTimeout("when2"); + } + + // 测试 FOR 的超时情况 + @Test + public void testFor1() { + assertTimeout("for1"); + } + + // 测试 FOR 的非超时情况 + @Test + public void testFor2() { + assertNotTimeout("for2"); + } + + // 测试 WHILE 的超时情况 + @Test + public void testWhile1() { + assertTimeout("while1"); + } + + // 测试 WHILE 的非超时情况 + @Test + public void testWhile2() { + assertNotTimeout("while2"); + } + + // 测试 ITERATOR 的超时情况 + @Test + public void testIterator1() { + assertTimeout("iterator1"); + } + + // 测试 ITERATOR 的非超时情况 + @Test + public void testIterator2() { + assertNotTimeout("iterator2"); + } + + // 测试 SWITCH 的超时情况 + @Test + public void testSwitch1() { + assertTimeout("switch1"); + } + + // 测试 SWITCH 的非超时情况 + @Test + public void testSwitch2() { + assertNotTimeout("switch2"); + } + + // 测试 IF 的超时情况 + @Test + public void testIf1() { + assertTimeout("if1"); + } + + // 测试 SWITCH 的非超时情况 + @Test + public void testIf2() { + assertNotTimeout("if2"); + } + + // 测试单个组件的超时情况 + @Test + public void testComponent1() { + assertTimeout("component1"); + } + + // 测试单个组件的非超时情况 + @Test + public void testComponent2() { + assertNotTimeout("component2"); + } + + // 测试 FINALLY，虽然超时，但 FINALLY 仍会执行 + @Test + public void testFinally1() { + LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY + DefaultContext contextBean = response.getFirstContextBean(); + Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); + } + + // 测试 maxWaitSeconds 关键字不能作用于 Finally + @Test + public void testFinally2() { + Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); + } + + private void assertTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + } + + private void assertNotTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertTrue(response.isSuccess()); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CmpConfig.java b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CmpConfig.java new file mode 100644 index 000000000..40abe9009 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CmpConfig.java @@ -0,0 +1,95 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import cn.hutool.core.collection.ListUtil; +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.annotation.LiteflowMethod; +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.enums.LiteFlowMethodEnum; +import com.yomahub.liteflow.enums.NodeTypeEnum; +import com.yomahub.liteflow.slot.DefaultContext; + +import java.util.Iterator; +import java.util.List; + +@LiteflowComponent +public class CmpConfig { + + public static final String CONTENT_KEY = "testKey"; + + private int count = 0; + + private boolean changed = false; + + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "a") + public void processA(NodeComponent bindCmp) { + try { + Thread.sleep(1000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("ACmp executed!"); + } + + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "b") + public void processB(NodeComponent bindCmp) { + try { + Thread.sleep(2000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("BCmp executed!"); + } + + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "c") + public void process(NodeComponent bindCmp) { + try { + Thread.sleep(5000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("CCmp executed!"); + } + + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "d") + public void processD(NodeComponent bindCmp) { + try { + Thread.sleep(500); + DefaultContext contextBean = bindCmp.getFirstContextBean(); + contextBean.setData(CONTENT_KEY, "value"); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("DCmp executed!"); + } + + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS_IF, nodeId = "f", nodeType = NodeTypeEnum.IF) + public boolean processIf(NodeComponent bindCmp) throws Exception { + return true; + } + + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS_SWITCH, nodeId = "s", nodeType = NodeTypeEnum.SWITCH) + public String processSwitch(NodeComponent bindCmp) throws Exception { + return "b"; + } + + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS_WHILE, nodeId = "w", nodeType = NodeTypeEnum.WHILE) + public boolean processWhile(NodeComponent bindCmp) throws Exception { + // 判断是否切换了 chain + if (bindCmp.getCurrChainId().equals("while2") && !changed) { + count = 0; + changed = true; + } + count++; + return count <= 2; + } + + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS_ITERATOR, nodeId = "x", nodeType = NodeTypeEnum.ITERATOR) + public Iterator processIterator(NodeComponent bindCmp) throws Exception { + List list = ListUtil.toList("one", "two"); + return list.iterator(); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/resources/maxWaitSeconds/application.properties b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/resources/maxWaitSeconds/application.properties new file mode 100644 index 000000000..4dae0deff --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/resources/maxWaitSeconds/application.properties @@ -0,0 +1 @@ +liteflow.rule-source=maxWaitSeconds/flow.el.xml \ No newline at end of file diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/resources/maxWaitSeconds/flow.el.xml b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/resources/maxWaitSeconds/flow.el.xml new file mode 100644 index 000000000..e32dc3203 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/resources/maxWaitSeconds/flow.el.xml @@ -0,0 +1,98 @@ + + + + + + + THEN(a,b).maxWaitSeconds(2); + + + + THEN(a,b).maxWaitSeconds(5); + + + + + + WHEN(a,c).maxWaitSeconds(3); + + + + WHEN(a,b).maxWaitSeconds(3); + + + + + + FOR(2).DO(a).maxWaitSeconds(1); + + + + FOR(2).DO(a).maxWaitSeconds(3); + + + + + WHILE(w).DO(a).maxWaitSeconds(1); + + + + WHILE(w).DO(a).maxWaitSeconds(3); + + + + + ITERATOR(x).DO(a).maxWaitSeconds(1); + + + + ITERATOR(x).DO(a).maxWaitSeconds(3); + + + + + + + SWITCH(s).TO(a, b).maxWaitSeconds(1); + + + + SWITCH(s).TO(a, b).maxWaitSeconds(3); + + + + + + + IF(f, b, c).maxWaitSeconds(1); + + + + IF(f, b, c).maxWaitSeconds(3); + + + + + + WHEN( + a.maxWaitSeconds(2), + c.maxWaitSeconds(3) + ); + + + + WHEN( + a.maxWaitSeconds(2), + b.maxWaitSeconds(3) + ); + + + + + + THEN(PRE(a), b, FINALLY(d)).maxWaitSeconds(2); + + + \ No newline at end of file From 5e095553cfdb879c864ae43a927e070102b4dce3 Mon Sep 17 00:00:00 2001 From: Dale Lee <1658850308@qq.com> Date: Sat, 8 Jul 2023 22:19:04 +0800 Subject: [PATCH 06/11] =?UTF-8?q?feature=20#I7I3LL=20=E5=A2=9E=E5=8A=A0sol?= =?UTF-8?q?on=E4=B8=8B=E7=9A=84=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../MaxWaitSecondsSolonTest.java | 178 ++++++++++++++++++ .../test/maxWaitSeconds/cmp/ACmp.java | 18 ++ .../test/maxWaitSeconds/cmp/BCmp.java | 18 ++ .../test/maxWaitSeconds/cmp/CCmp.java | 18 ++ .../test/maxWaitSeconds/cmp/DCmp.java | 25 +++ .../test/maxWaitSeconds/cmp/FCmp.java | 12 ++ .../test/maxWaitSeconds/cmp/SCmp.java | 13 ++ .../test/maxWaitSeconds/cmp/WCmp.java | 26 +++ .../test/maxWaitSeconds/cmp/XCmp.java | 17 ++ .../maxWaitSeconds/application.properties | 1 + .../test/resources/maxWaitSeconds/flow.el.xml | 98 ++++++++++ 11 files changed, 424 insertions(+) create mode 100644 liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java create mode 100644 liteflow-testcase-el/liteflow-testcase-el-solon/src/test/resources/maxWaitSeconds/application.properties create mode 100644 liteflow-testcase-el/liteflow-testcase-el-solon/src/test/resources/maxWaitSeconds/flow.el.xml diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java new file mode 100644 index 000000000..61c90dcd6 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java @@ -0,0 +1,178 @@ +package com.yomahub.liteflow.test.maxWaitSeconds; + +import com.yomahub.liteflow.builder.LiteFlowNodeBuilder; +import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder; +import com.yomahub.liteflow.core.FlowExecutor; +import com.yomahub.liteflow.enums.NodeTypeEnum; +import com.yomahub.liteflow.exception.WhenTimeoutException; +import com.yomahub.liteflow.flow.LiteflowResponse; +import com.yomahub.liteflow.slot.DefaultContext; +import com.yomahub.liteflow.test.BaseTest; +import com.yomahub.liteflow.test.maxWaitSeconds.cmp.ACmp; +import com.yomahub.liteflow.test.maxWaitSeconds.cmp.BCmp; +import com.yomahub.liteflow.test.maxWaitSeconds.cmp.CCmp; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.noear.solon.annotation.Inject; +import org.noear.solon.test.SolonJUnit4ClassRunner; +import org.noear.solon.test.annotation.TestPropertySource; + +import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; + +/** + * solon环境下超时控制测试 + * + * @author DaleLee + * @since 2.11.0 + */ +@RunWith(SolonJUnit4ClassRunner.class) +@TestPropertySource("classpath:/maxWaitSeconds/application.properties") +public class MaxWaitSecondsSolonTest extends BaseTest { + + @Inject + private FlowExecutor flowExecutor; + + // 测试 THEN 的超时情况 + @Test + public void testThen1() { + assertTimeout("then1"); + } + + // 测试 THEN 的非超时情况 + @Test + public void testThen2() { + assertNotTimeout("then2"); + } + + // 测试 When 的超时情况 + @Test + public void testWhen1() { + assertTimeout("when1"); + } + + // 测试 WHEN 的非超时情况 + @Test + public void testWhen2() { + assertNotTimeout("when2"); + } + + // 测试 FOR 的超时情况 + @Test + public void testFor1() { + assertTimeout("for1"); + } + + // 测试 FOR 的非超时情况 + @Test + public void testFor2() { + assertNotTimeout("for2"); + } + + // 测试 WHILE 的超时情况 + @Test + public void testWhile1() { + assertTimeout("while1"); + } + + // 测试 WHILE 的非超时情况 + @Test + public void testWhile2() { + assertNotTimeout("while2"); + } + + // 测试 ITERATOR 的超时情况 + @Test + public void testIterator1() { + assertTimeout("iterator1"); + } + + // 测试 ITERATOR 的非超时情况 + @Test + public void testIterator2() { + assertNotTimeout("iterator2"); + } + + // 测试 SWITCH 的超时情况 + @Test + public void testSwitch1() { + assertTimeout("switch1"); + } + + // 测试 SWITCH 的非超时情况 + @Test + public void testSwitch2() { + assertNotTimeout("switch2"); + } + + // 测试 IF 的超时情况 + @Test + public void testIf1() { + assertTimeout("if1"); + } + + // 测试 SWITCH 的非超时情况 + @Test + public void testIf2() { + assertNotTimeout("if2"); + } + + // 测试单个组件的超时情况 + @Test + public void testComponent1() { + assertTimeout("component1"); + } + + // 测试单个组件的非超时情况 + @Test + public void testComponent2() { + assertNotTimeout("component2"); + } + + // 测试 FINALLY，虽然超时，但 FINALLY 仍会执行 + @Test + public void testFinally1() { + LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY + DefaultContext contextBean = response.getFirstContextBean(); + Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); + + } + + // 测试 maxWaitSeconds 关键字不能作用于 Finally + @Test + public void testFinally2() { + LiteFlowNodeBuilder.createNode() + .setId("a") + .setName("组件A") + .setType(NodeTypeEnum.COMMON) + .setClazz(ACmp.class) + .build(); + LiteFlowNodeBuilder.createNode() + .setId("b") + .setName("组件B") + .setType(NodeTypeEnum.COMMON) + .setClazz(BCmp.class) + .build(); + LiteFlowNodeBuilder.createNode() + .setId("c") + .setName("组件C") + .setType(NodeTypeEnum.COMMON) + .setClazz(CCmp.class) + .build(); + Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); + } + + private void assertTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + } + + private void assertNotTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertTrue(response.isSuccess()); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java new file mode 100644 index 000000000..1b76405be --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/ACmp.java @@ -0,0 +1,18 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeComponent; + +@LiteflowComponent("a") +public class ACmp extends NodeComponent { + @Override + public void process() { + try { + Thread.sleep(1000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("ACmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java new file mode 100644 index 000000000..08bd6d21c --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/BCmp.java @@ -0,0 +1,18 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeComponent; + +@LiteflowComponent("b") +public class BCmp extends NodeComponent { + @Override + public void process() { + try { + Thread.sleep(2000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("BCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java new file mode 100644 index 000000000..e991188fd --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CCmp.java @@ -0,0 +1,18 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeComponent; + +@LiteflowComponent("c") +public class CCmp extends NodeComponent { + @Override + public void process() { + try { + Thread.sleep(5000); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("CCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java new file mode 100644 index 000000000..c502d7c31 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java @@ -0,0 +1,25 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeComponent; +import com.yomahub.liteflow.slot.DefaultContext; + + +@LiteflowComponent("d") +public class DCmp extends NodeComponent { + + public static final String CONTENT_KEY = "testKey"; + + @Override + public void process() { + try { + Thread.sleep(500); + DefaultContext contextBean = this.getFirstContextBean(); + contextBean.setData(CONTENT_KEY, "value"); + } catch (Exception e) { + e.printStackTrace(); + } + + System.out.println("DCmp executed!"); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java new file mode 100644 index 000000000..89ef9f92d --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/FCmp.java @@ -0,0 +1,12 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeIfComponent; + +@LiteflowComponent("f") +public class FCmp extends NodeIfComponent { + @Override + public boolean processIf() throws Exception { + return true; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java new file mode 100644 index 000000000..e0e138ef0 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/SCmp.java @@ -0,0 +1,13 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeSwitchComponent; + +@LiteflowComponent("s") +public class SCmp extends NodeSwitchComponent { + + @Override + public String processSwitch() throws Exception { + return "b"; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java new file mode 100644 index 000000000..1db12e3de --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java @@ -0,0 +1,26 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeWhileComponent; + +import java.util.HashSet; +import java.util.Set; + +@LiteflowComponent("w") +public class WCmp extends NodeWhileComponent { + private int count = 0; + + // 执行过的 chain + Set executedChain = new HashSet<>(); + + @Override + public boolean processWhile() throws Exception { + // 判断是否切换了 chain + if (!executedChain.contains(this.getCurrChainId())) { + count = 0; + executedChain.add(this.getCurrChainId()); + } + count++; + return count <= 2; + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java new file mode 100644 index 000000000..c8bf8b6df --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/XCmp.java @@ -0,0 +1,17 @@ +package com.yomahub.liteflow.test.maxWaitSeconds.cmp; + +import cn.hutool.core.collection.ListUtil; +import com.yomahub.liteflow.annotation.LiteflowComponent; +import com.yomahub.liteflow.core.NodeIteratorComponent; + +import java.util.Iterator; +import java.util.List; + +@LiteflowComponent("x") +public class XCmp extends NodeIteratorComponent { + @Override + public Iterator processIterator() throws Exception { + List list = ListUtil.toList("one", "two"); + return list.iterator(); + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/resources/maxWaitSeconds/application.properties b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/resources/maxWaitSeconds/application.properties new file mode 100644 index 000000000..4dae0deff --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/resources/maxWaitSeconds/application.properties @@ -0,0 +1 @@ +liteflow.rule-source=maxWaitSeconds/flow.el.xml \ No newline at end of file diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/resources/maxWaitSeconds/flow.el.xml b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/resources/maxWaitSeconds/flow.el.xml new file mode 100644 index 000000000..e32dc3203 --- /dev/null +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/resources/maxWaitSeconds/flow.el.xml @@ -0,0 +1,98 @@ + + + + + + + THEN(a,b).maxWaitSeconds(2); + + + + THEN(a,b).maxWaitSeconds(5); + + + + + + WHEN(a,c).maxWaitSeconds(3); + + + + WHEN(a,b).maxWaitSeconds(3); + + + + + + FOR(2).DO(a).maxWaitSeconds(1); + + + + FOR(2).DO(a).maxWaitSeconds(3); + + + + + WHILE(w).DO(a).maxWaitSeconds(1); + + + + WHILE(w).DO(a).maxWaitSeconds(3); + + + + + ITERATOR(x).DO(a).maxWaitSeconds(1); + + + + ITERATOR(x).DO(a).maxWaitSeconds(3); + + + + + + + SWITCH(s).TO(a, b).maxWaitSeconds(1); + + + + SWITCH(s).TO(a, b).maxWaitSeconds(3); + + + + + + + IF(f, b, c).maxWaitSeconds(1); + + + + IF(f, b, c).maxWaitSeconds(3); + + + + + + WHEN( + a.maxWaitSeconds(2), + c.maxWaitSeconds(3) + ); + + + + WHEN( + a.maxWaitSeconds(2), + b.maxWaitSeconds(3) + ); + + + + + + THEN(PRE(a), b, FINALLY(d)).maxWaitSeconds(2); + + + \ No newline at end of file From 605aab0694bf1b66e582e7d6d92d777eeb5c4e92 Mon Sep 17 00:00:00 2001 From: Dale Lee <1658850308@qq.com> Date: Sat, 8 Jul 2023 23:18:01 +0800 Subject: [PATCH 07/11] =?UTF-8?q?feature=20#I7I3LL=20=E5=AE=8C=E5=96=84?= =?UTF-8?q?=E4=BB=A3=E7=A0=81=E5=8F=8A=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../el/operator/MaxWaitSecondsOperator.java | 20 ++++++++++++++++--- ...xWaitSecondsELDeclMultiSpringbootTest.java | 2 +- .../test/maxWaitSeconds/cmp/CmpConfig.java | 9 ++++++--- ...> MaxWaitSecondsELDeclSpringbootTest.java} | 7 +++---- .../test/maxWaitSeconds/cmp/WCmp.java | 11 ++++++++++ .../maxWaitSeconds/MaxWaitSecondsTest.java | 6 ++++++ .../test/maxWaitSeconds/cmp/WCmp.java | 12 +++++++++++ .../MaxWaitSecondsSolonTest.java | 2 +- ...va => MaxWaitSecondsELSpringbootTest.java} | 11 +++++----- .../test/maxWaitSeconds/cmp/DCmp.java | 4 ++-- .../test/maxWaitSeconds/cmp/WCmp.java | 12 +++++++++++ .../MaxWaitSecondsELSpringTest.java | 6 ++++++ .../test/maxWaitSeconds/cmp/WCmp.java | 12 +++++++++++ 13 files changed, 95 insertions(+), 19 deletions(-) rename liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/{MaxWaitSecondsELDeclSpringBootTest.java => MaxWaitSecondsELDeclSpringbootTest.java} (95%) rename liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/{MaxWaitSecondsELSpringBootTest.java => MaxWaitSecondsELSpringbootTest.java} (95%) diff --git a/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/MaxWaitSecondsOperator.java b/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/MaxWaitSecondsOperator.java index a6b1d5bdc..89bb528be 100644 --- a/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/MaxWaitSecondsOperator.java +++ b/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/MaxWaitSecondsOperator.java @@ -47,7 +47,12 @@ public class MaxWaitSecondsOperator extends BaseOperator { } } - // 将一个 Executable 包装为带有单独超时控制的 WhenCondition + /** + * 将一个 Executable 包装为带有单独超时控制的 WhenCondition + * @param executable 带包装对象 + * @param maxWaitSeconds 最大等待秒数 + * @return 包装后的 WhenCondition + */ private WhenCondition wrappedByWhen(Executable executable, Integer maxWaitSeconds) { WhenCondition whenCondition = new WhenCondition(); whenCondition.addExecutable(executable); @@ -56,13 +61,22 @@ public class MaxWaitSecondsOperator extends BaseOperator { return whenCondition; } - // 判断 THEN 中是否含有 FINALLY 组件 + /** + * 判断 THEN 中是否含有 FINALLY 组件 + * @param executable 判断对象 + * @return 含有 FINALLY 组件返回 true，否则返回 false + */ private boolean containsFinally(Executable executable) { return executable instanceof ThenCondition && CollUtil.isNotEmpty(((ThenCondition) executable).getFinallyConditionList()); } - // 将 FINALLY 排除在超时控制之外 + /** + * 将 FINALLY 排除在超时控制之外 + * @param thenCondition 待处理的 ThenCondition + * @param maxWaitSeconds 最大等待秒数 + * @return 处理后的 ThenCondition + */ private ThenCondition handleFinally(ThenCondition thenCondition, Integer maxWaitSeconds) { // 进行如下转换 // THEN(PRE(a),b,FINALLY(c)) diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java index c853b3458..a936a1631 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java @@ -20,7 +20,7 @@ import javax.annotation.Resource; import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.CmpConfig.CONTENT_KEY; /** - * springboot环境下超时控制测试 + * Spring Boot 环境下超时控制测试 * * @author DaleLee * @since 2.11.0 diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CmpConfig.java b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CmpConfig.java index 40abe9009..db6967be4 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CmpConfig.java +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/CmpConfig.java @@ -8,8 +8,10 @@ import com.yomahub.liteflow.enums.LiteFlowMethodEnum; import com.yomahub.liteflow.enums.NodeTypeEnum; import com.yomahub.liteflow.slot.DefaultContext; +import java.util.HashSet; import java.util.Iterator; import java.util.List; +import java.util.Set; @LiteflowComponent public class CmpConfig { @@ -18,7 +20,8 @@ public class CmpConfig { private int count = 0; - private boolean changed = false; + // 执行过的 chain + Set executedChain = new HashSet<>(); @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "a") public void processA(NodeComponent bindCmp) { @@ -79,9 +82,9 @@ public class CmpConfig { @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS_WHILE, nodeId = "w", nodeType = NodeTypeEnum.WHILE) public boolean processWhile(NodeComponent bindCmp) throws Exception { // 判断是否切换了 chain - if (bindCmp.getCurrChainId().equals("while2") && !changed) { + if (!executedChain.contains(bindCmp.getCurrChainId())) { count = 0; - changed = true; + executedChain.add(bindCmp.getCurrChainId()); } count++; return count <= 2; diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringBootTest.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringbootTest.java similarity index 95% rename from liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringBootTest.java rename to liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringbootTest.java index c74ee5796..5aab2d502 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringBootTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringbootTest.java @@ -8,7 +8,6 @@ import com.yomahub.liteflow.exception.WhenTimeoutException; import com.yomahub.liteflow.flow.LiteflowResponse; import com.yomahub.liteflow.slot.DefaultContext; import com.yomahub.liteflow.test.BaseTest; -import com.yomahub.liteflow.test.loop.LoopELDeclSpringbootTest; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.ACmp; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.BCmp; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.CCmp; @@ -26,17 +25,17 @@ import javax.annotation.Resource; import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; /** - * springboot环境下超时控制测试 + * Spring Boot 环境下超时控制测试 * * @author DaleLee * @since 2.11.0 */ @RunWith(SpringRunner.class) @TestPropertySource(value = "classpath:/maxWaitSeconds/application.properties") -@SpringBootTest(classes = MaxWaitSecondsELDeclSpringBootTest.class) +@SpringBootTest(classes = MaxWaitSecondsELDeclSpringbootTest.class) @EnableAutoConfiguration @ComponentScan({ "com.yomahub.liteflow.test.maxWaitSeconds.cmp" }) -public class MaxWaitSecondsELDeclSpringBootTest extends BaseTest { +public class MaxWaitSecondsELDeclSpringbootTest extends BaseTest { @Resource private FlowExecutor flowExecutor; diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java index 3f1dbcdd3..4085405c2 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java @@ -7,13 +7,24 @@ import com.yomahub.liteflow.core.NodeComponent; import com.yomahub.liteflow.enums.LiteFlowMethodEnum; import com.yomahub.liteflow.enums.NodeTypeEnum; +import java.util.HashSet; +import java.util.Set; + @LiteflowComponent("w") @LiteflowCmpDefine(NodeTypeEnum.WHILE) public class WCmp { private int count = 0; + // 执行过的 chain + Set executedChain = new HashSet<>(); + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS_WHILE, nodeType = NodeTypeEnum.WHILE) public boolean processWhile(NodeComponent bindCmp) throws Exception { + // 判断是否切换了 chain + if (!executedChain.contains(bindCmp.getCurrChainId())) { + count = 0; + executedChain.add(bindCmp.getCurrChainId()); + } count++; return count <= 2; } diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java index 7746dcaa2..51b1aef60 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java @@ -19,6 +19,12 @@ import org.junit.Test; import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; +/** + * 非 Spring 环境下超时控制测试 + * + * @author DaleLee + * @since 2.11.0 + */ public class MaxWaitSecondsTest extends BaseTest { private static FlowExecutor flowExecutor; diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java index 42f9ca172..ecad318d1 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java @@ -2,10 +2,22 @@ package com.yomahub.liteflow.test.maxWaitSeconds.cmp; import com.yomahub.liteflow.core.NodeWhileComponent; +import java.util.HashSet; +import java.util.Set; + public class WCmp extends NodeWhileComponent { private int count = 0; + + // 执行过的 chain + Set executedChain = new HashSet<>(); + @Override public boolean processWhile() throws Exception { + // 判断是否切换了 chain + if (!executedChain.contains(this.getCurrChainId())) { + count = 0; + executedChain.add(this.getCurrChainId()); + } count++; return count <= 2; } diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java index 61c90dcd6..9ece6166b 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java @@ -21,7 +21,7 @@ import org.noear.solon.test.annotation.TestPropertySource; import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; /** - * solon环境下超时控制测试 + * Solon 环境下超时控制测试 * * @author DaleLee * @since 2.11.0 diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringBootTest.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringbootTest.java similarity index 95% rename from liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringBootTest.java rename to liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringbootTest.java index 931671042..b654afa19 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringBootTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringbootTest.java @@ -22,23 +22,24 @@ import org.springframework.test.context.junit4.SpringRunner; import javax.annotation.Resource; +import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; + /** - * springboot环境下超时控制测试 + * Spring Boot 环境下超时控制测试 * * @author DaleLee * @since 2.11.0 */ @RunWith(SpringRunner.class) @TestPropertySource(value = "classpath:/maxWaitSeconds/application.properties") -@SpringBootTest(classes = MaxWaitSecondsELSpringBootTest.class) +@SpringBootTest(classes = MaxWaitSecondsELSpringbootTest.class) @EnableAutoConfiguration @ComponentScan({ "com.yomahub.liteflow.test.maxWaitSeconds.cmp" }) -public class MaxWaitSecondsELSpringBootTest extends BaseTest { +public class MaxWaitSecondsELSpringbootTest extends BaseTest { + @Resource private FlowExecutor flowExecutor; - public static final String CONTENT_KEY = "testKey"; - // 测试 THEN 的超时情况 @Test public void testThen1() { diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java index 6e5801334..648c2f447 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/DCmp.java @@ -4,11 +4,11 @@ import com.yomahub.liteflow.annotation.LiteflowComponent; import com.yomahub.liteflow.core.NodeComponent; import com.yomahub.liteflow.slot.DefaultContext; -import static com.yomahub.liteflow.test.maxWaitSeconds.MaxWaitSecondsELSpringBootTest.CONTENT_KEY; - @LiteflowComponent("d") public class DCmp extends NodeComponent { + public static final String CONTENT_KEY = "testKey"; + @Override public void process() { try { diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java index 5cb8dac0c..1db12e3de 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java @@ -3,11 +3,23 @@ package com.yomahub.liteflow.test.maxWaitSeconds.cmp; import com.yomahub.liteflow.annotation.LiteflowComponent; import com.yomahub.liteflow.core.NodeWhileComponent; +import java.util.HashSet; +import java.util.Set; + @LiteflowComponent("w") public class WCmp extends NodeWhileComponent { private int count = 0; + + // 执行过的 chain + Set executedChain = new HashSet<>(); + @Override public boolean processWhile() throws Exception { + // 判断是否切换了 chain + if (!executedChain.contains(this.getCurrChainId())) { + count = 0; + executedChain.add(this.getCurrChainId()); + } count++; return count <= 2; } diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java index bc2dbd790..df18a9e49 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java @@ -21,6 +21,12 @@ import javax.annotation.Resource; import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; +/** + * Spring 环境下超时控制测试 + * + * @author DaleLee + * @since 2.11.0 + */ @RunWith(SpringRunner.class) @ContextConfiguration("classpath:/maxWaitSeconds/application.xml") public class MaxWaitSecondsELSpringTest extends BaseTest { diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java index 5cb8dac0c..1db12e3de 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/cmp/WCmp.java @@ -3,11 +3,23 @@ package com.yomahub.liteflow.test.maxWaitSeconds.cmp; import com.yomahub.liteflow.annotation.LiteflowComponent; import com.yomahub.liteflow.core.NodeWhileComponent; +import java.util.HashSet; +import java.util.Set; + @LiteflowComponent("w") public class WCmp extends NodeWhileComponent { private int count = 0; + + // 执行过的 chain + Set executedChain = new HashSet<>(); + @Override public boolean processWhile() throws Exception { + // 判断是否切换了 chain + if (!executedChain.contains(this.getCurrChainId())) { + count = 0; + executedChain.add(this.getCurrChainId()); + } count++; return count <= 2; } From 99413e6c3e434d62536800dcabfb6a8003fd4404 Mon Sep 17 00:00:00 2001 From: Dale Lee <1658850308@qq.com> Date: Wed, 12 Jul 2023 11:38:11 +0800 Subject: [PATCH 08/11] =?UTF-8?q?feature=20#I7I3LL=20=E5=A2=9E=E5=8A=A0Tim?= =?UTF-8?q?eoutCondition?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../el/operator/MaxWaitSecondsOperator.java | 35 +++++------ .../element/condition/TimeoutCondition.java | 58 +++++++++++++++++++ .../MaxWaitSecondsELSpringbootTest.java | 27 ++++++++- .../test/resources/maxWaitSeconds/flow.el.xml | 12 ++++ 4 files changed, 112 insertions(+), 20 deletions(-) create mode 100644 liteflow-core/src/main/java/com/yomahub/liteflow/flow/element/condition/TimeoutCondition.java diff --git a/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/MaxWaitSecondsOperator.java b/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/MaxWaitSecondsOperator.java index 89bb528be..e76252402 100644 --- a/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/MaxWaitSecondsOperator.java +++ b/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/MaxWaitSecondsOperator.java @@ -1,15 +1,13 @@ package com.yomahub.liteflow.builder.el.operator; import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.text.StrFormatter; import com.ql.util.express.exception.QLException; import com.yomahub.liteflow.builder.el.operator.base.BaseOperator; import com.yomahub.liteflow.builder.el.operator.base.OperatorHelper; import com.yomahub.liteflow.flow.element.Condition; import com.yomahub.liteflow.flow.element.Executable; -import com.yomahub.liteflow.flow.element.condition.ConditionKey; -import com.yomahub.liteflow.flow.element.condition.FinallyCondition; -import com.yomahub.liteflow.flow.element.condition.ThenCondition; -import com.yomahub.liteflow.flow.element.condition.WhenCondition; +import com.yomahub.liteflow.flow.element.condition.*; import java.util.List; import java.util.concurrent.TimeUnit; @@ -35,7 +33,7 @@ public class MaxWaitSecondsOperator extends BaseOperator { return whenCondition; } else if (executable instanceof FinallyCondition) { // FINALLY，报错 - String errorMsg = "The caller cannot be FinallyCondition item"; + String errorMsg = StrFormatter.format("The caller [{}] cannot use the keyword \"maxWaitSeconds'\"", executable.toString()); throw new QLException(errorMsg); } else if (containsFinally(executable)) { // 处理 THEN 中的 FINALLY @@ -43,26 +41,28 @@ public class MaxWaitSecondsOperator extends BaseOperator { return handleFinally(thenCondition, maxWaitSeconds); } else { // 其他情况，被 WHEN 包装 - return wrappedByWhen(executable, maxWaitSeconds); + return wrappedByTimeout(executable, maxWaitSeconds); } } /** - * 将一个 Executable 包装为带有单独超时控制的 WhenCondition - * @param executable 带包装对象 + * 将一个 Executable 包装为带有单独超时控制的 TimeoutCondition + * + * @param executable 待包装对象 * @param maxWaitSeconds 最大等待秒数 - * @return 包装后的 WhenCondition + * @return 包装后的 TimeoutCondition */ - private WhenCondition wrappedByWhen(Executable executable, Integer maxWaitSeconds) { - WhenCondition whenCondition = new WhenCondition(); - whenCondition.addExecutable(executable); - whenCondition.setMaxWaitTime(maxWaitSeconds); - whenCondition.setMaxWaitTimeUnit(TimeUnit.SECONDS); - return whenCondition; + private TimeoutCondition wrappedByTimeout(Executable executable, Integer maxWaitSeconds) { + TimeoutCondition timeoutCondition = new TimeoutCondition(); + timeoutCondition.addExecutable(executable); + timeoutCondition.setMaxWaitTime(maxWaitSeconds); + timeoutCondition.setMaxWaitTimeUnit(TimeUnit.SECONDS); + return timeoutCondition; } /** * 判断 THEN 中是否含有 FINALLY 组件 + * * @param executable 判断对象 * @return 含有 FINALLY 组件返回 true，否则返回 false */ @@ -73,7 +73,8 @@ public class MaxWaitSecondsOperator extends BaseOperator { /** * 将 FINALLY 排除在超时控制之外 - * @param thenCondition 待处理的 ThenCondition + * + * @param thenCondition 待处理的 ThenCondition * @param maxWaitSeconds 最大等待秒数 * @return 处理后的 ThenCondition */ @@ -95,7 +96,7 @@ public class MaxWaitSecondsOperator extends BaseOperator { finallyList.clear(); // 包装内部 THEN - WhenCondition whenCondition = wrappedByWhen(thenCondition, maxWaitSeconds); + WhenCondition whenCondition = wrappedByTimeout(thenCondition, maxWaitSeconds); outerThenCondition.addExecutable(whenCondition); return outerThenCondition; diff --git a/liteflow-core/src/main/java/com/yomahub/liteflow/flow/element/condition/TimeoutCondition.java b/liteflow-core/src/main/java/com/yomahub/liteflow/flow/element/condition/TimeoutCondition.java new file mode 100644 index 000000000..290535f62 --- /dev/null +++ b/liteflow-core/src/main/java/com/yomahub/liteflow/flow/element/condition/TimeoutCondition.java @@ -0,0 +1,58 @@ +package com.yomahub.liteflow.flow.element.condition; + +import cn.hutool.core.text.StrFormatter; +import cn.hutool.core.util.ObjectUtil; +import com.yomahub.liteflow.exception.WhenTimeoutException; +import com.yomahub.liteflow.flow.element.Chain; +import com.yomahub.liteflow.flow.element.Condition; +import com.yomahub.liteflow.flow.element.Executable; +import com.yomahub.liteflow.flow.element.Node; + +import java.util.concurrent.TimeoutException; + +/** + * 超时控制 Condition + * + * @author DaleLee + * @since 2.11.0 + */ +public class TimeoutCondition extends WhenCondition { + + @Override + public void executeCondition(Integer slotIndex) throws Exception { + try { + super.executeCondition(slotIndex); + } catch (WhenTimeoutException ex) { + // 将 WhenTimeoutException 转换为 TimeoutException + String errMsg = StrFormatter.format("Timed out when executing the chain [{}] because [{}] exceeded {} {}.", + this.getCurrChainId(), this.getCurrentExecutableId(), this.getMaxWaitTime(), this.getMaxWaitTimeUnit().toString().toLowerCase()); + throw new TimeoutException(errMsg); + } + } + + /** + * 获取当前组件的 id + * + * @return + */ + private String getCurrentExecutableId() { + // TimeoutCondition 只有一个 Executable + Executable executable = this.getExecutableList().get(0); + if (ObjectUtil.isNotNull(executable.getId())) { + // 已经有 id 了 + return executable.getId(); + } + // 定义 id + switch (executable.getExecuteType()) { + // chain 和 node 一般都有 id + case CHAIN: + return ((Chain) executable).getChainId(); + case CONDITION: + return "condition-" + ((Condition) executable).getConditionType().getName(); + case NODE: + return "node-" + ((Node) executable).getType().getCode(); + default: + return "unknown-executable"; + } + } +} diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringbootTest.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringbootTest.java index b654afa19..7e980d595 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringbootTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringbootTest.java @@ -22,6 +22,8 @@ import org.springframework.test.context.junit4.SpringRunner; import javax.annotation.Resource; +import java.util.concurrent.TimeoutException; + import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; /** @@ -34,7 +36,7 @@ import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; @TestPropertySource(value = "classpath:/maxWaitSeconds/application.properties") @SpringBootTest(classes = MaxWaitSecondsELSpringbootTest.class) @EnableAutoConfiguration -@ComponentScan({ "com.yomahub.liteflow.test.maxWaitSeconds.cmp" }) +@ComponentScan({"com.yomahub.liteflow.test.maxWaitSeconds.cmp"}) public class MaxWaitSecondsELSpringbootTest extends BaseTest { @Resource @@ -55,7 +57,8 @@ public class MaxWaitSecondsELSpringbootTest extends BaseTest { // 测试 When 的超时情况 @Test public void testWhen1() { - assertTimeout("when1"); + // WHEN 抛出的是 WhenTimeoutException + assertWhenTimeout("when1"); } // 测试 WHEN 的非超时情况 @@ -141,7 +144,7 @@ public class MaxWaitSecondsELSpringbootTest extends BaseTest { public void testFinally1() { LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY DefaultContext contextBean = response.getFirstContextBean(); Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); @@ -172,7 +175,25 @@ public class MaxWaitSecondsELSpringbootTest extends BaseTest { Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); } + // 测试 chain 的超时情况 + @Test + public void testChain1() { + assertTimeout("chain1"); + } + + // 测试 chain 的非超时情况 + @Test + public void testChain2() { + assertNotTimeout("chain2"); + } + private void assertTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + } + + private void assertWhenTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); Assert.assertFalse(response.isSuccess()); Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/resources/maxWaitSeconds/flow.el.xml b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/resources/maxWaitSeconds/flow.el.xml index e32dc3203..91869ae50 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/resources/maxWaitSeconds/flow.el.xml +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/resources/maxWaitSeconds/flow.el.xml @@ -95,4 +95,16 @@ THEN(PRE(a), b, FINALLY(d)).maxWaitSeconds(2); + + + THEN(b) + + + + testChain.maxWaitSeconds(1); + + + + testChain.maxWaitSeconds(3); + \ No newline at end of file From 93e5693db6aa8583c0cee0d9e9520f745d391fc2 Mon Sep 17 00:00:00 2001 From: Dale Lee <1658850308@qq.com> Date: Wed, 12 Jul 2023 15:18:01 +0800 Subject: [PATCH 09/11] =?UTF-8?q?feature=20#I7I3LL=20=E4=BF=AE=E6=94=B9?= =?UTF-8?q?=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...xWaitSecondsELDeclMultiSpringbootTest.java | 24 +++++++++++++++++-- .../test/resources/maxWaitSeconds/flow.el.xml | 12 ++++++++++ .../MaxWaitSecondsELDeclSpringbootTest.java | 24 +++++++++++++++++-- .../test/resources/maxWaitSeconds/flow.el.xml | 12 ++++++++++ .../maxWaitSeconds/MaxWaitSecondsTest.java | 24 +++++++++++++++++-- .../test/resources/maxWaitSeconds/flow.el.xml | 12 ++++++++++ .../MaxWaitSecondsSolonTest.java | 24 +++++++++++++++++-- .../test/resources/maxWaitSeconds/flow.el.xml | 12 ++++++++++ .../MaxWaitSecondsELSpringTest.java | 24 +++++++++++++++++-- .../test/resources/maxWaitSeconds/flow.el.xml | 12 ++++++++++ 10 files changed, 170 insertions(+), 10 deletions(-) diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java index a936a1631..44f9de204 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java @@ -17,6 +17,8 @@ import org.springframework.test.context.junit4.SpringRunner; import javax.annotation.Resource; +import java.util.concurrent.TimeoutException; + import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.CmpConfig.CONTENT_KEY; /** @@ -49,7 +51,7 @@ public class MaxWaitSecondsELDeclMultiSpringbootTest extends BaseTest { // 测试 When 的超时情况 @Test public void testWhen1() { - assertTimeout("when1"); + assertWhenTimeout("when1"); } // 测试 WHEN 的非超时情况 @@ -135,7 +137,7 @@ public class MaxWaitSecondsELDeclMultiSpringbootTest extends BaseTest { public void testFinally1() { LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY DefaultContext contextBean = response.getFirstContextBean(); Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); @@ -147,7 +149,25 @@ public class MaxWaitSecondsELDeclMultiSpringbootTest extends BaseTest { Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); } + // 测试 chain 的超时情况 + @Test + public void testChain1() { + assertTimeout("chain1"); + } + + // 测试 chain 的非超时情况 + @Test + public void testChain2() { + assertNotTimeout("chain2"); + } + private void assertTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + } + + private void assertWhenTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); Assert.assertFalse(response.isSuccess()); Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/resources/maxWaitSeconds/flow.el.xml b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/resources/maxWaitSeconds/flow.el.xml index e32dc3203..91869ae50 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/resources/maxWaitSeconds/flow.el.xml +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/resources/maxWaitSeconds/flow.el.xml @@ -95,4 +95,16 @@ THEN(PRE(a), b, FINALLY(d)).maxWaitSeconds(2); + + + THEN(b) + + + + testChain.maxWaitSeconds(1); + + + + testChain.maxWaitSeconds(3); + \ No newline at end of file diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringbootTest.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringbootTest.java index 5aab2d502..4c4883197 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringbootTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringbootTest.java @@ -22,6 +22,8 @@ import org.springframework.test.context.junit4.SpringRunner; import javax.annotation.Resource; +import java.util.concurrent.TimeoutException; + import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; /** @@ -54,7 +56,7 @@ public class MaxWaitSecondsELDeclSpringbootTest extends BaseTest { // 测试 When 的超时情况 @Test public void testWhen1() { - assertTimeout("when1"); + assertWhenTimeout("when1"); } // 测试 WHEN 的非超时情况 @@ -140,7 +142,7 @@ public class MaxWaitSecondsELDeclSpringbootTest extends BaseTest { public void testFinally1() { LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY DefaultContext contextBean = response.getFirstContextBean(); Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); @@ -170,7 +172,25 @@ public class MaxWaitSecondsELDeclSpringbootTest extends BaseTest { Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); } + // 测试 chain 的超时情况 + @Test + public void testChain1() { + assertTimeout("chain1"); + } + + // 测试 chain 的非超时情况 + @Test + public void testChain2() { + assertNotTimeout("chain2"); + } + private void assertTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + } + + private void assertWhenTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); Assert.assertFalse(response.isSuccess()); Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/resources/maxWaitSeconds/flow.el.xml b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/resources/maxWaitSeconds/flow.el.xml index e32dc3203..91869ae50 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/resources/maxWaitSeconds/flow.el.xml +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/resources/maxWaitSeconds/flow.el.xml @@ -95,4 +95,16 @@ THEN(PRE(a), b, FINALLY(d)).maxWaitSeconds(2); + + + THEN(b) + + + + testChain.maxWaitSeconds(1); + + + + testChain.maxWaitSeconds(3); + \ No newline at end of file diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java index 51b1aef60..be538913e 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java @@ -17,6 +17,8 @@ import org.junit.Assert; import org.junit.BeforeClass; import org.junit.Test; +import java.util.concurrent.TimeoutException; + import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; /** @@ -51,7 +53,7 @@ public class MaxWaitSecondsTest extends BaseTest { // 测试 When 的超时情况 @Test public void testWhen1() { - assertTimeout("when1"); + assertWhenTimeout("when1"); } // 测试 WHEN 的非超时情况 @@ -137,7 +139,7 @@ public class MaxWaitSecondsTest extends BaseTest { public void testFinally1() { LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY DefaultContext contextBean = response.getFirstContextBean(); Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); @@ -168,7 +170,25 @@ public class MaxWaitSecondsTest extends BaseTest { Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); } + // 测试 chain 的超时情况 + @Test + public void testChain1() { + assertTimeout("chain1"); + } + + // 测试 chain 的非超时情况 + @Test + public void testChain2() { + assertNotTimeout("chain2"); + } + private void assertTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + } + + private void assertWhenTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); Assert.assertFalse(response.isSuccess()); Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/resources/maxWaitSeconds/flow.el.xml b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/resources/maxWaitSeconds/flow.el.xml index 14bb4d482..09c955ca6 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/resources/maxWaitSeconds/flow.el.xml +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/resources/maxWaitSeconds/flow.el.xml @@ -105,4 +105,16 @@ THEN(PRE(a), b, FINALLY(d)).maxWaitSeconds(2); + + + THEN(b) + + + + testChain.maxWaitSeconds(1); + + + + testChain.maxWaitSeconds(3); + \ No newline at end of file diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java index 9ece6166b..feeb2c805 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java @@ -18,6 +18,8 @@ import org.noear.solon.annotation.Inject; import org.noear.solon.test.SolonJUnit4ClassRunner; import org.noear.solon.test.annotation.TestPropertySource; +import java.util.concurrent.TimeoutException; + import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; /** @@ -48,7 +50,7 @@ public class MaxWaitSecondsSolonTest extends BaseTest { // 测试 When 的超时情况 @Test public void testWhen1() { - assertTimeout("when1"); + assertWhenTimeout("when1"); } // 测试 WHEN 的非超时情况 @@ -134,7 +136,7 @@ public class MaxWaitSecondsSolonTest extends BaseTest { public void testFinally1() { LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY DefaultContext contextBean = response.getFirstContextBean(); Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); @@ -165,7 +167,25 @@ public class MaxWaitSecondsSolonTest extends BaseTest { Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); } + // 测试 chain 的超时情况 + @Test + public void testChain1() { + assertTimeout("chain1"); + } + + // 测试 chain 的非超时情况 + @Test + public void testChain2() { + assertNotTimeout("chain2"); + } + private void assertTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + } + + private void assertWhenTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); Assert.assertFalse(response.isSuccess()); Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/resources/maxWaitSeconds/flow.el.xml b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/resources/maxWaitSeconds/flow.el.xml index e32dc3203..91869ae50 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/resources/maxWaitSeconds/flow.el.xml +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/resources/maxWaitSeconds/flow.el.xml @@ -95,4 +95,16 @@ THEN(PRE(a), b, FINALLY(d)).maxWaitSeconds(2); + + + THEN(b) + + + + testChain.maxWaitSeconds(1); + + + + testChain.maxWaitSeconds(3); + \ No newline at end of file diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java index df18a9e49..085644f98 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java @@ -19,6 +19,8 @@ import org.springframework.test.context.junit4.SpringRunner; import javax.annotation.Resource; +import java.util.concurrent.TimeoutException; + import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; /** @@ -48,7 +50,7 @@ public class MaxWaitSecondsELSpringTest extends BaseTest { // 测试 When 的超时情况 @Test public void testWhen1() { - assertTimeout("when1"); + assertWhenTimeout("when1"); } // 测试 WHEN 的非超时情况 @@ -134,7 +136,7 @@ public class MaxWaitSecondsELSpringTest extends BaseTest { public void testFinally1() { LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY DefaultContext contextBean = response.getFirstContextBean(); Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); @@ -165,7 +167,25 @@ public class MaxWaitSecondsELSpringTest extends BaseTest { Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); } + // 测试 chain 的超时情况 + @Test + public void testChain1() { + assertTimeout("chain1"); + } + + // 测试 chain 的非超时情况 + @Test + public void testChain2() { + assertNotTimeout("chain2"); + } + private void assertTimeout(String chainId) { + LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); + Assert.assertFalse(response.isSuccess()); + Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + } + + private void assertWhenTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); Assert.assertFalse(response.isSuccess()); Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/maxWaitSeconds/flow.el.xml b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/maxWaitSeconds/flow.el.xml index e32dc3203..91869ae50 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/maxWaitSeconds/flow.el.xml +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/maxWaitSeconds/flow.el.xml @@ -95,4 +95,16 @@ THEN(PRE(a), b, FINALLY(d)).maxWaitSeconds(2); + + + THEN(b) + + + + testChain.maxWaitSeconds(1); + + + + testChain.maxWaitSeconds(3); + \ No newline at end of file From f521f92aaa036a5a5400ac6cd662147724b00a52 Mon Sep 17 00:00:00 2001 From: Dale Lee <1658850308@qq.com> Date: Wed, 12 Jul 2023 15:25:46 +0800 Subject: [PATCH 10/11] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E9=BB=98=E8=AE=A4WHEN?= =?UTF-8?q?=E7=BA=BF=E7=A8=8B=E6=B1=A0=E7=BA=BF=E7=A8=8B=E5=90=8D=E7=A7=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../liteflow/thread/LiteFlowDefaultWhenExecutorBuilder.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/liteflow-core/src/main/java/com/yomahub/liteflow/thread/LiteFlowDefaultWhenExecutorBuilder.java b/liteflow-core/src/main/java/com/yomahub/liteflow/thread/LiteFlowDefaultWhenExecutorBuilder.java index 8ae444c05..32242b0c8 100644 --- a/liteflow-core/src/main/java/com/yomahub/liteflow/thread/LiteFlowDefaultWhenExecutorBuilder.java +++ b/liteflow-core/src/main/java/com/yomahub/liteflow/thread/LiteFlowDefaultWhenExecutorBuilder.java @@ -22,7 +22,7 @@ public class LiteFlowDefaultWhenExecutorBuilder implements ExecutorBuilder { liteflowConfig = new LiteflowConfig(); } return buildDefaultExecutor(liteflowConfig.getWhenMaxWorkers(), liteflowConfig.getWhenMaxWorkers(), - liteflowConfig.getWhenQueueLimit(), "lf-when-thead-"); + liteflowConfig.getWhenQueueLimit(), "when-thread-"); } } From 09b7062cb8f40cb9750c786a6d0790776eafc64c Mon Sep 17 00:00:00 2001 From: Dale Lee <1658850308@qq.com> Date: Fri, 14 Jul 2023 11:06:08 +0800 Subject: [PATCH 11/11] =?UTF-8?q?feature=20#I7I3LL=20=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B=E6=9B=B4=E6=96=B0=E4=B8=BAJUnit5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...xWaitSecondsELDeclMultiSpringbootTest.java | 31 +++++++++---------- .../MaxWaitSecondsELDeclSpringbootTest.java | 29 +++++++++-------- .../maxWaitSeconds/MaxWaitSecondsTest.java | 27 ++++++++-------- .../MaxWaitSecondsSolonTest.java | 28 ++++++++--------- .../MaxWaitSecondsELSpringbootTest.java | 27 +++++++--------- .../MaxWaitSecondsELSpringTest.java | 30 +++++++++--------- 6 files changed, 82 insertions(+), 90 deletions(-) diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java index 44f9de204..cbcdf5f71 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-multi-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclMultiSpringbootTest.java @@ -6,17 +6,16 @@ import com.yomahub.liteflow.exception.WhenTimeoutException; import com.yomahub.liteflow.flow.LiteflowResponse; import com.yomahub.liteflow.slot.DefaultContext; import com.yomahub.liteflow.test.BaseTest; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.context.annotation.ComponentScan; import org.springframework.test.context.TestPropertySource; -import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.test.context.junit.jupiter.SpringExtension; import javax.annotation.Resource; - import java.util.concurrent.TimeoutException; import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.CmpConfig.CONTENT_KEY; @@ -27,11 +26,11 @@ import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.CmpConfig.CONTENT_KEY * @author DaleLee * @since 2.11.0 */ -@RunWith(SpringRunner.class) +@ExtendWith(SpringExtension.class) @TestPropertySource(value = "classpath:/maxWaitSeconds/application.properties") @SpringBootTest(classes = MaxWaitSecondsELDeclMultiSpringbootTest.class) @EnableAutoConfiguration -@ComponentScan({ "com.yomahub.liteflow.test.maxWaitSeconds.cmp" }) +@ComponentScan({"com.yomahub.liteflow.test.maxWaitSeconds.cmp"}) public class MaxWaitSecondsELDeclMultiSpringbootTest extends BaseTest { @Resource private FlowExecutor flowExecutor; @@ -136,17 +135,17 @@ public class MaxWaitSecondsELDeclMultiSpringbootTest extends BaseTest { @Test public void testFinally1() { LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(TimeoutException.class, response.getCause().getClass()); // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY DefaultContext contextBean = response.getFirstContextBean(); - Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); + Assertions.assertTrue(contextBean.hasData(CONTENT_KEY)); } // 测试 maxWaitSeconds 关键字不能作用于 Finally @Test public void testFinally2() { - Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); + Assertions.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); } // 测试 chain 的超时情况 @@ -163,18 +162,18 @@ public class MaxWaitSecondsELDeclMultiSpringbootTest extends BaseTest { private void assertTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(TimeoutException.class, response.getCause().getClass()); } private void assertWhenTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); } private void assertNotTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertTrue(response.isSuccess()); + Assertions.assertTrue(response.isSuccess()); } } diff --git a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringbootTest.java b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringbootTest.java index 4c4883197..0fe2a68fe 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringbootTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-declare-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELDeclSpringbootTest.java @@ -11,17 +11,16 @@ import com.yomahub.liteflow.test.BaseTest; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.ACmp; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.BCmp; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.CCmp; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.context.annotation.ComponentScan; import org.springframework.test.context.TestPropertySource; -import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.test.context.junit.jupiter.SpringExtension; import javax.annotation.Resource; - import java.util.concurrent.TimeoutException; import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; @@ -32,7 +31,7 @@ import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; * @author DaleLee * @since 2.11.0 */ -@RunWith(SpringRunner.class) +@ExtendWith(SpringExtension.class) @TestPropertySource(value = "classpath:/maxWaitSeconds/application.properties") @SpringBootTest(classes = MaxWaitSecondsELDeclSpringbootTest.class) @EnableAutoConfiguration @@ -141,11 +140,11 @@ public class MaxWaitSecondsELDeclSpringbootTest extends BaseTest { @Test public void testFinally1() { LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(TimeoutException.class, response.getCause().getClass()); // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY DefaultContext contextBean = response.getFirstContextBean(); - Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); + Assertions.assertTrue(contextBean.hasData(CONTENT_KEY)); } // 测试 maxWaitSeconds 关键字不能作用于 Finally @@ -169,7 +168,7 @@ public class MaxWaitSecondsELDeclSpringbootTest extends BaseTest { .setType(NodeTypeEnum.COMMON) .setClazz(CCmp.class) .build(); - Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); + Assertions.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); } // 测试 chain 的超时情况 @@ -186,18 +185,18 @@ public class MaxWaitSecondsELDeclSpringbootTest extends BaseTest { private void assertTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(TimeoutException.class, response.getCause().getClass()); } private void assertWhenTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); } private void assertNotTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertTrue(response.isSuccess()); + Assertions.assertTrue(response.isSuccess()); } } diff --git a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java index be538913e..3bf51e5c0 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-nospring/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsTest.java @@ -13,9 +13,10 @@ import com.yomahub.liteflow.test.BaseTest; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.ACmp; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.BCmp; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.CCmp; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + import java.util.concurrent.TimeoutException; @@ -31,7 +32,7 @@ public class MaxWaitSecondsTest extends BaseTest { private static FlowExecutor flowExecutor; - @BeforeClass + @BeforeAll public static void init() { LiteflowConfig config = new LiteflowConfig(); config.setRuleSource("maxWaitSeconds/flow.el.xml"); @@ -138,11 +139,11 @@ public class MaxWaitSecondsTest extends BaseTest { @Test public void testFinally1() { LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(TimeoutException.class, response.getCause().getClass()); // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY DefaultContext contextBean = response.getFirstContextBean(); - Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); + Assertions.assertTrue(contextBean.hasData(CONTENT_KEY)); } @@ -167,7 +168,7 @@ public class MaxWaitSecondsTest extends BaseTest { .setType(NodeTypeEnum.COMMON) .setClazz(CCmp.class) .build(); - Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); + Assertions.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); } // 测试 chain 的超时情况 @@ -184,19 +185,19 @@ public class MaxWaitSecondsTest extends BaseTest { private void assertTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(TimeoutException.class, response.getCause().getClass()); } private void assertWhenTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); } private void assertNotTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertTrue(response.isSuccess()); + Assertions.assertTrue(response.isSuccess()); } } diff --git a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java index feeb2c805..981d6b215 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-solon/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsSolonTest.java @@ -11,11 +11,11 @@ import com.yomahub.liteflow.test.BaseTest; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.ACmp; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.BCmp; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.CCmp; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.noear.solon.annotation.Inject; -import org.noear.solon.test.SolonJUnit4ClassRunner; +import org.noear.solon.test.SolonJUnit5Extension; import org.noear.solon.test.annotation.TestPropertySource; import java.util.concurrent.TimeoutException; @@ -28,7 +28,7 @@ import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; * @author DaleLee * @since 2.11.0 */ -@RunWith(SolonJUnit4ClassRunner.class) +@ExtendWith(SolonJUnit5Extension.class) @TestPropertySource("classpath:/maxWaitSeconds/application.properties") public class MaxWaitSecondsSolonTest extends BaseTest { @@ -135,11 +135,11 @@ public class MaxWaitSecondsSolonTest extends BaseTest { @Test public void testFinally1() { LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(TimeoutException.class, response.getCause().getClass()); // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY DefaultContext contextBean = response.getFirstContextBean(); - Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); + Assertions.assertTrue(contextBean.hasData(CONTENT_KEY)); } @@ -164,7 +164,7 @@ public class MaxWaitSecondsSolonTest extends BaseTest { .setType(NodeTypeEnum.COMMON) .setClazz(CCmp.class) .build(); - Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); + Assertions.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); } // 测试 chain 的超时情况 @@ -181,18 +181,18 @@ public class MaxWaitSecondsSolonTest extends BaseTest { private void assertTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(TimeoutException.class, response.getCause().getClass()); } private void assertWhenTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); } private void assertNotTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertTrue(response.isSuccess()); + Assertions.assertTrue(response.isSuccess()); } } diff --git a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringbootTest.java b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringbootTest.java index 7e980d595..a71ce42e4 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringbootTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-springboot/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringbootTest.java @@ -11,17 +11,14 @@ import com.yomahub.liteflow.test.BaseTest; import com.yomahub.liteflow.test.validateRule.cmp.ACmp; import com.yomahub.liteflow.test.validateRule.cmp.BCmp; import com.yomahub.liteflow.test.validateRule.cmp.CCmp; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.context.annotation.ComponentScan; import org.springframework.test.context.TestPropertySource; -import org.springframework.test.context.junit4.SpringRunner; import javax.annotation.Resource; - import java.util.concurrent.TimeoutException; import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; @@ -32,7 +29,6 @@ import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; * @author DaleLee * @since 2.11.0 */ -@RunWith(SpringRunner.class) @TestPropertySource(value = "classpath:/maxWaitSeconds/application.properties") @SpringBootTest(classes = MaxWaitSecondsELSpringbootTest.class) @EnableAutoConfiguration @@ -143,12 +139,11 @@ public class MaxWaitSecondsELSpringbootTest extends BaseTest { @Test public void testFinally1() { LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(TimeoutException.class, response.getCause().getClass()); // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY DefaultContext contextBean = response.getFirstContextBean(); - Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); - + Assertions.assertTrue(contextBean.hasData(CONTENT_KEY)); } // 测试 maxWaitSeconds 关键字不能作用于 Finally @@ -172,7 +167,7 @@ public class MaxWaitSecondsELSpringbootTest extends BaseTest { .setType(NodeTypeEnum.COMMON) .setClazz(CCmp.class) .build(); - Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); + Assertions.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); } // 测试 chain 的超时情况 @@ -189,18 +184,18 @@ public class MaxWaitSecondsELSpringbootTest extends BaseTest { private void assertTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(TimeoutException.class, response.getCause().getClass()); } private void assertWhenTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); } private void assertNotTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertTrue(response.isSuccess()); + Assertions.assertTrue(response.isSuccess()); } } diff --git a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java index 085644f98..f4aceb423 100644 --- a/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java +++ b/liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/java/com/yomahub/liteflow/test/maxWaitSeconds/MaxWaitSecondsELSpringTest.java @@ -11,14 +11,13 @@ import com.yomahub.liteflow.test.BaseTest; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.ACmp; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.BCmp; import com.yomahub.liteflow.test.maxWaitSeconds.cmp.CCmp; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.test.context.junit.jupiter.SpringExtension; import javax.annotation.Resource; - import java.util.concurrent.TimeoutException; import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; @@ -29,7 +28,7 @@ import static com.yomahub.liteflow.test.maxWaitSeconds.cmp.DCmp.CONTENT_KEY; * @author DaleLee * @since 2.11.0 */ -@RunWith(SpringRunner.class) +@ExtendWith(SpringExtension.class) @ContextConfiguration("classpath:/maxWaitSeconds/application.xml") public class MaxWaitSecondsELSpringTest extends BaseTest { @Resource @@ -135,12 +134,11 @@ public class MaxWaitSecondsELSpringTest extends BaseTest { @Test public void testFinally1() { LiteflowResponse response = flowExecutor.execute2Resp("finally", "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(TimeoutException.class, response.getCause().getClass()); // FINALLY 执行时在默认数据上下文中放入了 CONTENT_KEY DefaultContext contextBean = response.getFirstContextBean(); - Assert.assertTrue(contextBean.hasData(CONTENT_KEY)); - + Assertions.assertTrue(contextBean.hasData(CONTENT_KEY)); } // 测试 maxWaitSeconds 关键字不能作用于 Finally @@ -164,7 +162,7 @@ public class MaxWaitSecondsELSpringTest extends BaseTest { .setType(NodeTypeEnum.COMMON) .setClazz(CCmp.class) .build(); - Assert.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); + Assertions.assertFalse(LiteFlowChainELBuilder.validate("THEN(a, b, FINALLY(c).maxWaitSeconds(10))")); } // 测试 chain 的超时情况 @@ -181,18 +179,18 @@ public class MaxWaitSecondsELSpringTest extends BaseTest { private void assertTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(TimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(TimeoutException.class, response.getCause().getClass()); } private void assertWhenTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertFalse(response.isSuccess()); - Assert.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); + Assertions.assertFalse(response.isSuccess()); + Assertions.assertEquals(WhenTimeoutException.class, response.getCause().getClass()); } private void assertNotTimeout(String chainId) { LiteflowResponse response = flowExecutor.execute2Resp(chainId, "arg"); - Assert.assertTrue(response.isSuccess()); + Assertions.assertTrue(response.isSuccess()); } }