Test Case Recorder

package.json

@@ -48,6 +48,10 @@
 			{
 				"command": "cursorless.recomputeDecorationStyles",
 				"title": "Cursorless: Recompute decoration styles"
+			},
+			{
+				"command": "cursorless.recordTestCase",
+				"title": "Cursorless: Record test case"
 			}
 		],
 		"colors": [
@@ -196,15 +200,19 @@
 	},
 	"devDependencies": {
 		"@types/glob": "^7.1.3",
+		"@types/js-yaml": "^4.0.2",
 		"@types/mocha": "^8.0.4",
 		"@types/node": "^12.11.7",
+		"@types/sinon": "^10.0.2",
 		"@types/vscode": "^1.53.0",
 		"@typescript-eslint/eslint-plugin": "^4.9.0",
 		"@typescript-eslint/parser": "^4.9.0",
 		"esbuild": "^0.11.12",
 		"eslint": "^7.15.0",
 		"glob": "^7.1.6",
+		"js-yaml": "^3.14.1",
 		"mocha": "^8.1.3",
+		"sinon": "^11.1.1",
 		"typescript": "^4.1.2",
 		"vscode-test": "^1.4.1"
 	},
@@ -213,4 +221,4 @@
 		"immutability-helper": "^3.1.1",
 		"lodash": "^4.17.21"
 	}
-}
+}

src/Clipboard.ts

@@ -0,0 +1,12 @@
+import * as vscode from "vscode";
+
+/**
+ * A mockable layer over the vscode clipboard
+ *
+ * For unknown reasons it's not possible to mock the clipboard directly.
+ * Use this instead of vscode.env.clipboard so it can be mocked in testing.
+ **/
+export class Clipboard {
+  static readText = vscode.env.clipboard.readText;
+  static writeText = vscode.env.clipboard.writeText;
+}

src/NavigationMap.ts

@@ -43,15 +43,19 @@ export default class NavigationMap {
     [coloredSymbol: string]: Token;
   } = {};
 
-  private getKey(color: SymbolColor, character: string) {
+  static getKey(color: SymbolColor, character: string) {
     return `${color}.${character}`;
   }
 
   public addToken(color: SymbolColor, character: string, token: Token) {
-    this.map[this.getKey(color, character)] = token;
+    this.map[NavigationMap.getKey(color, character)] = token;
   }
 
   public getToken(color: SymbolColor, character: string) {
-    return this.map[this.getKey(color, character)];
+    return this.map[NavigationMap.getKey(color, character)];
+  }
+
+  public clear() {
+    this.map = {};
   }
 }

src/TestCase.ts

