Refactor JUnit 4 and JUnit 5 parts

Author: jeanbisutti

core/src/main/java/org/quickperf/issue/PerfIssuesEvaluator.java

@@ -33,9 +33,6 @@ private PerfIssuesEvaluator() {}
     public static final PerfIssuesEvaluator INSTANCE = new PerfIssuesEvaluator();
 
     public Collection<PerfIssuesToFormat> evaluatePerfIssues(SetOfAnnotationConfigs testAnnotationConfigs, TestExecutionContext testExecutionContext) {
-        if(testExecutionContext.isQuickPerfDisabled()) {
-            return Collections.emptyList();
-        }
         Map<Annotation, PerfRecord> perfRecordByAnnotation
                 = buildPerfRecordByAnnotation(testAnnotationConfigs, testExecutionContext);
 

core/src/main/java/org/quickperf/reporter/ConsoleReporter.java

@@ -63,7 +63,7 @@ void displayQuickPerfDebugInfos() {
         printExecutionOrders(executionOrderListAfter);
     }
 
-    public void displayQuickPerfAnnotations(Annotation[] perfAnnotations) {
+    void displayQuickPerfAnnotations(Annotation[] perfAnnotations) {
 
         List<Annotation> perfAnnotationsWithoutDisplayAppliedAnnotations =
                 removeDisplayAppliedAnnotations(perfAnnotations);

core/src/main/java/org/quickperf/testlauncher/MainClassArguments.java

@@ -0,0 +1,76 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2019-2019 the original author or authors.
+ */
+
+package org.quickperf.testlauncher;
+
+import org.quickperf.WorkingFolder;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+public class MainClassArguments {
+
+    private final String className;
+
+    private final String methodName;
+
+    private final String workingFolderPath;
+
+    private MainClassArguments(String className, String methodName, String workingFolderPath) {
+        this.className = className;
+        this.methodName = methodName;
+        this.workingFolderPath = workingFolderPath;
+    }
+
+    public String getClassName() {
+        return className;
+    }
+
+    public String getMethodName() {
+        return methodName;
+    }
+
+    public String getWorkingFolderPath() {
+        return workingFolderPath;
+    }
+
+    public static MainClassArguments buildFrom(Method testMethod
+                                             , WorkingFolder workingFolder) {
+        String className = retrieveClassNameOf(testMethod);
+        String methodName = testMethod.getName();
+        String workingFolderPath = workingFolder.getPath();
+        return new MainClassArguments(className, methodName, workingFolderPath);
+    }
+
+    private static String retrieveClassNameOf(Method method) {
+        Class<?> classOfTestMethod = method.getDeclaringClass();
+        return classOfTestMethod.getName();
+    }
+
+    public static MainClassArguments buildFromMainArguments(String... args) {
+        String className = args[0];
+        String methodName = args[1];
+        String workingFolderPath = args[2];
+        return new MainClassArguments(className, methodName, workingFolderPath);
+    }
+
+    public List<String> buildMainClassArgumentsForJvmCommand() {
+        List<String> arguments = new ArrayList<>(3);
+        arguments.add(className);
+        arguments.add(methodName);
+        arguments.add(workingFolderPath);
+        return arguments;
+    }
+
+}

core/src/main/java/org/quickperf/testlauncher/NewJvmTestLauncher.java

@@ -15,7 +15,10 @@
 
 import org.apache.commons.io.IOUtils;
 import org.quickperf.SystemProperties;
+import org.quickperf.TestExecutionContext;
 import org.quickperf.WorkingFolder;
+import org.quickperf.issue.BusinessOrTechnicalIssue;
+import org.quickperf.repository.BusinessOrTechnicalIssueRepository;
 
 import java.io.File;
 import java.io.IOException;
@@ -28,27 +31,36 @@ public class NewJvmTestLauncher {
 
     public static final NewJvmTestLauncher INSTANCE = new NewJvmTestLauncher();
 
+    private final BusinessOrTechnicalIssueRepository businessOrTechnicalIssueRepository = BusinessOrTechnicalIssueRepository.INSTANCE;
+
     private NewJvmTestLauncher() { }
 
-    public void run(Method testMethod
-                  , WorkingFolder workingFolder
-                  , AllJvmOptions jvmOptions
-                  , Class<?> mainClassToLaunchTestInANewJvm) {
+    public BusinessOrTechnicalIssue executeTestMethodInNewJwm( Method testMethod
+                                                             , TestExecutionContext testExecutionContext
+                                                             , Class<?> mainClassToLaunchTestInANewJvm) {
+        WorkingFolder workingFolder = testExecutionContext.getWorkingFolder();
+        AllJvmOptions jvmOptions = testExecutionContext.getJvmOptions();
+
+        executeTestInNewJvm(testMethod, workingFolder, jvmOptions, mainClassToLaunchTestInANewJvm);
+
+        return businessOrTechnicalIssueRepository.findFrom(workingFolder);
+    }
 
-        String className = retrieveClassNameFrom(testMethod);
-        String methodName = testMethod.getName();
+    private void executeTestInNewJvm(Method testMethod
+                                  , WorkingFolder workingFolder
+                                  , AllJvmOptions jvmOptions
+                                  , Class<?> mainClassToLaunchTestInANewJvm) {
+
+        MainClassArguments mainClassArguments = MainClassArguments.buildFrom(testMethod, workingFolder);
 
         List<String> jvmOptionsAsStrings = jvmOptions.asStrings(workingFolder);
 
-        List<String> jvmCommand
-                = buildCommandOfLaunchingJUnitCoreInANewJvm(
-                          className
-                        , methodName
-                        , jvmOptionsAsStrings
-                        , workingFolder.getPath()
-                        , mainClassToLaunchTestInANewJvm);
+        List<String> jvmCommand = buildCommand( mainClassArguments
+                                              , jvmOptionsAsStrings
+                                              , workingFolder.getPath()
+                                              , mainClassToLaunchTestInANewJvm);
 
-        CmdExecutionResult cmdExecutionResult  = tryWith(jvmCommand, workingFolder);
+        CmdExecutionResult cmdExecutionResult  = tryWith(jvmCommand);
 
         System.out.println(cmdExecutionResult.getMessage());
 
@@ -58,35 +70,27 @@ public void run(Method testMethod
 
     }
 
-    private static List<String> buildCommandOfLaunchingJUnitCoreInANewJvm(
-              String className
-            , String methodName
-            , List<String> jvmParamsAsString
-            , String workingFolderPath
-            , Class<?> mainClassToLaunchTest) {
+    private static List<String> buildCommand(MainClassArguments mainClassArguments
+                                           , List<String> jvmOptionsAsStrings
+                                           , String workingFolderPath
+                                           , Class<?> mainClassToLaunchTest) {
         List<String> command = new ArrayList<>();
         command.add(retrieveJavaExePath());
-        command.addAll(jvmParamsAsString);
+        command.addAll(jvmOptionsAsStrings);
         command.add(SystemProperties.TEST_CODE_EXECUTING_IN_NEW_JVM
-                                .buildForJvm("true")
+                                    .buildForJvm("true")
                    );
         command.add(SystemProperties.WORKING_FOLDER
-                                .buildForJvm(workingFolderPath)
+                                    .buildForJvm(workingFolderPath)
                    );
         command.add("-cp");
         command.add(retrieveCurrentClassPath());
         command.add(mainClassToLaunchTest.getCanonicalName());
-        command.add(className);
-        command.add(methodName);
-        command.add(workingFolderPath);
+        List<String> mainClassArgumentsAsStringList = mainClassArguments.buildMainClassArgumentsForJvmCommand();
+        command.addAll(mainClassArgumentsAsStringList);
         return command;
     }
 
-    private static String retrieveClassNameFrom(Method method) {
-        Class<?> classOfTestMethod = method.getDeclaringClass();
-        return classOfTestMethod.getName();
-    }
-
     private static String retrieveJavaExePath() {
         String javaHomeDirectoryPath = System.getProperty("java.home");
         return    javaHomeDirectoryPath
@@ -126,7 +130,7 @@ private String getErrorMessage() {
 
     }
 
-    private static CmdExecutionResult tryWith(List<String> cmd, WorkingFolder workingFolder) {
+    private static CmdExecutionResult tryWith(List<String> cmd) {
 
         try {
             final Process process = new ProcessBuilder(cmd).start();

core/src/main/java/org/quickperf/testlauncher/TestRunnerFromMain.java

@@ -0,0 +1,57 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2019-2019 the original author or authors.
+ */
+
+package org.quickperf.testlauncher;
+
+import org.quickperf.issue.BusinessOrTechnicalIssue;
+import org.quickperf.repository.BusinessOrTechnicalIssueRepository;
+
+public class TestRunnerFromMain {
+
+    public static final TestRunnerFromMain INSTANCE = new TestRunnerFromMain();
+
+    private TestRunnerFromMain() { }
+
+    public interface FrameworkTestRunner {
+
+        BusinessOrTechnicalIssue executeTestMethod(Class<?> testClass, String methodName);
+
+    }
+
+    public void executeTestMethod(FrameworkTestRunner frameworkTestRunner, String... mainArgs) throws ClassNotFoundException {
+
+        MainClassArguments mainClassArguments = MainClassArguments.buildFromMainArguments(mainArgs);
+
+        BusinessOrTechnicalIssue businessOrTechnicalIssue = executeTestMethod(frameworkTestRunner, mainClassArguments);
+
+        BusinessOrTechnicalIssueRepository businessOrTechnicalIssueRepository = BusinessOrTechnicalIssueRepository.INSTANCE;
+
+        String workingFolderPath = mainClassArguments.getWorkingFolderPath();
+        businessOrTechnicalIssueRepository.save(businessOrTechnicalIssue
+                                              , workingFolderPath);
+
+        // To be sure that Tomcat or Jetty web server will stop
+        System.exit(0);
+
+    }
+
+    private BusinessOrTechnicalIssue executeTestMethod(FrameworkTestRunner frameworkTestRunner, MainClassArguments mainClassArguments) throws ClassNotFoundException {
+        String className = mainClassArguments.getClassName();
+        Class<?> testClass = Class.forName(className);
+
+        String methodName = mainClassArguments.getMethodName();
+
+        return frameworkTestRunner.executeTestMethod(testClass, methodName);
+    }
+
+}

junit4/junit4-runner/src/main/java/org/quickperf/junit4/JUnit4TestRunner.java

@@ -0,0 +1,52 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2019-2019 the original author or authors.
+ */
+
+package org.quickperf.junit4;
+
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.quickperf.issue.BusinessOrTechnicalIssue;
+import org.quickperf.testlauncher.TestRunnerFromMain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class JUnit4TestRunner implements TestRunnerFromMain.FrameworkTestRunner {
+
+    @Override
+    public BusinessOrTechnicalIssue executeTestMethod(Class<?> testClass, String methodName) {
+
+        Request junitRequestOfMethod = Request.method(testClass, methodName);
+
+        Result testResult = new JUnitCore().run(junitRequestOfMethod);
+
+        List<Failure> jUnit4Failures = testResult.getFailures();
+
+        List<Throwable> jUnit4failuresAsThrowables = convertJUnit4FailuresToThrowables(jUnit4Failures);
+
+        return  BusinessOrTechnicalIssue.buildFrom(jUnit4failuresAsThrowables);
+
+    }
+
+    private List<Throwable> convertJUnit4FailuresToThrowables(List<Failure> jUnit4Failures) {
+        List<Throwable> throwables = new ArrayList<>();
+        for (Failure failure : jUnit4Failures) {
+            Throwable throwable = failure.getException();
+            throwables.add(throwable);
+        }
+        return throwables;
+    }
+
+}