Refactor run configuration for flexible argument passing

Based on infection-plugin architecture:

- TestoRunnerSettings: add @Tag/@Attribute annotations for XMLB serialization,
  new fields: command, suite, group, excludeGroup, repeat, parallel.
  fromPhpTestRunnerSettings() now copies Testo-specific fields.

- TestoRunConfigurationHandler: add prepareArguments() that builds argument list
  from settings (suite, group, excludeGroup, repeat, parallel). Overloaded
  prepareCommand() supports custom subcommand. Extract parseMethodName() for
  method#dataProvider parsing.

- TestoRunConfiguration: override createCommand() to take full control of
  command assembly. Extract fillTestRunnerArguments() for scope-based args
  (Type, Directory, File, Method, ConfigurationFile).

- TestoRunConfigurationSettings: add @Property/@transient for proper XMLB
  serialization of TestoRunnerSettings.

- TestoTestRunConfigurationEditor: add UI fields for command, suite, group,
  excludeGroup, repeat, parallel with proper reset/apply binding and
  reflection-based parent editor integration.

- Tests: full coverage for prepareArguments(), parseMethodName(),
  fromPhpTestRunnerSettings() with new fields.

https://claude.ai/code/session_01TmFvjfMtoxTvddQRBzsbPN

Author: claude

src/main/kotlin/com/github/xepozz/testo/tests/run/TestoRunConfiguration.kt

@@ -5,21 +5,30 @@ import com.github.xepozz.testo.isTestoExecutable
 import com.github.xepozz.testo.tests.TestoConsoleProperties
 import com.github.xepozz.testo.tests.TestoFrameworkType
 import com.github.xepozz.testo.tests.actions.TestoRerunFailedTestsAction
+import com.intellij.execution.ExecutionException
 import com.intellij.execution.Executor
 import com.intellij.execution.configurations.ConfigurationFactory
+import com.intellij.execution.configurations.ParametersList
 import com.intellij.execution.configurations.RunConfiguration
 import com.intellij.execution.testframework.sm.runner.SMTRunnerConsoleProperties
 import com.intellij.execution.ui.ConsoleView
 import com.intellij.openapi.options.SettingsEditor
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.text.StringUtil
+import com.jetbrains.php.PhpBundle
 import com.jetbrains.php.config.commandLine.PhpCommandLinePathProcessor
+import com.jetbrains.php.config.commandLine.PhpCommandSettings
+import com.jetbrains.php.config.commandLine.PhpCommandSettingsBuilder
+import com.jetbrains.php.config.interpreters.PhpInterpreter
 import com.jetbrains.php.run.PhpAsyncRunConfiguration
 import com.jetbrains.php.run.remote.PhpRemoteInterpreterManager
 import com.jetbrains.php.testFramework.PhpTestFrameworkConfiguration
 import com.jetbrains.php.testFramework.run.PhpTestRunConfiguration
 import com.jetbrains.php.testFramework.run.PhpTestRunConfigurationEditor
+import com.jetbrains.php.testFramework.run.PhpTestRunConfigurationHandler
 import com.jetbrains.php.testFramework.run.PhpTestRunConfigurationSettings
 import com.jetbrains.php.testFramework.run.PhpTestRunnerConfigurationEditor
+import com.jetbrains.php.testFramework.run.PhpTestRunnerSettings
 
 class TestoRunConfiguration(project: Project, factory: ConfigurationFactory) : PhpTestRunConfiguration(
     project,
@@ -29,6 +38,8 @@ class TestoRunConfiguration(project: Project, factory: ConfigurationFactory) : P
     TestoTestRunnerSettingsValidator,
     TestoRunConfigurationHandler.INSTANCE,
 ), PhpAsyncRunConfiguration {
+    val myHandler = TestoRunConfigurationHandler.INSTANCE
+
     val testoSettings
         get() = settings as TestoRunConfigurationSettings
 
@@ -46,9 +57,8 @@ class TestoRunConfiguration(project: Project, factory: ConfigurationFactory) : P
 
     override fun getConfigurationEditor(): SettingsEditor<out RunConfiguration> {
         val editor = super.getConfigurationEditor() as PhpTestRunConfigurationEditor
-        editor.setRunnerOptionsDocumentation("https://infection.github.io/guide/command-line-options.html")
+        editor.setRunnerOptionsDocumentation("https://github.com/testo/testo")
 
-//        return this.addExtensionEditor(editor)!!
         return TestoTestRunConfigurationEditor(editor, this)
     }
 
@@ -58,8 +68,54 @@ class TestoRunConfiguration(project: Project, factory: ConfigurationFactory) : P
         config: PhpTestFrameworkConfiguration?
     ) = project.basePath
 
