@typespec/http-specs 0.37.2

package/specs/parameters/spread/mockapi.ts

@@ -0,0 +1,216 @@
+import { MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.Parameters_Spread_Model_spreadAsRequestBody = passOnSuccess({
+  uri: `/parameters/spread/model/request-body`,
+  method: "put",
+  request: {
+    body: {
+      name: "foo",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals({ name: "foo" });
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_Spread_Model_spreadCompositeRequestOnlyWithBody = passOnSuccess({
+  uri: `/parameters/spread/model/composite-request-only-with-body`,
+  method: "put",
+  request: {
+    body: {
+      name: "foo",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals({ name: "foo" });
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_Spread_Model_spreadCompositeRequestWithoutBody = passOnSuccess({
+  uri: `/parameters/spread/model/composite-request-without-body/foo`,
+  method: "put",
+  request: {
+    headers: {
+      "test-header": "bar",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsHeader("test-header", "bar");
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_Spread_Model_spreadCompositeRequest = passOnSuccess({
+  uri: `/parameters/spread/model/composite-request/foo`,
+  method: "put",
+  request: {
+    body: {
+      name: "foo",
+    },
+    headers: {
+      "test-header": "bar",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsHeader("test-header", "bar");
+    req.expect.bodyEquals({ name: "foo" });
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_Spread_Model_spreadCompositeRequestMix = passOnSuccess({
+  uri: `/parameters/spread/model/composite-request-mix/foo`,
+  method: "put",
+  request: {
+    body: {
+      prop: "foo",
+    },
+    headers: {
+      "test-header": "bar",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsHeader("test-header", "bar");
+    req.expect.bodyEquals({ prop: "foo" });
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_Spread_Alias_spreadAsRequestBody = passOnSuccess({
+  uri: `/parameters/spread/alias/request-body`,
+  method: "put",
+  request: {
+    body: {
+      name: "foo",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals({ name: "foo" });
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_Spread_Alias_spreadAsRequestParameter = passOnSuccess({
+  uri: `/parameters/spread/alias/request-parameter/1`,
+  method: "put",
+  request: {
+    body: {
+      name: "foo",
+    },
+    headers: {
+      "x-ms-test-header": "bar",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsHeader("x-ms-test-header", "bar");
+    req.expect.bodyEquals({ name: "foo" });
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_Spread_Alias_spreadWithMultipleParameters = passOnSuccess({
+  uri: `/parameters/spread/alias/multiple-parameters/1`,
+  method: "put",
+  request: {
+    body: {
+      requiredString: "foo",
+      optionalInt: 1,
+      requiredIntList: [1, 2],
+      optionalStringList: ["foo", "bar"],
+    },
+    headers: {
+      "x-ms-test-header": "bar",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsHeader("x-ms-test-header", "bar");
+    req.expect.bodyEquals({
+      requiredString: "foo",
+      optionalInt: 1,
+      requiredIntList: [1, 2],
+      optionalStringList: ["foo", "bar"],
+    });
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_Spread_Alias_spreadParameterWithInnerModel = passOnSuccess({
+  uri: `/parameters/spread/alias/inner-model-parameter/1`,
+  method: "post",
+  request: {
+    body: {
+      name: "foo",
+    },
+    headers: {
+      "x-ms-test-header": "bar",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsHeader("x-ms-test-header", "bar");
+    req.expect.bodyEquals({ name: "foo" });
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_Spread_Alias_spreadParameterWithInnerAlias = passOnSuccess({
+  uri: `/parameters/spread/alias/inner-alias-parameter/1`,
+  method: "post",
+  request: {
+    body: {
+      name: "foo",
+      age: 1,
+    },
+    headers: {
+      "x-ms-test-header": "bar",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsHeader("x-ms-test-header", "bar");
+    req.expect.bodyEquals({ name: "foo", age: 1 });
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});

package/specs/payload/json-merge-patch/main.tsp

@@ -0,0 +1,183 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+
+@doc("Test for merge-patch+json content-type")
+@scenarioService("/json-merge-patch")
+namespace Payload.JsonMergePatch;
+
+@doc("Details about a resource.")
+model Resource {
+  name: string;
+  description?: string;
+  map?: Record<InnerModel>;
+  array?: InnerModel[];
+  intValue?: int32;
+  floatValue?: float32;
+  innerModel?: InnerModel;
+  intArray?: int32[];
+}
+
+@doc("Details about a resource for patch operation.")
+model ResourcePatch {
+  description?: string;
+  map?: Record<InnerModel>;
+  array?: InnerModel[];
+  intValue?: int32;
+  floatValue?: float32;
+  innerModel?: InnerModel;
+  intArray?: int32[];
+}
+
+@doc("It is the model used by Resource model")
+model InnerModel {
+  name?: string;
+  description?: string;
+}
+
+@scenario
+@scenarioDoc("""
+  
+  Expected input body:
+  ```json
+  {
+    "name": "Madge",
+    "description": "desc",
+    "map": {
+      "key": {
+        "name": "InnerMadge",
+        "description": "innerDesc"
+      }
+    },
+    "array": [
+      {
+        "name": "InnerMadge",
+        "description": "innerDesc"
+      }
+    ],
+    "intValue": 1,
+    "floatValue": 1.1,
+    "innerModel": {
+      "name": "InnerMadge",
+      "description": "innerDesc"
+    },
+    "intArray": [1, 2, 3]
+  }
+  ```
+  
+  Expected response body:
+  ```json
+  {
+    "name": "Madge",
+    "description": "desc",
+    "map": {
+      "key": {
+        "name": "InnerMadge",
+        "description": "innerDesc"
+      }
+    },
+    "array": [
+      {
+        "name": "InnerMadge",
+        "description": "innerDesc"
+      }
+    ],
+    "intValue": 1,
+    "floatValue": 1.1,
+    "innerModel": {
+      "name": "InnerMadge",
+      "description": "innerDesc"
+    },
+    "intArray": [1, 2, 3]
+  }
+  ```
+  """)
+@doc("Test content-type: application/merge-patch+json with required body")
+@route("/create/resource")
+@put
+op createResource(@body body: Resource): Resource;
+
+@scenario
+@scenarioDoc("""
+  Should serialize null values with merge-patch+json enabled.
+  
+  Expected input body:
+  ```json
+  {
+    "description": null,
+    "map": {
+      "key": {
+        "description": null
+      },
+      "key2": null
+    },
+    "array": null,
+    "intValue": null,
+    "floatValue": null,
+    "innerModel": null,
+    "intArray": null
+  }
+  ```
+  
+  Expected response body:
+  ```json
+  {
+    name: "Madge",
+    map: {
+      key: {
+        name: "InnerMadge"
+      }
+    }
+  }
+  ```
+  """)
+@doc("Test content-type: application/merge-patch+json with required body")
+@route("/update/resource")
+@patch
+op updateResource(
+  @header("content-type") contentType: "application/merge-patch+json",
+  @body body: ResourcePatch,
+): Resource;
+
+@scenario
+@scenarioDoc("""
+  Should serialize null values with merge-patch+json enabled.
+  
+  Expected input body:
+  ```json
+  {
+    "description": null,
+    "map": {
+      "key": {
+        "description": null
+      },
+      "key2": null
+    },
+    "array": null,
+    "intValue": null,
+    "floatValue": null,
+    "innerModel": null,
+    "intArray": null
+  }
+  ```
+  
+  Expected response body:
+  ```json
+  {
+    name: "Madge",
+    map: {
+      key: {
+        name: "InnerMadge"
+      }
+    }
+  }
+  ```
+  """)
+@doc("Test content-type: application/merge-patch+json with optional body")
+@route("/update/resource/optional")
+@patch
+op updateOptionalResource(
+  @header("content-type") contentType: "application/merge-patch+json",
+  @body body?: ResourcePatch,
+): Resource;

package/specs/payload/json-merge-patch/mockapi.ts

@@ -0,0 +1,146 @@
+import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+export const expectedCreateBody = {
+  name: "Madge",
+  description: "desc",
+  map: {
+    key: {
+      name: "InnerMadge",
+      description: "innerDesc",
+    },
+  },
+  array: [
+    {
+      name: "InnerMadge",
+      description: "innerDesc",
+    },
+  ],
+  intValue: 1,
+  floatValue: 1.1,
+  innerModel: {
+    name: "InnerMadge",
+    description: "innerDesc",
+  },
+  intArray: [1, 2, 3],
+};
+
+export const expectedUpdateBody = {
+  name: "Madge",
+  description: null,
+  map: {
+    key: {
+      name: "InnerMadge",
+      description: null,
+    },
+    key2: null,
+  },
+  array: null,
+  intValue: null,
+  floatValue: null,
+  innerModel: null,
+  intArray: null,
+};
+
+Scenarios.Payload_JsonMergePatch_createResource = passOnSuccess({
+  uri: "/json-merge-patch/create/resource",
+  method: "put",
+  request: {
+    body: expectedCreateBody,
+  },
+  response: {
+    status: 200,
+    body: json(expectedCreateBody),
+  },
+  handler: (req: MockRequest) => {
+    req.expect.coercedBodyEquals(expectedCreateBody);
+    return {
+      status: 200,
+      body: json(expectedCreateBody),
+    };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Payload_JsonMergePatch_updateResource = passOnSuccess({
+  uri: "/json-merge-patch/update/resource",
+  method: "patch",
+  request: {
+    body: expectedUpdateBody,
+  },
+  response: {
+    status: 200,
+    body: json({
+      name: "Madge",
+      map: {
+        key: {
+          name: "InnerMadge",
+        },
+      },
+    }),
+  },
+  handler: (req: MockRequest) => {
+    req.expect.deepEqual(req.body.description, expectedUpdateBody.description);
+    req.expect.deepEqual(req.body.map.key.description, expectedUpdateBody.map.key.description);
+    req.expect.deepEqual(req.body.map.key2, expectedUpdateBody.map.key2);
+    req.expect.deepEqual(req.body.array, expectedUpdateBody.array);
+    req.expect.deepEqual(req.body.intValue, expectedUpdateBody.intValue);
+    req.expect.deepEqual(req.body.floatValue, expectedUpdateBody.floatValue);
+    req.expect.deepEqual(req.body.innerModel, expectedUpdateBody.innerModel);
+    req.expect.deepEqual(req.body.intArray, expectedUpdateBody.intArray);
+    return {
+      status: 200,
+      body: json({
+        name: "Madge",
+        map: {
+          key: {
+            name: "InnerMadge",
+          },
+        },
+      }),
+    };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Payload_JsonMergePatch_updateOptionalResource = passOnSuccess({
+  uri: "/json-merge-patch/update/resource/optional",
+  method: "patch",
+  request: {
+    body: expectedUpdateBody,
+  },
+  response: {
+    status: 200,
+    body: json({
+      name: "Madge",
+      map: {
+        key: {
+          name: "InnerMadge",
+        },
+      },
+    }),
+  },
+  handler: (req: MockRequest) => {
+    req.expect.deepEqual(req.body.description, expectedUpdateBody.description);
+    req.expect.deepEqual(req.body.map.key.description, expectedUpdateBody.map.key.description);
+    req.expect.deepEqual(req.body.map.key2, expectedUpdateBody.map.key2);
+    req.expect.deepEqual(req.body.array, expectedUpdateBody.array);
+    req.expect.deepEqual(req.body.intValue, expectedUpdateBody.intValue);
+    req.expect.deepEqual(req.body.floatValue, expectedUpdateBody.floatValue);
+    req.expect.deepEqual(req.body.innerModel, expectedUpdateBody.innerModel);
+    req.expect.deepEqual(req.body.intArray, expectedUpdateBody.intArray);
+    return {
+      status: 200,
+      body: json({
+        name: "Madge",
+        map: {
+          key: {
+            name: "InnerMadge",
+          },
+        },
+      }),
+    };
+  },
+  kind: "MockApiDefinition",
+});

package/specs/payload/media-type/main.tsp

@@ -0,0 +1,54 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+using Azure.ClientGenerator.Core;
+
+/**
+ * Test the payload with different media types and different types of the payload itself.
+ */
+@supportedBy("dpg")
+@scenarioService("/payload/media-type")
+namespace Payload.MediaType;
+
+@operationGroup
+@route("/string-body")
+namespace StringBody {
+  @scenario
+  @scenarioDoc("""
+    Expected request body is a string '{cat}'.
+    """)
+  @post
+  @route("/sendAsText")
+  op sendAsText(@header contentType: "text/plain", @body text: string): OkResponse;
+
+  @scenario
+  @scenarioDoc("""
+    Expected response body is a string '{cat}'.
+    """)
+  @get
+  @route("/getAsText")
+  op getAsText(): {
+    @header contentType: "text/plain";
+    @body text: string;
+  };
+
+  @scenario
+  @scenarioDoc("""
+    Expected request body is "foo".
+    """)
+  @post
+  @route("/sendAsJson")
+  op sendAsJson(@header contentType: "application/json", @body text: string): OkResponse;
+
+  @scenario
+  @scenarioDoc("""
+    Expected response body is "foo".
+    """)
+  @get
+  @route("/getAsJson")
+  op getAsJson(): {
+    @header contentType: "application/json";
+    @body text: string;
+  };
+}

package/specs/payload/media-type/mockapi.ts

@@ -0,0 +1,88 @@
+import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.Payload_MediaType_StringBody_sendAsText = passOnSuccess({
+  uri: "/payload/media-type/string-body/sendAsText",
+  method: "post",
+  request: {
+    body: "{cat}",
+    headers: {
+      "Content-Type": "text/plain",
+    },
+  },
+  response: {
+    status: 200,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsHeader("content-type", "text/plain");
+    req.expect.bodyEquals("{cat}");
+    return { status: 200 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Payload_MediaType_StringBody_getAsText = passOnSuccess({
+  uri: "/payload/media-type/string-body/getAsText",
+  method: "get",
+  request: {
+    headers: {
+      accept: "text/plain",
+    },
+  },
+  response: {
+    status: 200,
+    body: { rawContent: "{cat}", contentType: "text/plain" },
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsHeader("accept", "text/plain");
+    return {
+      status: 200,
+      body: { rawContent: "{cat}", contentType: "text/plain" },
+    };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Payload_MediaType_StringBody_sendAsJson = passOnSuccess({
+  uri: "/payload/media-type/string-body/sendAsJson",
+  method: "post",
+  request: {
+    body: "foo",
+    headers: {
+      "Content-Type": "application/json",
+    },
+  },
+  response: {
+    status: 200,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsHeader("content-type", "application/json");
+    req.expect.bodyEquals("foo");
+    return { status: 200 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Payload_MediaType_StringBody_getAsJson = passOnSuccess({
+  uri: "/payload/media-type/string-body/getAsJson",
+  method: "get",
+  request: {
+    headers: {
+      accept: "application/json",
+    },
+  },
+  response: {
+    status: 200,
+    body: json("foo"),
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsHeader("accept", "application/json");
+    return {
+      status: 200,
+      body: json("foo"),
+      contentType: "application/json",
+    };
+  },
+  kind: "MockApiDefinition",
+});