@azure-tools/typespec-ts 0.11.0

package/test/integration/resiliencyDpgCustomization.spec.ts

@@ -0,0 +1,52 @@
+import { assert } from "chai";
+import ResiliencyDevDrivenClientFactory, {
+  ResiliencyDevDrivenClient
+} from "./generated/resiliency/devDriven/src/index.js";
+describe("ResiliencyDevDrivenClient Rest Client", () => {
+  let client: ResiliencyDevDrivenClient;
+
+  beforeEach(() => {
+    client = ResiliencyDevDrivenClientFactory({
+      allowInsecureConnection: true
+    });
+  });
+
+  describe("dpg customization with raw model", () => {
+    // comment out these test cases because the server is not ready
+    // https://github.com/Azure/autorest.typescript/issues/1535
+    xit("should get model", async () => {
+      const result = await client
+        .path("/resiliency/devdriven/customization/model/{mode}", "raw")
+        .get();
+      console.log(result);
+      assert.equal(result.status, "200");
+      assert.equal(result.body.received, "raw");
+    });
+
+    xit("should post model", async () => {
+      const result = await client
+        .path("/resiliency/devdriven/customization/model/{mode}", "raw")
+        .post({ body: { hello: "world!" } });
+      assert.equal(result.status, "200");
+      assert.equal(result.body.received, "raw");
+    });
+  });
+
+  describe("dpg customization with model model", () => {
+    xit("should get model", async () => {
+      const result = await client
+        .path("/resiliency/devdriven/customization/model/{mode}", "model")
+        .get();
+      assert.equal(result.status, "200");
+      assert.equal(result.body.received, "model");
+    });
+
+    xit("should post model", async () => {
+      const result = await client
+        .path("/resiliency/devdriven/customization/model/{mode}", "model")
+        .post({ body: { hello: "world!" } });
+      assert.equal(result.status, "200");
+      assert.equal(result.body.received, "model");
+    });
+  });
+});

package/test/integration/specialWords.spec.ts

