@typespec/protobuf 0.43.0

package/test/scenarios/simple-error/diagnostics.txt

@@ -0,0 +1,6 @@
+/test/main.tsp:12:5 - error @typespec/protobuf/field-index: field index 0 is invalid (must be an integer greater than zero)
+/test/main.tsp:13:5 - error @typespec/protobuf/field-index: field index 536870912 is out of bounds (must be less than 536870912)
+/test/main.tsp:14:5 - error @typespec/protobuf/field-index: field index 19000 falls within the implementation-reserved range of 19000-19999 inclusive
+/test/main.tsp:15:5 - error @typespec/protobuf/field-index: field index 19123 falls within the implementation-reserved range of 19000-19999 inclusive
+/test/main.tsp:16:5 - error @typespec/protobuf/field-index: field index 19999 falls within the implementation-reserved range of 19000-19999 inclusive
+/test/main.tsp:21:1 - error decorator-wrong-target: Cannot apply @message decorator to Test.Test since it is not assignable to object

package/test/scenarios/simple-error/input/main.tsp

@@ -0,0 +1,22 @@
+import "@typespec/protobuf";
+
+using TypeSpec.Protobuf;
+
+@package
+namespace Test;
+
+@Protobuf.service
+interface Service {
+  // invalid field index
+  invalidIndices(
+    @field(0) testInputField: string,
+    @field(536870912) testInputField2: string,
+    @field(19000) testInputField3: string,
+    @field(19123) testInputField4: string,
+    @field(19999) testInputField5: string
+  ): {};
+}
+
+// Cannot apply @message to interface
+@message
+interface Test {}

package/test/scenarios/simple-no-service/input/main.tsp

@@ -0,0 +1,22 @@
+import "@typespec/protobuf";
+
+using TypeSpec.Protobuf;
+
+@package({
+  name: "com.azure.Test",
+})
+namespace Test;
+
+model Input {
+  @field(1) testInputField: string;
+}
+
+model Output {
+  @field(1) testOutputField: int32;
+  @field(2) secondField: string;
+}
+
+@message
+model ExplicitlyDeclared {
+  @field(2) testField: string;
+}

package/test/scenarios/simple-no-service/output/@typespec/protobuf/com/azure/Test.proto

@@ -0,0 +1,18 @@
+/* Generated by Microsoft TypeSpec */
+
+syntax = "proto3";
+
+package com.azure.Test;
+
+message Input {
+  string testInputField = 1;
+}
+
+message Output {
+  int32 testOutputField = 1;
+  string secondField = 2;
+}
+
+message ExplicitlyDeclared {
+  string testField = 2;
+}

package/test/scenarios/streams/input/main.tsp

@@ -0,0 +1,30 @@
+import "@typespec/protobuf";
+
+using TypeSpec.Protobuf;
+
+@package
+namespace Test;
+
+@Protobuf.service
+interface Service {
+  @stream(StreamMode.Duplex)
+  duplex(...Input): Output;
+
+  @stream(StreamMode.In)
+  in(...Input): Output;
+
+  @stream(StreamMode.Out)
+  out(...Input): Output;
+
+  @stream(StreamMode.None)
+  none(...Input): Output;
+}
+
+model Input {
+  @field(1) testInputField: string;
+}
+
+model Output {
+  @field(1) testOutputField: int32;
+  @field(2) secondField: string;
+}

package/test/scenarios/streams/output/@typespec/protobuf/main.proto

@@ -0,0 +1,19 @@
+/* Generated by Microsoft TypeSpec */
+
+syntax = "proto3";
+
+message Input {
+  string testInputField = 1;
+}
+
+message Output {
+  int32 testOutputField = 1;
+  string secondField = 2;
+}
+
+service Service {
+  rpc Duplex(stream Input) returns (stream Output);
+  rpc In(stream Input) returns (Output);
+  rpc Out(Input) returns (stream Output);
+  rpc None(Input) returns (Output);
+}

package/test/scenarios/type-validation/diagnostics.txt

@@ -0,0 +1 @@
+/test/main.tsp:10:20 - error @typespec/protobuf/unsupported-return-type: Protobuf methods must return a named Model

package/test/scenarios/type-validation/input/main.tsp

@@ -0,0 +1,11 @@
+import "@typespec/protobuf";
+
+using TypeSpec.Protobuf;
+
+@package
+namespace Test;
+
+@Protobuf.service
+interface Service {
+  invalidReturn(): int32;
+}

package/test/scenarios/union/diagnostics.txt

