Change the Java API to get rid of Factory and to use AutoCloseable Runner. robotframework#2090

jussimalinen · jussimalinen · commit aefd6c2c719d · 2015-11-23T16:21:47.000+02:00
diff --git a/src/java/org/robotframework/RobotFramework.java b/src/java/org/robotframework/RobotFramework.java
@@ -15,9 +15,6 @@
 
 package org.robotframework;
 
-import org.robotframework.RunnerFactory;
-import org.robotframework.RobotRunner;
-
 /**
  *
  * Entry point for using Robot Framework from Java programs.
@@ -59,12 +56,8 @@ public static void main(String[] args) {
      *              for meaning of different return codes.
      */
     public static int run(String[] args) {
-        RunnerFactory context = new RunnerFactory();
-        RobotRunner runner = context.createRunner();
-        try {
+        try (RobotRunner runner = new RobotRunner()) {
             return runner.run(args);
-        } finally {
-            context.cleanup();
         }
     }
 }
diff --git a/src/java/org/robotframework/RobotPythonRunner.java b/src/java/org/robotframework/RobotPythonRunner.java
@@ -0,0 +1,11 @@
+package org.robotframework;
+
+/**
+ * Interface used by {@link org.robotframework.RobotRunner} internally to
+ * construct the Robot Framework Python class.
+ */
+public interface RobotPythonRunner {
+
+    public int run(String[] args);
+
+}
diff --git a/src/java/org/robotframework/RobotRunner.java b/src/java/org/robotframework/RobotRunner.java
@@ -15,12 +15,68 @@
 
 package org.robotframework;
 
+import org.python.core.PyObject;
+import org.python.util.PythonInterpreter;
+
 /**
- * An interface class that is used for creating a Jython object capable of
- * running Robot Framework.
+ * AutoCloseable Interface class that internally creates a Jython interpreter,
+ * allows running Robot tests with it, and cleans up the interpreter afterwards
+ * in close.<p>
+ *
+ * Example:
+ * <pre>
+ *
+ * {@code
+ * try (RobotRunner runner = new RobotRunner()) {
+ *     runner.run(new String[] {"mytests.txt"});
+ * }
+ * }
+ * </pre>
  */
-public interface RobotRunner {
+public class RobotRunner implements AutoCloseable {
+
+    private RobotPythonRunner runner;
+    private PythonInterpreter interpreter;
+
+    public RobotRunner() {
+        interpreter = new PythonInterpreter();
+        runner = createRunner();
+    }
+
+    /**
+     * Creates and returns an instance of the robot.JarRunner (implemented in
+     * Python), which can be used to execute tests.
+     */
+    private RobotPythonRunner createRunner() {
+        PyObject runnerClass = importRunnerClass();
+        PyObject runnerObject = runnerClass.__call__();
+        return (RobotPythonRunner) runnerObject.__tojava__(RobotPythonRunner.class);
+    }
+
+    private PyObject importRunnerClass() {
+        interpreter.exec("import robot; from robot.jarrunner import JarRunner");
+        return interpreter.get("JarRunner");
+    }
 
-    public int run(String[] args);
+    /**
+     * Runs the tests, but does not cleanup the interpreter afterwards.
+     *
+     * @param args
+     *              The command line options to Robot Framework.
+     *
+     * @return      Robot Framework return code. See
+     *              <a href="http://robotframework.org/robotframework/#user-guide"
+     *                 target="_top">Robot Framework User Guide</a>
+     *              for meaning of different return codes.
+     */
+    public int run(String[] args) {
+        return runner.run(args);
+    }
 
+    /**
+     * Cleans up the Jython interpreter.
+     */
+    public void close() {
+        interpreter.cleanup();
+    }
 }
diff --git a/src/java/org/robotframework/RunnerFactory.java b/src/java/org/robotframework/RunnerFactory.java
diff --git a/src/robot/jarrunner.py b/src/robot/jarrunner.py
@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from org.robotframework import RobotRunner
+from org.robotframework import RobotPythonRunner
 
 from robot.errors import INFO_PRINTED
 from robot.libdoc import libdoc_cli
@@ -44,7 +44,7 @@
 """
 
 
-class JarRunner(RobotRunner):
+class JarRunner(RobotPythonRunner):
     """Used for Java-Jython interop when RF is executed from .jar file."""
     _commands = {'run': run_cli, 'rebot': rebot_cli, 'tidy': tidy_cli,
                  'libdoc': libdoc_cli, 'testdoc': testdoc_cli}

Original file line number	Diff line number	Diff line change
`@@ -15,9 +15,6 @@`
`15`	`15`
`16`	`16`	`package org.robotframework;`
`17`	`17`
`18`		`-import org.robotframework.RunnerFactory;`
`19`		`-import org.robotframework.RobotRunner;`
`20`		`-`
`21`	`18`	`/**`
`22`	`19`	`*`
`23`	`20`	`* Entry point for using Robot Framework from Java programs.`
`@@ -59,12 +56,8 @@ public static void main(String[] args) {`
`59`	`56`	`* for meaning of different return codes.`
`60`	`57`	`*/`
`61`	`58`	`public static int run(String[] args) {`
`62`		`- RunnerFactory context = new RunnerFactory();`
`63`		`- RobotRunner runner = context.createRunner();`
`64`		`- try {`
	`59`	`+ try (RobotRunner runner = new RobotRunner()) {`
`65`	`60`	`return runner.run(args);`
`66`		`- } finally {`
`67`		`- context.cleanup();`
`68`	`61`	`}`
`69`	`62`	`}`
`70`	`63`	`}`