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

@@ -1,5 +1,6 @@
 import { TextDocumentChangeEvent } from "vscode";
 import { SymbolColor } from "./constants";
+import { SerializedRange, serializeRange } from "./TestCase";
 import { Token } from "./Types";
 
 /**
@@ -43,15 +44,27 @@ 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 serializeRanges() {
+    const rangeMap: { [coloredSymbol: string]: SerializedRange } = {};
+    Object.entries(this.map).forEach(([key, value]) => {
+      rangeMap[key] = serializeRange(value.range);
+    });
+    return rangeMap;
+  }
+
+  public clear() {
+    this.map = {};
   }
 }

src/TestCase.ts

@@ -0,0 +1,241 @@
+import * as path from "path";
+import * as fs from "fs";
+import * as yaml from "js-yaml";
+import * as vscode from "vscode";
+import { Position, Range, Selection } from "vscode";
+import { Clipboard } from "./Clipboard";
+import NavigationMap from "./NavigationMap";
+import { ThatMark } from "./ThatMark";
+import {
+  ActionType,
+  PartialTarget,
+  PrimitiveTarget,
+  SelectionWithEditor,
+  Target,
+} from "./Types";
+
+export type SerializedPosition = {
+  line: number;
+  character: number;
+};
+
+export type SerializedRange = {
+  start: SerializedPosition;
+  end: SerializedPosition;
+};
+
+export type SerializedSelection = {
+  anchor: SerializedPosition;
+  active: SerializedPosition;
+};
+
+export function serializeRange(range: Range): SerializedRange {
+  return {
+    start: serializePosition(range.start),
+    end: serializePosition(range.end),
+  };
+}
+
+export function serializeSelection(selection: Selection): SerializedSelection {
+  return {
+    active: serializePosition(selection.active),
+    anchor: serializePosition(selection.anchor),
+  };
+}
+
+export function serializePosition(position: Position): SerializedPosition {
+  return { line: position.line, character: position.character };
+}
+
+type TestCaseCommand = {
+  actionName: ActionType;
+  partialTargets: PartialTarget[];
+  extraArgs: any[];
+};
+
+type TestCaseContext = {
+  talonCommand: string;
+  thatMark: ThatMark;
+  targets: Target[];
+  navigationMap: NavigationMap;
+};
+
+type TestCaseSnapshot = {
+  document: string;
+  clipboard: string;
+  visibleRanges: SerializedRange[];
+  selections: SerializedSelection[];
+  thatMark: SerializedSelection[] | null;
+};
+
+type DecorationRanges = { [coloredSymbol: string]: SerializedRange };
+
+export type TestCaseFixture = {
+  talonCommand: string;
+  command: TestCaseCommand;
+  targets: Target[];
+  languageId: string;
+  marks: DecorationRanges;
+  initialState: TestCaseSnapshot;
+  finalState: TestCaseSnapshot;
+  returnValue: any;
+};
+
+export default class TestCase {
+  talonCommand: string;
+  command: TestCaseCommand;
+  languageId: string;
+  targets: Target[];
+  marks: DecorationRanges;
+  context: TestCaseContext;
+  initialState: TestCaseSnapshot | null = null;
+  finalState: TestCaseSnapshot | null = null;
+  returnValue: any = null;
+
+  constructor(command: TestCaseCommand, context: TestCaseContext) {
+    const activeEditor = vscode.window.activeTextEditor!;
+    const { navigationMap, targets, talonCommand } = context;
+
+    this.talonCommand = talonCommand;
+    this.command = command;
+    this.languageId = activeEditor.document.languageId;
+    this.marks = this.extractTargetedDecorations(targets, navigationMap);
+    this.targets = targets;
+    this.context = context;
+  }
+
+  extractPrimitiveTargetKeys(...targets: PrimitiveTarget[]) {
+    const keys: string[] = [];
+    targets.forEach((target) => {
+      if (target.mark.type === "decoratedSymbol") {
+        const { character, symbolColor } = target.mark;
+        keys.push(NavigationMap.getKey(symbolColor, character));
+      }
+    });
+    return keys;
+  }
+
+  extractTargetKeys(target: Target): string[] {
+    switch (target.type) {
+      case "primitive":
+        return this.extractPrimitiveTargetKeys(target);
+
+      case "list":
+        return target.elements.map(this.extractTargetKeys, this).flat();
+
+      case "range":
+        return this.extractPrimitiveTargetKeys(target.start, target.end);
+
+      default:
+        return [];
+    }
+  }
+
+  extractTargetedDecorations(targets: Target[], navigationMap: NavigationMap) {
+    if (!navigationMap) {
+      return {};
+    }
+
+    const decorationRanges = navigationMap.serializeRanges();
+    const targetedDecorations: DecorationRanges = {};
+    const targetKeys = targets.map(this.extractTargetKeys, this).flat();
+    targetKeys.forEach((key) => {
+      targetedDecorations[key] = decorationRanges[key];
+    });
+    return targetedDecorations;
+  }
+
+  isThatMarkTargeted() {
+    return this.targets.some(
+      (target) => target.type === "primitive" && target.mark.type === "that"
+    );
+  }
+
+  static async getSnapshot(
+    thatMark: SelectionWithEditor[]
+  ): Promise<TestCaseSnapshot> {
+    const activeEditor = vscode.window.activeTextEditor!;
+    return {
+      document: activeEditor.document.getText(),
+      selections: activeEditor.selections.map(serializeSelection),
+      visibleRanges: activeEditor.visibleRanges.map(serializeRange),
+      clipboard: await Clipboard.readText(),
+      thatMark: thatMark.map((mark) => serializeSelection(mark.selection)),
+    };
+  }
+
+  async getSnapshot(): Promise<TestCaseSnapshot> {
+    return await TestCase.getSnapshot(this.context.thatMark.get());
+  }
+
+  async saveSnapshot() {
+    const snapshot = await this.getSnapshot();
+
+    if (!["copy", "paste"].includes(this.command.actionName)) {
+      snapshot.clipboard = "";
+    }
+
+    if (!["fold", "unfold"].includes(this.command.actionName)) {
+      snapshot.visibleRanges = [];
+    }
+
+    if (this.initialState == null && !this.isThatMarkTargeted()) {
+      snapshot.thatMark = [];
+    }
+
+    if (this.initialState == null) {
+      this.initialState = snapshot;
+    } else if (this.finalState == null) {
+      this.finalState = snapshot;
+    } else {
+      throw Error("Both snapshots already taken");
+    }
+
+    return snapshot;
+  }
+
+  toYaml() {
+    if (this.initialState == null || this.finalState == null) {
+      throw Error("Two snapshots must be taken before serializing");
+    }
+    const fixture: TestCaseFixture = {
+      talonCommand: this.talonCommand,
+      command: this.command,
+      languageId: this.languageId,
+      targets: this.targets,
+      marks: this.marks,
+      initialState: this.initialState,
+      finalState: this.finalState,
+      returnValue: this.returnValue,
+    };
+    return yaml.dump(fixture, { noRefs: true, quotingType: '"' });
+  }
+
+  async writeFixture(filename: string) {
+    if (filename === "") {
+      throw new Error("Filename required");
+    }
+
+    const fixture = this.toYaml();
+    const workspacePath = vscode.workspace.workspaceFolders?.[0].uri.path;
+    let document;
+
+    if (workspacePath) {
+      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;
 }