@azure-tools/typespec-ts 0.11.0-alpha.20230413.3

package/test/commands/check-clean-tree.ts

@@ -0,0 +1,55 @@
+import { spawn, ChildProcess } from "child_process";
+
+const onExit = (childProcess: ChildProcess): Promise<string[]> => {
+  let messages: string[] = [];
+  return new Promise((resolve, reject) => {
+    if (childProcess.stdout) {
+      childProcess.stdout.on("data", (message) => messages.push(message));
+    }
+    childProcess.once("exit", (code: number) => {
+      if (code === 0) {
+        resolve(messages);
+      }
+      reject(new Error(`Exit with code: ${code}`));
+    });
+
+    childProcess.once("error", (error: Error) => {
+      reject(error);
+    });
+  });
+};
+
+async function check_tree() {
+  await onExit(
+    spawn("git", ["add", "-A"], {
+      stdio: [process.stdin, process.stdout, process.stderr]
+    })
+  );
+
+  // If there is any output from this command it means that
+  // there are non committed changes so we need to handle
+  // stout
+  const messages = await onExit(
+    spawn("git", ["diff", "--staged", "--compact-summary"])
+  );
+
+  if (messages.length !== 0) {
+    // Once we have verified that there are non committed changes
+    // run git diff again, this time forwarding the stout to present
+    // a readable hint to the user
+    await onExit(
+      spawn("git", ["diff", "--staged", "--compact-summary"], {
+        stdio: [process.stdin, process.stdout, process.stderr]
+      })
+    );
+
+    throw new Error(
+      "Git tree is dirty, regenerate all test cadl files and make sure that there are no un-intended changes"
+    );
+  }
+}
+
+check_tree().catch((error) => {
+  console.error(error);
+  process.exit(-1);
+});

package/test/commands/childProcessOnExit.ts

@@ -0,0 +1,16 @@
+import { ChildProcess } from "child_process";
+
+export const onExit = (childProcess: ChildProcess) => {
+  return new Promise<void>((resolve, reject) => {
+    childProcess.once("exit", (code: number) => {
+      if (code === 0) {
+        resolve();
+      }
+      reject(new Error(`Exit with code: ${code}`));
+    });
+
+    childProcess.once("error", (error: Error) => {
+      reject(error);
+    });
+  });
+};

package/test/commands/gen-cadl-ranch.ts

@@ -0,0 +1,21 @@
+import { cadls } from "./cadl-ranch-list.js";
+import { runTypespec } from "./run.js";
+import pkg from "chalk";
+const { bold } = pkg;
+const logError = (str: string) => console.error(bold.red(str));
+
+async function generateCadls() {
+  const list = cadls;
+  for (const cadl of list) {
+    await runTypespec(cadl);
+  }
+}
+
+async function main() {
+  await generateCadls();
+}
+
+main().catch((error) => {
+  logError(error);
+  process.exit(-1);
+});

package/test/commands/run.ts

@@ -0,0 +1,31 @@
+import { execSync } from "child_process";
+import { dirname, join as joinPath } from "path";
+import { fileURLToPath } from "url";
+import { CadlRanchConfig } from "./cadl-ranch-list.js";
+
+export async function runTypespec(config: CadlRanchConfig) {
+  const targetFolder = config.outputPath,
+    sourceTypespec = config.inputPath;
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  console.log(`=== Start ${targetFolder} ===`);
+
+  const typespecPath = joinPath(
+    `${__dirname}`,
+    "..",
+    "..",
+    `./temp/http/${sourceTypespec}`
+  );
+  const outputPath = joinPath(
+    `${__dirname}`,
+    "..",
+    `./integration/generated/${targetFolder}`
+  );
+  const typespecCommand = `cd ${outputPath} && npx tsp`;
+  const commandArguments: string[] = ["compile", `${typespecPath}`];
+  const command = `${typespecCommand} ${commandArguments.join(" ")}`;
+  console.log(command);
+  const result = execSync(command);
+  console.log(`=== End ${targetFolder} ===`);
+  return result;
+}

package/test/integration/arrayItemTypes.spec.ts

