@typespec/http-specs 0.1.0-alpha.9 → 0.1.0-dev.0

package/specs/encode/duration/mockapi.ts

@@ -4,6 +4,7 @@ import {
   MockRequest,
   passOnSuccess,
   ScenarioMockApi,
+  ValidationError,
 } from "@typespec/spec-api";
 
 export const Scenarios: Record<string, ScenarioMockApi> = {};
@@ -13,7 +14,7 @@ function createBodyServerTests(uri: string, data: any, value: any) {
     uri,
     method: "post",
     request: {
-      body: data,
+      body: json(data),
     },
     response: {
       status: 200,
@@ -65,6 +66,63 @@ Scenarios.Encode_Duration_Property_floatSecondsArray = createBodyServerTests(
   [35.625, 46.75],
 );
 
+Scenarios.Encode_Duration_Property_int32Milliseconds = createBodyServerTests(
+  "/encode/duration/property/int32-milliseconds",
+  {
+    value: 36000,
+  },
+  36000,
+);
+Scenarios.Encode_Duration_Property_floatMilliseconds = createBodyServerTests(
+  "/encode/duration/property/float-milliseconds",
+  {
+    value: 35625,
+  },
+  35625,
+);
+Scenarios.Encode_Duration_Property_float64Milliseconds = createBodyServerTests(
+  "/encode/duration/property/float64-milliseconds",
+  {
+    value: 35625,
+  },
+  35625,
+);
+Scenarios.Encode_Duration_Property_floatMillisecondsArray = createBodyServerTests(
+  "/encode/duration/property/float-milliseconds-array",
+  {
+    value: [35625, 46750],
+  },
+  [35625, 46750],
+);
+Scenarios.Encode_Duration_Property_int32SecondsLargerUnit = createBodyServerTests(
+  "/encode/duration/property/int32-seconds-larger-unit",
+  {
+    value: 120,
+  },
+  120,
+);
+Scenarios.Encode_Duration_Property_floatSecondsLargerUnit = createBodyServerTests(
+  "/encode/duration/property/float-seconds-larger-unit",
+  {
+    value: 150.0,
+  },
+  150.0,
+);
+Scenarios.Encode_Duration_Property_int32MillisecondsLargerUnit = createBodyServerTests(
+  "/encode/duration/property/int32-milliseconds-larger-unit",
+  {
+    value: 180000,
+  },
+  180000,
+);
+Scenarios.Encode_Duration_Property_floatMillisecondsLargerUnit = createBodyServerTests(
+  "/encode/duration/property/float-milliseconds-larger-unit",
+  {
+    value: 210000.0,
+  },
+  210000.0,
+);
+
 function createQueryServerTests(
   uri: string,
   paramData: any,
@@ -75,7 +133,7 @@ function createQueryServerTests(
     uri,
     method: "get",
     request: {
-      params: paramData,
+      query: paramData,
     },
     response: {
       status: 204,
@@ -89,6 +147,34 @@ function createQueryServerTests(
     kind: "MockApiDefinition",
   });
 }
+
+function createQueryFloatServerTests(uri: string, paramData: any, value: number) {
+  return passOnSuccess({
+    uri,
+    method: "get",
+    request: {
+      query: paramData,
+    },
+    response: {
+      status: 204,
+    },
+    handler: (req: MockRequest) => {
+      const actual = req.query["input"] as string;
+      const actualNum = parseFloat(actual);
+      if (isNaN(actualNum) || actualNum !== value) {
+        throw new ValidationError(
+          `Expected query param input=${value} but got ${actual}`,
+          String(value),
+          actual,
+        );
+      }
+      return {
+        status: 204,
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
 Scenarios.Encode_Duration_Query_default = createQueryServerTests(
   "/encode/duration/query/default",
   {
@@ -133,6 +219,64 @@ Scenarios.Encode_Duration_Query_float64Seconds = createQueryServerTests(
   "35.625",
 );
 
+Scenarios.Encode_Duration_Query_int32Milliseconds = createQueryServerTests(
+  "/encode/duration/query/int32-milliseconds",
+  {
+    input: 36000,
+  },
+  "36000",
+);
+Scenarios.Encode_Duration_Query_floatMilliseconds = createQueryFloatServerTests(
+  "/encode/duration/query/float-milliseconds",
+  {
+    input: 35625,
+  },
+  35625,
+);
+Scenarios.Encode_Duration_Query_float64Milliseconds = createQueryFloatServerTests(
+  "/encode/duration/query/float64-milliseconds",
+  {
+    input: 35625,
+  },
+  35625,
+);
+Scenarios.Encode_Duration_Query_int32MillisecondsArray = createQueryServerTests(
+  "/encode/duration/query/int32-milliseconds-array",
+  {
+    input: [36000, 47000].join(","),
+  },
+  ["36000", "47000"],
+  "csv",
+);
+Scenarios.Encode_Duration_Query_int32SecondsLargerUnit = createQueryServerTests(
+  "/encode/duration/query/int32-seconds-larger-unit",
+  {
+    input: 120,
+  },
+  "120",
+);
+Scenarios.Encode_Duration_Query_floatSecondsLargerUnit = createQueryFloatServerTests(
+  "/encode/duration/query/float-seconds-larger-unit",
+  {
+    input: 150,
+  },
+  150,
+);
+Scenarios.Encode_Duration_Query_int32MillisecondsLargerUnit = createQueryServerTests(
+  "/encode/duration/query/int32-milliseconds-larger-unit",
+  {
+    input: 180000,
+  },
+  "180000",
+);
+Scenarios.Encode_Duration_Query_floatMillisecondsLargerUnit = createQueryFloatServerTests(
+  "/encode/duration/query/float-milliseconds-larger-unit",
+  {
+    input: 210000,
+  },
+  210000,
+);
+
 function createHeaderServerTests(uri: string, headersData: any, value: any) {
   return passOnSuccess({
     uri,
@@ -147,6 +291,31 @@ function createHeaderServerTests(uri: string, headersData: any, value: any) {
   });
 }
 
+function createHeaderFloatServerTests(uri: string, value: number) {
+  return passOnSuccess({
+    uri,
+    method: "get",
+    response: {
+      status: 204,
+    },
+    handler: (req: MockRequest) => {
+      const actual = req.headers["duration"];
+      const actualNum = parseFloat(actual);
+      if (isNaN(actualNum) || actualNum !== value) {
+        throw new ValidationError(
+          `Expected header duration=${value} but got ${actual}`,
+          String(value),
+          actual,
+        );
+      }
+      return {
+        status: 204,
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+
 Scenarios.Encode_Duration_Header_default = createHeaderServerTests(
   "/encode/duration/header/default",
   {
@@ -189,3 +358,48 @@ Scenarios.Encode_Duration_Header_iso8601Array = createHeaderServerTests(
   },
   "P40D,P50D",
 );
+
+Scenarios.Encode_Duration_Header_int32Milliseconds = createHeaderServerTests(
+  "/encode/duration/header/int32-milliseconds",
+  {
+    duration: "36000",
+  },
+  "36000",
+);
+Scenarios.Encode_Duration_Header_floatMilliseconds = createHeaderFloatServerTests(
+  "/encode/duration/header/float-milliseconds",
+  35625,
+);
+Scenarios.Encode_Duration_Header_float64Milliseconds = createHeaderFloatServerTests(
+  "/encode/duration/header/float64-milliseconds",
+  35625,
+);
+Scenarios.Encode_Duration_Header_int32MillisecondsArray = createHeaderServerTests(
+  "/encode/duration/header/int32-milliseconds-array",
+  {
+    duration: ["36000", "47000"].join(","),
+  },
+  "36000,47000",
+);
+Scenarios.Encode_Duration_Header_int32SecondsLargerUnit = createHeaderServerTests(
+  "/encode/duration/header/int32-seconds-larger-unit",
+  {
+    duration: "120",
+  },
+  "120",
+);
+Scenarios.Encode_Duration_Header_floatSecondsLargerUnit = createHeaderFloatServerTests(
+  "/encode/duration/header/float-seconds-larger-unit",
+  150,
+);
+Scenarios.Encode_Duration_Header_int32MillisecondsLargerUnit = createHeaderServerTests(
+  "/encode/duration/header/int32-milliseconds-larger-unit",
+  {
+    duration: "180000",
+  },
+  "180000",
+);
+Scenarios.Encode_Duration_Header_floatMillisecondsLargerUnit = createHeaderFloatServerTests(
+  "/encode/duration/header/float-milliseconds-larger-unit",
+  210000,
+);

package/specs/encode/numeric/mockapi.ts

@@ -7,9 +7,9 @@ function createTests(uri: string, value: any) {
     uri,
     method: "post",
     request: {
-      body: {
+      body: json({
         value,
-      },
+      }),
     },
     response: {
       status: 200,

package/specs/parameters/basic/mockapi.ts

@@ -1,4 +1,4 @@
-import { passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+import { json, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
 
 export const Scenarios: Record<string, ScenarioMockApi> = {};
 function createServerTests(uri: string) {
@@ -6,9 +6,9 @@ function createServerTests(uri: string) {
     uri,
     method: "put",
     request: {
-      body: {
+      body: json({
         name: "foo",
-      },
+      }),
     },
     response: {
       status: 204,

package/specs/parameters/body-optionality/main.tsp

@@ -33,8 +33,10 @@ op requiredExplicit(@body body: BodyModel): NoContentResponse;
   ```json
   { "name": "foo" }
   ```
+  Expected Content-Type header: application/json
   
   Expected no request body for `omit`
+  Expected Content-Type header: must NOT be present
   """)
 @route("/optional-explicit")
 namespace OptionalExplicit {

package/specs/parameters/body-optionality/mockapi.ts

@@ -1,4 +1,10 @@
-import { MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+import {
+  json,
+  MockRequest,
+  passOnSuccess,
+  ScenarioMockApi,
+  ValidationError,
+} from "@typespec/spec-api";
 
 export const Scenarios: Record<string, ScenarioMockApi> = {};
 function createServerTests(uri: string, data: any) {
@@ -6,7 +12,7 @@ function createServerTests(uri: string, data: any) {
     uri,
     method: "post",
     request: {
-      body: data,
+      body: json(data),
     },
     response: {
       status: 204,
@@ -27,13 +33,18 @@ Scenarios.Parameters_BodyOptionality_OptionalExplicit = passOnSuccess([
     uri: "/parameters/body-optionality/optional-explicit/set",
     method: "post",
     request: {
-      body: {
+      body: json({
         name: "foo",
-      },
+      }),
     },
     response: {
       status: 204,
     },
+    handler: (req: MockRequest) => {
+      // Validate that Content-Type header is present when body is provided
+      req.expect.containsHeader("content-type", "application/json");
+      return { status: 204 };
+    },
     kind: "MockApiDefinition",
   },
   {
@@ -45,6 +56,15 @@ Scenarios.Parameters_BodyOptionality_OptionalExplicit = passOnSuccess([
     },
     handler: (req: MockRequest) => {
       req.expect.rawBodyEquals(undefined);
+      // Validate that Content-Type header is NOT present when body is omitted
+      const contentTypeHeader = req.headers["content-type"];
+      if (contentTypeHeader !== undefined) {
+        throw new ValidationError(
+          "Content-Type header must NOT be present when body is omitted",
+          undefined,
+          contentTypeHeader,
+        );
+      }
       return { status: 204 };
     },
     kind: "MockApiDefinition",

package/specs/parameters/collection-format/main.tsp

@@ -27,25 +27,9 @@ namespace Query {
     """)
   @route("/ssv")
   op ssv(
-    #suppress "deprecated" "Deprecated in next release"
     @doc("Possible values for colors are [blue,red,green]")
-    @query({
-      format: "ssv",
-    })
-    colors: string[],
-  ): NoContentResponse;
-
-  @scenario
-  @scenarioDoc("""
-    This test is testing sending a tsv collection format array query parameters
-    """)
-  @route("/tsv")
-  op tsv(
-    #suppress "deprecated" "Deprecated in next release"
-    @doc("Possible values for colors are [blue,red,green]")
-    @query({
-      format: "tsv",
-    })
+    @query
+    @encode(ArrayEncoding.spaceDelimited)
     colors: string[],
   ): NoContentResponse;
 
@@ -55,11 +39,9 @@ namespace Query {
     """)
   @route("/pipes")
   op pipes(
-    #suppress "deprecated" "Deprecated in next release"
     @doc("Possible values for colors are [blue,red,green]")
-    @query({
-      format: "pipes",
-    })
+    @query
+    @encode(ArrayEncoding.pipeDelimited)
     colors: string[],
   ): NoContentResponse;
 
@@ -84,9 +66,7 @@ namespace Header {
   @route("/csv")
   op csv(
     @doc("Possible values for colors are [blue,red,green]")
-    @header({
-      format: "csv",
-    })
+    @header
     colors: string[],
   ): NoContentResponse;
 }

package/specs/parameters/collection-format/mockapi.ts

@@ -8,7 +8,7 @@ Scenarios.Parameters_CollectionFormat_Query_multi = passOnSuccess({
   uri: `/parameters/collection-format/query/multi`,
   method: "get",
   request: {
-    params: { colors: ["blue", "red", "green"] },
+    query: { colors: ["blue", "red", "green"] },
   },
   response: {
     status: 204,
@@ -26,7 +26,7 @@ Scenarios.Parameters_CollectionFormat_Query_csv = passOnSuccess({
   uri: `/parameters/collection-format/query/csv`,
   method: "get",
   request: {
-    params: { colors: colors.join(",") },
+    query: { colors: colors.join(",") },
   },
   response: {
     status: 204,
@@ -38,19 +38,7 @@ Scenarios.Parameters_CollectionFormat_Query_ssv = passOnSuccess({
   uri: `/parameters/collection-format/query/ssv`,
   method: "get",
   request: {
-    params: { colors: colors.join(" ") },
-  },
-  response: {
-    status: 204,
-  },
-  kind: "MockApiDefinition",
-});
-
-Scenarios.Parameters_CollectionFormat_Query_tsv = passOnSuccess({
-  uri: `/parameters/collection-format/query/tsv`,
-  method: "get",
-  request: {
-    params: { colors: colors.join("\t") },
+    query: { colors: colors.join(" ") },
   },
   response: {
     status: 204,
@@ -62,7 +50,7 @@ Scenarios.Parameters_CollectionFormat_Query_pipes = passOnSuccess({
   uri: `/parameters/collection-format/query/pipes`,
   method: "get",
   request: {
-    params: { colors: colors.join("|") },
+    query: { colors: colors.join("|") },
   },
   response: {
     status: 204,

package/specs/parameters/path/main.tsp

@@ -0,0 +1,48 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@doc("Test for path parameters cases.")
+@scenarioService("/parameters/path")
+namespace Parameters.Path;
+
+@scenario
+@scenarioDoc("""
+  Test case for normal path parameter. 
+  
+  Should generate an operation like below:
+  ```
+  normal(name: string)
+  ```
+  
+  Expected request path:
+  ```
+  /normal/foo
+  ```
+  """)
+@route("/normal/{name}")
+op normal(@path name: string): NoContentResponse;
+
+@scenario
+@scenarioDoc("""
+  Test case for optional path parameter. 
+  
+  Should generate an operation like below:
+  ```
+  optional(name?: string)
+  ```
+  
+  Expected two request:
+  First request path:
+  ```
+  /optional
+  ```
+  Second request path:
+  ```
+  /optional/foo
+  ```
+  """)
+@route("/optional{/name}")
+op optional(@path name?: string): NoContentResponse;

package/specs/parameters/path/mockapi.ts

@@ -0,0 +1,34 @@
+import { passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.Parameters_Path_normal = passOnSuccess({
+  uri: "/parameters/path/normal/foo",
+  method: "get",
+
+  response: {
+    status: 204,
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_Path_optional = passOnSuccess([
+  {
+    uri: "/parameters/path/optional",
+    method: "get",
+
+    response: {
+      status: 204,
+    },
+    kind: "MockApiDefinition",
+  },
+  {
+    uri: "/parameters/path/optional/foo",
+    method: "get",
+
+    response: {
+      status: 204,
+    },
+    kind: "MockApiDefinition",
+  },
+]);

package/specs/parameters/query/main.tsp

@@ -0,0 +1,22 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@doc("Test for query parameter cases.")
+@scenarioService("/parameters/query")
+namespace Parameters.Query;
+
+@doc("Constant query parameter verification")
+@route("/constant")
+interface Constant {
+  /** post constant query value */
+  @scenario
+  @scenarioDoc("Expect to handle a constant value for query and mock api returns nothing")
+  @post
+  post(
+    @query
+    queryParam: "constantValue",
+  ): void;
+}

package/specs/parameters/query/mockapi.ts

@@ -0,0 +1,15 @@
+import { passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.Parameters_Query_Constant_post = passOnSuccess({
+  uri: "/parameters/query/constant",
+  method: `post`,
+  request: {
+    query: { queryParam: "constantValue" },
+  },
+  response: {
+    status: 204,
+  },
+  kind: "MockApiDefinition",
+});