[TypeSpec Validation] Refactor TsvHost (#26411)

- Export TsvRunnerHost and TsvTestHost as classes rather than consts
- Change test names to lower-case for consistency with typespec repo
- Delete incomplete FolderStructure rule
- TsvRunnerHost.gitOperation should succeed by default

Author: mikeharder

eng/tools/TypeSpecValidation/src/index.ts

@@ -19,7 +19,9 @@ export async function main() {
   const folder = parsedArgs.positionals[0];
   console.log("Running TypeSpecValidation on folder:", folder);
 
-  let rules = [
+  const host = new TsvRunnerHost();
+
+  const rules = [
     new FolderStructureRule(),
     new NpmPrefixRule(),
     new LinterRulesetRule(),
@@ -31,7 +33,7 @@ export async function main() {
   for (let i = 0; i < rules.length; i++) {
     const rule = rules[i];
     console.log("\nExecuting rule: " + rule.name);
-    const result = await rule.execute(TsvRunnerHost, folder);
+    const result = await rule.execute(host, folder);
     if (result.stdOutput) console.log(result.stdOutput);
     if (!result.success) {
       success = false;

eng/tools/TypeSpecValidation/src/tsv-host.ts

@@ -1,8 +1,7 @@
 export interface TsvHost {
+  checkFileExists(file: string): Promise<boolean>;
   gitOperation(folder: string): IGitOperation;
   runCmd(cmd: string, cwd: string): Promise<[Error | null, string, string]>;
-  checkFileExists(file: string): Promise<boolean>;
-  // TODO: Other functions that need mocks
 }
 
 export interface IGitOperation {

eng/tools/TypeSpecValidation/src/tsv-runner-host.ts

@@ -1,10 +1,17 @@
-import { TsvHost } from "./tsv-host.js";
+import { IGitOperation, TsvHost } from "./tsv-host.js";
 import { simpleGit } from "simple-git";
 import { runCmd, checkFileExists } from "./utils.js";
 
-export const TsvRunnerHost: TsvHost = {
-  gitOperation: simpleGit,
-  runCmd: runCmd,
-  checkFileExists: checkFileExists,
-  // TODO: Other functions that need mocks
-};
+export class TsvRunnerHost implements TsvHost {
+  checkFileExists(file: string): Promise<boolean> {
+    return checkFileExists(file);
+  }
+
+  gitOperation(folder: string): IGitOperation {
+    return simpleGit(folder);
+  }
+
+  runCmd(cmd: string, cwd: string): Promise<[Error | null, string, string]> {
+    return runCmd(cmd, cwd);
+  }
+}

eng/tools/TypeSpecValidation/test/compile.test.ts

@@ -1,15 +1,10 @@
-// import { error } from "node:console";
 import { CompileRule } from "../src/rules/compile.js";
-import { TsvTestHostGenerator } from "./tsv-test-host.js";
+import { TsvTestHost } from "./tsv-test-host.js";
 import { strict as assert } from "node:assert";
-describe("#Compile", function () {
-  it("Should fail if project cannot compile.", async function () {
-    let compileRule = new CompileRule();
-    let TsvTestHost = TsvTestHostGenerator({
-      runCmd: Promise.resolve([null, "success", "success"]),
-    });
-    const result = await compileRule.execute(TsvTestHost, "mockFolder");
+describe("compile", function () {
+  it("should succeed if project can compile", async function () {
+    const result = await new CompileRule().execute(new TsvTestHost(), TsvTestHost.folder);
+
     assert(result.success);
-    assert(result.stdOutput === "successsuccess");
   });
 });

eng/tools/TypeSpecValidation/test/folder-structure.test.ts

@@ -1,12 +1,11 @@
 import { GitDiffRule } from "../src/rules/git-diff.js";
-import { DefaultTsvTestHost } from "./tsv-test-host.js";
+import { TsvTestHost } from "./tsv-test-host.js";
 import { strict as assert } from "node:assert";
 
-describe("#GitDiff", function () {
-  it("Should fail if git diff produces output.", async function () {
-    let gitDiffRule = new GitDiffRule();
-    const result = await gitDiffRule.execute(DefaultTsvTestHost, "mockFolder");
-    assert(result.errorOutput);
-    assert(result.errorOutput.length !== 0);
+describe("git-diff", function () {
+  it("should succeed if git diff produces no output", async function () {
+    const result = await new GitDiffRule().execute(new TsvTestHost(), TsvTestHost.folder);
+
+    assert(result.success);
   });
 });

eng/tools/TypeSpecValidation/test/git-diff.test.ts

@@ -1,57 +1,36 @@
-import { TsvHost } from "../src/tsv-host.js";
+import { IGitOperation, TsvHost } from "../src/tsv-host.js";
 
-export function TsvTestHostGenerator(fnReturnSub: { [key: string]: Object }) {
-  let tsvTestHost = Object.assign({}, DefaultTsvTestHost); // Needs deep copy
-  for (let key in fnReturnSub) {
-    let typedKey = key as keyof TsvHost;
-    if (fnReturnSub[typedKey]) {
-      tsvTestHost = {
-        ...tsvTestHost,
-        [typedKey]: () => {
-          return fnReturnSub[typedKey];
-        },
-      };
-    } else {
-      tsvTestHost = {
-        ...tsvTestHost,
-        [typedKey]: () => {},
-      };
-    }
+export class TsvTestHost implements TsvHost {
+  static get folder() {
+    return "specification/foo/Foo";
   }
-  return tsvTestHost;
-}
 
-export const DefaultTsvTestHost: TsvHost = {
-  gitOperation: (folder: string) => {
+  gitOperation(_folder: string): IGitOperation {
     return {
       status: () => {
         return Promise.resolve({
-          modified: [`${folder}\n`],
-          isClean: () => {
-            return false;
-          },
+          modified: [],
+          isClean: () => true,
         });
       },
       diff: () => {
-        return Promise.resolve("diff");
+        return Promise.resolve("");
       },
       revparse: () => {
         return Promise.resolve("");
       },
     };
-  },
+  }
 
-  runCmd: async (cmd: string, cwd: string) => {
+  async runCmd(cmd: string, cwd: string): Promise<[Error | null, string, string]> {
     let err = null;
     let stdout = `default ${cmd} at ${cwd}`;
     let stderr = "";
 
     return [err, stdout, stderr];
-  },
+  }
 
-  checkFileExists: async (file: string) => {
-    console.log(`file ${file} exists`);
+  async checkFileExists(_file: string): Promise<boolean> {
     return true;
-  },
-  // TODO: Other functions that need mocks
-};
+  }
+}