@typespec/http-specs 0.37.2

package/specs/encode/duration/main.tsp

@@ -0,0 +1,322 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+using Azure.ClientGenerator.Core;
+
+@doc("Test for encode decorator on duration.")
+@supportedBy("dpg")
+@scenarioService("/encode/duration")
+namespace Encode.Duration;
+
+@operationGroup
+@route("/query")
+namespace Query {
+  @route("/default")
+  @scenario
+  @scenarioDoc("""
+    Test default encode for a duration parameter.
+    Expected query parameter `input=P40D`
+    """)
+  op default(
+    @query
+    input: duration,
+  ): NoContentResponse;
+
+  @route("/iso8601")
+  @scenario
+  @scenarioDoc("""
+    Test iso8601 encode for a duration parameter.
+    Expected query parameter `input=P40D`
+    """)
+  op iso8601(
+    @query
+    @encode(DurationKnownEncoding.ISO8601)
+    input: duration,
+  ): NoContentResponse;
+
+  @route("/int32-seconds")
+  @scenario
+  @scenarioDoc("""
+    Test int32 seconds encode for a duration parameter.
+    Expected query parameter `input=36`
+    """)
+  op int32Seconds(
+    @query
+    @encode(DurationKnownEncoding.seconds, int32)
+    input: duration,
+  ): NoContentResponse;
+
+  @route("/float-seconds")
+  @scenario
+  @scenarioDoc("""
+    Test float seconds encode for a duration parameter.
+    Expected query parameter `input=35.625`
+    """)
+  op floatSeconds(
+    @query
+    @encode(DurationKnownEncoding.seconds, float)
+    input: duration,
+  ): NoContentResponse;
+
+  @route("/float64-seconds")
+  @scenario
+  @scenarioDoc("""
+    Test float64 seconds encode for a duration parameter.
+    Expected query parameter `input=35.625`
+    """)
+  op float64Seconds(
+    @query
+    @encode(DurationKnownEncoding.seconds, float64)
+    input: duration,
+  ): NoContentResponse;
+
+  @encode(DurationKnownEncoding.seconds, int32)
+  scalar Int32Duration extends duration;
+
+  @route("/int32-seconds-array")
+  @scenario
+  @scenarioDoc("""
+    Test int32 seconds encode for a duration array parameter.
+    Expected query parameter `input=36,47`
+    """)
+  op int32SecondsArray(
+    #suppress "deprecated" "Deprecated in next release"
+    @query({
+      format: "csv",
+    })
+    input: Int32Duration[],
+  ): NoContentResponse;
+}
+
+@operationGroup
+@route("/property")
+namespace Property {
+  model DefaultDurationProperty {
+    value: duration;
+  }
+
+  model ISO8601DurationProperty {
+    @encode(DurationKnownEncoding.ISO8601)
+    value: duration;
+  }
+
+  model Int32SecondsDurationProperty {
+    @encode(DurationKnownEncoding.seconds, int32)
+    value: duration;
+  }
+
+  model FloatSecondsDurationProperty {
+    @encode(DurationKnownEncoding.seconds, float)
+    value: duration;
+  }
+
+  model Float64SecondsDurationProperty {
+    @encode(DurationKnownEncoding.seconds, float64)
+    value: duration;
+  }
+
+  @encode(DurationKnownEncoding.seconds, float32)
+  scalar Float32Duration extends duration;
+
+  model FloatSecondsDurationArrayProperty {
+    value: Float32Duration[];
+  }
+
+  @route("/default")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with default encode.
+    Expected request body:
+    ```json
+    {
+      "value": "P40D"
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": "P40D"
+    }
+    ```
+    """)
+  @post
+  op default(@body body: DefaultDurationProperty): DefaultDurationProperty;
+
+  @route("/iso8601")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with iso8601 encode.
+    Expected request body:
+    ```json
+    {
+      "value": "P40D"
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": "P40D"
+    }
+    ```
+    """)
+  @post
+  op iso8601(@body body: ISO8601DurationProperty): ISO8601DurationProperty;
+
+  @route("/int32-seconds")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with int32 seconds encode.
+    Expected request body:
+    ```json
+    {
+      "value": 36
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": 36
+    }
+    ```
+    """)
+  op int32Seconds(@body body: Int32SecondsDurationProperty): Int32SecondsDurationProperty;
+
+  @route("/float-seconds")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with float seconds encode.
+    Expected request body:
+    ```json
+    {
+      "value": 35.625
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": 35.625
+    }
+    ```
+    """)
+  op floatSeconds(@body body: FloatSecondsDurationProperty): FloatSecondsDurationProperty;
+
+  @route("/float64-seconds")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with float64 seconds encode.
+    Expected request body:
+    ```json
+    {
+      "value": 35.625
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": 35.625
+    }
+    ```
+    """)
+  op float64Seconds(@body body: Float64SecondsDurationProperty): Float64SecondsDurationProperty;
+
+  @route("/float-seconds-array")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains an array property which elements are duration with float seconds encode.
+    Expected request body:
+    ```json
+    {
+      "value": [35.625, 46.75]
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": [35.625, 46.75]
+    }
+    ```
+    """)
+  op floatSecondsArray(
+    @body body: FloatSecondsDurationArrayProperty,
+  ): FloatSecondsDurationArrayProperty;
+}
+
+@operationGroup
+@route("/header")
+namespace Header {
+  @route("/default")
+  @scenario
+  @scenarioDoc("""
+    Test default encode for a duration header.
+    Expected header `input=P40D`
+    """)
+  op default(
+    @header
+    duration: duration,
+  ): NoContentResponse;
+
+  @route("/iso8601")
+  @scenario
+  @scenarioDoc("""
+    Test iso8601 encode for a duration header.
+    Expected header `duration: P40D`
+    """)
+  op iso8601(
+    @header
+    @encode(DurationKnownEncoding.ISO8601)
+    duration: duration,
+  ): NoContentResponse;
+
+  @encode(DurationKnownEncoding.ISO8601)
+  scalar Iso8601Duration extends duration;
+
+  @route("/iso8601-array")
+  @scenario
+  @scenarioDoc("""
+    Test iso8601 encode for a duration array header.
+    Expected header `duration: [P40D,P50D]`
+    """)
+  op iso8601Array(
+    @header({
+      format: "csv",
+    })
+    duration: Iso8601Duration[],
+  ): NoContentResponse;
+
+  @route("/int32-seconds")
+  @scenario
+  @scenarioDoc("""
+    Test int32 seconds encode for a duration header.
+    Expected header `duration: 36`
+    """)
+  op int32Seconds(
+    @header
+    @encode(DurationKnownEncoding.seconds, int32)
+    duration: duration,
+  ): NoContentResponse;
+
+  @route("/float-seconds")
+  @scenario
+  @scenarioDoc("""
+    Test float seconds encode for a duration header.
+    Expected header `duration: 35.625`
+    """)
+  op floatSeconds(
+    @header
+    @encode(DurationKnownEncoding.seconds, float)
+    duration: duration,
+  ): NoContentResponse;
+
+  @route("/float64-seconds")
+  @scenario
+  @scenarioDoc("""
+    Test float64 seconds encode for a duration header.
+    Expected header `duration: 35.625`
+    """)
+  op float64Seconds(
+    @header
+    @encode(DurationKnownEncoding.seconds, float64)
+    duration: duration,
+  ): NoContentResponse;
+}

