@typespec/http-specs 0.1.0-alpha.0

package/specs/encode/duration/mockapi.ts

@@ -0,0 +1,191 @@
+import {
+  CollectionFormat,
+  json,
+  MockRequest,
+  passOnSuccess,
+  ScenarioMockApi,
+} from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+function createBodyServerTests(uri: string, data: any, value: any) {
+  return passOnSuccess({
+    uri,
+    method: "post",
+    request: {
+      body: data,
+    },
+    response: {
+      status: 200,
+      body: json(data),
+    },
+    kind: "MockApiDefinition",
+  });
+}
+Scenarios.Encode_Duration_Property_default = createBodyServerTests(
+  "/encode/duration/property/default",
+  {
+    value: "P40D",
+  },
+  "P40D",
+);
+Scenarios.Encode_Duration_Property_floatSeconds = createBodyServerTests(
+  "/encode/duration/property/float-seconds",
+  {
+    value: 35.625,
+  },
+  35.625,
+);
+Scenarios.Encode_Duration_Property_float64Seconds = createBodyServerTests(
+  "/encode/duration/property/float64-seconds",
+  {
+    value: 35.625,
+  },
+  35.625,
+);
+Scenarios.Encode_Duration_Property_int32Seconds = createBodyServerTests(
+  "/encode/duration/property/int32-seconds",
+  {
+    value: 36,
+  },
+  36,
+);
+Scenarios.Encode_Duration_Property_iso8601 = createBodyServerTests(
+  "/encode/duration/property/iso8601",
+  {
+    value: "P40D",
+  },
+  "P40D",
+);
+Scenarios.Encode_Duration_Property_floatSecondsArray = createBodyServerTests(
+  "/encode/duration/property/float-seconds-array",
+  {
+    value: [35.625, 46.75],
+  },
+  [35.625, 46.75],
+);
+
+function createQueryServerTests(
+  uri: string,
+  paramData: any,
+  value: any,
+  collectionFormat?: CollectionFormat,
+) {
+  return passOnSuccess({
+    uri,
+    method: "get",
+    request: {
+      params: paramData,
+    },
+    response: {
+      status: 204,
+    },
+    handler: (req: MockRequest) => {
+      req.expect.containsQueryParam("input", value, collectionFormat);
+      return {
+        status: 204,
+      };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+Scenarios.Encode_Duration_Query_default = createQueryServerTests(
+  "/encode/duration/query/default",
+  {
+    input: "P40D",
+  },
+  "P40D",
+);
+Scenarios.Encode_Duration_Query_iso8601 = createQueryServerTests(
+  "/encode/duration/query/iso8601",
+  {
+    input: "P40D",
+  },
+  "P40D",
+);
+Scenarios.Encode_Duration_Query_int32Seconds = createQueryServerTests(
+  "/encode/duration/query/int32-seconds",
+  {
+    input: 36,
+  },
+  "36",
+);
+Scenarios.Encode_Duration_Query_int32SecondsArray = createQueryServerTests(
+  "/encode/duration/query/int32-seconds-array",
+  {
+    input: [36, 47].join(","),
+  },
+  ["36", "47"],
+  "csv",
+);
+Scenarios.Encode_Duration_Query_floatSeconds = createQueryServerTests(
+  "/encode/duration/query/float-seconds",
+  {
+    input: 35.625,
+  },
+  "35.625",
+);
+Scenarios.Encode_Duration_Query_float64Seconds = createQueryServerTests(
+  "/encode/duration/query/float64-seconds",
+  {
+    input: 35.625,
+  },
+  "35.625",
+);
+
+function createHeaderServerTests(uri: string, headersData: any, value: any) {
+  return passOnSuccess({
+    uri,
+    method: "get",
+    request: {
+      headers: headersData,
+    },
+    response: {
+      status: 204,
+    },
+    kind: "MockApiDefinition",
+  });
+}
+
+Scenarios.Encode_Duration_Header_default = createHeaderServerTests(
+  "/encode/duration/header/default",
+  {
+    duration: "P40D",
+  },
+  "P40D",
+);
+Scenarios.Encode_Duration_Header_iso8601 = createHeaderServerTests(
+  "/encode/duration/header/iso8601",
+  {
+    duration: "P40D",
+  },
+  "P40D",
+);
+Scenarios.Encode_Duration_Header_int32Seconds = createHeaderServerTests(
+  "/encode/duration/header/int32-seconds",
+  {
+    duration: "36",
+  },
+  "36",
+);
+Scenarios.Encode_Duration_Header_floatSeconds = createHeaderServerTests(
+  "/encode/duration/header/float-seconds",
+  {
+    duration: "35.625",
+  },
+  "35.625",
+);
+Scenarios.Encode_Duration_Header_float64Seconds = createHeaderServerTests(
+  "/encode/duration/header/float64-seconds",
+  {
+    duration: "35.625",
+  },
+  "35.625",
+);
+Scenarios.Encode_Duration_Header_iso8601Array = createHeaderServerTests(
+  "/encode/duration/header/iso8601-array",
+  {
+    duration: ["P40D", "P50D"].join(","),
+  },
+  "P40D,P50D",
+);

package/specs/encode/numeric/main.tsp

@@ -0,0 +1,69 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@doc("Test for encode decorator on integer.")
+@scenarioService("/encode/numeric")
+namespace Encode.Numeric;
+
+@route("/property")
+namespace Property {
+  alias SendSafeIntAsString = SendIntAsString<safeint, "10000000000", SafeintAsStringProperty>;
+
+  @route("/safeint")
+  op safeintAsString is SendSafeIntAsString.sendIntAsString;
+
+  model SafeintAsStringProperty {
+    @encode(string)
+    value: safeint;
+  }
+
+  alias SendUint32AsString = SendIntAsString<uint32, "1", Uint32AsStringProperty>;
+
+  @route("/uint32")
+  op uint32AsStringOptional is SendUint32AsString.sendIntAsString;
+
+  model Uint32AsStringProperty {
+    @encode(string)
+    value?: uint32;
+  }
+
+  alias SendUint8AsString = SendIntAsString<uint8, "255", Uint8AsStringProperty>;
+
+  @route("/uint8")
+  op uint8AsString is SendUint8AsString.sendIntAsString;
+
+  model Uint8AsStringProperty {
+    @encode(string)
+    value: uint8;
+  }
+
+  interface SendIntAsString<IntType extends integer, StringValue extends string, Payload> {
+    @scenario
+    @scenarioDoc(
+      """
+        Test operation with request and response model contains property of {type} type with string encode.
+        Expected request body:
+        ```json
+        {
+          "value": "{value}"
+        }
+        ```
+        Expected response body:
+        ```json
+        {
+          "value": "{value}"
+        }
+        ```
+        """,
+      {
+        type: IntType,
+        value: StringValue,
+      }
+    )
+    @post
+    sendIntAsString(@body value: Payload): Payload;
+  }
+}

package/specs/encode/numeric/mockapi.ts

@@ -0,0 +1,32 @@
+import { json, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+function createTests(uri: string, value: any) {
+  return passOnSuccess({
+    uri,
+    method: "post",
+    request: {
+      body: {
+        value,
+      },
+    },
+    response: {
+      status: 200,
+      body: json({ value }),
+    },
+    kind: "MockApiDefinition",
+  });
+}
+Scenarios.Encode_Numeric_Property_safeintAsString = createTests(
+  "/encode/numeric/property/safeint",
+  "10000000000",
+);
+Scenarios.Encode_Numeric_Property_uint32AsStringOptional = createTests(
+  "/encode/numeric/property/uint32",
+  "1",
+);
+Scenarios.Encode_Numeric_Property_uint8AsString = createTests(
+  "/encode/numeric/property/uint8",
+  "255",
+);

package/specs/helper.ts

@@ -0,0 +1,8 @@
+import { resolvePath } from "@typespec/compiler";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+
+const root = resolvePath(fileURLToPath(import.meta.url), "../../../");
+
+export const pngFile = readFileSync(resolvePath(root, "assets/image.png"));
+export const jpgFile = readFileSync(resolvePath(root, "assets/image.jpg"));

package/specs/parameters/basic/main.tsp

@@ -0,0 +1,58 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@doc("Test for basic parameters cases.")
+@scenarioService("/parameters/basic")
+namespace Parameters.Basic;
+
+@route("/explicit-body")
+namespace ExplicitBody {
+  @doc("This is a simple model.")
+  model User {
+    name: string;
+  }
+
+  @scenario
+  @scenarioDoc("""
+    Test case for simple explicit body. 
+    
+    Should generate request body model named `User`.
+    Should generate an operation like below:
+    ```
+    spreadAsRequestBody(bodyParameter: BodyParameter)
+    ```
+    Note the parameter name is guessed from the model name and it may vary by language.
+    
+    Expected request body:
+    ```json
+    { "name": "foo" }
+    ```
+    """)
+  @route("/simple")
+  @put
+  op simple(@body body: User): NoContentResponse;
+}
+
+@route("/implicit-body")
+namespace ImplicitBody {
+  @scenario
+  @scenarioDoc("""
+    Test case for simple implicit body. 
+    
+    Should generate an operation like below:
+    ```
+    simple(name: string)
+    ```
+    
+    Expected request body:
+    ```json
+    { "name": "foo" }
+    ```
+    """)
+  @route("/simple")
+  @put
+  op simple(name: string): NoContentResponse;
+}

package/specs/parameters/basic/mockapi.ts

@@ -0,0 +1,25 @@
+import { passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+function createServerTests(uri: string) {
+  return passOnSuccess({
+    uri,
+    method: "put",
+    request: {
+      body: {
+        name: "foo",
+      },
+    },
+    response: {
+      status: 204,
+    },
+    kind: "MockApiDefinition",
+  });
+}
+
+Scenarios.Parameters_Basic_ExplicitBody_simple = createServerTests(
+  "/parameters/basic/explicit-body/simple",
+);
+Scenarios.Parameters_Basic_ImplicitBody_simple = createServerTests(
+  "/parameters/basic/implicit-body/simple",
+);

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

@@ -0,0 +1,61 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@doc("Test describing optionality of the request body.")
+@scenarioService("/parameters/body-optionality")
+namespace Parameters.BodyOptionality;
+
+model BodyModel {
+  name: string;
+}
+
+@scenario
+@scenarioDoc("""
+  Scenario defining how an explicit required body parameter is specified.
+  
+  Expected request body:
+  ```json
+  { "name": "foo" }
+  ```
+  """)
+@route("/required-explicit")
+@post
+op requiredExplicit(@body body: BodyModel): NoContentResponse;
+
+@scenario
+@scenarioDoc("""
+  Scenario defining how an explicit optional body parameter is specified.
+  
+  Expected request body for `set`
+  ```json
+  { "name": "foo" }
+  ```
+  
+  Expected no request body for `omit`
+  """)
+@route("/optional-explicit")
+namespace OptionalExplicit {
+  @route("/set")
+  @post
+  op set(@body body?: BodyModel): NoContentResponse;
+
+  @route("/omit")
+  @post
+  op omit(@body body?: BodyModel): NoContentResponse;
+}
+
+@scenario
+@scenarioDoc("""
+  Scenario defining how an implicit required body parameter is specified.
+    
+  Expected request body:
+  ```json
+  { "name": "foo" }
+  ```
+  """)
+@route("/required-implicit")
+@post
+op requiredImplicit(...BodyModel): NoContentResponse;

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

@@ -0,0 +1,59 @@
+import { MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+function createServerTests(uri: string, data: any) {
+  return passOnSuccess({
+    uri,
+    method: "post",
+    request: {
+      body: data,
+    },
+    response: {
+      status: 204,
+    },
+    kind: "MockApiDefinition",
+  });
+}
+
+Scenarios.Parameters_BodyOptionality_requiredExplicit = createServerTests(
+  "/parameters/body-optionality/required-explicit",
+  {
+    name: "foo",
+  },
+);
+
+Scenarios.Parameters_BodyOptionality_OptionalExplicit = passOnSuccess([
+  {
+    uri: "/parameters/body-optionality/optional-explicit/set",
+    method: "post",
+    request: {
+      body: {
+        name: "foo",
+      },
+    },
+    response: {
+      status: 204,
+    },
+    kind: "MockApiDefinition",
+  },
+  {
+    uri: "/parameters/body-optionality/optional-explicit/omit",
+    method: "post",
+    request: {},
+    response: {
+      status: 204,
+    },
+    handler: (req: MockRequest) => {
+      req.expect.rawBodyEquals(undefined);
+      return { status: 204 };
+    },
+    kind: "MockApiDefinition",
+  },
+]);
+
+Scenarios.Parameters_BodyOptionality_requiredImplicit = createServerTests(
+  "/parameters/body-optionality/required-implicit",
+  {
+    name: "foo",
+  },
+);

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

@@ -0,0 +1,92 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@doc("Test for collectionFormat.")
+@scenarioService("/parameters/collection-format")
+namespace Parameters.CollectionFormat;
+
+@route("/query")
+namespace Query {
+  @scenario
+  @scenarioDoc("""
+    This test is testing sending a multi collection format array query parameters
+    """)
+  @route("/multi")
+  op multi(
+    @doc("Possible values for colors are [blue,red,green]")
+    @query(#{ explode: true })
+    colors: string[],
+  ): NoContentResponse;
+
+  @scenario
+  @scenarioDoc("""
+    This test is testing sending a ssv collection format array query parameters
+    """)
+  @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",
+    })
+    colors: string[],
+  ): NoContentResponse;
+
+  @scenario
+  @scenarioDoc("""
+    This test is testing sending a pipes collection format array query parameters
+    """)
+  @route("/pipes")
+  op pipes(
+    #suppress "deprecated" "Deprecated in next release"
+    @doc("Possible values for colors are [blue,red,green]")
+    @query({
+      format: "pipes",
+    })
+    colors: string[],
+  ): NoContentResponse;
+
+  @scenario
+  @scenarioDoc("""
+    This test is testing sending a csv collection format array query parameters
+    """)
+  @route("/csv")
+  op csv(
+    @doc("Possible values for colors are [blue,red,green]")
+    @query
+    colors: string[],
+  ): NoContentResponse;
+}
+
+@route("/header")
+namespace Header {
+  @scenario
+  @scenarioDoc("""
+    This test is testing sending a csv collection format array header parameters
+    """)
+  @route("/csv")
+  op csv(
+    @doc("Possible values for colors are [blue,red,green]")
+    @header({
+      format: "csv",
+    })
+    colors: string[],
+  ): NoContentResponse;
+}

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

@@ -0,0 +1,83 @@
+import { MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+const colors = ["blue", "red", "green"];
+
+Scenarios.Parameters_CollectionFormat_Query_multi = passOnSuccess({
+  uri: `/parameters/collection-format/query/multi`,
+  method: "get",
+  request: {
+    params: { colors: ["blue", "red", "green"] },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsQueryParam("colors", ["blue", "red", "green"], "multi");
+    return {
+      status: 204,
+    };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_CollectionFormat_Query_csv = passOnSuccess({
+  uri: `/parameters/collection-format/query/csv`,
+  method: "get",
+  request: {
+    params: { colors: colors.join(",") },
+  },
+  response: {
+    status: 204,
+  },
+  kind: "MockApiDefinition",
+});
+
+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") },
+  },
+  response: {
+    status: 204,
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_CollectionFormat_Query_pipes = passOnSuccess({
+  uri: `/parameters/collection-format/query/pipes`,
+  method: "get",
+  request: {
+    params: { colors: colors.join("|") },
+  },
+  response: {
+    status: 204,
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Parameters_CollectionFormat_Header_csv = passOnSuccess({
+  uri: `/parameters/collection-format/header/csv`,
+  method: "get",
+  request: {
+    headers: { colors: colors.join(",") },
+  },
+  response: {
+    status: 204,
+  },
+  kind: "MockApiDefinition",
+});