@azure-tools/typespec-ts 0.11.0 → 0.12.0-alpha.20230501.1

package/test/integration/modelPropertyOptional.spec.ts

@@ -1,13 +1,13 @@
-import ModelsPropertyOptionalClientFactory, {
-  ModelsPropertyOptionalClient
+import TypePropertyOptionalClientFactory, {
+  TypePropertyOptionalClient
 } from "./generated/models/propertyOptional/src/index.js";
 import { assert } from "chai";
 
 describe("ModelsPropertyOptional Rest Client", () => {
-  let client: ModelsPropertyOptionalClient;
+  let client: TypePropertyOptionalClient;
 
   beforeEach(() => {
-    client = ModelsPropertyOptionalClientFactory({
+    client = TypePropertyOptionalClientFactory({
       allowInsecureConnection: true
     });
   });
@@ -15,7 +15,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get all string", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/string/all")
+        .path("/type/property/optional/string/all")
         .get();
       assert.strictEqual(result.status, "200");
       assert.strictEqual(result.body.property, "hello");
@@ -27,7 +27,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get default string", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/string/default")
+        .path("/type/property/optional/string/default")
         .get();
       assert.strictEqual(result.status, "200");
     } catch (err) {
@@ -38,7 +38,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put all string", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/string/all")
+        .path("/type/property/optional/string/all")
         .put({
           body: { property: "hello" }
         });
@@ -51,7 +51,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put default string", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/string/default")
+        .path("/type/property/optional/string/default")
         .put({ body: {} });
       assert.strictEqual(result.status, "204");
     } catch (err) {
@@ -62,7 +62,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get all bytes", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/bytes/all")
+        .path("/type/property/optional/bytes/all")
         .get();
       assert.strictEqual(result.status, "200");
       assert.strictEqual(result.body.property, "aGVsbG8sIHdvcmxkIQ==");
@@ -74,7 +74,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get default bytes", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/bytes/default")
+        .path("/type/property/optional/bytes/default")
         .get();
       assert.strictEqual(result.status, "200");
     } catch (err) {
@@ -85,7 +85,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put all bytes", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/bytes/all")
+        .path("/type/property/optional/bytes/all")
         .put({
           body: { property: "aGVsbG8sIHdvcmxkIQ==" }
         });
@@ -98,7 +98,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put default bytes", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/bytes/default")
+        .path("/type/property/optional/bytes/default")
         .put({
           body: {}
         });
@@ -111,7 +111,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get all datetime", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/datetime/all")
+        .path("/type/property/optional/datetime/all")
         .get();
       assert.strictEqual(result.status, "200");
       assert.strictEqual(result.body.property, "2022-08-26T18:38:00Z");
@@ -123,7 +123,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get default datetime", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/datetime/default")
+        .path("/type/property/optional/datetime/default")
         .get();
       assert.strictEqual(result.status, "200");
     } catch (err) {
@@ -134,7 +134,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put all datetime", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/datetime/all")
+        .path("/type/property/optional/datetime/all")
         .put({
           body: { property: "2022-08-26T18:38:00Z" }
         });
@@ -147,7 +147,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put default datetime", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/datetime/default")
+        .path("/type/property/optional/datetime/default")
         .put({
           body: {}
         });
@@ -160,7 +160,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get all duration", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/duration/all")
+        .path("/type/property/optional/duration/all")
         .get();
       assert.strictEqual(result.status, "200");
       assert.strictEqual(result.body.property, "P123DT22H14M12.011S");
@@ -172,7 +172,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get default duration", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/duration/default")
+        .path("/type/property/optional/duration/default")
         .get();
       assert.strictEqual(result.status, "200");
     } catch (err) {
@@ -183,7 +183,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put all duration", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/duration/all")
+        .path("/type/property/optional/duration/all")
         .put({
           body: { property: "P123DT22H14M12.011S" }
         });
@@ -196,7 +196,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put default duration", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/duration/default")
+        .path("/type/property/optional/duration/default")
         .put({
           body: {}
         });
@@ -209,7 +209,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get all collections bytes", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/collections/bytes/all")
+        .path("/type/property/optional/collections/bytes/all")
         .get();
       assert.strictEqual(result.status, "200");
       assert.strictEqual(result.body.property?.length, 2);