+    override fun createCommand(
+        interpreter: PhpInterpreter,
+        env: MutableMap<String?, String?>,
+        arguments: MutableList<String?>,
+        frameworkConfig: PhpTestFrameworkConfiguration?,
+        withDebugger: Boolean
+    ): PhpCommandSettings {
+        val command = PhpCommandSettingsBuilder(project, interpreter)
+            .loadAndStartDebug(withDebugger)
+            .build()
+
+        val executablePath = frameworkConfig?.executablePath
+        if (frameworkConfig == null || executablePath.isNullOrEmpty()) {
+            throw ExecutionException(
+                PhpBundle.message(
+                    "php.interpreter.base.configuration.is.not.provided.or.empty",
+                    frameworkName,
+                    if (command.isRemote) "'${interpreter.name}' interpreter" else "local machine",
+                )
+            )
+        }
+
+        val workingDirectory = getWorkingDirectory(project, settings, frameworkConfig)
+        if (workingDirectory.isNullOrEmpty()) {
+            throw ExecutionException(PhpBundle.message("php.interpreter.base.configuration.working.directory"))
+        }
+        command.setWorkingDir(workingDirectory)
+
+        myHandler.prepareArguments(arguments, testoSettings)
+        myHandler.prepareCommand(project, command, executablePath, null, testoSettings.runnerSettings.command)
+
+        command.importCommandLineSettings(settings.commandLineSettings, workingDirectory)
+        command.addEnvs(env)
+
+        fillTestRunnerArguments(
+            project,
+            workingDirectory,
+            settings.runnerSettings,
+            arguments,
+            command,
+            frameworkConfig,
+            myHandler,
+        )
+
+        return command
+    }
+
     override fun createTestConsoleProperties(executor: Executor): SMTRunnerConsoleProperties {
-//        println("createTestConsoleProperties")
         val manager = PhpRemoteInterpreterManager.getInstance()
 
         val pathProcessor = when (this.interpreter?.isRemote) {
@@ -76,8 +132,60 @@ class TestoRunConfiguration(project: Project, factory: ConfigurationFactory) : P
     }
 
     companion object Companion {
-        const val ID = "InfectionConsoleCommandRunConfiguration"
+        const val ID = "TestoConsoleCommandRunConfiguration"
+
+        private fun fillTestRunnerArguments(
+            project: Project,
+            workingDirectory: String,
+            testRunnerSettings: PhpTestRunnerSettings,
+            arguments: MutableList<String?>,
+            command: PhpCommandSettings,
+            configuration: PhpTestFrameworkConfiguration?,
+            handler: PhpTestRunConfigurationHandler,
+        ) {
+            val testRunnerOptions = testRunnerSettings.testRunnerOptions
+            if (StringUtil.isNotEmpty(testRunnerOptions)) {
+                command.addArguments(ParametersList.parse(testRunnerOptions!!).toList())
+            }
+
+            command.addArguments(arguments)
+
+            val configurationFilePath = getConfigurationFile(testRunnerSettings, configuration)
+            if (!configurationFilePath.isNullOrEmpty()) {
+                command.addArgument(handler.configFileOption)
+                command.addPathArgument(configurationFilePath)
+            }
+
+            val scope = testRunnerSettings.scope
+            when (scope) {
+                PhpTestRunnerSettings.Scope.Type -> handler.runType(
+                    project,
+                    command,
+                    StringUtil.notNullize(testRunnerSettings.selectedType),
+                    workingDirectory,
+                )
+
+                PhpTestRunnerSettings.Scope.Directory -> handler.runDirectory(
+                    project,
+                    command,
+                    StringUtil.notNullize(testRunnerSettings.directoryPath),
+                    workingDirectory,
+                )
+
+                PhpTestRunnerSettings.Scope.File -> handler.runFile(
+                    project,
+                    command,
+                    StringUtil.notNullize(testRunnerSettings.filePath),
+                    workingDirectory,
+                )
+
+                PhpTestRunnerSettings.Scope.Method -> {
+                    val filePath = StringUtil.notNullize(testRunnerSettings.filePath)
+                    handler.runMethod(project, command, filePath, testRunnerSettings.methodName, workingDirectory)
+                }
 
-//        val INSTANCE = TestoRunConfiguration()
+                PhpTestRunnerSettings.Scope.ConfigurationFile -> {}
+            }
+        }
     }
-}
+}

