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

package/test/integration/modelPropertyType.spec.ts

@@ -0,0 +1,119 @@
+import ModelsPropertyTypesClientFactory, {
+  ModelsPropertyTypesClient
+} from "./generated/models/propertyTypes/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: "boolean",
+    defaultValue: true
+  },
+  {
+    type: "string",
+    defaultValue: "hello"
+  },
+  {
+    type: "bytes",
+    defaultValue: "aGVsbG8sIHdvcmxkIQ=="
+  },
+  {
+    type: "int",
+    defaultValue: 42
+  },
+  {
+    type: "float",
+    defaultValue: 42.42
+  },
+  {
+    type: "datetime",
+    defaultValue: "2022-08-26T18:38:00Z",
+    convertedToFn: (value: string) => new Date(value).toISOString()
+  },
+  {
+    type: "duration",
+    defaultValue: "P123DT22H14M12.011S"
+  },
+  {
+    type: "enum",
+    defaultValue: "ValueOne"
+  },
+  {
+    type: "extensible-enum",
+    defaultValue: "UnknownValue"
+  },
+  {
+    type: "model",
+    defaultValue: { property: "hello" }
+  },
+  {
+    type: "collections/string",
+    defaultValue: ["hello", "world"]
+  },
+  {
+    type: "collections/int",
+    defaultValue: [1, 2]
+  },
+  {
+    type: "collections/model",
+    defaultValue: [{ property: "hello" }, { property: "world" }]
+  },
+  {
+    type: "dictionary/string",
+    defaultValue: { k1: "hello", k2: "world" }
+  },
+  {
+    type: "never",
+    defaultValue: undefined
+  }
+];
+describe("ModelsPropertyTypesClient Rest Client", () => {
+  let client: ModelsPropertyTypesClient;
+
+  beforeEach(() => {
+    client = ModelsPropertyTypesClientFactory({
+      allowInsecureConnection: true
+    });
+  });
+
+  matrix([testedTypes], async (params: TypeDetail) => {
+    it(`should get a ${params.type} value`, async () => {
+      try {
+        const result = await client
+          .path(`/models/properties/types/${params.type}` as any)
+          .get();
+        assert.strictEqual(result.status, "200");
+        assert.deepEqual(result.body.property, 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(`/models/properties/types/${params.type}` as any)
+          .put({
+            body: {
+              property
+            }
+          });
+        assert.strictEqual(result.status, "204");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+  });
+});

package/test/integration/modelUsage.spec.ts

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

package/test/integration/projection.spec.ts

@@ -0,0 +1,55 @@
+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/json").post({
+        body: {
+          codegen: "DPG"
+        }
+      });
+      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/client").post({
+        body: {
+          builtfrom: "DPG"
+        }
+      });
+      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/language").post({
+        body: {
+          wasMadeFor: "customers"
+        }
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});

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/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);
+    }
+  });
+});

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"]
+}