@@ -221,7 +221,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get default collections bytes", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/collections/bytes/default")
+        .path("/type/property/optional/collections/bytes/default")
         .get();
       assert.strictEqual(result.status, "200");
     } catch (err) {
@@ -232,7 +232,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put all collections bytes", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/collections/bytes/all")
+        .path("/type/property/optional/collections/bytes/all")
         .put({
           body: { property: ["aGVsbG8sIHdvcmxkIQ==", "aGVsbG8sIHdvcmxkIQ=="] }
         });
@@ -245,7 +245,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put default collections bytes", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/collections/bytes/default")
+        .path("/type/property/optional/collections/bytes/default")
         .put({
           body: {}
         });
@@ -258,7 +258,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get all collections model", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/collections/model/all")
+        .path("/type/property/optional/collections/model/all")
         .get();
       assert.strictEqual(result.status, "200");
       assert.strictEqual(result.body.property?.length, 2);
@@ -270,7 +270,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get default collections model", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/collections/model/default")
+        .path("/type/property/optional/collections/model/default")
         .get();
       assert.strictEqual(result.status, "200");
     } catch (err) {
@@ -281,7 +281,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put all collections model", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/collections/model/all")
+        .path("/type/property/optional/collections/model/all")
         .put({
           body: { property: [{ property: "hello" }, { property: "world" }] }
         });
@@ -294,7 +294,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put default collections model", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/collections/model/default")
+        .path("/type/property/optional/collections/model/default")
         .put({
           body: {}
         });
@@ -307,7 +307,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get models that will return all properties in the model", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/requiredAndOptional/all")
+        .path("/type/property/optional/requiredAndOptional/all")
         .get();
       assert.strictEqual(result.status, "200");
       assert.strictEqual(result.body.optionalProperty, "hello");
@@ -320,7 +320,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should get models that will return only the required properties", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/requiredAndOptional/requiredOnly")
+        .path("/type/property/optional/requiredAndOptional/requiredOnly")
         .get();
       assert.strictEqual(result.status, "200");
       assert.strictEqual(result.body.requiredProperty, 42);