src/main/kotlin/com/github/xepozz/testo/tests/run/TestoRunConfigurationHandler.kt

@@ -13,15 +13,45 @@ class TestoRunConfigurationHandler : PhpTestRunConfigurationHandler {
     override fun getConfigFileOption() = "--config"
 
     override fun prepareCommand(project: Project, commandSettings: PhpCommandSettings, exe: String, version: String?) {
+        prepareCommand(project, commandSettings, exe, version, "run")
+    }
+
+    fun prepareCommand(
+        project: Project,
+        commandSettings: PhpCommandSettings,
+        exe: String,
+        version: String?,
+        command: String,
+    ) {
         commandSettings.apply {
             setScript(exe, true)
-            addArgument("run")
-//            addArgument("--no-progress")
-//            addArgument("-n")
-//            addArgument("-q")
-//            addArgument("--logger-gitlab=php://stdout")
+            addArgument(command)
+        }
+    }
+
+    fun prepareArguments(arguments: MutableList<String?>, testoSettings: TestoRunConfigurationSettings) {
+        val runner = testoSettings.runnerSettings
+
+        if (runner.suite.isNotEmpty()) {
+            arguments.add("--suite")
+            arguments.add(runner.suite)
+        }
+        if (runner.group.isNotEmpty()) {
+            arguments.add("--group")
+            arguments.add(runner.group)
+        }
+        if (runner.excludeGroup.isNotEmpty()) {
+            arguments.add("--exclude-group")
+            arguments.add(runner.excludeGroup)
+        }
+        if (runner.repeat > 0) {
+            arguments.add("--repeat")
+            arguments.add(runner.repeat.toString())
+        }
+        if (runner.parallel > 0) {
+            arguments.add("--parallel")
+            arguments.add(runner.parallel.toString())
         }
-//        println("commandSettings: $commandSettings")
     }
 
     override fun runType(
@@ -30,8 +60,6 @@ class TestoRunConfigurationHandler : PhpTestRunConfigurationHandler {
         type: String,
         workingDirectory: String
     ) {
-//        println("runType: $type, $workingDirectory")
-
         phpCommandSettings.apply {
             addArgument("--suite")
             addArgument(type)
@@ -44,7 +72,6 @@ class TestoRunConfigurationHandler : PhpTestRunConfigurationHandler {
         directory: String,
         workingDirectory: String
     ) {
-//        println("runDirectory: $directory")
         if (directory.isEmpty()) return
 
         phpCommandSettings.apply {
@@ -59,7 +86,6 @@ class TestoRunConfigurationHandler : PhpTestRunConfigurationHandler {
         file: String,
         workingDirectory: String
     ) {
-//        println("runFile: $file")
         if (file.isEmpty()) return
 
         phpCommandSettings.apply {
@@ -75,25 +101,32 @@ class TestoRunConfigurationHandler : PhpTestRunConfigurationHandler {
         methodName: String,
         workingDirectory: String
     ) {
-//        println("runMethod: $file, $methodName")
         if (file.isEmpty()) return
 
-        val myMethodName = methodName.substringBefore('#')
-        val dataProvider = methodName.substringAfter('#', "")
-
-//        println("method: $myMethodName, dataProvider: $dataProvider")
+        val parsed = parseMethodName(methodName)
 
         phpCommandSettings.apply {
             addArgument("--path")
             addRelativePathArgument(file, workingDirectory)
-            if (myMethodName.isNotEmpty()) {
+            if (parsed.method.isNotEmpty()) {
                 addArgument("--filter")
-                addArgument(myMethodName)
+                addArgument(parsed.method)
             }
-            if (dataProvider.isNotEmpty()) {
+            if (parsed.dataProvider.isNotEmpty()) {
                 addArgument("--data-provider")
-                addArgument(dataProvider)
+                addArgument(parsed.dataProvider)
             }
         }
     }
-}
+
+    data class ParsedMethodName(
+        val method: String,
+        val dataProvider: String,
+    )
+
+    fun parseMethodName(methodName: String): ParsedMethodName {
+        val method = methodName.substringBefore('#')
+        val dataProvider = methodName.substringAfter('#', "")
+        return ParsedMethodName(method, dataProvider)
+    }
+}

src/main/kotlin/com/github/xepozz/testo/tests/run/TestoRunConfigurationSettings.kt

@@ -1,5 +1,7 @@
 package com.github.xepozz.testo.tests.run
 
+import com.intellij.util.xmlb.annotations.Property
+import com.intellij.util.xmlb.annotations.Transient
 import com.jetbrains.php.testFramework.run.PhpTestRunConfigurationSettings
 import com.jetbrains.php.testFramework.run.PhpTestRunnerSettings
 
@@ -10,22 +12,24 @@ class TestoRunConfigurationSettings : PhpTestRunConfigurationSettings() {
 
     override fun getRunnerSettings() = getTestoRunnerSettings()
 
+    @Transient
     override fun setRunnerSettings(runnerSettings: PhpTestRunnerSettings) {
         super.setRunnerSettings(TestoRunnerSettings.fromPhpTestRunnerSettings(runnerSettings))
     }
 
+    @Property(surroundWithTag = false)
     fun getTestoRunnerSettings(): TestoRunnerSettings {
         val settings = super.getRunnerSettings()
         if (settings is TestoRunnerSettings) {
             return settings
-        } else {
-            val copy = TestoRunnerSettings.fromPhpTestRunnerSettings(settings)
-            this.setTestoRunnerSettings(copy)
-            return copy
         }
+
+        val copy = TestoRunnerSettings.fromPhpTestRunnerSettings(settings)
+        setTestoRunnerSettings(copy)
+        return copy
     }
 
     fun setTestoRunnerSettings(runnerSettings: TestoRunnerSettings) {
-        this.setRunnerSettings(runnerSettings)
+        setRunnerSettings(runnerSettings)
     }
-}
+}

src/main/kotlin/com/github/xepozz/testo/tests/run/TestoRunnerSettings.kt

@@ -1,13 +1,34 @@
 package com.github.xepozz.testo.tests.run
 
+import com.intellij.util.xmlb.annotations.Attribute
+import com.intellij.util.xmlb.annotations.Tag
 import com.jetbrains.php.phpunit.coverage.PhpUnitCoverageEngine.CoverageEngine
 import com.jetbrains.php.testFramework.run.PhpTestRunnerSettings
 
+@Tag("TestoRunnerSettings")
 class TestoRunnerSettings(
     var dataProviderIndex: Int = -1,
     var dataSetIndex: Int = -1,
     var coverageEngine: CoverageEngine = CoverageEngine.XDEBUG,
     var parallelTestingEnabled: Boolean = false,
+
+    @Attribute("command")
+    var command: String = "run",
+
+    @Attribute("suite")
+    var suite: String = "",
+
+    @Attribute("group")
+    var group: String = "",
+
+    @Attribute("exclude_group")
+    var excludeGroup: String = "",
+
+    @Attribute("repeat")
+    var repeat: Int = 0,
+
+    @Attribute("parallel")
+    var parallel: Int = 0,
 ) : PhpTestRunnerSettings() {
     companion object Companion {
         @JvmStatic
@@ -23,7 +44,20 @@ class TestoRunnerSettings(
             runnerSettings.configurationFilePath = settings.configurationFilePath
             runnerSettings.testRunnerOptions = settings.testRunnerOptions
 
+            if (settings is TestoRunnerSettings) {
+                runnerSettings.dataProviderIndex = settings.dataProviderIndex
+                runnerSettings.dataSetIndex = settings.dataSetIndex
+                runnerSettings.coverageEngine = settings.coverageEngine
+                runnerSettings.parallelTestingEnabled = settings.parallelTestingEnabled
+                runnerSettings.command = settings.command
+                runnerSettings.suite = settings.suite
+                runnerSettings.group = settings.group
+                runnerSettings.excludeGroup = settings.excludeGroup
+                runnerSettings.repeat = settings.repeat
+                runnerSettings.parallel = settings.parallel
+            }
+
             return runnerSettings
         }
     }
-}
+}