Implement Spector integration tests for encode/array

packages/typespec-ts/test/azureModularIntegration/encodeArray.spec.ts

@@ -0,0 +1,102 @@
+import { assert } from "chai";
+import { ArrayClient } from "./generated/encode/array/src/index.js";
+
+describe("EncodeArrayClient Rest Client", () => {
+  let client: ArrayClient;
+
+  beforeEach(() => {
+    client = new ArrayClient({
+      endpoint: "http://localhost:3002",
+      allowInsecureConnection: true,
+      retryOptions: {
+        maxRetries: 0
+      }
+    });
+  });
+
+  describe("property", () => {
+    it("should handle commaDelimited string array", async () => {
+      const result = await client.property.commaDelimited({
+        value: ["blue", "red", "green"]
+      });
+      assert.deepEqual(result.value, ["blue", "red", "green"]);
+    });
+
+    it("should handle spaceDelimited string array", async () => {
+      const result = await client.property.spaceDelimited({
+        value: ["blue", "red", "green"]
+      });
+      assert.deepEqual(result.value, ["blue", "red", "green"]);
+    });
+
+    it("should handle pipeDelimited string array", async () => {
+      const result = await client.property.pipeDelimited({
+        value: ["blue", "red", "green"]
+      });
+      assert.deepEqual(result.value, ["blue", "red", "green"]);
+    });
+
+    it("should handle newlineDelimited string array", async () => {
+      const result = await client.property.newlineDelimited({
+        value: ["blue", "red", "green"]
+      });
+      assert.deepEqual(result.value, ["blue", "red", "green"]);
+    });
+
+    it("should handle enumCommaDelimited array", async () => {
+      const result = await client.property.enumCommaDelimited({
+        value: ["blue", "red", "green"]
+      });
+      assert.deepEqual(result.value, ["blue", "red", "green"]);
+    });
+
+    it("should handle enumSpaceDelimited array", async () => {
+      const result = await client.property.enumSpaceDelimited({
+        value: ["blue", "red", "green"]
+      });
+      assert.deepEqual(result.value, ["blue", "red", "green"]);
+    });
+
+    it("should handle enumPipeDelimited array", async () => {
+      const result = await client.property.enumPipeDelimited({
+        value: ["blue", "red", "green"]
+      });
+      assert.deepEqual(result.value, ["blue", "red", "green"]);
+    });
+
+    it("should handle enumNewlineDelimited array", async () => {
+      const result = await client.property.enumNewlineDelimited({
+        value: ["blue", "red", "green"]
+      });
+      assert.deepEqual(result.value, ["blue", "red", "green"]);
+    });
+
+    it("should handle extensibleEnumCommaDelimited array", async () => {
+      const result = await client.property.extensibleEnumCommaDelimited({
+        value: ["blue", "red", "green"]
+      });
+      assert.deepEqual(result.value, ["blue", "red", "green"]);
+    });
+
+    it("should handle extensibleEnumSpaceDelimited array", async () => {
+      const result = await client.property.extensibleEnumSpaceDelimited({
+        value: ["blue", "red", "green"]
+      });
+      assert.deepEqual(result.value, ["blue", "red", "green"]);
+    });
+
+    it("should handle extensibleEnumPipeDelimited array", async () => {
+      const result = await client.property.extensibleEnumPipeDelimited({
+        value: ["blue", "red", "green"]
+      });
+      assert.deepEqual(result.value, ["blue", "red", "green"]);
+    });
+
+    it("should handle extensibleEnumNewlineDelimited array", async () => {
+      const result = await client.property.extensibleEnumNewlineDelimited({
+        value: ["blue", "red", "green"]
+      });
+      assert.deepEqual(result.value, ["blue", "red", "green"]);
+    });
+  });
+});

packages/typespec-ts/test/azureModularIntegration/generated/encode/array/.gitignore

