openide/tools/intellij.tools.ide.starter/documentation/createCustomPerformanceCommand.md

PerformanceTesting plugin provides a way to execute commands inside IDE.
Command is an abstraction that performs an action using internal IntelliJ API. It's based on macroses but the main difference is that
there is a predefined set of commands that don't finish until the action is finished.

For example, when you invoke completion via macros - macros will be finished as soon as completion action is invoked.
If you use command `doComplete` the command will be finished when all the completion contributors have provided their results and the final
list is sorted.

To implement your own commands you need to create a plugin that extends performanceTestingPlugin.

Basic setup should look something like this:

Create a `resources/META-INF/plugin.xml`

```
<idea-plugin>
  <name>Your plugin name</name>
  <id>com.intellij.performancePlugin.myPlugin</id>

  <description>My integration tests</description>
  <depends>com.jetbrains.performancePlugin</depends>
  <depends>com.intellij.modules.lang</depends>

  <extensions defaultExtensionNs="com.jetbrains">
    <performancePlugin.commandProvider implementation="com.intellij.myPlugin.performanceTesting.MyPluginCommandProvider"/>
  </extensions>
</idea-plugin>
```

Then create a command provider

```
package com.intellij.myPlugin.performanceTesting

class MyPluginCommandProvider : CommandProvider {
  override fun getCommands() = mapOf(
      Pair(MyCommand.PREFIX, CreateCommand(::MyCommand)),
    )
}
```

And implementation of your own command

```
package com.intellij.myPlugin.performanceTesting.command

import com.intellij.openapi.ui.playback.PlaybackContext
import com.intellij.openapi.ui.playback.commands.PlaybackCommandCoroutineAdapter

internal class MyCommand(text: String, line: Int) : PlaybackCommandCoroutineAdapter(text, line) {
  companion object {
    const val PREFIX = CMD_PREFIX + "myCommandName"
  }

  override suspend fun doExecute(context: PlaybackContext) {
    TODO("YOUR CODE HERE")
  }
}
```

Test implementation (that will use Starter and tell the plugin to invoke your command) will like this

```
fun <T : CommandChain> T.runMyCommand(): T {
  addCommand(CMD_PREFIX + "myCommandName")
  return this
}

class ExampleOfMyCommandTest {

  @Test
  fun invokeMyCommand() {
    val context = Starter.newContext(testName = CurrentTestMethod.hyphenateWithClass(), testCase = TestCases.IU.JitPackAndroidExample)
      .skipIndicesInitialization() // skip indicies if indexing isn't necessary for test

    context.runIDE(
      commands = CommandChain()
        .runMyCommand()
        .exitApp()
    )
  }
}
```