@@ -0,0 +1,145 @@
+import * as path from "path";
+import * as fs from "fs";
+import * as yaml from "js-yaml";
+import * as vscode from "vscode";
+import NavigationMap from "./NavigationMap";
+import { ThatMark } from "./ThatMark";
+import { ActionType, PartialTarget, Target } from "./Types";
+import { extractTargetedMarks } from "./extractTargetedMarks";
+import { serializeMarks, SerializedMarks } from "./serializers";
+import { takeSnapshot, TestCaseSnapshot } from "./takeSnapshot";
+
+type TestCaseCommand = {
+  actionName: ActionType;
+  partialTargets: PartialTarget[];
+  extraArgs: any[];
+};
+
+type TestCaseContext = {
+  talonCommand: string;
+  thatMark: ThatMark;
+  targets: Target[];
+  navigationMap: NavigationMap;
+};
+
+export type TestCaseFixture = {
+  talonCommand: string;
+  command: TestCaseCommand;
+  targets: Target[];
+  languageId: string;
+  marks: SerializedMarks;
+  initialState: TestCaseSnapshot;
+  finalState: TestCaseSnapshot;
+  returnValue: unknown;
+};
+
+export class TestCase {
+  talonCommand: string;
+  command: TestCaseCommand;
+  languageId: string;
+  targets: Target[];
+  marks: SerializedMarks;
+  context: TestCaseContext;
+  initialState: TestCaseSnapshot | null = null;
+  finalState: TestCaseSnapshot | null = null;
+  returnValue: unknown = null;
+
+  constructor(command: TestCaseCommand, context: TestCaseContext) {
+    const activeEditor = vscode.window.activeTextEditor!;
+    const { navigationMap, targets, talonCommand } = context;
+    const targetedMarks = extractTargetedMarks(targets, navigationMap);
+
+    this.talonCommand = talonCommand;
+    this.command = command;
+    this.languageId = activeEditor.document.languageId;
+    this.marks = serializeMarks(targetedMarks);
+    this.targets = targets;
+    this.context = context;
+  }
+
+  private includesThatMark(target: Target) {
+    if (target.type === "primitive" && target.mark.type === "that") {
+      return true;
+    } else if (target.type === "list") {
+      return target.elements.some(this.includesThatMark, this);
+    } else if (target.type === "range") {
+      return [target.start, target.end].some(this.includesThatMark, this);
+    }
+    return false;
+  }
+
+  private getExcludedFields() {
+    const excludableFields = {
+      clipboard: !["copy", "paste"].includes(this.command.actionName),
+      thatMark:
+        this.initialState == null &&
+        !this.targets.some(this.includesThatMark, this),
+      visibleRanges: ![
+        "fold",
+        "unfold",
+        "scrollToBottom",
+        "scrollToCenter",
+        "scrollToTop",
+      ].includes(this.command.actionName),
+    };
+
+    return Object.keys(excludableFields).filter(
+      (field) => excludableFields[field]
+    );
+  }
+
+  private toYaml() {
+    if (this.initialState == null || this.finalState == null) {
+      throw Error("Two snapshots must be taken before serializing");
+    }
+    const fixture: TestCaseFixture = {
+      talonCommand: this.talonCommand,
+      languageId: this.languageId,
+      command: this.command,
+      targets: this.targets,
+      marks: this.marks,
+      initialState: this.initialState,
+      finalState: this.finalState,
+      returnValue: this.returnValue,
+    };
+    return yaml.dump(fixture, { noRefs: true, quotingType: '"' });
+  }
+
+  async recordInitialState() {
+    const excludeFields = this.getExcludedFields();
+    this.initialState = await takeSnapshot(
+      this.context.thatMark,
+      excludeFields
+    );
+  }
+
+  async recordFinalState(returnValue: unknown) {
+    const excludeFields = this.getExcludedFields();
+    this.returnValue = returnValue;
+    this.finalState = await takeSnapshot(this.context.thatMark, excludeFields);
+  }
+
+  async writeFile(filename: string) {
+    const fixture = this.toYaml();
+    const workspacePath = vscode.workspace.workspaceFolders?.[0].uri.path;
+    let document;
+
+    if (workspacePath && filename) {
+      const fixturePath = path.join(
+        workspacePath,
+        "testFixtures",
+        `${filename}.yml`
+      );
+      fs.writeFileSync(fixturePath, fixture);
+      document = await vscode.workspace.openTextDocument(fixturePath);
+    } else {
+      document = await vscode.workspace.openTextDocument({
+        language: "yaml",
+        content: fixture,
+      });
+    }
+    await vscode.window.showTextDocument(document, {
+      viewColumn: vscode.ViewColumn.Beside,
+    });
+  }
+}

src/ThatMark.ts

@@ -0,0 +1,13 @@
+import { SelectionWithEditor } from "./Types";
+
+export class ThatMark {
+  private mark: SelectionWithEditor[] = [];
+
+  set(value: SelectionWithEditor[]) {
+    this.mark = value;
+  }
+
+  get() {
+    return this.mark;
+  }
+}

src/Types.ts

@@ -248,6 +248,7 @@ export type ActionRecord = Record<ActionType, Action>;
 export interface Graph {
   readonly actions: ActionRecord;
   readonly editStyles: EditStyles;
+  readonly navigationMap: NavigationMap;
 }
 
 export interface DecorationColorSetting {

src/addDecorationsToEditor.ts

@@ -13,7 +13,12 @@ interface CharacterTokenInfo {
   tokenIdx: number;
 }
 
-export function addDecorationsToEditors(decorations: Decorations) {
+export function addDecorationsToEditors(
+  navigationMap: NavigationMap,
+  decorations: Decorations
+) {
+  navigationMap.clear();
+
   var editors: vscode.TextEditor[];
 
   if (vscode.window.activeTextEditor == null) {
@@ -85,8 +90,6 @@ export function addDecorationsToEditors(decorations: Decorations) {
     ])
   );
 
-  const navigationMap = new NavigationMap();
-
   // Picks the character with minimum color such that the next token that contains
   // that character is as far away as possible.
   // TODO: Could be improved by ignoring subsequent tokens that also contain
@@ -151,6 +154,4 @@ export function addDecorationsToEditors(decorations: Decorations) {
       editor.setDecorations(decorations.decorationMap[color]!, ranges[color]!);
     });
   });
-
-  return navigationMap;
 }