技术问询：如何获取所有test methods的名称？

Hey there! I notice you’ve asked twice about how to get all test method names in your test suite—great question, since the approach depends a lot on which testing framework you’re using. Let’s walk through common scenarios with concrete examples:

Java’s JUnit ecosystem has two major versions, each with its own way to extract test method names.

JUnit 4: Using Reflection #

JUnit 4 marks test methods with the @Test annotation, so we can use Java’s reflection API to scan a test class and pick out methods with this annotation.

import java.lang.reflect.Method;
import org.junit.Test;

public class TestMethodLister {
    public static void main(String[] args) {
        // Replace with your actual test class
        Class<?> testClass = UserAuthenticationTest.class;
        
        for (Method method : testClass.getDeclaredMethods()) {
            if (method.isAnnotationPresent(Test.class)) {
                System.out.println("Test Method: " + method.getName());
            }
        }
    }
}

Just swap UserAuthenticationTest with your test class name, and this will print every method marked with @Test.

JUnit 5: Using JUnit Platform API #

JUnit 5 uses a more flexible platform system. You can use its launcher API to discover and list test methods, even across multiple classes.

import org.junit.platform.launcher.Launcher;
import org.junit.platform.launcher.LauncherDiscoveryRequest;
import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
import org.junit.platform.launcher.core.LauncherFactory;
import org.junit.platform.launcher.listeners.SummaryGeneratingListener;
import org.junit.platform.launcher.listeners.TestExecutionSummary;
import static org.junit.platform.engine.discovery.DiscoverySelectors.selectClass;

public class JUnit5TestLister {
    public static void main(String[] args) {
        // Build a request to target your test class
        LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
                .selectors(selectClass(PaymentProcessingTest.class)) // Replace with your test class
                .build();

        Launcher launcher = LauncherFactory.create();
        SummaryGeneratingListener listener = new SummaryGeneratingListener();

        // Register the listener and execute the discovery
        launcher.registerTestExecutionListeners(listener);
        launcher.execute(request);

        // Extract test names from the summary (includes passed, failed, skipped)
        TestExecutionSummary summary = listener.getSummary();
        summary.getTestsFound().forEach(testDescriptor -> {
            if (testDescriptor.isTest()) {
                System.out.println("Test Method: " + testDescriptor.getDisplayName());
            }
        });
    }
}

This will list all test methods in your target class, regardless of their execution status.

Pytest uses convention-over-configuration (test methods/functions start with test_), but there are a couple of ways to extract their names.

Option 1: Use Pytest Hooks #

Add this to a conftest.py file in your test directory, and pytest will print all test names when it runs:

def pytest_collection_modifyitems(items):
    print("\nAll Test Methods:")
    for item in items:
        # item.nodeid gives the full path + method name, item.name is just the method name
        print(f"- {item.name}")

Option 2: Scan Test Files Programmatically #

If you want to extract names without running pytest, use Python’s inspect module to scan test files directly:

import inspect
import os

def get_test_names(module_path):
    # Import the test module
    module_name = os.path.splitext(os.path.basename(module_path))[0]
    module = __import__(module_name, fromlist=[''])
    
    # Filter functions that start with 'test_'
    test_names = []
    for name, obj in inspect.getmembers(module):
        if inspect.isfunction(obj) and name.startswith('test_'):
            test_names.append(name)
    return test_names

# Example: Get tests from a single file
print(get_test_names("./tests/test_checkout.py"))

# Example: Scan all test files in a directory
def scan_all_tests(directory):
    all_tests = []
    for root, _, files in os.walk(directory):
        for file in files:
            if file.startswith('test_') and file.endswith('.py'):
                file_path = os.path.join(root, file)
                all_tests.extend(get_test_names(file_path))
    return all_tests

print(scan_all_tests("./tests"))

For Jest, you can either parse test files directly or use Jest’s internal API to discover tests. Here’s a simple script to extract test names by reading file content:

const fs = require('fs');
const path = require('path');

function getJestTestNames(testDir) {
    const testNames = [];
    // Regex to match test/it blocks with string literals
    const testRegex = /(test|it)\(['"](.*?)['"],/g;

    // Walk through all test files
    function walkDir(dir) {
        const files = fs.readdirSync(dir);
        for (const file of files) {
            const fullPath = path.join(dir, file);
            if (fs.statSync(fullPath).isDirectory()) {
                walkDir(fullPath);
            } else if (file.endsWith('.test.js') || file.endsWith('.spec.js')) {
                const content = fs.readFileSync(fullPath, 'utf8');
                let match;
                while ((match = testRegex.exec(content)) !== null) {
                    testNames.push(match[2]);
                }
            }
        }
    }

    walkDir(testDir);
    return testNames;
}

// Example: Get tests from your __tests__ directory
console.log(getJestTestNames("./__tests__"));

Hope one of these solutions fits your workflow! If you’re using a less common framework, just let me know and I can help tailor the approach.

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