@typespec/http-specs 0.1.0-alpha.3-dev.6 → 0.1.0-alpha.30-dev.0

package/specs/payload/pageable/mockapi.ts

@@ -1,12 +1,217 @@
-import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+import {
+  dyn,
+  dynItem,
+  json,
+  MockRequest,
+  passOnSuccess,
+  ScenarioMockApi,
+  ValidationError,
+} from "@typespec/spec-api";
 
 export const Scenarios: Record<string, ScenarioMockApi> = {};
 
+const FirstPage = [
+  { id: "1", name: "dog" },
+  { id: "2", name: "cat" },
+];
+
+const SecondPage = [
+  { id: "3", name: "bird" },
+  { id: "4", name: "fish" },
+];
+
+const FirstResponseTokenInBody = {
+  status: 200,
+  body: json({
+    pets: FirstPage,
+    nextToken: "page2",
+  }),
+};
+
+const SecondResponse = {
+  status: 200,
+  body: json({
+    pets: SecondPage,
+  }),
+};
+
+const FirstResponseTokenInHeader = {
+  status: 200,
+  body: json({
+    pets: FirstPage,
+  }),
+  headers: {
+    "next-token": "page2",
+    foo: "foo",
+  },
+};
+
+const RequestTokenInQuery = {
+  query: { token: "page2", bar: "bar" },
+  headers: { foo: "foo" },
+};
+
+const RequestTokenInHeader = { headers: { token: "page2", foo: "foo" }, query: { bar: "bar" } };
+
+function createTests(reqInfo: "query" | "header", resInfo: "body" | "header") {
+  const uri = `/payload/pageable/server-driven-pagination/continuationtoken/request-${reqInfo}-response-${resInfo}`;
+  function createHandler() {
+    return (req: MockRequest) => {
+      req.expect.containsHeader("foo", "foo");
+      req.expect.containsQueryParam("bar", "bar");
+      const token = reqInfo === "header" ? req.headers?.token : req.query?.token;
+      switch (token) {
+        case undefined:
+          return resInfo === "header" ? FirstResponseTokenInHeader : FirstResponseTokenInBody;
+        case "page2":
+          return SecondResponse;
+        default:
+          throw new ValidationError(
+            "Unsupported continuation token",
+            `"undefined" | "page2"`,
+            token,
+          );
+      }
+    };
+  }
+
+  return passOnSuccess([
+    {
+      uri: uri,
+      method: "get",
+      request: { headers: { foo: "foo" }, query: { bar: "bar" } },
+      response: resInfo === "header" ? FirstResponseTokenInHeader : FirstResponseTokenInBody,
+      handler: createHandler(),
+      kind: "MockApiDefinition",
+    },
+    {
+      uri: uri,
+      method: "get",
+      request: reqInfo === "header" ? RequestTokenInHeader : RequestTokenInQuery,
+      response: SecondResponse,
+      handler: createHandler(),
+      kind: "MockApiDefinition",
+    },
+  ]);
+}
+
 Scenarios.Payload_Pageable_ServerDrivenPagination_link = passOnSuccess([
   {
     uri: "/payload/pageable/server-driven-pagination/link",
     method: "get",
     request: {},
+    response: {
+      status: 200,
+      body: json({
+        pets: FirstPage,
+        next: dyn`${dynItem("baseUrl")}/payload/pageable/server-driven-pagination/link/nextPage`,
+      }),
+    },
+    kind: "MockApiDefinition",
+  },
+  {
+    uri: "/payload/pageable/server-driven-pagination/link/nextPage",
+    method: "get",
+    request: {},
+    response: SecondResponse,
+    kind: "MockApiDefinition",
+  },
+]);
+
+Scenarios.Payload_Pageable_ServerDrivenPagination_linkString = passOnSuccess([
+  {
+    uri: "/payload/pageable/server-driven-pagination/link-string",
+    method: "get",
+    request: {},
+    response: {
+      status: 200,
+      body: json({
+        pets: FirstPage,
+        next: dyn`${dynItem("baseUrl")}/payload/pageable/server-driven-pagination/link-string/nextPage`,
+      }),
+    },
+    kind: "MockApiDefinition",
+  },
+  {
+    uri: "/payload/pageable/server-driven-pagination/link-string/nextPage",
+    method: "get",
+    request: {},
+    response: SecondResponse,
+    kind: "MockApiDefinition",
+  },
+]);
+
+Scenarios.Payload_Pageable_ServerDrivenPagination_nestedLink = passOnSuccess([
+  {
+    uri: "/payload/pageable/server-driven-pagination/nested-link",
+    method: "get",
+    request: {},
+    response: {
+      status: 200,
+      body: json({
+        nestedItems: {
+          pets: FirstPage,
+        },
+        nestedNext: {
+          next: dyn`${dynItem("baseUrl")}/payload/pageable/server-driven-pagination/nested-link/nextPage`,
+        },
+      }),
+    },
+    kind: "MockApiDefinition",
+  },
+  {
+    uri: "/payload/pageable/server-driven-pagination/nested-link/nextPage",
+    method: "get",
+    request: {},
+    response: {
+      status: 200,
+      body: json({
+        nestedItems: {
+          pets: SecondPage,
+        },
+      }),
+    },
+    kind: "MockApiDefinition",
+  },
+]);
+
+Scenarios.Payload_Pageable_ServerDrivenPagination_ContinuationToken_requestQueryResponseBody =
+  createTests("query", "body");
+
+Scenarios.Payload_Pageable_ServerDrivenPagination_ContinuationToken_requestHeaderResponseBody =
+  createTests("header", "body");
+
+Scenarios.Payload_Pageable_ServerDrivenPagination_ContinuationToken_requestQueryResponseHeader =
+  createTests("query", "header");
+
+Scenarios.Payload_Pageable_ServerDrivenPagination_ContinuationToken_requestHeaderResponseHeader =
+  createTests("header", "header");
+
+Scenarios.Payload_Pageable_PageSize_listWithoutContinuation = passOnSuccess([
+  {
+    uri: "/payload/pageable/pagesize/without-continuation",
+    method: "get",
+    request: {},
+    response: {
+      status: 200,
+      body: json({
+        pets: [
+          { id: "1", name: "dog" },
+          { id: "2", name: "cat" },
+          { id: "3", name: "bird" },
+          { id: "4", name: "fish" },
+        ],
+      }),
+    },
+    kind: "MockApiDefinition",
+  },
+]);
+
+Scenarios.Payload_Pageable_PageSize_listWithPageSize = passOnSuccess([
+  {
+    uri: "/payload/pageable/pagesize/list",
+    method: "get",
+    request: { query: { pageSize: "2" } },
     response: {
       status: 200,
       body: json({
@@ -14,40 +219,295 @@ Scenarios.Payload_Pageable_ServerDrivenPagination_link = passOnSuccess([
           { id: "1", name: "dog" },
           { id: "2", name: "cat" },
         ],
-        links: {
-          next: "/payload/pageable/server-driven-pagination/link/nextPage",
-        },
       }),
     },
     handler: (req: MockRequest) => {
-      return {
-        status: 200,
-        body: json({
-          pets: [
-            { id: "1", name: "dog" },
-            { id: "2", name: "cat" },
-          ],
-          links: {
-            next: `${req.baseUrl}/payload/pageable/server-driven-pagination/link/nextPage`,
-          },
-        }),
-      };
+      const pageSize = req.query?.pageSize;
+
+      switch (pageSize) {
+        case "2":
+          return {
+            status: 200,
+            body: json({
+              pets: [
+                { id: "1", name: "dog" },
+                { id: "2", name: "cat" },
+              ],
+            }),
+          };
+        case "4":
+          return {
+            status: 200,
+            body: json({
+              pets: [
+                { id: "1", name: "dog" },
+                { id: "2", name: "cat" },
+                { id: "3", name: "bird" },
+                { id: "4", name: "fish" },
+              ],
+            }),
+          };
+        default:
+          throw new ValidationError("Unsupported page size", `"2" | "4"`, pageSize);
+      }
     },
     kind: "MockApiDefinition",
   },
   {
-    uri: "/payload/pageable/server-driven-pagination/link/nextPage",
+    uri: "/payload/pageable/pagesize/list",
     method: "get",
-    request: {},
+    request: { query: { pageSize: "4" } },
     response: {
       status: 200,
       body: json({
         pets: [
+          { id: "1", name: "dog" },
+          { id: "2", name: "cat" },
           { id: "3", name: "bird" },
           { id: "4", name: "fish" },
         ],
       }),
     },
+    handler: (req: MockRequest) => {
+      const pageSize = req.query?.pageSize;
+
+      switch (pageSize) {
+        case "2":
+          return {
+            status: 200,
+            body: json({
+              pets: [
+                { id: "1", name: "dog" },
+                { id: "2", name: "cat" },
+              ],
+            }),
+          };
+        case "4":
+          return {
+            status: 200,
+            body: json({
+              pets: [
+                { id: "1", name: "dog" },
+                { id: "2", name: "cat" },
+                { id: "3", name: "bird" },
+                { id: "4", name: "fish" },
+              ],
+            }),
+          };
+        default:
+          throw new ValidationError("Unsupported page size", `"2" | "4"`, pageSize);
+      }
+    },
     kind: "MockApiDefinition",
   },
 ]);
+
+Scenarios.Payload_Pageable_ServerDrivenPagination_ContinuationToken_requestQueryNestedResponseBody =
+  passOnSuccess([
+    {
+      uri: "/payload/pageable/server-driven-pagination/continuationtoken/request-query-nested-response-body",
+      method: "get",
+      request: { headers: { foo: "foo" }, query: { bar: "bar" } },
+      response: {
+        status: 200,
+        body: json({
+          nestedItems: {
+            pets: FirstPage,
+          },
+          nestedNext: {
+            nextToken: "page2",
+          },
+        }),
+      },
+      handler: (req: MockRequest) => {
+        req.expect.containsHeader("foo", "foo");
+        req.expect.containsQueryParam("bar", "bar");
+        const token = req.query?.token;
+
+        switch (token) {
+          case undefined:
+            return {
+              status: 200,
+              body: json({
+                nestedItems: {
+                  pets: FirstPage,
+                },
+                nestedNext: {
+                  nextToken: "page2",
+                },
+              }),
+            };
+          case "page2":
+            return {
+              status: 200,
+              body: json({
+                nestedItems: {
+                  pets: SecondPage,
+                },
+              }),
+            };
+          default:
+            throw new ValidationError(
+              "Unsupported continuation token",
+              `"undefined" | "page2"`,
+              token,
+            );
+        }
+      },
+      kind: "MockApiDefinition",
+    },
+    {
+      uri: "/payload/pageable/server-driven-pagination/continuationtoken/request-query-nested-response-body",
+      method: "get",
+      request: RequestTokenInQuery,
+      response: {
+        status: 200,
+        body: json({
+          nestedItems: {
+            pets: SecondPage,
+          },
+        }),
+      },
+      handler: (req: MockRequest) => {
+        req.expect.containsHeader("foo", "foo");
+        req.expect.containsQueryParam("bar", "bar");
+        const token = req.query?.token;
+
+        switch (token) {
+          case undefined:
+            return {
+              status: 200,
+              body: json({
+                nestedItems: {
+                  pets: FirstPage,
+                },
+                nestedNext: {
+                  nextToken: "page2",
+                },
+              }),
+            };
+          case "page2":
+            return {
+              status: 200,
+              body: json({
+                nestedItems: {
+                  pets: SecondPage,
+                },
+              }),
+            };
+          default:
+            throw new ValidationError(
+              "Unsupported continuation token",
+              `"undefined" | "page2"`,
+              token,
+            );
+        }
+      },
+      kind: "MockApiDefinition",
+    },
+  ]);
+
+Scenarios.Payload_Pageable_ServerDrivenPagination_ContinuationToken_requestHeaderNestedResponseBody =
+  passOnSuccess([
+    {
+      uri: "/payload/pageable/server-driven-pagination/continuationtoken/request-header-nested-response-body",
+      method: "get",
+      request: { headers: { foo: "foo" }, query: { bar: "bar" } },
+      response: {
+        status: 200,
+        body: json({
+          nestedItems: {
+            pets: FirstPage,
+          },
+          nestedNext: {
+            nextToken: "page2",
+          },
+        }),
+      },
+      handler: (req: MockRequest) => {
+        req.expect.containsHeader("foo", "foo");
+        req.expect.containsQueryParam("bar", "bar");
+        const token = req.headers?.token;
+
+        switch (token) {
+          case undefined:
+            return {
+              status: 200,
+              body: json({
+                nestedItems: {
+                  pets: FirstPage,
+                },
+                nestedNext: {
+                  nextToken: "page2",
+                },
+              }),
+            };
+          case "page2":
+            return {
+              status: 200,
+              body: json({
+                nestedItems: {
+                  pets: SecondPage,
+                },
+              }),
+            };
+          default:
+            throw new ValidationError(
+              "Unsupported continuation token",
+              `"undefined" | "page2"`,
+              token,
+            );
+        }
+      },
+      kind: "MockApiDefinition",
+    },
+    {
+      uri: "/payload/pageable/server-driven-pagination/continuationtoken/request-header-nested-response-body",
+      method: "get",
+      request: RequestTokenInHeader,
+      response: {
+        status: 200,
+        body: json({
+          nestedItems: {
+            pets: SecondPage,
+          },
+        }),
+      },
+      handler: (req: MockRequest) => {
+        req.expect.containsHeader("foo", "foo");
+        req.expect.containsQueryParam("bar", "bar");
+        const token = req.headers?.token;
+
+        switch (token) {
+          case undefined:
+            return {
+              status: 200,
+              body: json({
+                nestedItems: {
+                  pets: FirstPage,
+                },
+                nestedNext: {
+                  nextToken: "page2",
+                },
+              }),
+            };
+          case "page2":
+            return {
+              status: 200,
+              body: json({
+                nestedItems: {
+                  pets: SecondPage,
+                },
+              }),
+            };
+          default:
+            throw new ValidationError(
+              "Unsupported continuation token",
+              `"undefined" | "page2"`,
+              token,
+            );
+        }
+      },
+      kind: "MockApiDefinition",
+    },
+  ]);

package/specs/payload/xml/mockapi.ts

@@ -139,10 +139,7 @@ function createServerTests(uri: string, data?: any) {
       uri,
       method: "put",
       request: {
-        body: data,
-        headers: {
-          "content-type": "application/xml",
-        },
+        body: xml(data),
       },
       handler: (req: MockRequest) => {
         req.expect.containsHeader("content-type", "application/xml");

package/specs/response/status-code-range/main.tsp

@@ -0,0 +1,82 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+/**
+ * Test for range of status code.
+ */
+@scenarioService("/response/status-code-range")
+namespace Response.StatusCodeRange;
+
+@scenario
+@scenarioDoc("""
+  Test case for range of status code in error response.
+  
+  Verify that the result of the API is an error/exception in client, and the error response can be de-serialized to ErrorInRange model (instead of DefaultError model).
+  
+  Expected status code 494 and response body:
+  ```json
+  { 
+    "code": "request-header-too-large",
+    "message": "Request header too large"
+  }
+  ```
+  """)
+@route("/error-response-status-code-in-range")
+@get
+op errorResponseStatusCodeInRange(): NoContentResponse | ErrorInRange | DefaultError;
+
+@scenario
+@scenarioDoc("""
+  Test case for range of status code in error response.
+  
+  Verify that the result of the API is an error/exception in client, and the error response can be de-serialized to NotFoundError model (instead of Standard4XXError model).
+  
+  Expected status code 404 and response body:
+  ```json
+  { 
+    "code": "not-found",
+    "resourceId": "resource1"
+  }
+  ```
+  """)
+@route("/error-response-status-code-404")
+@get
+op errorResponseStatusCode404(): NoContentResponse | NotFoundError | Standard4XXError;
+
+@error
+model NotFoundError {
+  @statusCode
+  _: 404;
+
+  code: string;
+  resourceId: string;
+}
+
+@error
+model ErrorInRange {
+  @minValue(494)
+  @maxValue(499)
+  @statusCode
+  _: int32;
+
+  code: string;
+  message: string;
+}
+
+@error
+model Standard4XXError {
+  @minValue(400)
+  @maxValue(499)
+  @statusCode
+  _: int32;
+
+  code: string;
+}
+
+@error
+model DefaultError {
+  code: string;
+}

package/specs/response/status-code-range/mockapi.ts

@@ -0,0 +1,31 @@
+import { json, passOnCode, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.Response_StatusCodeRange_errorResponseStatusCodeInRange = passOnCode(494, {
+  uri: "/response/status-code-range/error-response-status-code-in-range",
+  method: "get",
+  request: {},
+  response: {
+    status: 494,
+    body: json({
+      code: "request-header-too-large",
+      message: "Request header too large",
+    }),
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Response_StatusCodeRange_errorResponseStatusCode404 = passOnCode(404, {
+  uri: "/response/status-code-range/error-response-status-code-404",
+  method: "get",
+  request: {},
+  response: {
+    status: 404,
+    body: json({
+      code: "not-found",
+      resourceId: "resource1",
+    }),
+  },
+  kind: "MockApiDefinition",
+});