@@ -0,0 +1 @@
+/test/main.tsp:14:3 - error @typespec/protobuf/unsupported-field-type: a message field's type may not be a union

package/test/scenarios/union/input/main.tsp

@@ -0,0 +1,33 @@
+import "@typespec/protobuf";
+
+using TypeSpec.Protobuf;
+
+@package
+namespace Test;
+
+@Protobuf.service
+interface Service {
+  foo(...Input): Output;
+}
+
+model Input {
+  @field(1) value: U;
+}
+
+model InputA {
+  @field(1) testInputField: string;
+}
+
+union U {
+  a: InputA,
+  b: InputB,
+}
+
+model InputB {
+  @field(1) testInputField: uint32;
+}
+
+model Output {
+  @field(1) testOutputField: int32;
+  @field(2) secondField: string;
+}

package/test/scenarios.test.ts

@@ -0,0 +1,226 @@
+import assert from "assert";
+import path from "path";
+import url from "url";
+
+import micromatch from "micromatch";
+
+import { formatDiagnostic } from "@typespec/compiler";
+import {
+  createTestHost,
+  resolveVirtualPath,
+  TypeSpecTestLibrary,
+} from "@typespec/compiler/testing";
+import { readdirSync, statSync } from "fs";
+import { mkdir, readdir, readFile, rm, stat, writeFile } from "fs/promises";
+
+const SCENARIOS_DIRECTORY = url.fileURLToPath(new url.URL("../../test/scenarios", import.meta.url));
+
+const shouldRecord = process.env.RECORD === "true";
+const patternsToRun = process.env.RUN_SCENARIOS?.split(",") ?? ["*"];
+
+const TypeSpecProtobufTestLibrary: TypeSpecTestLibrary = {
+  name: "@typespec/protobuf",
+  packageRoot: path.resolve(url.fileURLToPath(import.meta.url), "../../../"),
+  files: [
+    { realDir: "", pattern: "package.json", virtualPath: "./node_modules/@typespec/protobuf" },
+    {
+      realDir: "dist/src",
+      pattern: "*.js",
+      virtualPath: "./node_modules/@typespec/protobuf/dist/src",
+    },
+    { realDir: "lib/", pattern: "*.tsp", virtualPath: "./node_modules/@typespec/protobuf/lib" },
+  ],
+};
+
+describe("protobuf scenarios", function () {
+  const scenarios = readdirSync(SCENARIOS_DIRECTORY)
+    .map((dn) => path.join(SCENARIOS_DIRECTORY, dn))
+    .filter((dn) => statSync(dn).isDirectory());
+
+  for (const scenario of scenarios) {
+    const scenarioName = path.basename(scenario);
+
+    const shouldRun = micromatch.isMatch(scenarioName, patternsToRun);
+
+    shouldRun &&
+      it(scenarioName, async function () {
+        const inputFiles = await readdirRecursive(path.join(scenario, "input"));
+        const emitResult = await doEmit(inputFiles);
+
+        const expectationDirectory = path.resolve(scenario, "output");
+        const diagnosticsExpectationPath = path.resolve(scenario, "diagnostics.txt");
+
+        if (shouldRecord) {
+          // Write new output to the scenario's output folder.
+
+          await writeExpectationDirectory(expectationDirectory, emitResult.files);
+
+          await rm(diagnosticsExpectationPath, { force: true });
+
+          if (emitResult.diagnostics.length > 0) {
+            const diagnostics = emitResult.diagnostics.join("\n");
+
+            await writeFile(diagnosticsExpectationPath, diagnostics);
+          }
+        } else {
+          // It's an error if any file in the expected files is missing, if any file in the output files doesn't have a
+          // corresponding expectation, or if any file in the output files doesn't match its corresponding output file
+          // character for character.
+
+          let err: Error | undefined = undefined;
+
+          // `throwIfNoEntry` is not supported with promisified fs.promises.stat.
+          if (!statSync(expectationDirectory, { throwIfNoEntry: false })) {
+            assert.strictEqual(
+              Object.entries(emitResult.files).length,
+              0,
+              "no expectations exist, but output files were generated"
+            );
+          } else {
+            const expectedFiles = await readdirRecursive(expectationDirectory);
+
+            // Need to defer this error until we've checked for diagnostics below. If diagnostics were unexpectedly
+            // raised and inhibited emit, that should be the primary error, not this one.
+            try {
+              assertFilesAsExpected(emitResult.files, expectedFiles);
+            } catch (e: unknown) {
+              err = e as Error;
+            }
+          }
+
+          let expectedDiagnostics: string;
+          try {
+            expectedDiagnostics = (await readFile(diagnosticsExpectationPath)).toString("utf-8");
+          } catch {
+            expectedDiagnostics = "";
+          }
+
+          // Fix the start of lines on Windows
+          const processedDiagnostics =
+            process.platform === "win32"
+              ? emitResult.diagnostics.map((d) => d.replace(/^Z:/, ""))
+              : emitResult.diagnostics;
+
+          const diagnostics = processedDiagnostics.join("\n");
+
+          assert.strictEqual(diagnostics, expectedDiagnostics, "expected equivalent diagnostics");
+
+          if (err) throw err;
+        }
+      });
+  }
+});
+
+interface EmitResult {
+  files: Record<string, string>;
+  diagnostics: string[];
+}
+
+async function doEmit(files: Record<string, string>): Promise<EmitResult> {
+  const baseOutputPath = resolveVirtualPath("test-output/");
+
+  const host = await createTestHost({
+    libraries: [TypeSpecProtobufTestLibrary],
+  });
+
+  for (const [fileName, content] of Object.entries(files)) {
+    host.addTypeSpecFile(fileName, content);
+  }
+
+  const [, diagnostics] = await host.compileAndDiagnose("main.tsp", {
+    outputDir: baseOutputPath,
+    noEmit: false,
+    emitters: {
+      "@typespec/protobuf": {},
+    },
+  });
+
+  return {
+    files: Object.fromEntries(
+      [...host.fs.entries()]
+        .filter(([name]) => name.startsWith(baseOutputPath))
+        .map(([name, value]) => [name.replace(baseOutputPath, ""), value])
+    ),
+    diagnostics: diagnostics.map(formatDiagnostic),
+  };
+}
+
+function assertFilesAsExpected(
+  outputFiles: Record<string, string>,
+  expectedFiles: Record<string, string>
+) {
+  for (const fn of Object.keys(expectedFiles)) {
+    assert.ok(
+      Object.prototype.hasOwnProperty.call(outputFiles, fn),
+      `expected file ${fn} was not produced`
+    );
+  }
+
+  for (const [fn, content] of Object.entries(outputFiles)) {
+    const expectedContent = expectedFiles[fn];
+
+    assert.ok(expectedContent, `output file ${fn} has no corresponding expectation`);
+
+    assert.strictEqual(content, expectedContent);
+  }
+}
+
+/**
+ * Writes an expectation map to disk.
+ *
+ * @param expectationDirectory - The directory to write to.
+ * @param outputFiles - A map of relative paths to file contents.
+ */
+async function writeExpectationDirectory(
+  expectationDirectory: string,
+  outputFiles: Record<string, string>
+) {
+  const fileEntries = Object.entries(outputFiles);
+
+  // It'll be annoying to fiddle with .gitkeep files, so let's omit the `output` directory if it's empty.
+  if (fileEntries.length === 0) {
+    return;
+  }
+
+  await rm(expectationDirectory, { recursive: true, force: true });
+
+  await mkdir(expectationDirectory);
+
+  for (const [fn, content] of fileEntries) {
+    const fullPath = path.join(expectationDirectory, fn);
+    await mkdir(path.dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, content);
+  }
+}
+
+/**
+ * @param dir - The directory to read recursively.
+ * @param base - The base directory to use for relative paths.
+ * @returns A map of relative paths to file contents.
+ */
+async function readdirRecursive(dir: string, base: string = dir): Promise<Record<string, string>> {
+  const res: Record<string, string> = {};
+
+  for (const entry of (await readdir(dir)).map((e) => path.join(dir, e))) {
+    const stats = await stat(entry);
+
+    if (stats.isDirectory()) {
+      for (const [name, content] of Object.entries(await readdirRecursive(entry, base))) {
+        res[name] = content;
+      }
+    } else if (stats.isFile()) {
+      const content = (await readFile(entry)).toString("utf-8");
+
+      const relativePath = path.relative(base, entry);
+
+      const correctedPath =
+        process.platform === "win32" ? relativePath.replace(/\\/g, "/") : relativePath;
+
+      res[correctedPath] = content;
+    } else {
+      throw new Error("Unsupported file type.");
+    }
+  }
+
+  return res;
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../tsconfig.json",
+  "references": [
+    { "path": "../compiler/tsconfig.json" },
+    { "path": "../rest/tsconfig.json" },
+    { "path": "../openapi/tsconfig.json" }
+  ],
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": ".",
+    "tsBuildInfoFile": "temp/tsconfig.tsbuildinfo",
+    "types": ["node", "mocha"]
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts"]
+}