@typespec/http-specs 0.1.0-alpha.0

package/specs/encode/datetime/mockapi.ts

@@ -0,0 +1,274 @@
+import {
+  CollectionFormat,
+  json,
+  MockRequest,
+  passOnSuccess,
+  ScenarioMockApi,
+  validateValueFormat,
+  ValidationError,
+} from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+function createQueryServerTests(
+  uri: string,
+  paramData: any,
+  format: "rfc7231" | "rfc3339" | undefined,
+  value: any,
+  collectionFormat?: CollectionFormat,
+) {
+  return passOnSuccess({
+    uri,
+    method: "get",
+    request: {
+      params: paramData,
+    },
+    response: {
+      status: 204,
+    },
+    handler(req: MockRequest) {
+      if (format) {
+        validateValueFormat(req.query["value"] as string, format);
+        if (Date.parse(req.query["value"] as string) !== Date.parse(value)) {
+          throw new ValidationError(`Wrong value`, value, req.query["value"]);
+        }
+      } else {
+        req.expect.containsQueryParam("value", value, collectionFormat);
+      }
+      return {
+        status: 204,
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+Scenarios.Encode_Datetime_Query_default = createQueryServerTests(
+  "/encode/datetime/query/default",
+  {
+    value: "2022-08-26T18:38:00.000Z",
+  },
+  "rfc3339",
+  "2022-08-26T18:38:00.000Z",
+);
+Scenarios.Encode_Datetime_Query_rfc3339 = createQueryServerTests(
+  "/encode/datetime/query/rfc3339",
+  {
+    value: "2022-08-26T18:38:00.000Z",
+  },
+  "rfc3339",
+  "2022-08-26T18:38:00.000Z",
+);
+Scenarios.Encode_Datetime_Query_rfc7231 = createQueryServerTests(
+  "/encode/datetime/query/rfc7231",
+  {
+    value: "Fri, 26 Aug 2022 14:38:00 GMT",
+  },
+  "rfc7231",
+  "Fri, 26 Aug 2022 14:38:00 GMT",
+);
+Scenarios.Encode_Datetime_Query_unixTimestamp = createQueryServerTests(
+  "/encode/datetime/query/unix-timestamp",
+  {
+    value: 1686566864,
+  },
+  undefined,
+  "1686566864",
+);
+Scenarios.Encode_Datetime_Query_unixTimestampArray = createQueryServerTests(
+  "/encode/datetime/query/unix-timestamp-array",
+  {
+    value: [1686566864, 1686734256].join(","),
+  },
+  undefined,
+  ["1686566864", "1686734256"],
+  "csv",
+);
+function createPropertyServerTests(
+  uri: string,
+  data: any,
+  format: "rfc7231" | "rfc3339" | undefined,
+  value: any,
+) {
+  return passOnSuccess({
+    uri,
+    method: "post",
+    request: {
+      body: data,
+    },
+    response: {
+      status: 200,
+    },
+    handler: (req: MockRequest) => {
+      if (format) {
+        validateValueFormat(req.body["value"], format);
+        if (Date.parse(req.body["value"]) !== Date.parse(value)) {
+          throw new ValidationError(`Wrong value`, value, req.body["value"]);
+        }
+      } else {
+        req.expect.coercedBodyEquals({ value: value });
+      }
+      return {
+        status: 200,
+        body: json({ value: value }),
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+Scenarios.Encode_Datetime_Property_default = createPropertyServerTests(
+  "/encode/datetime/property/default",
+  {
+    value: "2022-08-26T18:38:00.000Z",
+  },
+  "rfc3339",
+  "2022-08-26T18:38:00.000Z",
+);
+Scenarios.Encode_Datetime_Property_rfc3339 = createPropertyServerTests(
+  "/encode/datetime/property/rfc3339",
+  {
+    value: "2022-08-26T18:38:00.000Z",
+  },
+  "rfc3339",
+  "2022-08-26T18:38:00.000Z",
+);
+Scenarios.Encode_Datetime_Property_rfc7231 = createPropertyServerTests(
+  "/encode/datetime/property/rfc7231",
+  {
+    value: "Fri, 26 Aug 2022 14:38:00 GMT",
+  },
+  "rfc7231",
+  "Fri, 26 Aug 2022 14:38:00 GMT",
+);
+Scenarios.Encode_Datetime_Property_unixTimestamp = createPropertyServerTests(
+  "/encode/datetime/property/unix-timestamp",
+  {
+    value: 1686566864,
+  },
+  undefined,
+  1686566864,
+);
+Scenarios.Encode_Datetime_Property_unixTimestampArray = createPropertyServerTests(
+  "/encode/datetime/property/unix-timestamp-array",
+  {
+    value: [1686566864, 1686734256],
+  },
+  undefined,
+  [1686566864, 1686734256],
+);
+function createHeaderServerTests(
+  uri: string,
+  data: any,
+  format: "rfc7231" | "rfc3339" | undefined,
+  value: any,
+) {
+  return passOnSuccess({
+    uri,
+    method: "get",
+    request: {
+      headers: data,
+    },
+    response: {
+      status: 204,
+    },
+    handler(req: MockRequest) {
+      if (format) {
+        validateValueFormat(req.headers["value"], format);
+        if (Date.parse(req.headers["value"]) !== Date.parse(value)) {
+          throw new ValidationError(`Wrong value`, value, req.headers["value"]);
+        }
+      } else {
+        req.expect.containsHeader("value", value);
+      }
+      return {
+        status: 204,
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+Scenarios.Encode_Datetime_Header_default = createHeaderServerTests(
+  "/encode/datetime/header/default",
+  {
+    value: "Fri, 26 Aug 2022 14:38:00 GMT",
+  },
+  "rfc7231",
+  "Fri, 26 Aug 2022 14:38:00 GMT",
+);
+Scenarios.Encode_Datetime_Header_rfc3339 = createHeaderServerTests(
+  "/encode/datetime/header/rfc3339",
+  {
+    value: "2022-08-26T18:38:00.000Z",
+  },
+  "rfc3339",
+  "2022-08-26T18:38:00.000Z",
+);
+Scenarios.Encode_Datetime_Header_rfc7231 = createHeaderServerTests(
+  "/encode/datetime/header/rfc7231",
+  {
+    value: "Fri, 26 Aug 2022 14:38:00 GMT",
+  },
+  "rfc7231",
+  "Fri, 26 Aug 2022 14:38:00 GMT",
+);
+Scenarios.Encode_Datetime_Header_unixTimestamp = createHeaderServerTests(
+  "/encode/datetime/header/unix-timestamp",
+  {
+    value: 1686566864,
+  },
+  undefined,
+  "1686566864",
+);
+Scenarios.Encode_Datetime_Header_unixTimestampArray = createHeaderServerTests(
+  "/encode/datetime/header/unix-timestamp-array",
+  {
+    value: [1686566864, 1686734256].join(","),
+  },
+  undefined,
+  "1686566864,1686734256",
+);
+function createResponseHeaderServerTests(uri: string, data: any, value: any) {
+  return passOnSuccess({
+    uri,
+    method: "get",
+    request: {},
+    response: {
+      status: 204,
+      headers: data,
+    },
+    handler: (req: MockRequest) => {
+      return {
+        status: 204,
+        headers: { value: value },
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+Scenarios.Encode_Datetime_ResponseHeader_default = createResponseHeaderServerTests(
+  "/encode/datetime/responseheader/default",
+  {
+    value: "Fri, 26 Aug 2022 14:38:00 GMT",
+  },
+  "Fri, 26 Aug 2022 14:38:00 GMT",
+);
+Scenarios.Encode_Datetime_ResponseHeader_rfc3339 = createResponseHeaderServerTests(
+  "/encode/datetime/responseheader/rfc3339",
+  {
+    value: "2022-08-26T18:38:00.000Z",
+  },
+  "2022-08-26T18:38:00.000Z",
+);
+Scenarios.Encode_Datetime_ResponseHeader_rfc7231 = createResponseHeaderServerTests(
+  "/encode/datetime/responseheader/rfc7231",
+  {
+    value: "Fri, 26 Aug 2022 14:38:00 GMT",
+  },
+  "Fri, 26 Aug 2022 14:38:00 GMT",
+);
+Scenarios.Encode_Datetime_ResponseHeader_unixTimestamp = createResponseHeaderServerTests(
+  "/encode/datetime/responseheader/unix-timestamp",
+  {
+    value: "1686566864",
+  },
+  1686566864,
+);

package/specs/encode/duration/main.tsp

@@ -0,0 +1,318 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@doc("Test for encode decorator on duration.")
+@scenarioService("/encode/duration")
+namespace Encode.Duration;
+
+@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;
+}
+
+@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;
+}
+
+@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;
+}