@azure-tools/typespec-ts 0.13.0 → 0.13.1

package/test/integration/modelInheritance.spec.ts

@@ -1,192 +0,0 @@
-import TypeModelInheritanceClientFactory, {
-  TypeModelInheritanceClient,
-  Salmon,
-  SharkOutput
-} from "./generated/models/inheritance/src/index.js";
-import { assert } from "chai";
-
-describe("ModelsInheritance Rest Client", () => {
-  let client: TypeModelInheritanceClient;
-
-  beforeEach(() => {
-    client = TypeModelInheritanceClientFactory({
-      allowInsecureConnection: true
-    });
-  });
-
-  const validBody = { name: "abc", age: 32, smart: true };
-  it("should get valid", async () => {
-    try {
-      const result = await client.path("/type/model/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("/type/model/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("/type/model/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("/type/model/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("/type/model/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("/type/model/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("/type/model/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("/type/model/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("/type/model/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/modelPropertyNullable.spec.ts

@@ -1,115 +0,0 @@
-import { assert } from "chai";
-import TypePropertyNullableClientFactory, {
-  TypePropertyNullableClient
-} from "./generated/models/propertyNullable/src/index.js";
-import { matrix } from "../util/matrix.js";
-
-interface TypeDetail {
-  type: string;
-  defaultValue: any;
-  convertedToFn?: (_: any) => any;
-}
-
-const testedTypes: TypeDetail[] = [
-  {
-    type: "string",
-    defaultValue: "hello"
-  },
-  {
-    type: "bytes",
-    defaultValue: "aGVsbG8sIHdvcmxkIQ=="
-  },
-  {
-    type: "datetime",
-    defaultValue: "2022-08-26T18:38:00Z"
-  },
-  {
-    type: "duration",
-    defaultValue: "P123DT22H14M12.011S"
-  },
-  {
-    type: "collections/bytes",
-    defaultValue: ["aGVsbG8sIHdvcmxkIQ==", "aGVsbG8sIHdvcmxkIQ=="]
-  },
-  {
-    type: "collections/model",
-    defaultValue: [{ property: "hello" }, { property: "world" }]
-  }
-];
-describe("ModelsPropertyNullableClient Rest Client", () => {
-  let client: TypePropertyNullableClient;
-
-  beforeEach(() => {
-    client = TypePropertyNullableClientFactory({
-      allowInsecureConnection: true
-    });
-  });
-
-  matrix([testedTypes], async (params: TypeDetail) => {
-    it(`should get a null value for nullable ${params.type}`, async () => {
-      try {
-        const result = await client
-          .path(`/type/property/nullable/${params.type}/null` as any)
-          .get();
-        assert.strictEqual(result.status, "200");
-        assert.strictEqual(result.body.nullableProperty, null);
-        assert.deepEqual(result.body.requiredProperty, "foo");
-      } catch (err) {
-        assert.fail(err as string);
-      }
-    });
-
-    it(`should get a non-null value for nullable ${params.type}`, async () => {
-      try {
-        const result = await client
-          .path(`/type/property/nullable/${params.type}/non-null` as any)
-          .get();
-        assert.strictEqual(result.status, "200");
-        assert.deepEqual(result.body.nullableProperty, params.defaultValue);
-        assert.deepEqual(result.body.requiredProperty, "foo");
-      } catch (err) {
-        assert.fail(err as string);
-      }
-    });
-
-    it(`should patch a null value for nullable ${params.type}`, async () => {
-      try {
-        const result = await client
-          .path(`/type/property/nullable/${params.type}/null` as any)
-          .patch({
-            contentType: "application/merge-patch+json",
-            body: {
-              requiredProperty: "foo",
-              nullableProperty: null
-            }
-          });
-        assert.strictEqual(result.status, "204");
-      } catch (err) {
-        assert.fail(err as string);
-      }
-    });
-
-    it(`should patch a non-null value for nullable ${params.type}`, async () => {
-      try {
-        let property;
-        if (params.convertedToFn) {
-          property = params.convertedToFn(params.defaultValue);
-        } else {
-          property = params.defaultValue;
-        }
-        const result = await client
-          .path(`/type/property/nullable/${params.type}/non-null` as any)
-          .patch({
-            contentType: "application/merge-patch+json",
-            body: {
-              requiredProperty: "foo",
-              nullableProperty: property || null
-            }
-          });
-        assert.strictEqual(result.status, "204");
-      } catch (err) {
-        assert.fail(err as string);
-      }
-    });
-  });
-});

package/test/integration/modelPropertyOptional.spec.ts

@@ -1,362 +0,0 @@
-import TypePropertyOptionalClientFactory, {
-  TypePropertyOptionalClient
-} from "./generated/models/propertyOptional/src/index.js";
-import { assert } from "chai";
-
-describe("ModelsPropertyOptional Rest Client", () => {
-  let client: TypePropertyOptionalClient;
-
-  beforeEach(() => {
-    client = TypePropertyOptionalClientFactory({
-      allowInsecureConnection: true
-    });
-  });
-
-  it("should get all string", async () => {
-    try {
-      const result = await client
-        .path("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/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("/type/property/optional/requiredAndOptional/requiredOnly")
-        .put({
-          body: {
-            requiredProperty: 42
-          }
-        });
-      assert.strictEqual(result.status, "204");
-    } catch (err) {
-      assert.fail(err as string);
-    }
-  });
-});