Add coverage cases for arrays-item-types in cadl-ranch

packages/typespec-ts/src/modular/helpers/operationHelpers.ts

@@ -944,7 +944,7 @@ function deserializeResponseValue(
           type.elementType!,
           "p",
           runtimeImports,
-          required,
+          true,
           [...typeStack, type.elementType!],
           type.elementType?.format
         )})`;

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

@@ -318,6 +318,10 @@ export const modularTsps: TypeSpecRanchConfig[] = [
   {
     outputPath: "models/empty",
     inputPath: "type/model/empty"
+  },
+  {
+    outputPath: "arrays/items",
+    inputPath: "type/array"
   }
 ];
 

packages/typespec-ts/test/modularIntegration/generated/arrays/items/src/ArrayClient.ts

@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import { Pipeline } from "@azure/core-rest-pipeline";
+import {
+  getInt32ValueOperations,
+  Int32ValueOperations,
+} from "./classic/int32Value/index.js";
+import {
+  getInt64ValueOperations,
+  Int64ValueOperations,
+} from "./classic/int64Value/index.js";
+import {
+  getBooleanValueOperations,
+  BooleanValueOperations,
+} from "./classic/booleanValue/index.js";
+import {
+  getStringValueOperations,
+  StringValueOperations,
+} from "./classic/stringValue/index.js";
+import {
+  getFloat32ValueOperations,
+  Float32ValueOperations,
+} from "./classic/float32Value/index.js";
+import {
+  getDatetimeValueOperations,
+  DatetimeValueOperations,
+} from "./classic/datetimeValue/index.js";
+import {
+  getDurationValueOperations,
+  DurationValueOperations,
+} from "./classic/durationValue/index.js";
+import {
+  getUnknownValueOperations,
+  UnknownValueOperations,
+} from "./classic/unknownValue/index.js";
+import {
+  getModelValueOperations,
+  ModelValueOperations,
+} from "./classic/modelValue/index.js";
+import {
+  getNullableFloatValueOperations,
+  NullableFloatValueOperations,
+} from "./classic/nullableFloatValue/index.js";
+import { createArray, ArrayClientOptions, ArrayContext } from "./api/index.js";
+
+export { ArrayClientOptions } from "./api/ArrayContext.js";
+
+export class ArrayClient {
+  private _client: ArrayContext;
+  /** The pipeline used by this client to make requests */
+  public readonly pipeline: Pipeline;
+
+  /** Illustrates various of dictionaries. */
+  constructor(options: ArrayClientOptions = {}) {
+    this._client = createArray(options);
+    this.pipeline = this._client.pipeline;
+    this.int32Value = getInt32ValueOperations(this._client);
+    this.int64Value = getInt64ValueOperations(this._client);
+    this.booleanValue = getBooleanValueOperations(this._client);
+    this.stringValue = getStringValueOperations(this._client);
+    this.float32Value = getFloat32ValueOperations(this._client);
+    this.datetimeValue = getDatetimeValueOperations(this._client);
+    this.durationValue = getDurationValueOperations(this._client);
+    this.unknownValue = getUnknownValueOperations(this._client);
+    this.modelValue = getModelValueOperations(this._client);
+    this.nullableFloatValue = getNullableFloatValueOperations(this._client);
+  }
+
+  /** The operation groups for Int32Value */
+  public readonly int32Value: Int32ValueOperations;
+  /** The operation groups for Int64Value */
+  public readonly int64Value: Int64ValueOperations;
+  /** The operation groups for BooleanValue */
+  public readonly booleanValue: BooleanValueOperations;
+  /** The operation groups for StringValue */
+  public readonly stringValue: StringValueOperations;
+  /** The operation groups for Float32Value */
+  public readonly float32Value: Float32ValueOperations;
+  /** The operation groups for DatetimeValue */
+  public readonly datetimeValue: DatetimeValueOperations;
+  /** The operation groups for DurationValue */
+  public readonly durationValue: DurationValueOperations;
+  /** The operation groups for UnknownValue */
+  public readonly unknownValue: UnknownValueOperations;
+  /** The operation groups for ModelValue */
+  public readonly modelValue: ModelValueOperations;
+  /** The operation groups for NullableFloatValue */
+  public readonly nullableFloatValue: NullableFloatValueOperations;
+}

packages/typespec-ts/test/modularIntegration/generated/arrays/items/src/api/ArrayContext.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import { ClientOptions } from "@azure-rest/core-client";
+import { ArrayContext } from "../rest/index.js";
+import getClient from "../rest/index.js";
+
+export interface ArrayClientOptions extends ClientOptions {}
+
+export { ArrayContext } from "../rest/index.js";
+
+/** Illustrates various of dictionaries. */
+export function createArray(options: ArrayClientOptions = {}): ArrayContext {
+  const clientContext = getClient(options);
+  return clientContext;
+}

packages/typespec-ts/test/modularIntegration/generated/arrays/items/src/api/booleanValue/index.ts

@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import {
+  ArrayContext as Client,
+  BooleanValueGet200Response,
+  BooleanValuePut204Response,
+} from "../../rest/index.js";
+import {
+  StreamableMethod,
+  operationOptionsToRequestParameters,
+  createRestError,
+} from "@azure-rest/core-client";
+import {
+  BooleanValueGetOptions,
+  BooleanValuePutOptions,
+} from "../../models/options.js";
+
+export function _booleanValueGetSend(
+  context: Client,
+  options: BooleanValueGetOptions = { requestOptions: {} },
+): StreamableMethod<BooleanValueGet200Response> {
+  return context
+    .path("/type/array/boolean")
+    .get({ ...operationOptionsToRequestParameters(options) });
+}
+
+export async function _booleanValueGetDeserialize(
+  result: BooleanValueGet200Response,
+): Promise<boolean[]> {
+  if (result.status !== "200") {
+    throw createRestError(result);
+  }
+
+  return result.body;
+}
+
+export async function booleanValueGet(
+  context: Client,
+  options: BooleanValueGetOptions = { requestOptions: {} },
+): Promise<boolean[]> {
+  const result = await _booleanValueGetSend(context, options);
+  return _booleanValueGetDeserialize(result);
+}
+
+export function _booleanValuePutSend(
+  context: Client,
+  body: boolean[],
+  options: BooleanValuePutOptions = { requestOptions: {} },
+): StreamableMethod<BooleanValuePut204Response> {
+  return context
+    .path("/type/array/boolean")
+    .put({ ...operationOptionsToRequestParameters(options), body: body });
+}
+
+export async function _booleanValuePutDeserialize(
+  result: BooleanValuePut204Response,
+): Promise<void> {
+  if (result.status !== "204") {
+    throw createRestError(result);
+  }
+
+  return;
+}
+
+export async function booleanValuePut(
+  context: Client,
+  body: boolean[],
+  options: BooleanValuePutOptions = { requestOptions: {} },
+): Promise<void> {
+  const result = await _booleanValuePutSend(context, body, options);
+  return _booleanValuePutDeserialize(result);
+}

packages/typespec-ts/test/modularIntegration/generated/arrays/items/src/api/datetimeValue/index.ts

@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import {
+  ArrayContext as Client,
+  DatetimeValueGet200Response,
+  DatetimeValuePut204Response,
+} from "../../rest/index.js";
+import {
+  StreamableMethod,
+  operationOptionsToRequestParameters,
+  createRestError,
+} from "@azure-rest/core-client";
+import {
+  DatetimeValueGetOptions,
+  DatetimeValuePutOptions,
+} from "../../models/options.js";
+
+export function _datetimeValueGetSend(
+  context: Client,
+  options: DatetimeValueGetOptions = { requestOptions: {} },
+): StreamableMethod<DatetimeValueGet200Response> {
+  return context
+    .path("/type/array/datetime")
+    .get({ ...operationOptionsToRequestParameters(options) });
+}
+
+export async function _datetimeValueGetDeserialize(
+  result: DatetimeValueGet200Response,
+): Promise<Date[]> {
+  if (result.status !== "200") {
+    throw createRestError(result);
+  }
+
+  return !result.body ? result.body : result.body.map((p) => new Date(p));
+}
+
+export async function datetimeValueGet(
+  context: Client,
+  options: DatetimeValueGetOptions = { requestOptions: {} },
+): Promise<Date[]> {
+  const result = await _datetimeValueGetSend(context, options);
+  return _datetimeValueGetDeserialize(result);
+}
+
+export function _datetimeValuePutSend(
+  context: Client,
+  body: Date[],
+  options: DatetimeValuePutOptions = { requestOptions: {} },
+): StreamableMethod<DatetimeValuePut204Response> {
+  return context
+    .path("/type/array/datetime")
+    .put({ ...operationOptionsToRequestParameters(options), body: body });
+}
+
+export async function _datetimeValuePutDeserialize(
+  result: DatetimeValuePut204Response,
+): Promise<void> {
+  if (result.status !== "204") {
+    throw createRestError(result);
+  }
+
+  return;
+}
+
+export async function datetimeValuePut(
+  context: Client,
+  body: Date[],
+  options: DatetimeValuePutOptions = { requestOptions: {} },
+): Promise<void> {
+  const result = await _datetimeValuePutSend(context, body, options);
+  return _datetimeValuePutDeserialize(result);
+}

packages/typespec-ts/test/modularIntegration/generated/arrays/items/src/api/durationValue/index.ts

@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import {
+  ArrayContext as Client,
+  DurationValueGet200Response,
+  DurationValuePut204Response,
+} from "../../rest/index.js";
+import {
+  StreamableMethod,
+  operationOptionsToRequestParameters,
+  createRestError,
+} from "@azure-rest/core-client";
+import {
+  DurationValueGetOptions,
+  DurationValuePutOptions,
+} from "../../models/options.js";
+
+export function _durationValueGetSend(
+  context: Client,
+  options: DurationValueGetOptions = { requestOptions: {} },
+): StreamableMethod<DurationValueGet200Response> {
+  return context
+    .path("/type/array/duration")
+    .get({ ...operationOptionsToRequestParameters(options) });
+}
+
+export async function _durationValueGetDeserialize(
+  result: DurationValueGet200Response,
+): Promise<string[]> {
+  if (result.status !== "200") {
+    throw createRestError(result);
+  }
+
+  return result.body;
+}
+
+export async function durationValueGet(
+  context: Client,
+  options: DurationValueGetOptions = { requestOptions: {} },
+): Promise<string[]> {
+  const result = await _durationValueGetSend(context, options);
+  return _durationValueGetDeserialize(result);
+}
+
+export function _durationValuePutSend(
+  context: Client,
+  body: string[],
+  options: DurationValuePutOptions = { requestOptions: {} },
+): StreamableMethod<DurationValuePut204Response> {
+  return context
+    .path("/type/array/duration")
+    .put({ ...operationOptionsToRequestParameters(options), body: body });
+}
+
+export async function _durationValuePutDeserialize(
+  result: DurationValuePut204Response,
+): Promise<void> {
+  if (result.status !== "204") {
+    throw createRestError(result);
+  }
+
+  return;
+}
+
+export async function durationValuePut(
+  context: Client,
+  body: string[],
+  options: DurationValuePutOptions = { requestOptions: {} },
+): Promise<void> {
+  const result = await _durationValuePutSend(context, body, options);
+  return _durationValuePutDeserialize(result);
+}