@@ -0,0 +1,73 @@
+import SpecialWordsClientFactory, {
+  DerivedModel,
+  SpecialWordsClient
+} from "./generated/specialWords/src/index.js";
+import { assert } from "chai";
+describe("HelloClient Rest Client", () => {
+  let client: SpecialWordsClient;
+  const modelValue: DerivedModel = {
+    "model.kind": "derived",
+    "derived.name": "my.name",
+    for: "value"
+  };
+
+  beforeEach(() => {
+    client = SpecialWordsClientFactory({ allowInsecureConnection: true });
+  });
+
+  it("should get special words for operation `for`", async () => {
+    try {
+      const result = await client.path("/special-words/operation/for").get();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get special words for parameter `if`", async () => {
+    try {
+      const result = await client.path("/special-words/parameter/if").get({
+        headers: {
+          if: "weekend"
+        }
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get special words for parameter `filter`", async () => {
+    try {
+      const result = await client.path("/special-words/parameter/filter").get({
+        queryParameters: {
+          filter: "abc*."
+        }
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get special words for model", async () => {
+    try {
+      const result = await client.path("/special-words/model/get").get();
+      assert.strictEqual(result.status, "200");
+      assert.deepEqual(result.body, modelValue);
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put special words for model", async () => {
+    try {
+      const result = await client.path("/special-words/model/put").put({
+        body: modelValue
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});

package/test/integration/unions.spec.ts

@@ -0,0 +1,69 @@
+import UnionsClientFactory, {
+  UnionsClient
+} from "./generated/unions/src/index.js";
+import { assert } from "chai";
+describe("UnionsClient Rest Client", () => {
+  let client: UnionsClient;
+
+  beforeEach(() => {
+    client = UnionsClientFactory({ allowInsecureConnection: true });
+  });
+
+  it("should post input simple number union", async () => {
+    try {
+      const result = await client.path("/unions/int").post({
+        body: {
+          simpleUnion: 1
+        }
+      });
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should post simple number array union", async () => {
+    try {
+      const result = await client.path("/unions/int-array").post({
+        body: {
+          simpleUnion: [1, 2]
+        }
+      });
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should post named union model1", async () => {
+    try {
+      const result = await client.path("/unions/model1").post({
+        body: {
+          namedUnion: {
+            name: "model1",
+            prop1: 1
+          }
+        }
+      });
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should post named union model2", async () => {
+    try {
+      const result = await client.path("/unions/model2").post({
+        body: {
+          namedUnion: {
+            name: "model2",
+            prop2: 2
+          }
+        }
+      });
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});

package/test/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../tsconfig.test.json",
+  "include": ["./**/*.ts", "./**/**/*.ts"]
+}

package/test/unit/azureCoreOperationsGenerator.spec.ts

@@ -0,0 +1,71 @@
+import { assert } from "chai";
+import {
+  emitParameterFromCadl,
+  emitResponsesFromCadl
+} from "./util/emitUtil.js";
+
+describe("typespec-azure-core: operation templates", () => {
+  it("ResourceCreateWithServiceProvidedName", async () => {
+    const { parameters, responses } = await compileResourceOperation(
+      `@test op create is Azure.Core.ResourceCreateWithServiceProvidedName<TestModel, Customizations>;`
+    );
+    assert.ok(parameters);
+    assert.ok(responses);
+  });
+});
+
+async function compileResourceOperation(code: string) {
+  const content = `
+    #suppress "@azure-tools/typespec-azure-core/documentation-required" "for test"
+    model TestModel {
+      @key
+      @visibility("read")
+      @segment("test")
+      name: string;
+      value: int32;
+    }
+
+    #suppress "@azure-tools/typespec-azure-core/documentation-required" "for test"
+    model CustomParameters {
+      #suppress "@azure-tools/typespec-azure-core/casing-style" "for test"
+      @header
+      "x-ms-foobar": string;
+
+      @query
+      nameHint: string;
+
+      customBodyParam: string;
+    }
+
+    #suppress "@azure-tools/typespec-azure-core/documentation-required" "for test"
+    model CustomResponseProperties {
+      #suppress "@azure-tools/typespec-azure-core/documentation-required" "for test"
+      #suppress "@azure-tools/typespec-azure-core/casing-style" "for test"
+      @header
+      "x-ms-response-id": int32;
+      #suppress "@azure-tools/typespec-azure-core/casing-style" "for test"
+      @doc("A timestamp when this job or item was created (in unix epochs).")
+      @visibility("read")
+      created_at?: int32;
+    }
+
+    #suppress "@azure-tools/typespec-azure-core/documentation-required" "for test"
+    model Customizations {
+      parameters: CustomParameters;
+      response: CustomResponseProperties;
+    }
+
+    #suppress "@azure-tools/typespec-azure-core/documentation-required" "for test"
+    model CustomizationsNoBody {
+      parameters: OmitProperties<CustomParameters, "customBodyParam">;
+      response: CustomResponseProperties;
+    }
+
+    #suppress "@azure-tools/typespec-azure-core/documentation-required" "for test"
+    ${code}
+    `;
+  const parameters = await emitParameterFromCadl(content, true);
+  const responses = await emitResponsesFromCadl(content, true);
+
+  return { parameters, responses };
+}

package/test/unit/clientDefinitionGenerator.spec.ts

@@ -0,0 +1,73 @@
+import { assert } from "chai";
+import { emitClientDefinitionFromCadl } from "./util/emitUtil.js";
+import { assertEqualContent } from "./util/testUtil.js";
+
+describe("Client definition generation", () => {
+  it("should generate method-level parameter", async () => {
+    const clientDef = await emitClientDefinitionFromCadl(
+      `
+      @route("/{id}")
+      @doc("This is the longer description")
+      op read(@path id: string): {};
+      `
+    );
+    assert.ok(clientDef);
+    // console.log(clientDef);
+    assertEqualContent(
+      clientDef?.content!,
+      `
+      import { ReadParameters } from "./parameters";
+      import { Read200Response } from "./responses";
+      import { Client, StreamableMethod } from "@azure-rest/core-client";
+
+      export interface Read {
+          /** This is the longer description */
+          get(options?: ReadParameters): StreamableMethod<Read200Response>;
+      }
+
+      export interface Routes {
+          /** Resource for '/\\{id\\}' has methods for the following verbs: get */
+          (path: "/{id}", id: string): Read;
+      }
+      
+      export type testClient = Client & {
+              path: Routes;
+      };
+    `
+    );
+  });
+
+  it("should normalize method-level parameter", async () => {
+    const clientDef = await emitClientDefinitionFromCadl(
+      `
+      @route("/{TransactionID}")
+      @doc("This is the longer description")
+      op read(@path TransactionID: string): {};
+      `
+    );
+    assert.ok(clientDef);
+    // console.log(clientDef);
+    assertEqualContent(
+      clientDef?.content!,
+      `
+      import { ReadParameters } from "./parameters";
+      import { Read200Response } from "./responses";
+      import { Client, StreamableMethod } from "@azure-rest/core-client";
+
+      export interface Read {
+          /** This is the longer description */
+          get(options?: ReadParameters): StreamableMethod<Read200Response>;
+      }
+
+      export interface Routes {
+          /** Resource for '/\\{TransactionID\\}' has methods for the following verbs: get */
+          (path: "/{TransactionID}", transactionID: string): Read;
+      }
+      
+      export type testClient = Client & {
+              path: Routes;
+      };
+    `
+    );
+  });
+});