fix: handle Pest v2 describe+dataset testSuiteStarted and Pest v3 truncated suite names

recca0120 · recca0120 · commit 3d7ab62456d0 · 2026-03-13T12:06:20.000+08:00
- PestV2Fixer: extend decodeEvaluable to handle → separator in describe block evaluable names (e.g. __pest_evaluable__something__→_it_should_detect_OK_but_does_not)
- TestResultObserver: add prefix fallback for Pest v3 testSuiteStarted/Finished whose names are truncated due to mb_strrpos+substr byte/char mismatch; restricted to suite events only to avoid false positives
diff --git a/packages/extension/src/Observers/TestResultObserver.test.ts b/packages/extension/src/Observers/TestResultObserver.test.ts
@@ -3,6 +3,8 @@ import type {
     TestDefinition,
     TestFailed,
     TestFinished,
+    TestSuiteFinished,
+    TestSuiteStarted,
 } from '@vscode-phpunit/phpunit';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import {
@@ -189,6 +191,67 @@ describe('TestResultObserver', () => {
         expect(message.stackTrace).toBeUndefined();
     });
 
+    // Pest v3 bug: Str::beforeLast uses mb_strrpos (char offset) with substr (byte offset).
+    // The → character (U+2192) is 3 UTF-8 bytes but 1 char, so testSuiteStarted/Finished names
+    // are truncated by 2 bytes per → character.
+    it('should find parent item via prefix match when Pest v3 truncates testSuiteStarted name', () => {
+        const parentItem = ctrl.createTestItem(
+            'tests/Unit/SampleTests.php::`something` \u2192 it should detect OK but does not',
+            'it should detect OK but does not',
+            Uri.file('/project/tests/SampleTests.php'),
+        );
+        const testItemById = buildTestItemById([testItem, parentItem]);
+        const obs = new TestResultObserver(queue, testRun, testItemById);
+
+        obs.testSuiteStarted({
+            event: 'testSuiteStarted' as unknown as TeamcityEvent,
+            id: 'tests/Unit/SampleTests.php::`something` \u2192 it should detect OK but does n',
+            flowId: 1,
+            name: '`something` \u2192 it should detect OK but does n',
+        } as unknown as TestSuiteStarted);
+
+        expect(testRun.started).toHaveBeenCalledWith(parentItem);
+    });
+
+    it('should mark parent passed via prefix match when Pest v3 truncates testSuiteFinished name', () => {
+        const parentItem = ctrl.createTestItem(
+            'tests/Unit/SampleTests.php::`something` \u2192 it should detect OK but does not',
+            'it should detect OK but does not',
+            Uri.file('/project/tests/SampleTests.php'),
+        );
+        const testItemById = buildTestItemById([testItem, parentItem]);
+        const obs = new TestResultObserver(queue, testRun, testItemById);
+
+        obs.testSuiteFinished({
+            event: 'testSuiteFinished' as unknown as TeamcityEvent,
+            id: 'tests/Unit/SampleTests.php::`something` \u2192 it should detect OK but does n',
+            flowId: 1,
+            name: '`something` \u2192 it should detect OK but does n',
+        } as unknown as TestSuiteFinished);
+
+        expect(testRun.passed).toHaveBeenCalledWith(parentItem);
+    });
+
+    it('should not use prefix match for regular testStarted events with → in id', () => {
+        const parentItem = ctrl.createTestItem(
+            'tests/Unit/ArchTest.php::preset  \u2192 php ',
+            'preset  \u2192 php ',
+            Uri.file('/project/tests/ArchTest.php'),
+        );
+        const testItemById = buildTestItemById([testItem, parentItem]);
+        const obs = new TestResultObserver(queue, testRun, testItemById);
+
+        // runtime id has no trailing space — should NOT match via prefix fallback for testStarted
+        obs.testStarted({
+            event: 'testStarted' as unknown as TeamcityEvent,
+            id: 'tests/Unit/ArchTest.php::preset  \u2192 php',
+            flowId: 1,
+            name: 'preset  \u2192 php',
+        } as never);
+
+        expect(testRun.started).not.toHaveBeenCalledWith(parentItem);
+    });
+
     it('should not use TestMessage.diff when expected/actual are missing', () => {
         const diffSpy = vi.spyOn(TestMessage, 'diff');
 
diff --git a/packages/extension/src/Observers/TestResultObserver.ts b/packages/extension/src/Observers/TestResultObserver.ts
@@ -38,7 +38,7 @@ export class TestResultObserver implements TestRunnerObserver {
     }
 
     testSuiteStarted(result: TestSuiteStarted): void {
-        this.doRun(result, (test) => this.testRun.started(test));
+        this.doRun(result, (test) => this.testRun.started(test), true);
     }
 
     testStarted(result: TestStarted): void {
@@ -60,7 +60,7 @@ export class TestResultObserver implements TestRunnerObserver {
     }
 
     testSuiteFinished(result: TestSuiteFinished): void {
-        this.doRun(result, (test) => this.testRun.passed(test));
+        this.doRun(result, (test) => this.testRun.passed(test), true);
     }
 
     private message(result: TestFailed | TestIgnored, test: TestItem) {
@@ -100,20 +100,45 @@ export class TestResultObserver implements TestRunnerObserver {
         return message;
     }
 
-    private doRun(result: TestResult, updateTestRun: (testItem: TestItem) => void) {
-        const testItem = this.find(result);
+    private doRun(
+        result: TestResult,
+        updateTestRun: (testItem: TestItem) => void,
+        usePrefixFallback = false,
+    ) {
+        const testItem = this.find(result, usePrefixFallback);
         if (!testItem) {
             return;
         }
 
         updateTestRun(testItem);
     }
 
-    private find(result: TestResult) {
+    private find(result: TestResult, usePrefixFallback = false) {
         if (!('id' in result) || typeof result.id !== 'string') {
             return undefined;
         }
 
-        return this.testItemById.get(result.id);
+        const exact = this.testItemById.get(result.id);
+        if (exact) {
+            return exact;
+        }
+
+        // Pest v3 has a bug: Str::beforeLast uses mb_strrpos (char offset) with substr (byte offset).
+        // The → character (U+2192) is 3 UTF-8 bytes but 1 char, so testSuiteStarted/Finished names
+        // are truncated by 2 bytes per → character. The truncated ID is a prefix of the full parent ID.
+        // Only apply to suite events to avoid false positives on regular test events.
+        if (
+            usePrefixFallback &&
+            result.id.includes('\u2192') &&
+            !result.id.includes(' with data set ')
+        ) {
+            for (const [key, item] of this.testItemById) {
+                if (key.startsWith(result.id) && !key.includes(' with data set ')) {
+                    return item;
+                }
+            }
+        }
+
+        return undefined;
     }
 }
diff --git a/packages/phpunit/src/TestIdentifier/PestTestIdentifier.test.ts b/packages/phpunit/src/TestIdentifier/PestTestIdentifier.test.ts
@@ -77,6 +77,13 @@ describe('PestTestIdentifier', () => {
                 'Users\\path\\to\\tests\\Unit\\DatasetTest::__pest_evaluable_it_business_closed',
                 'tests/Unit/DatasetTest.php::it business closed',
             ],
+            // describe('something', fn() => it('test', fn())->with([...]))
+            // v2 testSuiteStarted uses evaluable encoding with → separator
+            [
+                'file:///path/to/tests/Unit/SampleTests.php',
+                'Users\\path\\to\\tests\\Unit\\SampleTests::__pest_evaluable__something__\u2192_it_should_detect_OK_but_does_not',
+                'tests/Unit/SampleTests.php::`something` \u2192 it should detect OK but does not',
+            ],
         ])('fromLocationHint(%j, %j) → id: %s', (locationHint, name, expectedId) => {
             const result = transformer.fromLocationHint(locationHint, name);
             expect(result.id).toBe(expectedId);
diff --git a/packages/phpunit/src/TestIdentifier/PestV2Fixer.ts b/packages/phpunit/src/TestIdentifier/PestV2Fixer.ts
@@ -4,19 +4,58 @@ function hasPrefix(id?: string) {
     return id?.includes(PREFIX) ?? false;
 }
 
-function decodeEvaluable(encoded: string) {
-    const idx = encoded.indexOf(PREFIX);
-    if (idx === -1) {
+function decodeDescribePart(inner: string): string {
+    const segments: string[] = [];
+    let current = '';
+    let i = 0;
+    while (i < inner.length) {
+        if (inner[i] === '_' && inner[i + 1] === '_') {
+            current += '_';
+            i += 2;
+        } else if (inner[i] === '_') {
+            segments.push(current);
+            current = '';
+            i++;
+        } else {
+            current += inner[i];
+            i++;
+        }
+    }
+    segments.push(current);
+    const isFQN = segments.every((p) => /^[A-Z]/.test(p));
+    return `\`${segments.join(isFQN ? '\\' : ' ')}\``;
+}
+
+function decodeEvaluable(encoded: string): string {
+    const prefixIdx = encoded.indexOf(PREFIX);
+    if (prefixIdx === -1) {
         return encoded;
     }
 
-    const before = encoded.slice(0, idx);
-    let method = encoded.slice(idx + PREFIX.length);
+    const before = encoded.slice(0, prefixIdx);
+    const methodFull = encoded.slice(prefixIdx + PREFIX.length);
+
+    const datasetIdx = methodFull.search(/\s+with\s+data\s+set\s+/);
+    const methodPart = datasetIdx >= 0 ? methodFull.slice(0, datasetIdx) : methodFull;
+    const datasetSuffix = datasetIdx >= 0 ? methodFull.slice(datasetIdx) : '';
+
+    const segments = methodPart.split('_\u2192_');
+    if (segments.length < 2) {
+        const decoded = methodPart.replace(/__|_/g, (m) => (m === '__' ? '_' : ' '));
+        return before + decoded + datasetSuffix;
+    }
+
+    const describeParts = segments.slice(0, -1);
+    const testPart = segments[segments.length - 1];
+
+    const decodedDescribes = describeParts.map((part) => {
+        const inner = part.replace(/^_/, '').replace(/_$/, '');
+        return decodeDescribePart(inner);
+    });
 
-    // reverse: single _ → space, double __ → literal _
-    method = method.replace(/__|_/g, (m) => (m === '__' ? '_' : ' '));
+    const decodedTest = testPart.replace(/__|_/g, (m) => (m === '__' ? '_' : ' '));
 
-    return before + method;
+    return before + [...decodedDescribes, decodedTest].join(' \u2192 ') + datasetSuffix;
 }
 
 export const PestV2Fixer = {
diff --git a/packages/phpunit/tests/fixtures/pest-stub/tests/Unit/SampleTests.php b/packages/phpunit/tests/fixtures/pest-stub/tests/Unit/SampleTests.php
@@ -0,0 +1,15 @@
+<?php
+
+describe('something', function () {
+    it('should detect OK but does not', function (int $number) {
+        expect($number)->toBeGreaterThan(3);
+    })->with([
+        4,
+        8,
+    ]);
+    it('still does not detect OK', function () {
+        expect(6)->toBeGreaterThan(3);
+    })->with([
+        4,
+    ]);
+});
