testing: allow toggling whether tests use fuzzy match

Fixes microsoft#140405

Author: connor4312

src/vs/workbench/contrib/testing/browser/testingExplorerFilter.ts

@@ -204,6 +204,17 @@ class FiltersDropdownMenuActionViewItem extends DropdownMenuActionViewItem {
 				dispose: () => null
 			})),
 			new Separator(),
+			{
+				checked: this.filters.fuzzy.value,
+				class: undefined,
+				enabled: true,
+				id: 'fuzzy',
+				label: localize('testing.filters.fuzzyMatch', "Fuzzy Match"),
+				run: () => this.filters.fuzzy.value = !this.filters.fuzzy.value,
+				tooltip: '',
+				dispose: () => null
+			},
+			new Separator(),
 			{
 				checked: this.filters.isFilteringFor(TestFilterTerm.Hidden),
 				class: undefined,

src/vs/workbench/contrib/testing/browser/testingExplorerView.ts

@@ -513,6 +513,7 @@ export class TestingExplorerViewModel extends Disposable {
 
 		this._register(Event.any(
 			filterState.text.onDidChange,
+			filterState.fuzzy.onDidChange,
 			testService.excluded.onTestExclusionsChanged,
 		)(this.tree.refilter, this.tree));
 
@@ -911,13 +912,14 @@ class TestsFilter implements ITreeFilter<TestExplorerTreeElement> {
 			return FilterResult.Include;
 		}
 
+		const fuzzy = this.state.fuzzy.value;
 		for (let e: TestItemTreeElement | null = element; e; e = e.parent) {
 			// start as included if the first glob is a negation
 			let included = this.state.globList[0].include === false ? FilterResult.Include : FilterResult.Inherit;
 			const data = e.label.toLowerCase();
 
 			for (const { include, text } of this.state.globList) {
-				if (fuzzyContains(data, text)) {
+				if (fuzzy ? fuzzyContains(data, text) : data.includes(text)) {
 					included = include ? FilterResult.Include : FilterResult.Exclude;
 				}
 			}

src/vs/workbench/contrib/testing/common/testExplorerFilterState.ts

@@ -5,7 +5,9 @@
 import { Emitter, Event } from 'vs/base/common/event';
 import { splitGlobAware } from 'vs/base/common/glob';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
 import { IObservableValue, MutableObservableValue } from 'vs/workbench/contrib/testing/common/observableValue';
+import { StoredValue } from 'vs/workbench/contrib/testing/common/storedValue';
 import { namespaceTestTag } from 'vs/workbench/contrib/testing/common/testTypes';
 
 export interface ITestExplorerFilterState {
@@ -35,6 +37,11 @@ export interface ITestExplorerFilterState {
 	 */
 	readonly excludeTags: ReadonlySet<string>;
 
+	/**
+	 * Whether fuzzy searching is enabled.
+	 */
+	readonly fuzzy: MutableObservableValue<boolean>;
+
 	/**
 	 * Focuses the filter input in the test explorer view.
 	 */
@@ -81,10 +88,19 @@ export class TestExplorerFilterState implements ITestExplorerFilterState {
 	/** @inheritdoc */
 	public readonly text = new MutableObservableValue('');
 
+	/** @inheritdoc */
+	public readonly fuzzy = MutableObservableValue.stored(new StoredValue<boolean>({
+		key: 'testHistoryFuzzy',
+		scope: StorageScope.GLOBAL,
+		target: StorageTarget.USER,
+	}, this.storageService), false);
+
 	public readonly reveal = new MutableObservableValue</* test ID */string | undefined>(undefined);
 
 	public readonly onDidRequestInputFocus = this.focusEmitter.event;
 
+	constructor(@IStorageService private readonly storageService: IStorageService) { }
+
 	/** @inheritdoc */
 	public focusInput() {
 		this.focusEmitter.fire();

src/vs/workbench/contrib/testing/test/common/testExplorerFilterState.test.ts

@@ -4,13 +4,14 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as assert from 'assert';
+import { InMemoryStorageService } from 'vs/platform/storage/common/storage';
 import { TestExplorerFilterState, TestFilterTerm } from 'vs/workbench/contrib/testing/common/testExplorerFilterState';
 
 
 suite('TestExplorerFilterState', () => {
 	let t: TestExplorerFilterState;
 	setup(() => {
-		t = new TestExplorerFilterState();
+		t = new TestExplorerFilterState(new InMemoryStorageService());
 	});
 
 	const assertFilteringFor = (expected: { [T in TestFilterTerm]?: boolean }) => {