添加 JobRunner的快捷测试用例

qq254963746 · qq254963746 · commit 33aa6f2295aa · 2015-09-13T21:40:23.000+08:00
diff --git a/README.md b/README.md
@@ -336,7 +336,35 @@ class JobRunnerB implements JobRunner {
         return null;
     }
 }
-```
+```
+##TaskTracker的JobRunner测试
+一般在编写TaskTracker的时候，只需要测试JobRunner的实现逻辑是否正确，又不想启动LTS进行远程测试。为了方便测试，LTS提供了JobRunner的快捷测试方法。自己的测试类集成`com.lts.tasktracker.runner.JobRunnerTester`即可，并实现`initContext`和`newJobRunner`方法即可。如`lts-example`中的例子：
+
+```java
+public class TestJobRunnerTester extends JobRunnerTester {
+	
+    public static void main(String[] args) throws Throwable {
+        //  1. Mock Job 数据
+        Job job = new Job();
+        job.setTaskId("2313213");
+        // 2. 运行测试
+        TestJobRunnerTester tester = new TestJobRunnerTester();
+        Result result = tester.run(job);
+        System.out.println(JSONUtils.toJSONString(result));
+    }
+	
+    @Override
+    protected void initContext() {
+        // TODO 初始化Spring容器等
+    }
+	
+    @Override
+    protected JobRunner newJobRunner() {
+        return new TestJobRunner();
+    }
+}
+```
+
 ##SPI扩展说明
 ###LTS-Logger扩展
 1. 引入`lts-logger-api-{version}.jar`
