Add Spector cases for serializing lossy duration encodings as integers

.chronus/changes/copilot-add-spector-case-serialization-2026-5-1-18-57-48.md

@@ -0,0 +1,7 @@
+---
+changeKind: internal
+packages:
+  - "@typespec/http-specs"
+---
+
+Add encode/duration int32-seconds-fractional Spector scenarios verifying a fractional duration is serialized as an integer

packages/http-specs/spec-summary.md

@@ -888,6 +888,16 @@ 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 36.25 seconds, e.g. TimeSpan.FromSeconds(36.25) in C#.
+Even though the underlying value is fractional, the client must serialize it as an integer (not a floating point number such as `36.25`).
+This scenario specifically exercises the lossy encode case where the source type carries more precision than the target encoding; it is not about arbitrary type mismatches, which are already covered by other round-trip scenarios.
+The value is chosen so that rounding and truncating both yield the same integer, so the expected header is `duration: 36`.
+
 ### Encode_Duration_Header_int32SecondsLargerUnit
 
 - Endpoint: `get /encode/duration/header/int32-seconds-larger-unit`
@@ -1165,6 +1175,31 @@ 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 36.25 seconds, e.g. TimeSpan.FromSeconds(36.25) in C#.
+Even though the underlying value is fractional, the client must serialize it as an integer (not a floating point number such as `36.25`).
+This scenario specifically exercises the lossy encode case where the source type carries more precision than the target encoding; it is not about arbitrary type mismatches, which are already covered by other round-trip scenarios.
+The value is chosen so that rounding and truncating both yield the same integer.
+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 +1330,16 @@ 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 36.25 seconds, e.g. TimeSpan.FromSeconds(36.25) in C#.
+Even though the underlying value is fractional, the client must serialize it as an integer (not a floating point number such as `36.25`).
+This scenario specifically exercises the lossy encode case where the source type carries more precision than the target encoding; it is not about arbitrary type mismatches, which are already covered by other round-trip scenarios.
+The value is chosen so that rounding and truncating both yield the same integer, so the expected query parameter is `input=36`.
+
 ### Encode_Duration_Query_int32SecondsLargerUnit
 
 - Endpoint: `get /encode/duration/query/int32-seconds-larger-unit`

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

@@ -45,6 +45,21 @@ 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 36.25 seconds, e.g. TimeSpan.FromSeconds(36.25) in C#.
+    Even though the underlying value is fractional, the client must serialize it as an integer (not a floating point number such as `36.25`).
+    This scenario specifically exercises the lossy encode case where the source type carries more precision than the target encoding; it is not about arbitrary type mismatches, which are already covered by other round-trip scenarios.
+    The value is chosen so that rounding and truncating both yield the same integer, so the expected query parameter is `input=36`.
+    """)
+  op int32SecondsFractional(
+    @query
+    @encode(DurationKnownEncoding.seconds, int32)
+    input: duration,
+  ): NoContentResponse;
+
   @route("/int32-seconds-larger-unit")
   @scenario
   @scenarioDoc("""
@@ -202,6 +217,11 @@ namespace Property {
     value: duration;
   }
 
+  model Int32SecondsFractionalDurationProperty {
+    @encode(DurationKnownEncoding.seconds, int32)
+    value: duration;
+  }
+
   model FloatSecondsDurationProperty {
     @encode(DurationKnownEncoding.seconds, float)
     value: duration;
@@ -320,6 +340,31 @@ 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 36.25 seconds, e.g. TimeSpan.FromSeconds(36.25) in C#.
+    Even though the underlying value is fractional, the client must serialize it as an integer (not a floating point number such as `36.25`).
+    This scenario specifically exercises the lossy encode case where the source type carries more precision than the target encoding; it is not about arbitrary type mismatches, which are already covered by other round-trip scenarios.
+    The value is chosen so that rounding and truncating both yield the same integer.
+    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 +648,21 @@ 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 36.25 seconds, e.g. TimeSpan.FromSeconds(36.25) in C#.
+    Even though the underlying value is fractional, the client must serialize it as an integer (not a floating point number such as `36.25`).
+    This scenario specifically exercises the lossy encode case where the source type carries more precision than the target encoding; it is not about arbitrary type mismatches, which are already covered by other round-trip scenarios.
+    The value is chosen so that rounding and truncating both yield the same integer, so the expected header is `duration: 36`.
+    """)
+  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,44 @@ 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.
+// The duration (36.25s) is chosen so rounding and truncating both yield 36.
+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,
+        );
+      }
+      if (value !== 36) {
+        throw new ValidationError(
+          `Expected body property "value" to be 36 but got ${value}`,
+          "36",
+          value,
+        );
+      }
+      return {
+        status: 200,
+        body: json({ value }),
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
 Scenarios.Encode_Duration_Property_default = createBodyServerTests(
   "/encode/duration/property/default",
   {
@@ -51,6 +89,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 +216,38 @@ 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.
+// The duration (36.25s) is chosen so rounding and truncating both yield 36.
+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,
+        );
+      }
+      if (actual !== "36") {
+        throw new ValidationError(`Expected query param input=36 but got ${actual}`, "36", actual);
+      }
+      return {
+        status: 204,
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
 Scenarios.Encode_Duration_Query_default = createQueryServerTests(
   "/encode/duration/query/default",
   {
@@ -196,6 +269,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 +400,40 @@ function createHeaderFloatServerTests(uri: string, value: number) {
   });
 }
 
+// Validates that a duration with a fractional (sub-second) component is serialized as an integer.
+// The duration (36.25s) is chosen so rounding and truncating both yield 36.
+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,
+        );
+      }
+      if (actual !== "36") {
+        throw new ValidationError(`Expected header duration=36 but got ${actual}`, "36", actual);
+      }
+      return {
+        status: 204,
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+
 Scenarios.Encode_Duration_Header_default = createHeaderServerTests(
   "/encode/duration/header/default",
   {
@@ -342,6 +455,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",
   {