@@ -332,7 +332,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put a body with all properties present", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/requiredAndOptional/all")
+        .path("/type/property/optional/requiredAndOptional/all")
         .put({
           body: {
             requiredProperty: 42,
@@ -348,7 +348,7 @@ describe("ModelsPropertyOptional Rest Client", () => {
   it("should put a body with only required properties", async () => {
     try {
       const result = await client
-        .path("/models/properties/optional/requiredAndOptional/requiredOnly")
+        .path("/type/property/optional/requiredAndOptional/requiredOnly")
         .put({
           body: {
             requiredProperty: 42

package/test/integration/modelPropertyType.spec.ts

@@ -1,5 +1,5 @@
-import ModelsPropertyTypesClientFactory, {
-  ModelsPropertyTypesClient
+import TypePropertyValueTypesClientFactory, {
+  TypePropertyValueTypesClient
 } from "./generated/models/propertyTypes/src/index.js";
 import { assert } from "chai";
 import { matrix } from "../util/matrix.js";
@@ -74,10 +74,10 @@ const testedTypes: TypeDetail[] = [
   }
 ];
 describe("ModelsPropertyTypesClient Rest Client", () => {
-  let client: ModelsPropertyTypesClient;
+  let client: TypePropertyValueTypesClient;
 
   beforeEach(() => {
-    client = ModelsPropertyTypesClientFactory({
+    client = TypePropertyValueTypesClientFactory({
       allowInsecureConnection: true
     });
   });
@@ -86,7 +86,7 @@ describe("ModelsPropertyTypesClient Rest Client", () => {
     it(`should get a ${params.type} value`, async () => {
       try {
         const result = await client
-          .path(`/models/properties/types/${params.type}` as any)
+          .path(`/type/property/value-types/${params.type}` as any)
           .get();
         assert.strictEqual(result.status, "200");
         assert.deepEqual(result.body.property, params.defaultValue);
@@ -104,7 +104,7 @@ describe("ModelsPropertyTypesClient Rest Client", () => {
           property = params.defaultValue;
         }
         const result = await client
-          .path(`/models/properties/types/${params.type}` as any)
+          .path(`/type/property/value-types/${params.type}` as any)
           .put({
             body: {
               property

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

@@ -0,0 +1,102 @@
+import { assert } from "chai";
+import ProjectionClientFactory, {
+  ProjectionClient
+} from "./generated/projection/src/index.js";
+describe("Projected Name Rest Client", () => {
+  let client: ProjectionClient;
+
+  beforeEach(() => {
+    client = ProjectionClientFactory({
+      allowInsecureConnection: true,
+      retryOptions: {
+        maxRetries: 0
+      }
+    });
+  });
+
+  it("should respect json projection", async () => {
+    try {
+      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);
+    }
+  });
+
+  it("should not respect client projection", async () => {
+    try {
+      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);
+    }
+  });
+
+  it("should not respect language projection", async () => {
+    try {
+      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,86 @@
 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 client1: ServiceDrivenOldClient;
 
   beforeEach(() => {
-    client = ResiliencyDevDrivenClientFactory({
+    client1 = ServiceDrivenOldClientFactory("v1", {
       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");
-    });
+  let client2: ServiceDrivenNewClient;
 
-    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");
+  beforeEach(() => {
+    client2 = ServiceDrivenNewClientFactory("v2", {
+      allowInsecureConnection: true
     });
   });
 
-  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");
+  describe("resiliency with service driven", () => {
+    it("should work with none parameter", async () => {
+      const result1 = await client1
+        .path("/add-optional-param/from-none")
+        .head();
+
+      assert.equal(result1.status, "204");
+      const result2 = await client2.path("/add-optional-param/from-none").head({
+        queryParameters: {
+          "new-parameter": "new"
+        }
+      });
+
+      assert.equal(result2.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 optional parameter", async () => {
+      const result1 = await client1
+        .path("/add-optional-param/from-one-optional")
+        .get({
+          queryParameters: {
+            parameter: "optional"
+          }
+        });
+      assert.equal(result1.status, "204");
+      const result2 = await client2
+        .path("/add-optional-param/from-one-optional")
+        .get({
+          queryParameters: {
+            parameter: "optional",
+            "new-parameter": "new"
+          }
+        });
+      assert.equal(result2.status, "204");
     });
+
+    it("should work with one required parameter", async () => {
+      const result1 = await client1
+        .path("/add-optional-param/from-one-required")
+        .get({
+          queryParameters: {
+            parameter: "required"
+          }
+        });
+      assert.equal(result1.status, "204");
+      const result2 = await client2
+        .path("/add-optional-param/from-one-required")
+        .get({
+          queryParameters: {
+            parameter: "required",
+            "new-parameter": "new"
+          }
+        });
+      assert.equal(result2.status, "204");
+    });
+  });
+
+  it("should work with add operation", async () => {
+    const result2 = await client2.path("/add-operation").delete()
+    assert.equal(result2.status, "204");
   });
 });

package/test/integration/server.spec.ts

@@ -0,0 +1,59 @@
+import { assert } from "chai";
+import SingleParamInServerPathClientFactory, {
+  SingleParamInServerPathClient
+} from "./generated/server/path/single/src/index.js";
+import MultipleParamInServerPathClientFactory, {
+  MultipleParamInServerPathClient
+} from "./generated/server/path/multiple/src/index.js";
+describe("SingleParamInServerPath Rest Client", () => {
+  let client: SingleParamInServerPathClient;
+
+  beforeEach(() => {
+    client = SingleParamInServerPathClientFactory("http://localhost:3000", {
+      allowInsecureConnection: true,
+      retryOptions: {
+        maxRetries: 0
+      }
+    });
+  });
+
+  it("should work with no param", async () => {
+    try {
+      const result = await client.path("/server/path/single/myOp").head();
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});
+
+describe("MultipleParamInServerPath Rest Client", () => {
+  let client: MultipleParamInServerPathClient;
+
+  beforeEach(() => {
+    client = MultipleParamInServerPathClientFactory("http://localhost:3000", {
+      allowInsecureConnection: true,
+      retryOptions: {
+        maxRetries: 0
+      }
+    });
+  });
+
+  it("should work with no param", async () => {
+    try {
+      const result = await client.path("/").get();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should work with param", async () => {
+    try {
+      const result = await client.path("/{keyword}", "test").get();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});