1.0.14: junit 5

CHANGELOG.md

@@ -10,7 +10,10 @@
 
 ## [Unreleased]
 ### Added
+NA
 
+### Changed
+- remove the annoying inspector for unittest check during writing the unittest, reason: inspector is for something that can be fast fixed, but the unittest check is not, so remove it to avoid the confusion.
 
 ## 1.0.0 - 2024-10-12
 ### Initial Release
@@ -105,3 +108,7 @@
 - Tool window:
     - Update the tool window to show the test case scan result on completion.
     - Move all tool window into one multi-tab tool window.
+
+## 1.0.14 - 2025-06-08
+- remove the annoying inspector for unittest check during writing the unittest, reason: inspector is for something that can be fast fixed, but the unittest check is not, so remove it to avoid the confusion.
+- add the support to Junit 5 from version 5.7.0 to 5.13.0.

gradle.properties

@@ -5,7 +5,7 @@ pluginName = TestCraft-Pro
 pluginRepositoryUrl = https://github.com/jaksonlin/testcraft-pro
 # SemVer format -> https://semver.org
 
-pluginVersion = 1.0.13
+pluginVersion = 1.0.14
 
 
 # Supported build number ranges and IntelliJ Platform versions -> https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html

src/main/java/com/github/jaksonlin/testcraft/application/actions/PreCommitValidationAction.java

@@ -0,0 +1,140 @@
+package com.github.jaksonlin.testcraft.application.actions;
+
+import com.github.jaksonlin.testcraft.infrastructure.commands.testscan.UnittestFileBatchScanCommand;
+import com.github.jaksonlin.testcraft.infrastructure.services.business.RunHistoryManagerService;
+import com.github.jaksonlin.testcraft.infrastructure.services.config.InvalidTestCaseConfigService;
+import com.github.jaksonlin.testcraft.infrastructure.services.system.I18nService;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.actionSystem.DataContext;
+import com.intellij.openapi.actionSystem.impl.SimpleDataContext;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vcs.CheckinProjectPanel;
+import com.intellij.openapi.vcs.changes.CommitContext;
+import com.intellij.openapi.vcs.checkin.CheckinHandler;
+import com.intellij.openapi.vcs.checkin.CheckinHandlerFactory;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiManager;
+import com.intellij.openapi.ui.Messages;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public class PreCommitValidationAction extends CheckinHandlerFactory {
+    @Override
+    public @NotNull CheckinHandler createHandler(@NotNull CheckinProjectPanel checkinProjectPanel, @NotNull CommitContext commitContext) {
+        return null;
+    }
+//    private final InvalidTestCaseConfigService invalidTestCaseConfigService;
+//    private final RunHistoryManagerService runHistoryManager;
+//
+//    public PreCommitValidationAction() {
+//        this.invalidTestCaseConfigService = ApplicationManager.getApplication().getService(InvalidTestCaseConfigService.class);
+//        this.runHistoryManager = RunHistoryManagerService.getInstance();
+//    }
+//
+//    @Override
+//    public @NotNull CheckinHandler createHandler(@NotNull CheckinProjectPanel checkinProjectPanel, @NotNull CommitContext commitContext) {
+//
+//        return new CheckinHandler() {
+//            @Override
+//            public ReturnResult beforeCheckin() {
+//                try {
+//                    if (!invalidTestCaseConfigService.isEnable()) {
+//                        return ReturnResult.COMMIT;
+//                    }
+//
+//                    Project project = checkinProjectPanel.getProject();
+//                    if (project == null) {
+//                        return ReturnResult.COMMIT;
+//                    }
+//
+//                    Collection<VirtualFile> files = checkinProjectPanel.getVirtualFiles();
+//                    if (files == null || files.isEmpty()) {
+//                        return ReturnResult.COMMIT;
+//                    }
+//
+//                    // Collect test files
+//                    List<PsiFile> testFiles = new ArrayList<>();
+//                    PsiManager psiManager = PsiManager.getInstance(project);
+//                    for (VirtualFile file : files) {
+//                        if (file.getName().endsWith("Test.java")) {
+//                            PsiFile psiFile = psiManager.findFile(file);
+//                            if (psiFile != null) {
+//                                testFiles.add(psiFile);
+//                            }
+//                        }
+//                    }
+//
+//                    if (!testFiles.isEmpty()) {
+//                        // Create a simple data context for the action event
+//                        DataContext dataContext = SimpleDataContext.getProjectContext(project);
+//                        AnActionEvent actionEvent = AnActionEvent.createFromDataContext(
+//                            "PreCommitValidation",
+//                            null,
+//                            dataContext
+//                        );
+//
+//                        // Run validation on all test files
+//                        UnittestFileBatchScanCommand scanCommand = new UnittestFileBatchScanCommand(project, actionEvent);
+//
+//                        // Create a CompletableFuture to handle the validation result
+//                        CompletableFuture<Boolean> validationFuture = new CompletableFuture<>();
+//
+//                        // Add a listener to handle the validation result
+////                        scanCommand.setOnValidationCompleteListener(hasInvalidTests -> {
+////                            validationFuture.complete(hasInvalidTests);
+////                        });
+//
+//                        // Execute the validation
+//                        scanCommand.execute();
+//
+//                        try {
+//                            // Wait for validation to complete with a timeout
+//                            boolean hasInvalidTests = validationFuture.get(30, TimeUnit.SECONDS);
+//
+//                            if (hasInvalidTests) {
+//                                // Show error message and block commit
+//                                Messages.showErrorDialog(
+//                                    project,
+//                                    I18nService.getInstance().message("testscan.commit_blocked_message"),
+//                                    I18nService.getInstance().message("testscan.test_case_validation_results")
+//                                );
+//
+//                                return ReturnResult.CANCEL;
+//                            }
+//                        } catch (InterruptedException | ExecutionException | TimeoutException ex) {
+//                            // Handle timeout or other errors
+//                            Messages.showErrorDialog(
+//                                project,
+//                                I18nService.getInstance().message("testscan.validation_timeout_message"),
+//                                I18nService.getInstance().message("testscan.test_case_validation_results")
+//                            );
+//                            return ReturnResult.CANCEL;
+//                        }
+//                    }
+//
+//                    return ReturnResult.COMMIT;
+//                } catch (Exception e) {
+//                    // Handle any unexpected errors
+//                    Project project = checkinProjectPanel.getProject();
+//                    if (project != null) {
+//                        Messages.showErrorDialog(
+//                            project,
+//                            "An unexpected error occurred during pre-commit validation: " + e.getMessage(),
+//                            "Pre-commit Validation Error"
+//                        );
+//                    }
+//                    return ReturnResult.COMMIT;
+//                }
+//            }
+//        };
+//    }
+} 

