@azure-tools/typespec-ts 0.13.0 → 0.13.1-alpha.20230609.1

package/test/integration/modelPropertyType.spec.ts

@@ -1,135 +0,0 @@
-import TypePropertyValueTypesClientFactory, {
-  TypePropertyValueTypesClient
-} 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
-  },
-  {
-    type: "unknown/string",
-    defaultValue: "hello"
-  },
-  {
-    type: "unknown/int",
-    defaultValue: 42
-  },
-  {
-    type: "unknown/dict",
-    defaultValue: { k1: "hello", k2: 42 }
-  },
-  {
-    type: "unknown/array",
-    defaultValue: ["hello", "world"]
-  }
-];
-describe("ModelsPropertyTypesClient Rest Client", () => {
-  let client: TypePropertyValueTypesClient;
-
-  beforeEach(() => {
-    client = TypePropertyValueTypesClientFactory({
-      allowInsecureConnection: true
-    });
-  });
-
-  matrix([testedTypes], async (params: TypeDetail) => {
-    it(`should get a ${params.type} value`, async () => {
-      try {
-        const result = await client
-          .path(`/type/property/value-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(`/type/property/value-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

@@ -1,47 +0,0 @@
-import TypeModelUsageClientFactory, {
-  TypeModelUsageClient
-} from "./generated/models/usage/src/index.js";
-import { assert } from "chai";
-describe("ModelsUsageClient Rest Client", () => {
-  let client: TypeModelUsageClient;
-  const body = {
-    requiredProp: "example-value"
-  };
-
-  beforeEach(() => {
-    client = TypeModelUsageClientFactory({ allowInsecureConnection: true });
-  });
-
-  it("should post input model correctly", async () => {
-    try {
-      const result = await client.path("/type/model/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("/type/model/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("/type/model/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

@@ -1,102 +0,0 @@
-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,147 +0,0 @@
-import { assert } from "chai";
-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 client11: ServiceDrivenOldClient;
-  let client12: ServiceDrivenOldClient;
-  let client21: ServiceDrivenNewClient;
-  let client22: ServiceDrivenNewClient;
-
-  beforeEach(() => {
-    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("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");
-    });
-
-    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");
-    });
-
-    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/server.spec.ts

@@ -1,59 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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/spreadParameters.spec.ts

@@ -1,82 +0,0 @@
-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);
-    }
-  });
-});