Remove TestCaseContext (#1485)

## Checklist

- [ ] I have added
[tests](https://www.cursorless.org/docs/contributing/test-case-recorder/)
- [ ] I have updated the
[docs](https://github.com/cursorless-dev/cursorless/tree/main/docs) and
[cheatsheet](https://github.com/cursorless-dev/cursorless/tree/main/cursorless-talon/src/cheatsheet)
- [ ] I have not broken the cheatsheet

Author: pokey

packages/cursorless-engine/src/core/commandRunner/CommandRunner.ts

@@ -72,7 +72,6 @@ export class CommandRunner {
 
       const commandComplete = canonicalizeAndValidateCommand(command);
       const {
-        spokenForm,
         action: { name: actionName, args: actionArgs },
         targets: partialTargetDescriptors,
         usePrePhraseSnapshot,
@@ -127,13 +126,10 @@ export class CommandRunner {
           : [];
 
       if (this.testCaseRecorder.isActive()) {
-        const context = {
-          targets: targetDescriptors,
-          storedTargets: this.storedTargets,
-          hatTokenMap: readableHatMap,
-          spokenForm,
-        };
-        await this.testCaseRecorder.preCommandHook(commandComplete, context);
+        await this.testCaseRecorder.preCommandHook(
+          readableHatMap,
+          commandComplete,
+        );
       }
 
       // NB: We do this once test recording has started so that we can capture

packages/cursorless-engine/src/cursorlessEngine.ts

@@ -38,7 +38,7 @@ export function createCursorlessEngine(
 
   const storedTargets = new StoredTargetMap();
 
-  const testCaseRecorder = new TestCaseRecorder(hatTokenMap);
+  const testCaseRecorder = new TestCaseRecorder(hatTokenMap, storedTargets);
 
   const languageDefinitions = new LanguageDefinitions(treeSitter);
 

packages/cursorless-engine/src/testCaseRecorder/TestCase.ts

@@ -4,6 +4,7 @@ import {
   extractTargetedMarks,
   ExtraSnapshotField,
   marksToPlainObject,
+  PartialTargetDescriptor,
   PlainSpyIDERecordedValues,
   ReadOnlyHatMap,
   serialize,
@@ -16,22 +17,15 @@ import {
   Token,
 } from "@cursorless/common";
 import { pick } from "lodash";
-import { StoredTargetMap } from "..";
 import { ide } from "../singletons/ide.singleton";
 import { cleanUpTestCaseCommand } from "../testUtil/cleanUpTestCaseCommand";
 import { extractTargetKeys } from "../testUtil/extractTargetKeys";
 import { takeSnapshot } from "../testUtil/takeSnapshot";
-import { TargetDescriptor } from "../typings/TargetDescriptor";
-
-export type TestCaseContext = {
-  storedTargets: StoredTargetMap;
-  targets: TargetDescriptor[];
-  hatTokenMap: ReadOnlyHatMap;
-};
+import { StoredTargetMap } from "..";
 
 export class TestCase {
   private languageId: string;
-  private fullTargets: TargetDescriptor[];
+  private partialTargetDescriptors: PartialTargetDescriptor[];
   private initialState: TestCaseSnapshot | null = null;
   private finalState?: TestCaseSnapshot;
   thrownError?: ThrownError;
@@ -44,7 +38,8 @@ export class TestCase {
 
   constructor(
     command: CommandLatest,
-    private context: TestCaseContext,
+    private hatTokenMap: ReadOnlyHatMap,
+    private storedTargets: StoredTargetMap,
     private spyIde: SpyIDE,
     private isHatTokenMapTest: boolean = false,
     private isDecorationsTest: boolean = false,
@@ -55,34 +50,33 @@ export class TestCase {
     const activeEditor = ide().activeTextEditor!;
     this.command = cleanUpTestCaseCommand(command);
 
-    const { targets } = context;
-
-    this.targetKeys = targets.map(extractTargetKeys).flat();
+    this.targetKeys = command.targets.map(extractTargetKeys).flat();
 
     this.languageId = activeEditor.document.languageId;
-    this.fullTargets = targets;
+    this.partialTargetDescriptors = command.targets;
     this._awaitingFinalMarkInfo = isHatTokenMapTest;
   }
 
   private getMarks() {
     let marks: Record<string, Token>;
 
-    const { hatTokenMap } = this.context;
-
     if (this.isHatTokenMapTest) {
       // If we're doing a navigation map test, then we grab the entire
       // navigation map because we'll filter it later based on the marks
       // referenced in the expected follow up command
-      marks = Object.fromEntries(hatTokenMap.getEntries());
+      marks = Object.fromEntries(this.hatTokenMap.getEntries());
     } else {
-      marks = extractTargetedMarks(this.targetKeys, hatTokenMap);
+      marks = extractTargetedMarks(this.targetKeys, this.hatTokenMap);
     }
 
     return marksToPlainObject(marks);
   }
 
-  private includesThatMark(target: TargetDescriptor, type: string): boolean {
-    if (target.type === "primitive" && target.mark.type === type) {
+  private includesThatMark(
+    target: PartialTargetDescriptor,
+    type: string,
+  ): boolean {
+    if (target.type === "primitive" && target.mark?.type === type) {
       return true;
     } else if (target.type === "list") {
       return target.elements.some((target) =>
@@ -114,13 +108,13 @@ export class TestCase {
       thatMark:
         (!isInitialSnapshot && !this.captureFinalThatMark) ||
         (isInitialSnapshot &&
-          !this.fullTargets.some((target) =>
+          !this.partialTargetDescriptors.some((target) =>
             this.includesThatMark(target, "that"),
           )),
       sourceMark:
         (!isInitialSnapshot && !this.captureFinalThatMark) ||
         (isInitialSnapshot &&
-          !this.fullTargets.some((target) =>
+          !this.partialTargetDescriptors.some((target) =>
             this.includesThatMark(target, "source"),
           )),
       visibleRanges: !visibleRangeActions.includes(this.command.action.name),
@@ -154,7 +148,7 @@ export class TestCase {
   async recordInitialState() {
     const excludeFields = this.getExcludedFields(true);
     this.initialState = await takeSnapshot(
-      this.context.storedTargets,
+      this.storedTargets,
       excludeFields,
       this.extraSnapshotFields,
       ide().activeTextEditor!,
@@ -168,7 +162,7 @@ export class TestCase {
     const excludeFields = this.getExcludedFields(false);
     this.returnValue = returnValue;
     this.finalState = await takeSnapshot(
-      this.context.storedTargets,
+      this.storedTargets,
       excludeFields,
       this.extraSnapshotFields,
       ide().activeTextEditor!,
@@ -185,8 +179,10 @@ export class TestCase {
       raw == null ? undefined : spyIDERecordedValuesToPlainObject(raw);
   }
 
-  filterMarks(command: CommandLatest, context: TestCaseContext) {
-    const marksToCheck = context.targets.map(extractTargetKeys).flat();
+  filterMarks() {
+    const marksToCheck = this.partialTargetDescriptors
+      .map(extractTargetKeys)
+      .flat();
     const keys = this.targetKeys.concat(marksToCheck);
 
     this.initialState!.marks = pick(

packages/cursorless-engine/src/testCaseRecorder/TestCaseRecorder.ts

@@ -9,6 +9,7 @@ import {
   HatTokenMap,
   IDE,
   marksToPlainObject,
+  ReadOnlyHatMap,
   serialize,
   SerializedMarks,
   showError,
@@ -26,7 +27,8 @@ import { merge } from "lodash";
 import * as path from "path";
 import { ide, injectIde } from "../singletons/ide.singleton";
 import { takeSnapshot } from "../testUtil/takeSnapshot";
-import { TestCase, TestCaseContext } from "./TestCase";
+import { TestCase } from "./TestCase";
+import { StoredTargetMap } from "../core/StoredTargets";
 
 const CALIBRATION_DISPLAY_DURATION_MS = 50;
 
@@ -100,7 +102,10 @@ export class TestCaseRecorder {
   private spyIde: SpyIDE | undefined;
   private originalIde: IDE | undefined;
 
-  constructor(private hatTokenMap: HatTokenMap) {
+  constructor(
+    private hatTokenMap: HatTokenMap,
+    private storedTargets: StoredTargetMap,
+  ) {
     const { runMode } = ide();
 
     this.fixtureRoot =
@@ -284,7 +289,7 @@ export class TestCaseRecorder {
     this.paused = false;
   }
 
-  async preCommandHook(command: CommandLatest, context: TestCaseContext) {
+  async preCommandHook(hatTokenMap: ReadOnlyHatMap, command: CommandLatest) {
     if (this.testCase != null) {
       // If testCase is not null and we are just before a command, this means
       // that this command is the follow up command indicating which marks we
@@ -293,7 +298,7 @@ export class TestCaseRecorder {
         this.testCase.awaitingFinalMarkInfo,
         () => "expected to be awaiting final mark info",
       );
-      this.testCase.filterMarks(command, context);
+      this.testCase.filterMarks();
       await this.finishTestCase();
     } else {
       // Otherwise, we are starting a new test case
@@ -303,7 +308,8 @@ export class TestCaseRecorder {
 
       this.testCase = new TestCase(
         command,
-        context,
+        hatTokenMap,
+        this.storedTargets,
         this.spyIde,
         this.isHatTokenMapTest,
         this.isDecorationsTest,

packages/cursorless-engine/src/testUtil/extractTargetKeys.ts

@@ -3,14 +3,9 @@ import {
   PartialTargetDescriptor,
   getKey,
 } from "@cursorless/common";
-import {
-  PrimitiveTargetDescriptor,
-  TargetDescriptor,
-} from "../typings/TargetDescriptor";
+import { PrimitiveTargetDescriptor } from "../typings/TargetDescriptor";
 
-export function extractTargetKeys(
-  target: TargetDescriptor | PartialTargetDescriptor,
-): string[] {
+export function extractTargetKeys(target: PartialTargetDescriptor): string[] {
   switch (target.type) {
     case "primitive":
       return extractPrimitiveTargetKeys(target);