package/specs/encode/duration/mockapi.ts

@@ -0,0 +1,204 @@
+import {
+  CollectionFormat,
+  json,
+  MockRequest,
+  passOnSuccess,
+  ScenarioMockApi,
+} from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+function createBodyServerTests(uri: string, data: any, value: any) {
+  return passOnSuccess({
+    uri,
+    method: "post",
+    request: {
+      body: data,
+    },
+    response: {
+      status: 200,
+      body: json(data),
+    },
+    handler: (req: MockRequest) => {
+      req.expect.coercedBodyEquals({ value: value });
+      return {
+        status: 200,
+        body: json({ value: value }),
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+Scenarios.Encode_Duration_Property_default = createBodyServerTests(
+  "/encode/duration/property/default",
+  {
+    value: "P40D",
+  },
+  "P40D",
+);
+Scenarios.Encode_Duration_Property_default = createBodyServerTests(
+  "/encode/duration/property/float-seconds",
+  {
+    value: 35.625,
+  },
+  35.625,
+);
+Scenarios.Encode_Duration_Property_float64Seconds = createBodyServerTests(
+  "/encode/duration/property/float64-seconds",
+  {
+    value: 35.625,
+  },
+  35.625,
+);
+Scenarios.Encode_Duration_Property_int32Seconds = createBodyServerTests(
+  "/encode/duration/property/int32-seconds",
+  {
+    value: 36,
+  },
+  36,
+);
+Scenarios.Encode_Duration_Property_iso8601 = createBodyServerTests(
+  "/encode/duration/property/iso8601",
+  {
+    value: "P40D",
+  },
+  "P40D",
+);
+Scenarios.Encode_Duration_Property_floatSecondsArray = createBodyServerTests(
+  "/encode/duration/property/float-seconds-array",
+  {
+    value: [35.625, 46.75],
+  },
+  [35.625, 46.75],
+);
+
+function createQueryServerTests(
+  uri: string,
+  paramData: any,
+  value: any,
+  collectionFormat?: CollectionFormat,
+) {
+  return passOnSuccess({
+    uri,
+    method: "get",
+    request: {
+      params: paramData,
+    },
+    response: {
+      status: 204,
+    },
+    handler: (req: MockRequest) => {
+      req.expect.containsQueryParam("input", value, collectionFormat);
+      return {
+        status: 204,
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+Scenarios.Encode_Duration_Query_default = createQueryServerTests(
+  "/encode/duration/query/default",
+  {
+    input: "P40D",
+  },
+  "P40D",
+);
+Scenarios.Encode_Duration_Query_iso8601 = createQueryServerTests(
+  "/encode/duration/query/iso8601",
+  {
+    input: "P40D",
+  },
+  "P40D",
+);
+Scenarios.Encode_Duration_Query_int32Seconds = createQueryServerTests(
+  "/encode/duration/query/int32-seconds",
+  {
+    input: 36,
+  },
+  "36",
+);
+Scenarios.Encode_Duration_Query_int32SecondsArray = createQueryServerTests(
+  "/encode/duration/query/int32-seconds-array",
+  {
+    input: [36, 47].join(","),
+  },
+  ["36", "47"],
+  "csv",
+);
+Scenarios.Encode_Duration_Query_floatSeconds = createQueryServerTests(
+  "/encode/duration/query/float-seconds",
+  {
+    input: 35.625,
+  },
+  "35.625",
+);
+Scenarios.Encode_Duration_Query_float64Seconds = createQueryServerTests(
+  "/encode/duration/query/float64-seconds",
+  {
+    input: 35.625,
+  },
+  "35.625",
+);
+
+function createHeaderServerTests(uri: string, headersData: any, value: any) {
+  return passOnSuccess({
+    uri,
+    method: "get",
+    request: {
+      headers: headersData,
+    },
+    response: {
+      status: 204,
+    },
+    handler: (req: MockRequest) => {
+      req.expect.containsHeader("duration", value);
+      return {
+        status: 204,
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+
+Scenarios.Encode_Duration_Header_default = createHeaderServerTests(
+  "/encode/duration/header/default",
+  {
+    duration: "P40D",
+  },
+  "P40D",
+);
+Scenarios.Encode_Duration_Header_iso8601 = createHeaderServerTests(
+  "/encode/duration/header/iso8601",
+  {
+    duration: "P40D",
+  },
+  "P40D",
+);
+Scenarios.Encode_Duration_Header_int32Seconds = createHeaderServerTests(
+  "/encode/duration/header/int32-seconds",
+  {
+    duration: 36,
+  },
+  "36",
+);
+Scenarios.Encode_Duration_Header_floatSeconds = createHeaderServerTests(
+  "/encode/duration/header/float-seconds",
+  {
+    duration: 35.625,
+  },
+  "35.625",
+);
+Scenarios.Encode_Duration_Header_floatSeconds = createHeaderServerTests(
+  "/encode/duration/header/float64-seconds",
+  {
+    duration: 35.625,
+  },
+  "35.625",
+);
+Scenarios.Encode_Duration_Header_iso8601Array = createHeaderServerTests(
+  "/encode/duration/header/iso8601-array",
+  {
+    duration: ["P40D", "P50D"].join(","),
+  },
+  "P40D,P50D",
+);

package/specs/encode/numeric/main.tsp

@@ -0,0 +1,71 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+using Azure.ClientGenerator.Core;
+
+@doc("Test for encode decorator on integer.")
+@supportedBy("dpg")
+@scenarioService("/encode/numeric")
+namespace Encode.Numeric;
+
+@operationGroup
+@route("/property")
+namespace Property {
+  alias SendSafeIntAsString = SendIntAsString<safeint, "10000000000", SafeintAsStringProperty>;
+
+  @route("/safeint")
+  op safeintAsString is SendSafeIntAsString.sendIntAsString;
+
+  model SafeintAsStringProperty {
+    @encode(string)
+    value: safeint;
+  }
+
+  alias SendUint32AsString = SendIntAsString<uint32, "1", Uint32AsStringProperty>;
+
+  @route("/uint32")
+  op uint32AsStringOptional is SendUint32AsString.sendIntAsString;
+
+  model Uint32AsStringProperty {
+    @encode(string)
+    value?: uint32;
+  }
+
+  alias SendUint8AsString = SendIntAsString<uint8, "255", Uint8AsStringProperty>;
+
+  @route("/uint8")
+  op uint8AsString is SendUint8AsString.sendIntAsString;
+
+  model Uint8AsStringProperty {
+    @encode(string)
+    value: uint8;
+  }
+
+  interface SendIntAsString<IntType extends integer, StringValue extends string, Payload> {
+    @scenario
+    @scenarioDoc(
+      """
+        Test operation with request and response model contains property of {type} type with string encode.
+        Expected request body:
+        ```json
+        {
+          "value": "{value}"
+        }
+        ```
+        Expected response body:
+        ```json
+        {
+          "value": "{value}"
+        }
+        ```
+        """,
+      {
+        type: IntType,
+        value: StringValue,
+      }
+    )
+    @post
+    sendIntAsString(@body value: Payload): Payload;
+  }
+}

package/specs/encode/numeric/mockapi.ts

@@ -0,0 +1,39 @@
+import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+function createTests(uri: string, value: any) {
+  return passOnSuccess({
+    uri,
+    method: "post",
+    request: {
+      body: {
+        value,
+      },
+    },
+    response: {
+      status: 200,
+      body: json({ value }),
+    },
+    handler: (req: MockRequest) => {
+      req.expect.coercedBodyEquals({ value });
+      return {
+        status: 200,
+        body: json({ value }),
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+Scenarios.Encode_Numeric_Property_safeintAsString = createTests(
+  "/encode/numeric/property/safeint",
+  "10000000000",
+);
+Scenarios.Encode_Numeric_Property_uint32AsStringOptional = createTests(
+  "/encode/numeric/property/uint32",
+  "1",
+);
+Scenarios.Encode_Numeric_Property_uint8AsString = createTests(
+  "/encode/numeric/property/uint8",
+  "255",
+);

package/specs/helper.ts

@@ -0,0 +1,8 @@
+import { resolvePath } from "@typespec/compiler";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+
+const root = resolvePath(fileURLToPath(import.meta.url), "../../../");
+
+export const pngFile = readFileSync(resolvePath(root, "assets/image.png"));
+export const jpgFile = readFileSync(resolvePath(root, "assets/image.jpg"));

package/specs/parameters/basic/main.tsp

@@ -0,0 +1,61 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+using Azure.ClientGenerator.Core;
+
+@doc("Test for basic parameters cases.")
+@supportedBy("dpg")
+@scenarioService("/parameters/basic")
+namespace Parameters.Basic;
+
+@route("/explicit-body")
+@operationGroup
+namespace ExplicitBody {
+  @doc("This is a simple model.")
+  model User {
+    name: string;
+  }
+
+  @scenario
+  @scenarioDoc("""
+    Test case for simple explicit body. 
+    
+    Should generate request body model named `User`.
+    Should generate an operation like below:
+    ```
+    spreadAsRequestBody(bodyParameter: BodyParameter)
+    ```
+    Note the parameter name is guessed from the model name and it may vary by language.
+    
+    Expected request body:
+    ```json
+    { "name": "foo" }
+    ```
+    """)
+  @route("/simple")
+  @put
+  op simple(@body body: User): NoContentResponse;
+}
+
+@route("/implicit-body")
+@operationGroup
+namespace ImplicitBody {
+  @scenario
+  @scenarioDoc("""
+    Test case for simple implicit body. 
+    
+    Should generate an operation like below:
+    ```
+    simple(name: string)
+    ```
+    
+    Expected request body:
+    ```json
+    { "name": "foo" }
+    ```
+    """)
+  @route("/simple")
+  @put
+  op simple(name: string): NoContentResponse;
+}