@azure-tools/typespec-ts 0.11.0

package/test/integration/modelInheritance.spec.ts

@@ -0,0 +1,192 @@
+import ModelsInheritanceClientFactory, {
+  ModelsInheritanceClient,
+  Salmon,
+  SharkOutput
+} from "./generated/models/inheritance/src/index.js";
+import { assert } from "chai";
+
+describe("ModelsInheritance Rest Client", () => {
+  let client: ModelsInheritanceClient;
+
+  beforeEach(() => {
+    client = ModelsInheritanceClientFactory({
+      allowInsecureConnection: true
+    });
+  });
+
+  const validBody = { name: "abc", age: 32, smart: true };
+  it("should get valid", async () => {
+    try {
+      const result = await client.path("/models/inheritance/valid").get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.age, 32);
+      assert.strictEqual(result.body.name, "abc");
+      assert.strictEqual(result.body.smart, true);
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put valid", async () => {
+    try {
+      const result = await client.path("/models/inheritance/valid").put({
+        body: validBody
+      });
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.age, 32);
+      assert.strictEqual(result.body.name, "abc");
+      assert.strictEqual(result.body.smart, true);
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should post valid", async () => {
+    try {
+      const result = await client.path("/models/inheritance/valid").post({
+        body: validBody
+      });
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get polymorphic body", async () => {
+    try {
+      const result = await client
+        .path("/models/inheritance/discriminated/model")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.age, 1);
+      assert.strictEqual(result.body.kind, "shark");
+      assert.strictEqual((result.body as SharkOutput).sharktype, "goblin");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put polymorphic body", async () => {
+    try {
+      const result = await client
+        .path("/models/inheritance/discriminated/model")
+        .put({
+          body: {
+            age: 1,
+            kind: "shark",
+            sharktype: "goblin"
+          }
+        });
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  const validRecursiveBody = {
+    age: 1,
+    kind: "salmon",
+    partner: {
+      age: 2,
+      kind: "shark",
+      sharktype: "saw",
+    },
+    friends: [
+      {
+        age: 2,
+        kind: "salmon",
+        partner: {
+          age: 3,
+          kind: "salmon",
+        },
+        hate: {
+          key1: {
+            age: 4,
+            kind: "salmon",
+          },
+          key2: {
+            age: 2,
+            kind: "shark",
+            sharktype: "goblin",
+          },
+        },
+      },
+      {
+        age: 3,
+        kind: "shark",
+        sharktype: "goblin",
+      },
+    ],
+    hate: {
+      key3: {
+        age: 3,
+        kind: "shark",
+        sharktype: "saw",
+      },
+      key4: {
+        age: 2,
+        kind: "salmon",
+        friends: [
+          {
+            age: 1,
+            kind: "salmon",
+          },
+          {
+            age: 4,
+            kind: "shark",
+            sharktype: "goblin",
+          },
+        ],
+      },
+    },
+  };
+  it("should get recursive body", async () => {
+    try {
+      const result = await client
+        .path("/models/inheritance/discriminated/recursivemodel")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(JSON.stringify(result.body), JSON.stringify(validRecursiveBody));
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put recursive body", async () => {
+    try {
+      const result = await client
+        .path("/models/inheritance/discriminated/recursivemodel")
+        .put({
+            body: validRecursiveBody as Salmon
+        });
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+  
+  it("should get missing discriminator body", async () => {
+    try {
+      const result = await client
+        .path("/models/inheritance/discriminated/missingdiscriminator")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.age, 1);
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get wrong discriminator body", async () => {
+    try {
+      const result = await client
+        .path("/models/inheritance/discriminated/wrongdiscriminator")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.age, 1);
+      assert.strictEqual(result.body.kind, "wrongKind")
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});

package/test/integration/modelPropertyOptional.spec.ts

@@ -0,0 +1,362 @@
+import ModelsPropertyOptionalClientFactory, {
+  ModelsPropertyOptionalClient
+} from "./generated/models/propertyOptional/src/index.js";
+import { assert } from "chai";
+
+describe("ModelsPropertyOptional Rest Client", () => {
+  let client: ModelsPropertyOptionalClient;
+
+  beforeEach(() => {
+    client = ModelsPropertyOptionalClientFactory({
+      allowInsecureConnection: true
+    });
+  });
+
+  it("should get all string", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/string/all")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.property, "hello");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get default string", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/string/default")
+        .get();
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put all string", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/string/all")
+        .put({
+          body: { property: "hello" }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put default string", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/string/default")
+        .put({ body: {} });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get all bytes", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/bytes/all")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.property, "aGVsbG8sIHdvcmxkIQ==");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get default bytes", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/bytes/default")
+        .get();
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put all bytes", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/bytes/all")
+        .put({
+          body: { property: "aGVsbG8sIHdvcmxkIQ==" }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put default bytes", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/bytes/default")
+        .put({
+          body: {}
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get all datetime", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/datetime/all")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.property, "2022-08-26T18:38:00Z");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get default datetime", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/datetime/default")
+        .get();
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put all datetime", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/datetime/all")
+        .put({
+          body: { property: "2022-08-26T18:38:00Z" }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put default datetime", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/datetime/default")
+        .put({
+          body: {}
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get all duration", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/duration/all")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.property, "P123DT22H14M12.011S");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get default duration", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/duration/default")
+        .get();
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put all duration", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/duration/all")
+        .put({
+          body: { property: "P123DT22H14M12.011S" }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put default duration", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/duration/default")
+        .put({
+          body: {}
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get all collections bytes", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/collections/bytes/all")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.property?.length, 2);
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get default collections bytes", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/collections/bytes/default")
+        .get();
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put all collections bytes", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/collections/bytes/all")
+        .put({
+          body: { property: ["aGVsbG8sIHdvcmxkIQ==", "aGVsbG8sIHdvcmxkIQ=="] }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put default collections bytes", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/collections/bytes/default")
+        .put({
+          body: {}
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get all collections model", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/collections/model/all")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.property?.length, 2);
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get default collections model", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/collections/model/default")
+        .get();
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put all collections model", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/collections/model/all")
+        .put({
+          body: { property: [{ property: "hello" }, { property: "world" }] }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put default collections model", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/collections/model/default")
+        .put({
+          body: {}
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get models that will return all properties in the model", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/requiredAndOptional/all")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.optionalProperty, "hello");
+      assert.strictEqual(result.body.requiredProperty, 42);
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get models that will return only the required properties", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/requiredAndOptional/requiredOnly")
+        .get();
+      assert.strictEqual(result.status, "200");
+      assert.strictEqual(result.body.requiredProperty, 42);
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put a body with all properties present", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/requiredAndOptional/all")
+        .put({
+          body: {
+            requiredProperty: 42,
+            optionalProperty: "hello"
+          }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should put a body with only required properties", async () => {
+    try {
+      const result = await client
+        .path("/models/properties/optional/requiredAndOptional/requiredOnly")
+        .put({
+          body: {
+            requiredProperty: 42
+          }
+        });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});

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