Add Spector cases for serializing lossy duration encodings as integers

packages/http-specs/spec-summary.md

@@ -888,6 +888,15 @@ Expected header `duration: 180000`
 Test int32 seconds encode for a duration header.
 Expected header `duration: 36`
 
+### Encode_Duration_Header_int32SecondsFractional
+
+- Endpoint: `get /encode/duration/header/int32-seconds-fractional`
+
+Test int32 seconds encode for a duration header whose value has a fractional (sub-second) component.
+The duration is 35.625 seconds, e.g. TimeSpan.FromSeconds(35.625) in C#.
+Even though the underlying value is fractional, the client must serialize it as an integer (not a floating point number), e.g. `duration: 36`.
+Expected header to be an integer (the fractional part is dropped during serialization).
+
 ### Encode_Duration_Header_int32SecondsLargerUnit
 
 - Endpoint: `get /encode/duration/header/int32-seconds-larger-unit`
@@ -1165,6 +1174,29 @@ Expected response body:
 }
 ```
 
+### Encode_Duration_Property_int32SecondsFractional
+
+- Endpoint: `get /encode/duration/property/int32-seconds-fractional`
+
+Test operation with request and response model contains a duration property with int32 seconds encode whose value has a fractional (sub-second) component.
+The duration is 35.625 seconds, e.g. TimeSpan.FromSeconds(35.625) in C#.
+Even though the underlying value is fractional, the client must serialize it as an integer (not a floating point number).
+Expected request body:
+
+```json
+{
+  "value": 36
+}
+```
+
+Expected response body:
+
+```json
+{
+  "value": 36
+}
+```
+
 ### Encode_Duration_Property_int32SecondsLargerUnit
 
 - Endpoint: `get /encode/duration/property/int32-seconds-larger-unit`
@@ -1295,6 +1327,15 @@ Expected query parameter `input=36`
 Test int32 seconds encode for a duration array parameter.
 Expected query parameter `input=36,47`
 
+### Encode_Duration_Query_int32SecondsFractional
+
+- Endpoint: `get /encode/duration/query/int32-seconds-fractional`
+
+Test int32 seconds encode for a duration parameter whose value has a fractional (sub-second) component.
+The duration is 35.625 seconds, e.g. TimeSpan.FromSeconds(35.625) in C#.
+Even though the underlying value is fractional, the client must serialize it as an integer (not a floating point number), e.g. `input=36`.
+Expected query parameter to be an integer (the fractional part is dropped during serialization).
+
 ### Encode_Duration_Query_int32SecondsLargerUnit
 
 - Endpoint: `get /encode/duration/query/int32-seconds-larger-unit`

packages/http-specs/specs/encode/duration/main.tsp

@@ -45,6 +45,20 @@ namespace Query {
     input: duration,
   ): NoContentResponse;
 
+  @route("/int32-seconds-fractional")
+  @scenario
+  @scenarioDoc("""
+    Test int32 seconds encode for a duration parameter whose value has a fractional (sub-second) component.
+    The duration is 35.625 seconds, e.g. TimeSpan.FromSeconds(35.625) in C#.
+    Even though the underlying value is fractional, the client must serialize it as an integer (not a floating point number), e.g. `input=36`.
+    Expected query parameter to be an integer (the fractional part is dropped during serialization).
+    """)
+  op int32SecondsFractional(
+    @query
+    @encode(DurationKnownEncoding.seconds, int32)
+    input: duration,
+  ): NoContentResponse;
+
   @route("/int32-seconds-larger-unit")
   @scenario
   @scenarioDoc("""
@@ -202,6 +216,11 @@ namespace Property {
     value: duration;
   }
 
+  model Int32SecondsFractionalDurationProperty {
+    @encode(DurationKnownEncoding.seconds, int32)
+    value: duration;
+  }
+
   model FloatSecondsDurationProperty {
     @encode(DurationKnownEncoding.seconds, float)
     value: duration;
@@ -320,6 +339,29 @@ namespace Property {
     """)
   op int32Seconds(@body body: Int32SecondsDurationProperty): Int32SecondsDurationProperty;
 
+  @route("/int32-seconds-fractional")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with int32 seconds encode whose value has a fractional (sub-second) component.
+    The duration is 35.625 seconds, e.g. TimeSpan.FromSeconds(35.625) in C#.
+    Even though the underlying value is fractional, the client must serialize it as an integer (not a floating point number).
+    Expected request body:
+    ```json
+    {
+      "value": 36
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": 36
+    }
+    ```
+    """)
+  op int32SecondsFractional(
+    @body body: Int32SecondsFractionalDurationProperty,
+  ): Int32SecondsFractionalDurationProperty;
+
   @route("/float-seconds")
   @scenario
   @scenarioDoc("""
@@ -603,6 +645,20 @@ namespace Header {
     duration: duration,
   ): NoContentResponse;
 
+  @route("/int32-seconds-fractional")
+  @scenario
+  @scenarioDoc("""
+    Test int32 seconds encode for a duration header whose value has a fractional (sub-second) component.
+    The duration is 35.625 seconds, e.g. TimeSpan.FromSeconds(35.625) in C#.
+    Even though the underlying value is fractional, the client must serialize it as an integer (not a floating point number), e.g. `duration: 36`.
+    Expected header to be an integer (the fractional part is dropped during serialization).
+    """)
+  op int32SecondsFractional(
+    @header
+    @encode(DurationKnownEncoding.seconds, int32)
+    duration: duration,
+  ): NoContentResponse;
+
   @route("/int32-seconds-larger-unit")
   @scenario
   @scenarioDoc("""

packages/http-specs/specs/encode/duration/mockapi.ts

@@ -23,6 +23,36 @@ function createBodyServerTests(uri: string, data: any, value: any) {
     kind: "MockApiDefinition",
   });
 }
+
+// Validates that a duration with a fractional (sub-second) component is serialized as an integer.
+function createBodyIntServerTests(uri: string) {
+  return passOnSuccess({
+    uri,
+    method: "post",
+    request: {
+      body: json({ value: 36 }),
+    },
+    response: {
+      status: 200,
+      body: json({ value: 36 }),
+    },
+    handler: (req: MockRequest) => {
+      const value = req.body?.value;
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        throw new ValidationError(
+          `Expected body property "value" to be serialized as an integer but got ${value}`,
+          "an integer",
+          value,
+        );
+      }
+      return {
+        status: 200,
+        body: json({ value }),
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
 Scenarios.Encode_Duration_Property_default = createBodyServerTests(
   "/encode/duration/property/default",
   {
@@ -51,6 +81,9 @@ Scenarios.Encode_Duration_Property_int32Seconds = createBodyServerTests(
   },
   36,
 );
+Scenarios.Encode_Duration_Property_int32SecondsFractional = createBodyIntServerTests(
+  "/encode/duration/property/int32-seconds-fractional",
+);
 Scenarios.Encode_Duration_Property_iso8601 = createBodyServerTests(
   "/encode/duration/property/iso8601",
   {
@@ -175,6 +208,34 @@ function createQueryFloatServerTests(uri: string, paramData: any, value: number)
     kind: "MockApiDefinition",
   });
 }
+
+// Validates that a duration with a fractional (sub-second) component is serialized as an integer.
+function createQueryIntServerTests(uri: string, paramData: any) {
+  return passOnSuccess({
+    uri,
+    method: "get",
+    request: {
+      query: paramData,
+    },
+    response: {
+      status: 204,
+    },
+    handler: (req: MockRequest) => {
+      const actual = req.query["input"] as string;
+      if (!/^[-+]?\d+$/.test(actual)) {
+        throw new ValidationError(
+          `Expected query param input to be serialized as an integer but got ${actual}`,
+          "an integer",
+          actual,
+        );
+      }
+      return {
+        status: 204,
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
 Scenarios.Encode_Duration_Query_default = createQueryServerTests(
   "/encode/duration/query/default",
   {
@@ -196,6 +257,12 @@ Scenarios.Encode_Duration_Query_int32Seconds = createQueryServerTests(
   },
   "36",
 );
+Scenarios.Encode_Duration_Query_int32SecondsFractional = createQueryIntServerTests(
+  "/encode/duration/query/int32-seconds-fractional",
+  {
+    input: 36,
+  },
+);
 Scenarios.Encode_Duration_Query_int32SecondsArray = createQueryServerTests(
   "/encode/duration/query/int32-seconds-array",
   {
@@ -321,6 +388,36 @@ function createHeaderFloatServerTests(uri: string, value: number) {
   });
 }
 
+// Validates that a duration with a fractional (sub-second) component is serialized as an integer.
+function createHeaderIntServerTests(uri: string) {
+  return passOnSuccess({
+    uri,
+    method: "get",
+    request: {
+      headers: {
+        duration: "36",
+      },
+    },
+    response: {
+      status: 204,
+    },
+    handler: (req: MockRequest) => {
+      const actual = req.headers["duration"];
+      if (!/^[-+]?\d+$/.test(actual)) {
+        throw new ValidationError(
+          `Expected header duration to be serialized as an integer but got ${actual}`,
+          "an integer",
+          actual,
+        );
+      }
+      return {
+        status: 204,
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+
 Scenarios.Encode_Duration_Header_default = createHeaderServerTests(
   "/encode/duration/header/default",
   {
@@ -342,6 +439,9 @@ Scenarios.Encode_Duration_Header_int32Seconds = createHeaderServerTests(
   },
   "36",
 );
+Scenarios.Encode_Duration_Header_int32SecondsFractional = createHeaderIntServerTests(
+  "/encode/duration/header/int32-seconds-fractional",
+);
 Scenarios.Encode_Duration_Header_floatSeconds = createHeaderServerTests(
   "/encode/duration/header/float-seconds",
   {