feat(benchmark): only mode (#2039)

docs/api/index.md

@@ -296,6 +296,23 @@ You can use `bench.skip` syntax to skip running certain benchmarks.
   })
   ```
 
+### bench.only
+
+- **Type:** `(name: string, fn: BenchFunction, options?: BenchOptions) => void`
+
+Use `bench.only` to only run certain benchmarks in a given suite. This is useful when debugging.
+
+  ```ts
+  import { bench } from 'vitest'
+
+  bench.only('normal sorting', () => {
+    const x = [1, 5, 4, 2, 3]
+    x.sort((a, b) => {
+      return a - b
+    })
+  })
+  ```
+
 ## describe
 
 When you use `test` or `bench` in the top level of file, they are collected as part of the implicit suite for it. Using `describe` you can define a new suite in the current context, as a set of related tests or benchmarks and other nested suites. A suite lets you organize your tests and benchmarks so reports are more clear.

packages/vitest/src/runtime/run.ts

@@ -238,8 +238,9 @@ export async function runSuite(suite: Suite) {
   else {
     try {
       const beforeAllCleanups = await callSuiteHook(suite, suite, 'beforeAll', [suite])
+
       if (isRunningInBenchmark()) {
-        await runBenchmarkSuit(suite)
+        await runBenchmarkSuite(suite)
       }
       else {
         for (let tasksGroup of partitionSuiteChildren(suite)) {
@@ -301,21 +302,24 @@ function createBenchmarkResult(name: string): BenchmarkResult {
   } as BenchmarkResult
 }
 
-async function runBenchmarkSuit(suite: Suite) {
+async function runBenchmarkSuite(suite: Suite) {
   const { Task, Bench } = await importTinybench()
   const start = performance.now()
 
   const benchmarkGroup = []
   const benchmarkSuiteGroup = []
   for (const task of suite.tasks) {
+    if (task.mode !== 'run')
+      continue
+
     if (task.type === 'benchmark')
       benchmarkGroup.push(task)
     else if (task.type === 'suite')
       benchmarkSuiteGroup.push(task)
   }
 
   if (benchmarkSuiteGroup.length)
-    await Promise.all(benchmarkSuiteGroup.map(subSuite => runBenchmarkSuit(subSuite)))
+    await Promise.all(benchmarkSuiteGroup.map(subSuite => runBenchmarkSuite(subSuite)))
 
   if (benchmarkGroup.length) {
     const defer = createDefer()

packages/vitest/src/runtime/suite.ts

@@ -116,7 +116,7 @@ function createSuiteCollector(name: string, factory: SuiteFactory = () => { }, m
   })
 
   const benchmark = createBenchmark(function (name: string, fn = noop, options: BenchOptions) {
-    const mode = this.skip ? 'skip' : 'run'
+    const mode = this.only ? 'only' : this.skip ? 'skip' : 'run'
 
     if (!isRunningInBenchmark())
       throw new Error('`bench()` is only available in benchmark mode. Run with `vitest bench` instead.')
@@ -251,14 +251,14 @@ function createTest(fn: (
 
 function createBenchmark(fn: (
   (
-    this: Record<'skip', boolean | undefined>,
+    this: Record<'skip' | 'only', boolean | undefined>,
     name: string,
     fn: BenchFunction,
     options: BenchOptions
   ) => void
 )) {
   const benchmark = createChainable(
-    ['skip'],
+    ['skip', 'only'],
     fn,
   ) as BenchmarkAPI
 

packages/vitest/src/types/benchmark.ts

@@ -53,7 +53,7 @@ export interface BenchmarkResult extends TinybenchResult {
 
 export type BenchFunction = (this: BenchFactory) => Promise<void> | void
 export type BenchmarkAPI = ChainableFunction<
-'skip',
+'skip' | 'only',
 [name: string, fn: BenchFunction, options?: BenchOptions],
 void
 > & {