@@ -0,0 +1,6 @@
+/**
+!/src
+/src/**
+!/src/index.d.ts
+!/.gitignore
+!/tspconfig.yaml

packages/typespec-ts/test/azureModularIntegration/generated/encode/array/src/index.d.ts

@@ -0,0 +1,118 @@
+import { ClientOptions } from '@azure-rest/core-client';
+import { OperationOptions } from '@azure-rest/core-client';
+import { Pipeline } from '@azure/core-rest-pipeline';
+
+export declare class ArrayClient {
+    private _client;
+    readonly pipeline: Pipeline;
+    constructor(options?: ArrayClientOptionalParams);
+    readonly property: PropertyOperations;
+}
+
+export declare interface ArrayClientOptionalParams extends ClientOptions {
+}
+
+export declare type Colors = "blue" | "red" | "green";
+
+export declare type ColorsExtensibleEnum = "blue" | "red" | "green";
+
+export declare interface CommaDelimitedArrayProperty {
+    value: string[];
+}
+
+export declare interface CommaDelimitedEnumArrayProperty {
+    value: Colors[];
+}
+
+export declare interface CommaDelimitedExtensibleEnumArrayProperty {
+    value: ColorsExtensibleEnum[];
+}
+
+export declare interface NewlineDelimitedArrayProperty {
+    value: string[];
+}
+
+export declare interface NewlineDelimitedEnumArrayProperty {
+    value: Colors[];
+}
+
+export declare interface NewlineDelimitedExtensibleEnumArrayProperty {
+    value: ColorsExtensibleEnum[];
+}
+
+export declare interface PipeDelimitedArrayProperty {
+    value: string[];
+}
+
+export declare interface PipeDelimitedEnumArrayProperty {
+    value: Colors[];
+}
+
+export declare interface PipeDelimitedExtensibleEnumArrayProperty {
+    value: ColorsExtensibleEnum[];
+}
+
+export declare interface PropertyCommaDelimitedOptionalParams extends OperationOptions {
+}
+
+export declare interface PropertyEnumCommaDelimitedOptionalParams extends OperationOptions {
+}
+
+export declare interface PropertyEnumNewlineDelimitedOptionalParams extends OperationOptions {
+}
+
+export declare interface PropertyEnumPipeDelimitedOptionalParams extends OperationOptions {
+}
+
+export declare interface PropertyEnumSpaceDelimitedOptionalParams extends OperationOptions {
+}
+
+export declare interface PropertyExtensibleEnumCommaDelimitedOptionalParams extends OperationOptions {
+}
+
+export declare interface PropertyExtensibleEnumNewlineDelimitedOptionalParams extends OperationOptions {
+}
+
+export declare interface PropertyExtensibleEnumPipeDelimitedOptionalParams extends OperationOptions {
+}
+
+export declare interface PropertyExtensibleEnumSpaceDelimitedOptionalParams extends OperationOptions {
+}
+
+export declare interface PropertyNewlineDelimitedOptionalParams extends OperationOptions {
+}
+
+export declare interface PropertyOperations {
+    extensibleEnumNewlineDelimited: (body: NewlineDelimitedExtensibleEnumArrayProperty, options?: PropertyExtensibleEnumNewlineDelimitedOptionalParams) => Promise<NewlineDelimitedExtensibleEnumArrayProperty>;
+    extensibleEnumPipeDelimited: (body: PipeDelimitedExtensibleEnumArrayProperty, options?: PropertyExtensibleEnumPipeDelimitedOptionalParams) => Promise<PipeDelimitedExtensibleEnumArrayProperty>;
+    extensibleEnumSpaceDelimited: (body: SpaceDelimitedExtensibleEnumArrayProperty, options?: PropertyExtensibleEnumSpaceDelimitedOptionalParams) => Promise<SpaceDelimitedExtensibleEnumArrayProperty>;
+    extensibleEnumCommaDelimited: (body: CommaDelimitedExtensibleEnumArrayProperty, options?: PropertyExtensibleEnumCommaDelimitedOptionalParams) => Promise<CommaDelimitedExtensibleEnumArrayProperty>;
+    enumNewlineDelimited: (body: NewlineDelimitedEnumArrayProperty, options?: PropertyEnumNewlineDelimitedOptionalParams) => Promise<NewlineDelimitedEnumArrayProperty>;
+    enumPipeDelimited: (body: PipeDelimitedEnumArrayProperty, options?: PropertyEnumPipeDelimitedOptionalParams) => Promise<PipeDelimitedEnumArrayProperty>;
+    enumSpaceDelimited: (body: SpaceDelimitedEnumArrayProperty, options?: PropertyEnumSpaceDelimitedOptionalParams) => Promise<SpaceDelimitedEnumArrayProperty>;
+    enumCommaDelimited: (body: CommaDelimitedEnumArrayProperty, options?: PropertyEnumCommaDelimitedOptionalParams) => Promise<CommaDelimitedEnumArrayProperty>;
+    newlineDelimited: (body: NewlineDelimitedArrayProperty, options?: PropertyNewlineDelimitedOptionalParams) => Promise<NewlineDelimitedArrayProperty>;
+    pipeDelimited: (body: PipeDelimitedArrayProperty, options?: PropertyPipeDelimitedOptionalParams) => Promise<PipeDelimitedArrayProperty>;
+    spaceDelimited: (body: SpaceDelimitedArrayProperty, options?: PropertySpaceDelimitedOptionalParams) => Promise<SpaceDelimitedArrayProperty>;
+    commaDelimited: (body: CommaDelimitedArrayProperty, options?: PropertyCommaDelimitedOptionalParams) => Promise<CommaDelimitedArrayProperty>;
+}
+
+export declare interface PropertyPipeDelimitedOptionalParams extends OperationOptions {
+}
+
+export declare interface PropertySpaceDelimitedOptionalParams extends OperationOptions {
+}
+
+export declare interface SpaceDelimitedArrayProperty {
+    value: string[];
+}
+
+export declare interface SpaceDelimitedEnumArrayProperty {
+    value: Colors[];
+}
+
+export declare interface SpaceDelimitedExtensibleEnumArrayProperty {
+    value: ColorsExtensibleEnum[];
+}
+
+export { }

packages/typespec-ts/test/azureModularIntegration/generated/encode/array/tspconfig.yaml

@@ -0,0 +1,13 @@
+emit:
+  - "@azure-tools/typespec-ts"
+options:
+  "@azure-tools/typespec-ts":
+    emitter-output-dir: "{project-root}"
+    generate-test: false
+    add-credentials: false
+    flavor: azure
+    azure-sdk-for-js: false
+    is-typespec-test: true
+    package-details:
+      name: "@msinternal/encode-array"
+      description: "Encode Array Test Service"

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

@@ -879,6 +879,10 @@ export const azureModularTsps = [
     outputPath: "encode/numeric",
     inputPath: "encode/numeric"
   },
+  {
+    outputPath: "encode/array",
+    inputPath: "encode/array"
+  },
   {
     outputPath: "payload/pageable",
     inputPath: "payload/pageable"