[TypeSpec Validation] Must emit "@azure-tools/typespec-autorest" by default (#26314)

- Specs containing file "main.tsp" must emit "@azure-tools/typespec-autorest" by default
- Also check compiler output for defense-in-depth
- Fixes #25041

Author: mikeharder

eng/tools/TypeSpecValidation/src/index.ts

@@ -1,5 +1,6 @@
 import { parseArgs, ParseArgsConfig } from "node:util";
 import { CompileRule } from "./rules/compile.js";
+import { EmitAutorestRule } from "./rules/emit-autorest.js";
 import { FolderStructureRule } from "./rules/folder-structure.js";
 import { FormatRule } from "./rules/format.js";
 import { GitDiffRule } from "./rules/git-diff.js";
@@ -25,6 +26,7 @@ export async function main() {
   const rules = [
     new FolderStructureRule(),
     new NpmPrefixRule(),
+    new EmitAutorestRule(),
     new LinterRulesetRule(),
     new CompileRule(),
     new FormatRule(),

eng/tools/TypeSpecValidation/src/rules/compile.ts

@@ -17,6 +17,13 @@ export class CompileRule implements Rule {
         `npx --no tsp compile . --warn-as-error`,
         folder,
       );
+      if (
+        stdout.toLowerCase().includes("no emitter was configured") ||
+        stdout.toLowerCase().includes("no output was generated")
+      ) {
+        success = false;
+        errorOutput += "No emitter was configured and/or no output was generated.";
+      }
       if (err) {
         success = false;
         errorOutput += err.message;

eng/tools/TypeSpecValidation/src/rules/emit-autorest.ts

@@ -0,0 +1,43 @@
+import { join } from "path";
+import { parse as yamlParse } from "yaml";
+import { Rule } from "../rule.js";
+import { RuleResult } from "../rule-result.js";
+import { TsvHost } from "../tsv-host.js";
+
+export class EmitAutorestRule implements Rule {
+  readonly name = "EmitAutorest";
+
+  readonly description = 'Must emit "@azure-tools/typespec-autorest" by default';
+
+  async execute(host: TsvHost, folder: string): Promise<RuleResult> {
+    let success = true;
+    let stdOutput = "";
+    let errorOutput = "";
+
+    const mainTspExists = await host.checkFileExists(join(folder, "main.tsp"));
+    stdOutput += `mainTspExists: ${mainTspExists}\n`;
+
+    if (mainTspExists) {
+      const configText = await host.readTspConfig(folder);
+      const config = yamlParse(configText);
+
+      const emit = config?.emit;
+      stdOutput += `emit: ${JSON.stringify(emit)}\n`;
+
+      if (!emit?.includes("@azure-tools/typespec-autorest")) {
+        success = false;
+        errorOutput +=
+          "tspconfig.yaml must include the following emitter by default:\n" +
+          "\n" +
+          "emit:\n" +
+          '  - "@azure-tools/typespec-autorest"\n';
+      }
+    }
+
+    return {
+      success: success,
+      stdOutput: stdOutput,
+      errorOutput: errorOutput,
+    };
+  }
+}

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

@@ -1,6 +1,7 @@
 export interface TsvHost {
   checkFileExists(file: string): Promise<boolean>;
   gitOperation(folder: string): IGitOperation;
+  readTspConfig(folder: string): Promise<string>;
   runCmd(cmd: string, cwd: string): Promise<[Error | null, string, string]>;
 }
 

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

@@ -1,3 +1,5 @@
+import { join } from "path";
+import { readFile } from "fs/promises";
 import { IGitOperation, TsvHost } from "./tsv-host.js";
 import { simpleGit } from "simple-git";
 import { runCmd, checkFileExists } from "./utils.js";
@@ -11,6 +13,10 @@ export class TsvRunnerHost implements TsvHost {
     return simpleGit(folder);
   }
 
+  readTspConfig(folder: string): Promise<string> {
+    return readFile(join(folder, "tspconfig.yaml"), "utf-8");
+  }
+
   runCmd(cmd: string, cwd: string): Promise<[Error | null, string, string]> {
     return runCmd(cmd, cwd);
   }

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

@@ -7,4 +7,34 @@ describe("compile", function () {
 
     assert(result.success);
   });
+
+  it("should fail if no emitter was configured", async function () {
+    let host = new TsvTestHost();
+    host.runCmd = async (cmd: string, _cwd: string): Promise<[Error | null, string, string]> => {
+      if (cmd.includes("tsp compile .")) {
+        return [null, "no emitter was configured", ""];
+      } else {
+        return [null, "", ""];
+      }
+    };
+
+    const result = await new CompileRule().execute(host, TsvTestHost.folder);
+
+    assert(!result.success);
+  });
+
+  it("should fail if no output was generated", async function () {
+    let host = new TsvTestHost();
+    host.runCmd = async (cmd: string, _cwd: string): Promise<[Error | null, string, string]> => {
+      if (cmd.includes("tsp compile .")) {
+        return [null, "no output was generated", ""];
+      } else {
+        return [null, "", ""];
+      }
+    };
+
+    const result = await new CompileRule().execute(host, TsvTestHost.folder);
+
+    assert(!result.success);
+  });
 });

eng/tools/TypeSpecValidation/test/emit-autorest.ts

@@ -0,0 +1,61 @@
+import { join } from "path";
+import { EmitAutorestRule } from "../src/rules/emit-autorest.js";
+import { TsvTestHost } from "./tsv-test-host.js";
+import { strict as assert } from "node:assert";
+
+describe("emit-autorest", function () {
+  it("should succeed if no main.tsp", async function () {
+    let host = new TsvTestHost();
+    host.checkFileExists = async (file: string) => file != join(TsvTestHost.folder, "main.tsp");
+
+    const result = await new EmitAutorestRule().execute(host, TsvTestHost.folder);
+
+    assert(result.success);
+  });
+
+  it("should succeed if emits autorest", async function () {
+    let host = new TsvTestHost();
+    host.readTspConfig = async (_folder: string) => `
+emit:
+  - "@azure-tools/typespec-autorest"
+`;
+
+    const result = await new EmitAutorestRule().execute(host, TsvTestHost.folder);
+
+    assert(result.success);
+  });
+
+  it("should fail if config is empty", async function () {
+    let host = new TsvTestHost();
+    host.readTspConfig = async (_folder: string) => "";
+
+    const result = await new EmitAutorestRule().execute(host, TsvTestHost.folder);
+
+    assert(!result.success);
+  });
+
+  it("should fail if no emit", async function () {
+    let host = new TsvTestHost();
+    host.readTspConfig = async (_folder: string) => `
+linter:
+  extends:
+    - "@azure-tools/typespec-azure-core/all"
+`;
+
+    const result = await new EmitAutorestRule().execute(host, TsvTestHost.folder);
+
+    assert(!result.success);
+  });
+
+  it("should fail if no emit autorest", async function () {
+    let host = new TsvTestHost();
+    host.readTspConfig = async (_folder: string) => `
+emit:
+- foo
+`;
+
+    const result = await new EmitAutorestRule().execute(host, TsvTestHost.folder);
+
+    assert(!result.success);
+  });
+});

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

@@ -33,4 +33,21 @@ export class TsvTestHost implements TsvHost {
   async checkFileExists(_file: string): Promise<boolean> {
     return true;
   }
+
+  async readTspConfig(_folder: string): Promise<string> {
+    // Sample config that should cause all rules to succeed
+    return `
+emit:
+  - "@azure-tools/typespec-autorest"
+linter:
+  extends:
+    - "@azure-tools/typespec-azure-core/all"
+options:
+  "@azure-tools/typespec-autorest":
+    azure-resource-provider-folder: "data-plane"
+    emitter-output-dir: "{project-root}/.."
+    examples-directory: "examples"
+    output-file: "{azure-resource-provider-folder}/{service-name}/{version-status}/{version}/openapi.json"
+`;
+  }
 }