如何自动化IntelliJ中查找类全量测试覆盖率的手动流程？

Great question! That manual workflow of hunting dependencies and building run configs one by one is such a time drain—let's break down three automated solutions, starting with the easiest built-in option:

1. Use IntelliJ's Built-In "Run All Tests Covering Selected Code" (No Setup Needed) #

You might have missed this hidden gem in IntelliJ's right-click menu, but it's perfect for this exact use case:

• Open your target class in the editor
• Right-click anywhere inside the class body
• Hover over Run → Select Run 'All Tests Covering [YourClassName]' with Coverage
• IntelliJ takes care of the rest: it automatically finds every test class that references or covers your target class, spins up a temporary run config with coverage enabled, and displays the full coverage results directly in your editor once tests finish.

This is the fastest, zero-effort way to get the coverage data you need without any scripting or code changes.

2. Automate via IntelliJ's Groovy Script Console (For Repeatable, Custom Workflows) #

If you need to run this workflow frequently or tweak it (e.g., filter tests by package), use IntelliJ's Script Console to automate the entire process with a Groovy script. This leverages IntelliJ's internal project API to skip the manual steps:

• Open the Script Console (go to View > Tool Windows > Script Console, or press Alt+F12 and switch to the Script Console tab)
• Paste this script, replacing com.yourpackage.YourTargetClass with your actual class's fully qualified name:

import com.intellij.openapi.project.Project
import com.intellij.psi.PsiClass
import com.intellij.psi.search.searches.ReferencesSearch
import com.intellij.execution.RunManager
import com.intellij.execution.junit.JUnitConfiguration
import com.intellij.execution.junit.JUnitConfigurationType
import com.intellij.psi.search.GlobalSearchScope
import com.intellij.psi.JavaPsiFacade
import com.intellij.execution.ExecutionManager

def project = projectManager.openProjects[0]
def targetClassName = "com.yourpackage.YourTargetClass"
def targetClass = JavaPsiFacade.getInstance(project).findClass(targetClassName, GlobalSearchScope.allScope(project))

if (!targetClass) {
    println("❌ Target class '$targetClassName' not found in the project!")
    return
}

// Find all test classes that reference the target class
def testClasses = []
ReferencesSearch.search(targetClass, GlobalSearchScope.projectScope(project)).findAll().each { ref ->
    def containingFile = ref.element.containingFile.psiFile
    def testClass = containingFile.classes.firstOrNull()
    if (testClass) {
        // Check if it's a test class (looks for JUnit 4 or 5 annotations)
        def isTestClass = testClass.annotations.any { 
            it.qualifiedName in ["org.junit.Test", "org.junit.jupiter.api.Test"] 
        }
        if (isTestClass && !testClasses.contains(testClass)) {
            testClasses.add(testClass)
        }
    }
}

if (testClasses.isEmpty()) {
    println("ℹ️ No test classes found referencing '$targetClassName'.")
    return
}

// Create a new JUnit run configuration with coverage enabled
def runManager = RunManager.getInstance(project)
def jUnitConfigType = runManager.configurationTypes.find { it instanceof JUnitConfigurationType }
def configFactory = jUnitConfigType.configurationFactories[0]
def configName = "Coverage for ${targetClass.name}"
def runConfig = runManager.createConfiguration(configName, configFactory)

def jUnitConfig = runConfig.configuration as JUnitConfiguration
jUnitConfig.setTestKind(JUnitConfiguration.TEST_KIND_PATTERN)
// Build the pattern from unique test class FQNs
def testPattern = testClasses.collect { it.qualifiedName }.join(",")
jUnitConfig.setPattern(testPattern)

// Enable coverage for this run
def runnerSettings = jUnitConfig.runnerSettings
runnerSettings.codeCoverageEnabled = true

// Save and execute the configuration
runManager.addConfiguration(runConfig)
runManager.selectedConfiguration = runConfig
ExecutionManager.getInstance(project).restartRunProfile(runConfig)

println("✅ Started coverage run for ${testClasses.size()} test classes targeting ${targetClass.name}!")

• Click the run button in the Script Console—IntelliJ will create a dedicated run config, execute all relevant tests with coverage, and open the coverage report automatically.

3. Maintain a Dynamic Test Suite (For Long-Term, Shared Workflows) #

If your team needs to run this coverage check regularly, create a dynamic test suite that automatically includes all tests referencing your target class. This requires a small amount of test code, but it's easy to share and run:

• Create a new test class (e.g., YourTargetClassCoverageSuite)
• For JUnit 5, use a custom class selector to filter tests that reference your target class. Here's a simplified example (you can expand the filtering logic as needed):

import org.junit.platform.engine.discovery.ClassSelector;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.platform.runner.Selector;
import org.junit.platform.runner.Selectors;
import org.junit.runner.RunWith;

import java.util.ArrayList;
import java.util.List;

@RunWith(JUnitPlatform.class)
@Selectors(selectors = {
        @Selector(value = ClassSelector.class, arguments = "com.yourpackage.tests")
})
public class YourTargetClassCoverageSuite {
    // Optional: Add static initialization to filter only tests referencing YourTargetClass
    static {
        // Use reflection or IntelliJ's API to scan and filter test classes
        // For example, check if the test class contains references to YourTargetClass
    }
}

• Once set up, you can run this suite with coverage anytime—IntelliJ will execute all matching tests and show you the full coverage for your target class.

内容的提问来源于stack exchange，提问作者Bill K