add-encode-byte-cadl-ranch-test (#2003)

* add-encode-byte-cadl-ranch-test

* resolve comments

packages/typespec-ts/test/commands/cadl-ranch-list.ts

@@ -21,6 +21,10 @@ export const rlcTsps: TypeSpecRanchConfig[] = [
     outputPath: "parameters/body-optionality",
     inputPath: "parameters/body-optionality"
   },
+  {
+    outputPath: "encode/bytes",
+    inputPath: "encode/bytes"
+  },
   {
     outputPath: "encode/duration",
     inputPath: "encode/duration"

packages/typespec-ts/test/integration/encodeBytes.spec.ts

@@ -0,0 +1,189 @@
+import { assert } from "chai";
+import EncodeBytesClientFactory, {
+  BytesClient
+} from "./generated/encode/bytes/src/index.js";
+import { buildCsvCollection } from "./generated/encode/bytes/src/serializeHelper.js";
+describe("EncodeDatetimeClient Rest Client", () => {
+  let client: BytesClient;
+
+  beforeEach(() => {
+    client = EncodeBytesClientFactory({
+      allowInsecureConnection: true,
+      retryOptions: {
+        maxRetries: 0
+      }
+    });
+  });
+
+  describe("query", () => {
+    it(`should get bytes`, async () => {
+      try {
+        const result = await client.path(`/encode/bytes/query/default`).get({
+          queryParameters: {
+            value: "dGVzdA=="
+          }
+        });
+        assert.strictEqual(result.status, "204");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+    it(`should get bytes base64 encoding`, async () => {
+      try {
+        const result = await client.path(`/encode/bytes/query/base64`).get({
+          queryParameters: {
+            value: "dGVzdA=="
+          }
+        });
+        assert.strictEqual(result.status, "204");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+    it(`should get bytes base64url encoding`, async () => {
+      try {
+        const result = await client.path(`/encode/bytes/query/base64url`).get({
+          queryParameters: {
+            value: "dGVzdA"
+          }
+        });
+        assert.strictEqual(result.status, "204");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+    it(`should get bytes base64url-array`, async () => {
+      try {
+        const result = await client
+          .path(`/encode/bytes/query/base64url-array`)
+          .get({
+            queryParameters: {
+              value: ["dGVzdA", "dGVzdA"]
+            }
+          });
+        assert.strictEqual(result.status, "204");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+  });
+
+
+  describe("property", () => {
+    it(`should post bytes`, async () => {
+      try {
+        const result = await client.path(`/encode/bytes/property/default`).post({
+          body: {
+            value: "dGVzdA=="
+          }
+        });
+        assert.strictEqual(result.status, "200");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+    it(`should post bytes base64 encoding`, async () => {
+      try {
+        const result = await client.path(`/encode/bytes/property/base64`).post({
+          body: {
+            value: "dGVzdA=="
+          }
+        });
+        assert.strictEqual(result.status, "200");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+    it(`should post bytes base64url encoding`, async () => {
+      try {
+        const result = await client.path(`/encode/bytes/property/base64url`).post({
+          body: {
+            value: "dGVzdA"
+          }
+        });
+        assert.strictEqual(result.status, "200");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+    it(`should post bytes base64url array`, async () => {
+      try {
+        const result = await client
+          .path(`/encode/bytes/property/base64url-array`)
+          .post({
+            body: {
+              value: ["dGVzdA", "dGVzdA"]
+            }
+          });
+        assert.strictEqual(result.status, "200");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+  });
+
+  describe("header", () => {
+    it(`should get bytes`, async () => {
+      try {
+        const result = await client.path(`/encode/bytes/header/default`).get({
+          headers: {
+            value: "dGVzdA=="
+          }
+        });
+        assert.strictEqual(result.status, "204");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+    it(`should get bytes base64 encoding`, async () => {
+      try {
+        const result = await client.path(`/encode/bytes/header/base64`).get({
+          headers: {
+            value: "dGVzdA=="
+          }
+        });
+        assert.strictEqual(result.status, "204");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+    it(`should get bytes base64url encoding`, async () => {
+      try {
+        const result = await client.path(`/encode/bytes/header/base64url`).get({
+          headers: {
+            value: "dGVzdA"
+          }
+        });
+        assert.strictEqual(result.status, "204");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+    it(`should get bytes  base64url-array`, async () => {
+      try {
+        const result = await client
+          .path(`/encode/bytes/header/base64url-array`)
+          .get({
+            headers: {
+              value: buildCsvCollection(["dGVzdA", "dGVzdA"])
+            }
+          });
+        assert.strictEqual(result.status, "204");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+
+  });
+});

packages/typespec-ts/test/integration/generated/encode/bytes/src/bytesClient.ts

@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import { getClient, ClientOptions } from "@azure-rest/core-client";
+import { logger } from "./logger";
+import { BytesClient } from "./clientDefinitions";
+
+/**
+ * Initialize a new instance of `BytesClient`
+ * @param options - the parameter for all optional parameters
+ */
+export default function createClient(options: ClientOptions = {}): BytesClient {
+  const baseUrl = options.baseUrl ?? `http://localhost:3000`;
+  options.apiVersion = options.apiVersion ?? "1.0.0";
+  const userAgentInfo = `azsdk-js-encode-bytes-rest/1.0.0-beta.1`;
+  const userAgentPrefix =
+    options.userAgentOptions && options.userAgentOptions.userAgentPrefix
+      ? `${options.userAgentOptions.userAgentPrefix} ${userAgentInfo}`
+      : `${userAgentInfo}`;
+  options = {
+    ...options,
+    userAgentOptions: {
+      userAgentPrefix,
+    },
+    loggingOptions: {
+      logger: options.loggingOptions?.logger ?? logger.info,
+    },
+  };
+
+  const client = getClient(baseUrl, options) as BytesClient;
+
+  return client;
+}

packages/typespec-ts/test/integration/generated/encode/bytes/src/clientDefinitions.ts

@@ -0,0 +1,133 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import {
+  QueryDefaultParameters,
+  QueryBase64Parameters,
+  QueryBase64urlParameters,
+  QueryBase64urlArrayParameters,
+  PropertyDefaultParameters,
+  PropertyBase64Parameters,
+  PropertyBase64urlParameters,
+  PropertyBase64urlArrayParameters,
+  HeaderDefaultParameters,
+  HeaderBase64Parameters,
+  HeaderBase64urlParameters,
+  HeaderBase64urlArrayParameters,
+} from "./parameters";
+import {
+  QueryDefault204Response,
+  QueryBase64204Response,
+  QueryBase64url204Response,
+  QueryBase64urlArray204Response,
+  PropertyDefault200Response,
+  PropertyBase64200Response,
+  PropertyBase64url200Response,
+  PropertyBase64urlArray200Response,
+  HeaderDefault204Response,
+  HeaderBase64204Response,
+  HeaderBase64url204Response,
+  HeaderBase64urlArray204Response,
+} from "./responses";
+import { Client, StreamableMethod } from "@azure-rest/core-client";
+
+export interface QueryDefault {
+  get(
+    options: QueryDefaultParameters
+  ): StreamableMethod<QueryDefault204Response>;
+}
+
+export interface QueryBase64 {
+  get(options: QueryBase64Parameters): StreamableMethod<QueryBase64204Response>;
+}
+
+export interface QueryBase64url {
+  get(
+    options: QueryBase64urlParameters
+  ): StreamableMethod<QueryBase64url204Response>;
+}
+
+export interface QueryBase64urlArray {
+  get(
+    options: QueryBase64urlArrayParameters
+  ): StreamableMethod<QueryBase64urlArray204Response>;
+}
+
+export interface PropertyDefault {
+  post(
+    options: PropertyDefaultParameters
+  ): StreamableMethod<PropertyDefault200Response>;
+}
+
+export interface PropertyBase64 {
+  post(
+    options: PropertyBase64Parameters
+  ): StreamableMethod<PropertyBase64200Response>;
+}
+
+export interface PropertyBase64url {
+  post(
+    options: PropertyBase64urlParameters
+  ): StreamableMethod<PropertyBase64url200Response>;
+}
+
+export interface PropertyBase64urlArray {
+  post(
+    options: PropertyBase64urlArrayParameters
+  ): StreamableMethod<PropertyBase64urlArray200Response>;
+}
+
+export interface HeaderDefault {
+  get(
+    options: HeaderDefaultParameters
+  ): StreamableMethod<HeaderDefault204Response>;
+}
+
+export interface HeaderBase64 {
+  get(
+    options: HeaderBase64Parameters
+  ): StreamableMethod<HeaderBase64204Response>;
+}
+
+export interface HeaderBase64url {
+  get(
+    options: HeaderBase64urlParameters
+  ): StreamableMethod<HeaderBase64url204Response>;
+}
+
+export interface HeaderBase64urlArray {
+  get(
+    options: HeaderBase64urlArrayParameters
+  ): StreamableMethod<HeaderBase64urlArray204Response>;
+}
+
+export interface Routes {
+  /** Resource for '/encode/bytes/query/default' has methods for the following verbs: get */
+  (path: "/encode/bytes/query/default"): QueryDefault;
+  /** Resource for '/encode/bytes/query/base64' has methods for the following verbs: get */
+  (path: "/encode/bytes/query/base64"): QueryBase64;
+  /** Resource for '/encode/bytes/query/base64url' has methods for the following verbs: get */
+  (path: "/encode/bytes/query/base64url"): QueryBase64url;
+  /** Resource for '/encode/bytes/query/base64url-array' has methods for the following verbs: get */
+  (path: "/encode/bytes/query/base64url-array"): QueryBase64urlArray;
+  /** Resource for '/encode/bytes/property/default' has methods for the following verbs: post */
+  (path: "/encode/bytes/property/default"): PropertyDefault;
+  /** Resource for '/encode/bytes/property/base64' has methods for the following verbs: post */
+  (path: "/encode/bytes/property/base64"): PropertyBase64;
+  /** Resource for '/encode/bytes/property/base64url' has methods for the following verbs: post */
+  (path: "/encode/bytes/property/base64url"): PropertyBase64url;
+  /** Resource for '/encode/bytes/property/base64url-array' has methods for the following verbs: post */
+  (path: "/encode/bytes/property/base64url-array"): PropertyBase64urlArray;
+  /** Resource for '/encode/bytes/header/default' has methods for the following verbs: get */
+  (path: "/encode/bytes/header/default"): HeaderDefault;
+  /** Resource for '/encode/bytes/header/base64' has methods for the following verbs: get */
+  (path: "/encode/bytes/header/base64"): HeaderBase64;
+  /** Resource for '/encode/bytes/header/base64url' has methods for the following verbs: get */
+  (path: "/encode/bytes/header/base64url"): HeaderBase64url;
+  /** Resource for '/encode/bytes/header/base64url-array' has methods for the following verbs: get */
+  (path: "/encode/bytes/header/base64url-array"): HeaderBase64urlArray;
+}
+
+export type BytesClient = Client & {
+  path: Routes;
+};

packages/typespec-ts/test/integration/generated/encode/bytes/src/index.ts

@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import BytesClient from "./bytesClient";
+
+export * from "./bytesClient";
+export * from "./parameters";
+export * from "./responses";
+export * from "./clientDefinitions";
+export * from "./models";
+export * from "./outputModels";
+
+export default BytesClient;

packages/typespec-ts/test/integration/generated/encode/bytes/src/logger.ts

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import { createClientLogger } from "@azure/logger";
+export const logger = createClientLogger("encode-bytes");