@azure-tools/typespec-ts 0.12.0 → 0.13.0

package/test/integration/modelUsage.spec.ts

@@ -1,20 +1,20 @@
-import ModelsUsageClientFactory, {
-  ModelsUsageClient
+import TypeModelUsageClientFactory, {
+  TypeModelUsageClient
 } from "./generated/models/usage/src/index.js";
 import { assert } from "chai";
 describe("ModelsUsageClient Rest Client", () => {
-  let client: ModelsUsageClient;
+  let client: TypeModelUsageClient;
   const body = {
     requiredProp: "example-value"
   };
 
   beforeEach(() => {
-    client = ModelsUsageClientFactory({ allowInsecureConnection: true });
+    client = TypeModelUsageClientFactory({ allowInsecureConnection: true });
   });
 
   it("should post input model correctly", async () => {
     try {
-      const result = await client.path("/models/usage/input").post({
+      const result = await client.path("/type/model/usage/input").post({
         body
       });
       assert.strictEqual(result.status, "204");
@@ -25,7 +25,7 @@ describe("ModelsUsageClient Rest Client", () => {
 
   it("should get output model correctly", async () => {
     try {
-      const result = await client.path("/models/usage/output").get();
+      const result = await client.path("/type/model/usage/output").get();
       assert.strictEqual(result.status, "200");
       assert.deepEqual(result.body, body);
     } catch (err) {
@@ -36,7 +36,7 @@ describe("ModelsUsageClient Rest Client", () => {
   it("should get output model correctly", async () => {
     try {
       const result = await client
-        .path("/models/usage/input-output")
+        .path("/type/model/usage/input-output")
         .post({ body });
       assert.strictEqual(result.status, "200");
       assert.deepEqual(result.body, body);

package/test/integration/projection.spec.ts

@@ -16,11 +16,13 @@ describe("Projected Name Rest Client", () => {
 
   it("should respect json projection", async () => {
     try {
-      const result = await client.path("/projection/json").post({
-        body: {
-          codegen: "DPG"
-        }
-      });
+      const result = await client
+        .path("/projection/projected-name/property/json")
+        .post({
+          body: {
+            wireName: true
+          }
+        });
       assert.strictEqual(result.status, "204");
     } catch (err) {
       assert.fail(err as string);
@@ -29,11 +31,13 @@ describe("Projected Name Rest Client", () => {
 
   it("should not respect client projection", async () => {
     try {
-      const result = await client.path("/projection/client").post({
-        body: {
-          builtfrom: "DPG"
-        }
-      });
+      const result = await client
+        .path("/projection/projected-name/property/client")
+        .post({
+          body: {
+            defaultName: true
+          }
+        });
       assert.strictEqual(result.status, "204");
     } catch (err) {
       assert.fail(err as string);
@@ -42,11 +46,54 @@ describe("Projected Name Rest Client", () => {
 
   it("should not respect language projection", async () => {
     try {
-      const result = await client.path("/projection/language").post({
-        body: {
-          wasMadeFor: "customers"
-        }
-      });
+      const result = await client
+        .path("/projection/projected-name/property/language")
+        .post({
+          body: {
+            defaultName: true
+          }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should not respect language projection", async () => {
+    try {
+      const result = await client
+        .path("/projection/projected-name/property/json-and-client")
+        .post({
+          body: {
+            wireName: true
+          }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should not respect operation projection", async () => {
+    try {
+      const result = await client
+        .path("/projection/projected-name/operation")
+        .post();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should not respect operation projection", async () => {
+    try {
+      const result = await client
+        .path("/projection/projected-name/parameter")
+        .post({
+          queryParameters: {
+            "default-name": "true"
+          }
+        });
       assert.strictEqual(result.status, "204");
     } catch (err) {
       assert.fail(err as string);

package/test/integration/resiliencyDpgCustomization.spec.ts

@@ -1,52 +1,147 @@
 import { assert } from "chai";
-import ResiliencyDevDrivenClientFactory, {
-  ResiliencyDevDrivenClient
-} from "./generated/resiliency/devDriven/src/index.js";
+import ServiceDrivenOldClientFactory, {
+  ServiceDrivenOldClient
+} from "./generated/resiliency/srvDriven1/src/index.js";
+import ServiceDrivenNewClientFactory, {
+  ServiceDrivenNewClient
+} from "./generated/resiliency/srvDriven2/src/index.js";
 describe("ResiliencyDevDrivenClient Rest Client", () => {
-  let client: ResiliencyDevDrivenClient;
+  let client11: ServiceDrivenOldClient;
+  let client12: ServiceDrivenOldClient;
+  let client21: ServiceDrivenNewClient;
+  let client22: ServiceDrivenNewClient;
 
   beforeEach(() => {
-    client = ResiliencyDevDrivenClientFactory({
-      allowInsecureConnection: true
+    client11 = ServiceDrivenOldClientFactory("v1", {
+      allowInsecureConnection: true,
+      apiVersion: "v1"
+    });
+    client12 = ServiceDrivenOldClientFactory("v2", {
+      allowInsecureConnection: true,
+      apiVersion: "v1"
+    });
+    client21 = ServiceDrivenNewClientFactory("v2", {
+      allowInsecureConnection: true,
+      apiVersion: "v1"
+    });
+    client22 = ServiceDrivenNewClientFactory("v2", {
+      allowInsecureConnection: true,
+      apiVersion: "v2"
     });
   });
 
-  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("resiliency with service driven", () => {
+    it("should work with none parameter", async () => {
+      const result11 = await client11
+        .path("/add-optional-param/from-none")
+        .head();
+
+      assert.equal(result11.status, "204");
+      const result12 = await client12
+      .path("/add-optional-param/from-none")
+      .head();
+
+      assert.equal(result12.status, "204");
+      const result21 = await client21.path("/add-optional-param/from-none").head({
+        queryParameters: {
+          "new-parameter": "new"
+        }
+      });
+
+      assert.equal(result21.status, "204");
+      const result22 = await client22.path("/add-optional-param/from-none").head({
+        queryParameters: {
+          "new-parameter": "new"
+        }
+      });
+
+      assert.equal(result22.status, "204");
     });
-  });
 
-  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");
+    it("should work with one optional parameter", async () => {
+      const result11 = await client11
+        .path("/add-optional-param/from-one-optional")
+        .get({
+          queryParameters: {
+            parameter: "optional"
+          }
+        });
+      assert.equal(result11.status, "204");
+      const result12 = await client12
+      .path("/add-optional-param/from-one-optional")
+      .get({
+        queryParameters: {
+          parameter: "optional"
+        }
+      });
+      assert.equal(result12.status, "204");
+      const result21 = await client21
+        .path("/add-optional-param/from-one-optional")
+        .get({
+          queryParameters: {
+            parameter: "optional",
+            "new-parameter": "new"
+          }
+        });
+      assert.equal(result21.status, "204");
+      const result22 = await client22
+      .path("/add-optional-param/from-one-optional")
+      .get({
+        queryParameters: {
+          parameter: "optional",
+          "new-parameter": "new"
+        }
+      });
+      assert.equal(result22.status, "204");
     });
 
-    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");
+    it("should work with one required parameter", async () => {
+      const result11 = await client11
+        .path("/add-optional-param/from-one-required")
+        .get({
+          queryParameters: {
+            parameter: "required"
+          }
+        });
+      assert.equal(result11.status, "204");
+      const result12 = await client12
+      .path("/add-optional-param/from-one-required")
+      .get({
+        queryParameters: {
+          parameter: "required"
+        }
+      });
+    assert.equal(result12.status, "204");
+      const result21 = await client21
+        .path("/add-optional-param/from-one-required")
+        .get({
+          queryParameters: {
+            parameter: "required",
+            "new-parameter": "new"
+          }
+        });
+      assert.equal(result21.status, "204");
+      const result22 = await client22
+      .path("/add-optional-param/from-one-required")
+      .get({
+        queryParameters: {
+          parameter: "required",
+          "new-parameter": "new"
+        }
+      });
+    assert.equal(result22.status, "204");
+    });
+  });
+
+  it("should work with add operation", async () => {
+    const client122 = ServiceDrivenOldClientFactory("v2", {
+      allowInsecureConnection: true,
+      apiVersion: "v2"
     });
+    const result122 = await client122.pathUnchecked("/add-operation").delete();
+    assert.equal(result122.status, "204");
+    const result22 = await client22.path("/add-operation").delete()
+    assert.equal(result22.status, "204");
   });
 });

package/test/integration/spreadParameters.spec.ts

@@ -0,0 +1,82 @@
+import ParametersSpreadClientFactory, {
+  ParametersSpreadClient
+} from "./generated/parameters/spread/src/index.js";
+import { assert } from "chai";
+describe("HelloClient Rest Client", () => {
+  let client: ParametersSpreadClient;
+
+  beforeEach(() => {
+    client = ParametersSpreadClientFactory({ allowInsecureConnection: true });
+  });
+
+  it("should spread named model", async () => {
+    try {
+      const result = await client
+        .path("/parameters/spread/model/request-body")
+        .put({
+          body: {
+            name: "foo"
+          }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should spread alias with only body param", async () => {
+    try {
+      const result = await client
+        .path("/parameters/spread/alias/request-body")
+        .put({
+          body: {
+            name: "foo"
+          }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should spread alias with mixed params", async () => {
+    try {
+      const result = await client
+        .path("/parameters/spread/alias/request-parameter/{id}", "1")
+        .put({
+          body: {
+            name: "foo"
+          },
+          headers: {
+            "x-ms-test-header": "bar"
+          }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should spread alias with more than 5 params", async () => {
+    try {
+      const result = await client
+        .path("/parameters/spread/alias/multiple-parameters/{id}", "1")
+        .put({
+          body: {
+            prop1: "foo1",
+            prop2: "foo2",
+            prop3: "foo3",
+            prop4: "foo4",
+            prop5: "foo5",
+            prop6: "foo6"
+          },
+          headers: {
+            "x-ms-test-header": "bar"
+          }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});

package/test/integration/unions.spec.ts

@@ -11,7 +11,7 @@ describe("UnionsClient Rest Client", () => {
 
   it("should post input simple number union", async () => {
     try {
-      const result = await client.path("/unions/int").post({
+      const result = await client.path("/type/union/int").post({
         body: {
           simpleUnion: 1
         }
@@ -24,7 +24,7 @@ describe("UnionsClient Rest Client", () => {
 
   it("should post simple number array union", async () => {
     try {
-      const result = await client.path("/unions/int-array").post({
+      const result = await client.path("/type/union/int-array").post({
         body: {
           simpleUnion: [1, 2]
         }
@@ -37,7 +37,7 @@ describe("UnionsClient Rest Client", () => {
 
   it("should post named union model1", async () => {
     try {
-      const result = await client.path("/unions/model1").post({
+      const result = await client.path("/type/union/model1").post({
         body: {
           namedUnion: {
             name: "model1",
@@ -53,7 +53,7 @@ describe("UnionsClient Rest Client", () => {
 
   it("should post named union model2", async () => {
     try {
-      const result = await client.path("/unions/model2").post({
+      const result = await client.path("/type/union/model2").post({
         body: {
           namedUnion: {
             name: "model2",

package/test/unit/apiVersion.spec.ts

@@ -130,12 +130,13 @@ const buildDefaultReturn = (hasDefault: boolean) => {
     : `options.apiVersion = options.apiVersion ?? "2022-05-15-preview";`;
   return `
   import { getClient, ClientOptions } from "@azure-rest/core-client";
+  import { logger } from "./logger";
   import { testClient } from "./clientDefinitions";
   
   /**
    * Initialize a new instance of \`testClient\`
-   * @param endpoint type: string, The endpoint to use.
-   * @param options type: ClientOptions, the parameter for all optional parameters
+   * @param endpoint - The endpoint to use.
+   * @param options - the parameter for all optional parameters
    */
   export default function createClient(
     endpoint: string,
@@ -154,6 +155,9 @@ const buildDefaultReturn = (hasDefault: boolean) => {
       userAgentOptions: {
         userAgentPrefix,
       },
+      loggingOptions: {
+        logger: options.loggingOptions?.logger ?? logger.info
+      },
     };
   
     const client = getClient(baseUrl, options) as testClient;
@@ -165,6 +169,7 @@ const buildDefaultReturn = (hasDefault: boolean) => {
 const buildPathReturn_WithDefault = () => {
   return `
   import { getClient, ClientOptions } from "@azure-rest/core-client";
+  import { logger } from "./logger";
   import { testClient } from "./clientDefinitions";
 
   export interface testClientOptions extends ClientOptions {
@@ -173,8 +178,8 @@ const buildPathReturn_WithDefault = () => {
   
   /**
    * Initialize a new instance of \`testClient\`
-   * @param endpoint type: string, The endpoint to use.
-   * @param options type: testClientOptions, the parameter for all optional parameters
+   * @param endpoint - The endpoint to use.
+   * @param options - the parameter for all optional parameters
    */
   export default function createClient(
     endpoint: string,
@@ -193,6 +198,9 @@ const buildPathReturn_WithDefault = () => {
       userAgentOptions: {
         userAgentPrefix,
       },
+      loggingOptions: {
+        logger: options.loggingOptions?.logger ?? logger.info
+      },
     };
   
     const client = getClient(baseUrl, options) as testClient;
@@ -204,13 +212,14 @@ const buildPathReturn_WithDefault = () => {
 const buildPathReturn_WithoutDefault = () => {
   return `
   import { getClient, ClientOptions } from "@azure-rest/core-client";
+  import { logger } from "./logger";
   import { testClient } from "./clientDefinitions";
   
   /**
    * Initialize a new instance of \`testClient\`
-   * @param endpoint type: string, The endpoint to use.
-   * @param apiVersion type: string, Api Version Possible values: 2022-05-15-preview
-   * @param options type: ClientOptions, the parameter for all optional parameters
+   * @param endpoint - The endpoint to use.
+   * @param apiVersion - Api Version Possible values: 2022-05-15-preview
+   * @param options - the parameter for all optional parameters
    */
   export default function createClient(
     endpoint: string,
@@ -229,6 +238,9 @@ const buildPathReturn_WithoutDefault = () => {
       userAgentOptions: {
         userAgentPrefix,
       },
+      loggingOptions: {
+        logger: options.loggingOptions?.logger ?? logger.info
+      },
     };
   
     const client = getClient(baseUrl, options) as testClient;