@@ -0,0 +1,96 @@
+import ArrayItemTypesClientFactory, {
+  ArrayItemTypesClient
+} from "./generated/arrays/itemTypes/src/index.js";
+import { assert } from "chai";
+import { matrix } from "../util/matrix.js";
+
+interface TypeDetail {
+  type: string;
+  defaultValue: any;
+  convertedToFn?: (_: any) => any;
+}
+
+const testedTypes: TypeDetail[] = [
+  {
+    type: "int32",
+    defaultValue: [1, 2]
+  },
+  {
+    type: "int64",
+    defaultValue: [Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER]
+  },
+  {
+    type: "boolean",
+    defaultValue: [true, false]
+  },
+  {
+    type: "string",
+    defaultValue: ["hello", ""]
+  },
+  {
+    type: "float32",
+    defaultValue: [42.42]
+  },
+  {
+    type: "datetime",
+    defaultValue: ["2022-08-26T18:38:00Z"]
+  },
+  {
+    type: "duration",
+    defaultValue: ["P123DT22H14M12.011S"]
+  },
+  {
+    type: "unknown",
+    defaultValue: [1, "hello", null]
+  },
+  {
+    type: "model",
+    defaultValue: [{ property: "hello" }, { property: "world" }]
+  },
+  {
+    type: "nullable-float",
+    defaultValue: [1.2, null, 3.0]
+  }
+];
+describe("Array Item-Types Client", () => {
+  let client: ArrayItemTypesClient;
+
+  beforeEach(() => {
+    client = ArrayItemTypesClientFactory({
+      allowInsecureConnection: true
+    });
+  });
+
+  matrix([testedTypes], async (params: TypeDetail) => {
+    it(`should get a ${params.type} value`, async () => {
+      try {
+        const result = await client
+          .path(`/arrays/item-types/${params.type}` as any)
+          .get();
+        assert.strictEqual(result.status, "200");
+        assert.deepEqual(result.body, params.defaultValue);
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+    it(`should put a ${params.type} value`, async () => {
+      try {
+        let property;
+        if (params.convertedToFn) {
+          property = params.convertedToFn(params.defaultValue);
+        } else {
+          property = params.defaultValue;
+        }
+        const result = await client
+          .path(`/arrays/item-types/${params.type}` as any)
+          .put({
+            body: property
+          });
+        assert.strictEqual(result.status, "204");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+  });
+});

package/test/integration/authApiKey.spec.ts

@@ -0,0 +1,38 @@
+import ApiKeyClientFactory, {
+  AuthApiKeyClient
+} from "./generated/authentication/apiKey/src/index.js";
+import { assert } from "chai";
+describe("AuthApiKeyClient Rest Client", () => {
+  let client: AuthApiKeyClient;
+
+  beforeEach(() => {
+    client = ApiKeyClientFactory(
+      {
+        key: "valid-key"
+      },
+      { allowInsecureConnection: true }
+    );
+  });
+
+  it("should return 204 when the apiKey is valid", async () => {
+    try {
+      const result = await client.path("/authentication/api-key/valid").get();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      console.log(err);
+      assert.fail(err as string);
+    }
+  });
+
+  it("should return 403 when the apiKey is invalid", async () => {
+    try {
+      const result = await client.path("/authentication/api-key/invalid").get();
+      assert.strictEqual(result.status, "403");
+      if (result.status === "403") {
+        assert.strictEqual(result.body.error, "invalid-api-key");
+      }
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});

package/test/integration/authOauth2.spec.ts

@@ -0,0 +1,65 @@
+import Outh2ClientFactory, {
+  AuthOauth2Client
+} from "./generated/authentication/oauth2/src/index.js";
+import { assert } from "chai";
+import {
+  bearerTokenAuthenticationPolicyName,
+  PipelinePolicy
+} from "@azure/core-rest-pipeline";
+import { customBearerTokenAuthenticationPolicy } from "../util/customBearerTokenTestingPolicy.js";
+
+describe("AuthOauth2Client Rest Client", () => {
+  let client: AuthOauth2Client;
+  let policy: PipelinePolicy;
+  const defaultScope = "https://security.microsoft.com/.default";
+
+  beforeEach(() => {
+    client = Outh2ClientFactory(
+      {
+        getToken: async () => Promise.resolve(null)
+      },
+      { allowInsecureConnection: true }
+    );
+    policy = customBearerTokenAuthenticationPolicy({
+      scopes: defaultScope,
+      credential: {
+        getToken: async () => {
+          return {
+            token: defaultScope,
+            expiresOnTimestamp: Date.now()
+          };
+        }
+      }
+    });
+    client.pipeline.removePolicy({
+      name: bearerTokenAuthenticationPolicyName
+    });
+    client.pipeline.addPolicy(policy);
+  });
+
+  it("should return 204 when the token is valid", async () => {
+    try {
+      const result = await client.path("/authentication/oauth2/valid").get();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      console.log(err);
+      assert.fail(err as string);
+    }
+  });
+
+  it("should return 403 when the token is invalid", async () => {
+    try {
+      client.pipeline.removePolicy({
+        name: bearerTokenAuthenticationPolicyName
+      });
+      const result = await client.path("/authentication/oauth2/invalid").get();
+      assert.strictEqual(result.status, "403");
+      if (result.status === "403") {
+        assert.strictEqual(result.body.error, "invalid-grant");
+      }
+    } catch (err) {
+      console.log(err);
+      assert.fail(err as string);
+    }
+  });
+});

package/test/integration/authUnion.spec.ts

@@ -0,0 +1,72 @@
+import { assert } from "chai";
+import {
+  bearerTokenAuthenticationPolicyName,
+  PipelinePolicy
+} from "@azure/core-rest-pipeline";
+import { customBearerTokenAuthenticationPolicy } from "../util/customBearerTokenTestingPolicy.js";
+import AuthUnionClientFactory, {
+  AuthUnionClient
+} from "./generated/authentication/union/src/index.js";
+
+describe("AuthUnionClient Rest Client", () => {
+  let client: AuthUnionClient;
+  let policy: PipelinePolicy;
+  const defaultScope = "https://security.microsoft.com/.default";
+
+  function prepareToken() {
+    client = AuthUnionClientFactory(
+      {
+        getToken: async () => Promise.resolve(null)
+      },
+      { allowInsecureConnection: true }
+    );
+    policy = customBearerTokenAuthenticationPolicy({
+      scopes: defaultScope,
+      credential: {
+        getToken: async () => {
+          return {
+            token: defaultScope,
+            expiresOnTimestamp: Date.now()
+          };
+        }
+      }
+    });
+    client.pipeline.removePolicy({
+      name: bearerTokenAuthenticationPolicyName
+    });
+    client.pipeline.addPolicy(policy);
+  }
+
+  function prepareKey() {
+    client = AuthUnionClientFactory(
+      {
+        key: "valid-key"
+      },
+      { allowInsecureConnection: true }
+    );
+  }
+
+  it("should return 204 when the token is valid", async () => {
+    prepareToken();
+    try {
+      const result = await client
+        .path("/authentication/union/validtoken")
+        .get();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      console.log(err);
+      assert.fail(err as string);
+    }
+  });
+
+  it("should return 204 when the key is valid", async () => {
+    prepareKey();
+    try {
+      const result = await client.path("/authentication/union/validkey").get();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      console.log(err);
+      assert.fail(err as string);
+    }
+  });
+});

package/test/integration/collectionFormat.spec.ts

@@ -0,0 +1,74 @@
+import { assert } from "chai";
+import CollectionFormatClientFactory, {
+  buildMultiCollection,
+  CollectionFormatClient
+} from "./generated/parameters/collection-format/src/index.js";
+describe("Collection Format Rest Client", () => {
+  let client: CollectionFormatClient;
+  const colors = ["blue", "red", "green"];
+
+  beforeEach(() => {
+    client = CollectionFormatClientFactory({
+      allowInsecureConnection: true,
+      retryOptions: {
+        maxRetries: 0
+      }
+    });
+  });
+
+  it("should serialize multi format query array parameter", async () => {
+    try {
+      const result = await client.path("/parameters/collection-format/query/multi").get({
+        queryParameters: {
+          colors: buildMultiCollection(colors, "colors")
+        },
+        skipUrlEncoding: true
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should serialize csv format query array parameter", async () => {
+    try {
+      const result = await client.path("/parameters/collection-format/query/csv").get({
+        queryParameters: {
+          colors: colors
+        },
+        skipUrlEncoding: true
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should serialize csv format header array parameter", async () => {
+    try {
+      const result = await client.path("/parameters/collection-format/header/csv").get({
+        headers: {
+          colors: colors as any
+        },
+        skipUrlEncoding: true
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  //   it.skip("should serialize default format query array parameter", async () => {
+  //     try {
+  //       const result = await client.path("/collectionFormat/default").get({
+  //         queryParameters: {
+  //           colors: buildMultiCollection(colors, 'colors')
+  //         },
+  //         skipUrlEncoding: true
+  //       });
+  //       assert.strictEqual(result.status, "200");
+  //     } catch (err) {
+  //       assert.fail(err as string);
+  //     }
+  //   });
+});

package/test/integration/dictionary.spec.ts

@@ -0,0 +1,106 @@
+import { assert } from "chai";
+import { matrix } from "../util/matrix.js";
+import DictClientFactory, {
+  DictClient
+} from "./generated/dictionary/src/index.js";
+
+interface TypeDetail {
+  type: string;
+  defaultValue: any;
+  convertedToFn?: (_: any) => any;
+}
+
+const testedTypes: TypeDetail[] = [
+  {
+    type: "int32",
+    defaultValue: { k1: 1, k2: 2 }
+  },
+  {
+    type: "int64",
+    defaultValue: { k1: Number.MAX_SAFE_INTEGER, k2: Number.MIN_SAFE_INTEGER }
+  },
+  {
+    type: "boolean",
+    defaultValue: { k1: true, k2: false }
+  },
+  {
+    type: "string",
+    defaultValue: { k1: "hello", k2: "" }
+  },
+  {
+    type: "float32",
+    defaultValue: { k1: 42.42 }
+  },
+  {
+    type: "datetime",
+    defaultValue: { k1: "2022-08-26T18:38:00Z" }
+  },
+  {
+    type: "duration",
+    defaultValue: { k1: "P123DT22H14M12.011S" }
+  },
+  {
+    type: "unknown",
+    defaultValue: { k1: 1, k2: "hello", k3: null }
+  },
+  {
+    type: "model",
+    defaultValue: { k1: { property: "hello" }, k2: { property: "world" } }
+  },
+  {
+    type: "model/recursive",
+    defaultValue: {
+      k1: { property: "hello", children: {} },
+      k2: {
+        property: "world",
+        children: { "k2.1": { property: "inner world" } }
+      }
+    }
+  },
+  {
+    type: "nullable-float",
+    defaultValue: { k1: 1.2, k2: 0.5, k3: null }
+  }
+];
+describe("Dictionary Client", () => {
+  let client: DictClient;
+
+  beforeEach(() => {
+    client = DictClientFactory({
+      allowInsecureConnection: true
+    });
+  });
+
+  matrix([testedTypes], async (params: TypeDetail) => {
+    it(`should get a ${params.type} value`, async () => {
+      try {
+        const result = await client
+          .path(`/dictionary/${params.type}` as any)
+          .get();
+        assert.strictEqual(result.status, "200");
+        assert.deepEqual(result.body, params.defaultValue);
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+    it(`should put a ${params.type} value`, async () => {
+      try {
+        let property;
+        if (params.convertedToFn) {
+          property = params.convertedToFn(params.defaultValue);
+        } else {
+          property = params.defaultValue;
+        }
+        const result = await client
+          .path(`/dictionary/${params.type}` as any)
+          .put({
+            body: property
+          });
+        assert.strictEqual(result.status, "204");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+  });
+});

package/test/integration/extensibleEnums.spec.ts

@@ -0,0 +1,61 @@
+import EnumsExtensibleClientFactory, {
+  EnumsExtensibleClient
+} from "./generated/enums/extensible/src/index.js";
+import { assert } from "chai";
+describe("ExtensibleEnums Rest Client", () => {
+  let client: EnumsExtensibleClient;
+
+  beforeEach(() => {
+    client = EnumsExtensibleClientFactory({ allowInsecureConnection: true });
+  });
+
+  it("should get known value", async () => {
+    try {
+      const result = await client
+        .path("/enums/extensible/string/known-value")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body, "Monday");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put known value", async () => {
+    try {
+      const result = await client
+        .path("/enums/extensible/string/known-value")
+        .put({
+          body: JSON.stringify("Monday")
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get unknown value", async () => {
+    try {
+      const result = await client
+        .path("/enums/extensible/string/unknown-value")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body, "Weekend");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put unknown value", async () => {
+    try {
+      const result = await client
+        .path("/enums/extensible/string/unknown-value")
+        .put({
+          body: JSON.stringify("Weekend")
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});

package/test/integration/fixedEnums.spec.ts

@@ -0,0 +1,52 @@
+import { assert } from "chai";
+import EnumsFixedClientFactory, {
+  EnumsFixedClient
+} from "./generated/enums/fixed/src/index.js";
+describe("FixedEnums Rest Client", () => {
+  let client: EnumsFixedClient;
+
+  beforeEach(() => {
+    client = EnumsFixedClientFactory({
+      allowInsecureConnection: true,
+      retryOptions: {
+        maxRetries: 0
+      }
+    });
+  });
+
+  it("should get known value", async () => {
+    try {
+      const result = await client.path("/enums/fixed/string/known-value").get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body, "Monday");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put known value", async () => {
+    try {
+      const result = await client.path("/enums/fixed/string/known-value").put({
+        body: "Monday",
+        contentType: "application/json"
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put unknown value and receives 500", async () => {
+    try {
+      const result = await client
+        .path("/enums/fixed/string/unknown-value")
+        .put({
+          body: "Weekend" as any,
+          contentType: "application/json"
+        });
+      assert.strictEqual(result.status, "500");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});