src/main/java/com/github/jaksonlin/testcraft/domain/context/PitestContext.java

@@ -30,6 +30,24 @@ public class PitestContext {
     private String workingDirectory;
     private String methodsToMutate;
     private String mutatorGroup;
+    private Boolean isJunit5;
+    private String javaVersion;
+
+    public String getJavaVersion() {
+        return javaVersion;
+    }
+
+    public void setJavaVersion(String javaVersion) {
+        this.javaVersion = javaVersion;
+    }
+
+    public Boolean getIsJunit5() {
+        return isJunit5;
+    }
+
+    public void setIsJunit5(Boolean isJunit5) {
+        this.isJunit5 = isJunit5;
+    }
 
     public String getMutatorGroup() {
         return mutatorGroup;

src/main/java/com/github/jaksonlin/testcraft/infrastructure/commands/pitest/MethodToMutateCommand.java

@@ -1,6 +1,8 @@
 package com.github.jaksonlin.testcraft.infrastructure.commands.pitest;
 
+import java.io.IOException;
 import java.util.List;
+import java.util.Optional;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
@@ -28,21 +30,29 @@ public void execute() {
     }
 
     private List<String> getTargetClassMethods() {
-        ClassFileInfo classFileInfo = javaFileProcessor.getFullyQualifiedName(getContext().getTargetClassFilePath());
-        List<String> methods = classFileInfo.getMethods();
-        ItemSelectionComponent<String> itemSelectionComponent = new ItemSelectionComponent<String>(getProject(), "Select the methods to mutate");
-        itemSelectionComponent.setItems(methods);
-        AtomicReference<List<String>> result = new AtomicReference<>();
-        ApplicationManager.getApplication().invokeAndWait(() -> {
-            itemSelectionComponent.showDialog();
-            result.set(itemSelectionComponent.getSelectedItems());
-        }, ModalityState.defaultModalityState());
-
-
-        // format into QualifiedClassName::methodName
-        return result.get().stream()
-            .map(method -> classFileInfo.getFullyQualifiedName() + "::" + method)
-            .collect(Collectors.toList());
+        try {
+            Optional<ClassFileInfo> classFileInfo = javaFileProcessor.getFullyQualifiedName(getContext().getTargetClassFilePath());
+            if (!classFileInfo.isPresent()) {
+                showError("Cannot get fully qualified name for target class");
+                throw new IllegalStateException("Cannot get fully qualified name for target class");
+            }
+            List<String> methods = classFileInfo.get().getMethods();
+            ItemSelectionComponent<String> itemSelectionComponent = new ItemSelectionComponent<String>(getProject(), "Select the methods to mutate");
+            itemSelectionComponent.setItems(methods);
+            AtomicReference<List<String>> result = new AtomicReference<>();
+            ApplicationManager.getApplication().invokeAndWait(() -> {
+                itemSelectionComponent.showDialog();
+                result.set(itemSelectionComponent.getSelectedItems());
+            }, ModalityState.defaultModalityState());
+            // format into QualifiedClassName::methodName
+            return result.get().stream()
+                .map(method -> classFileInfo.get().getFullyQualifiedName() + "::" + method)
+                .collect(Collectors.toList());
+        } catch(IOException ex){
+            showError("Error getting fully qualified name for target class: " + ex.getMessage());
+            throw new IllegalStateException("Error getting fully qualified name for target class", ex);
+        }
+
     }
 
 }

src/main/java/com/github/jaksonlin/testcraft/infrastructure/commands/pitest/MultiTargetClassCheckCommand.java

@@ -11,8 +11,10 @@
 import com.github.jaksonlin.testcraft.util.TargetClassInfo;
 import com.github.jaksonlin.testcraft.util.JavaFileProcessor;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.concurrent.atomic.AtomicReference;
 
 public class MultiTargetClassCheckCommand extends PitestCommand {
@@ -25,7 +27,7 @@
     public void execute() {
         List<String> targetClassFilePaths = getMultiTargetClass();
         if (targetClassFilePaths == null || targetClassFilePaths.isEmpty()) {
             return;
         }
         //getContext().setTargetClassFilePaths(targetClassFilePaths);
     }
@@ -47,15 +49,20 @@
             showError("Cannot find target class file");
             throw new IllegalStateException("Cannot find target class file");
         }
-        ClassFileInfo classInfo = javaFileProcessor.getFullyQualifiedName(targetClassInfo.getFile().toString());
+        try {
+            Optional<ClassFileInfo> classInfo = javaFileProcessor.getFullyQualifiedName(targetClassInfo.getFile().toString());
 
-        if (classInfo == null) {
-            showError("Cannot get fully qualified name for target class");
-            throw new IllegalStateException("Cannot get fully qualified name for target class");
+            if (!classInfo.isPresent()) {
+                showError("Cannot get fully qualified name for target class");
+                throw new IllegalStateException("Cannot get fully qualified name for target class");
+            }
+            List<String> fullyQualifiedNames = new ArrayList<>();
+            fullyQualifiedNames.add(classInfo.get().getFullyQualifiedName());
+            return fullyQualifiedNames;
+        } catch (IOException e) {
+            showError("Error getting fully qualified name for target class: " + e.getMessage());
+            throw new IllegalStateException("Error getting fully qualified name for target class", e);
         }
-        List<String> fullyQualifiedNames = new ArrayList<>();
-        fullyQualifiedNames.add(classInfo.getFullyQualifiedName());
-        return fullyQualifiedNames;
     }
 
     private String displayCandidateClass(String classCandidateName) {