diff --git a/lts-core/src/main/java/com/lts/core/logger/support/FailsafeLogger.java b/lts-core/src/main/java/com/lts/core/logger/support/FailsafeLogger.java
@@ -27,105 +27,105 @@ private String appendContextMessage(String msg) {
     public void trace(String msg, Throwable e) {
         try {
             logger.trace(appendContextMessage(msg), e);
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void trace(Throwable e) {
         try {
             logger.trace(e);
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void trace(String msg) {
         try {
             logger.trace(appendContextMessage(msg));
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void debug(String msg, Throwable e) {
         try {
             logger.debug(appendContextMessage(msg), e);
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void debug(Throwable e) {
         try {
             logger.debug(e);
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void debug(String msg) {
         try {
             logger.debug(appendContextMessage(msg));
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void info(String msg, Throwable e) {
         try {
             logger.info(appendContextMessage(msg), e);
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void info(String msg) {
         try {
             logger.info(appendContextMessage(msg));
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void warn(String msg, Throwable e) {
         try {
             logger.warn(appendContextMessage(msg), e);
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void warn(String msg) {
         try {
             logger.warn(appendContextMessage(msg));
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void error(String msg, Throwable e) {
         try {
             logger.error(appendContextMessage(msg), e);
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void error(String msg) {
         try {
             logger.error(appendContextMessage(msg));
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void error(Throwable e) {
         try {
             logger.error(e);
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void info(Throwable e) {
         try {
             logger.info(e);
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
     public void warn(Throwable e) {
         try {
             logger.warn(e);
-        } catch (Throwable t) {
+        } catch (Throwable ignored) {
         }
     }
 
diff --git a/lts-example/src/main/java/com/lts/example/support/TestJobRunnerTester.java b/lts-example/src/main/java/com/lts/example/support/TestJobRunnerTester.java
@@ -0,0 +1,33 @@
+package com.lts.example.support;
+
+import com.lts.core.commons.utils.JSONUtils;
+import com.lts.core.domain.Job;
+import com.lts.tasktracker.Result;
+import com.lts.tasktracker.runner.JobRunner;
+import com.lts.tasktracker.runner.JobRunnerTester;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 9/13/15.
+ */
+public class TestJobRunnerTester extends JobRunnerTester {
+
+    public static void main(String[] args) throws Throwable {
+        //  Mock Job 数据
+        Job job = new Job();
+        job.setTaskId("2313213");
+        // 运行测试
+        TestJobRunnerTester tester = new TestJobRunnerTester();
+        Result result = tester.run(job);
+        System.out.println(JSONUtils.toJSONString(result));
+    }
+
+    @Override
+    protected void initContext() {
+        // TODO 初始化Spring容器
+    }
+
+    @Override
+    protected JobRunner newJobRunner() {
+        return new TestJobRunner();
+    }
+}
diff --git a/lts-tasktracker/src/main/java/com/lts/tasktracker/logger/BizLoggerFactory.java b/lts-tasktracker/src/main/java/com/lts/tasktracker/logger/BizLoggerFactory.java
@@ -19,6 +19,12 @@ public class BizLoggerFactory {
      * 保证一个TaskTracker只能有一个Logger, 因为一个jvm可以有多个TaskTracker
      */
     public static BizLogger getLogger(Level level, RemotingClientDelegate remotingClient, TaskTrackerApplication application) {
+
+        // 单元测试的时候返回 Mock
+        if (Environment.UNIT_TEST == LTSConfig.getEnvironment()) {
+            return new MockBizLogger(level);
+        }
+
         String key = application.getConfig().getIdentity();
         BizLogger logger = BIZ_LOGGER_CONCURRENT_HASH_MAP.get(key);
         if (logger == null) {
@@ -27,22 +33,12 @@ public static BizLogger getLogger(Level level, RemotingClientDelegate remotingCl
                 if (logger != null) {
                     return logger;
                 }
-                logger = create(level, remotingClient, application);
+                logger = new BizLoggerImpl(level, remotingClient, application);
 
                 BIZ_LOGGER_CONCURRENT_HASH_MAP.put(key, logger);
             }
         }
         return logger;
     }
 
-    /**
-     * 单元测试的时候返回 Mock
-     */
-    private static BizLogger create(Level level, RemotingClientDelegate remotingClient, TaskTrackerApplication application) {
-        if (Environment.UNIT_TEST == LTSConfig.getEnvironment()) {
-            return new MockBizLogger(level);
-        }
-        return new BizLoggerImpl(level, remotingClient, application);
-    }
-
 }
diff --git a/lts-tasktracker/src/main/java/com/lts/tasktracker/runner/JobRunnerTester.java b/lts-tasktracker/src/main/java/com/lts/tasktracker/runner/JobRunnerTester.java
@@ -0,0 +1,40 @@
+package com.lts.tasktracker.runner;
+
+import com.lts.core.cluster.LTSConfig;
+import com.lts.core.constant.Environment;
+import com.lts.core.constant.Level;
+import com.lts.core.domain.Job;
+import com.lts.tasktracker.Result;
+import com.lts.tasktracker.logger.BizLoggerFactory;
+
+/**
+ * 为了方便JobRunner测试设计的
+ *
+ * @author Robert HG (254963746@qq.com) on 9/13/15.
+ */
+public abstract class JobRunnerTester {
+
+    public Result run(Job job) throws Throwable {
+        // 1. 设置LTS环境为 UNIT_TEST
+        LTSConfig.setEnvironment(Environment.UNIT_TEST);
+        // 设置 BizLogger
+        LtsLoggerFactory.setLogger(BizLoggerFactory.getLogger(Level.INFO, null, null));
+        // 2. load context (Spring Context 或者其他的)
+        initContext();
+        // 3. new jobRunner
+        JobRunner jobRunner = newJobRunner();
+        // 4. run job
+        return jobRunner.run(job);
+    }
+
+    /**
+     * 初始化上下文 (Spring Context等),准备运行环境
+     */
+    protected abstract void initContext();
+
+    /**
+     * 创建JobRunner
+     */
+    protected abstract JobRunner newJobRunner();
+
+}

Original file line number	Diff line number	Diff line change
`@@ -27,105 +27,105 @@ private String appendContextMessage(String msg) {`
`27`	`27`	`public void trace(String msg, Throwable e) {`
`28`	`28`	`try {`
`29`	`29`	`logger.trace(appendContextMessage(msg), e);`
`30`		`- } catch (Throwable t) {`
	`30`	`+ } catch (Throwable ignored) {`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`public void trace(Throwable e) {`
`35`	`35`	`try {`
`36`	`36`	`logger.trace(e);`
`37`		`- } catch (Throwable t) {`
	`37`	`+ } catch (Throwable ignored) {`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`public void trace(String msg) {`
`42`	`42`	`try {`
`43`	`43`	`logger.trace(appendContextMessage(msg));`
`44`		`- } catch (Throwable t) {`
	`44`	`+ } catch (Throwable ignored) {`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`public void debug(String msg, Throwable e) {`
`49`	`49`	`try {`
`50`	`50`	`logger.debug(appendContextMessage(msg), e);`
`51`		`- } catch (Throwable t) {`
	`51`	`+ } catch (Throwable ignored) {`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`public void debug(Throwable e) {`
`56`	`56`	`try {`
`57`	`57`	`logger.debug(e);`
`58`		`- } catch (Throwable t) {`
	`58`	`+ } catch (Throwable ignored) {`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`public void debug(String msg) {`
`63`	`63`	`try {`
`64`	`64`	`logger.debug(appendContextMessage(msg));`
`65`		`- } catch (Throwable t) {`
	`65`	`+ } catch (Throwable ignored) {`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`public void info(String msg, Throwable e) {`
`70`	`70`	`try {`
`71`	`71`	`logger.info(appendContextMessage(msg), e);`
`72`		`- } catch (Throwable t) {`
	`72`	`+ } catch (Throwable ignored) {`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`public void info(String msg) {`
`77`	`77`	`try {`
`78`	`78`	`logger.info(appendContextMessage(msg));`
`79`		`- } catch (Throwable t) {`
	`79`	`+ } catch (Throwable ignored) {`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`public void warn(String msg, Throwable e) {`
`84`	`84`	`try {`
`85`	`85`	`logger.warn(appendContextMessage(msg), e);`
`86`		`- } catch (Throwable t) {`
	`86`	`+ } catch (Throwable ignored) {`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`public void warn(String msg) {`
`91`	`91`	`try {`
`92`	`92`	`logger.warn(appendContextMessage(msg));`
`93`		`- } catch (Throwable t) {`
	`93`	`+ } catch (Throwable ignored) {`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`public void error(String msg, Throwable e) {`
`98`	`98`	`try {`
`99`	`99`	`logger.error(appendContextMessage(msg), e);`
`100`		`- } catch (Throwable t) {`
	`100`	`+ } catch (Throwable ignored) {`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`public void error(String msg) {`
`105`	`105`	`try {`
`106`	`106`	`logger.error(appendContextMessage(msg));`
`107`		`- } catch (Throwable t) {`
	`107`	`+ } catch (Throwable ignored) {`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`public void error(Throwable e) {`
`112`	`112`	`try {`
`113`	`113`	`logger.error(e);`
`114`		`- } catch (Throwable t) {`
	`114`	`+ } catch (Throwable ignored) {`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`public void info(Throwable e) {`
`119`	`119`	`try {`
`120`	`120`	`logger.info(e);`
`121`		`- } catch (Throwable t) {`
	`121`	`+ } catch (Throwable ignored) {`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`public void warn(Throwable e) {`
`126`	`126`	`try {`
`127`	`127`	`logger.warn(e);`
`128`		`- } catch (Throwable t) {`
	`128`	`+ } catch (Throwable ignored) {`
`129`	`129`	`}`
`130`	`130`	`}`
`131`	`131`