@typespec/http-specs 0.37.2

package/specs/parameters/basic/mockapi.ts

@@ -0,0 +1,29 @@
+import { MockRequest, 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,
+    },
+    handler: (req: MockRequest) => {
+      req.expect.bodyEquals({ name: "foo" });
+      return { 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,63 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+using Azure.ClientGenerator.Core;
+
+@doc("Test describing optionality of the request body.")
+@supportedBy("dpg")
+@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`
+  """)
+@operationGroup
+@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,71 @@
+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,
+    },
+    handler: (req: MockRequest) => {
+      req.expect.bodyEquals({ name: "foo" });
+      return { 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,
+    },
+    handler: (req: MockRequest) => {
+      req.expect.bodyEquals({ name: "foo" });
+      return { status: 204 };
+    },
+    kind: "MockApiDefinition",
+  },
+  {
+    uri: "/parameters/body-optionality/optional-explicit/omit",
+    method: "post",
+    request: {
+      body: {
+        name: "foo",
+      },
+    },
+    response: {
+      status: 204,
+    },
+    handler: (req: MockRequest) => {
+      req.expect.bodyEquals({ name: "foo" });
+      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,95 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+using Azure.ClientGenerator.Core;
+
+@doc("Test for collectionFormat.")
+@supportedBy("dpg")
+@scenarioService("/parameters/collection-format")
+namespace Parameters.CollectionFormat;
+
+@route("/query")
+@operationGroup
+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")
+@operationGroup
+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,113 @@
+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,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsQueryParam("colors", ["blue", "red", "green"], "csv");
+    return {
+      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,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsQueryParam("colors", ["blue", "red", "green"], "ssv");
+    return {
+      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,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsQueryParam("colors", ["blue", "red", "green"], "tsv");
+    return {
+      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,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsQueryParam("colors", ["blue", "red", "green"], "pipes");
+    return {
+      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,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsHeader("colors", "blue,red,green");
+    return {
+      status: 204,
+    };
+  },
+  kind: "MockApiDefinition",
+});

package/specs/parameters/spread/main.tsp

@@ -0,0 +1,340 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+using Azure.ClientGenerator.Core;
+
+@doc("Test for the spread operator.")
+@supportedBy("dpg")
+@scenarioService("/parameters/spread")
+namespace Parameters.Spread;
+
+@route("/model")
+@operationGroup
+namespace Model {
+  @doc("This is a simple model.")
+  model BodyParameter {
+    name: string;
+  }
+
+  @scenario
+  @scenarioDoc("""
+    Test case for spread named model. 
+    
+    Should not generate request body model named `BodyParameter`.
+    Should generate an operation like below:
+    ```
+    spreadAsRequestBody(name: string)
+    ```
+    Note the parameter name is guessed from the model name and it may vary by language.
+    
+    Expected request body:
+    ```json
+    { "name": "foo" }
+    ```
+    """)
+  @route("/request-body")
+  @put
+  op spreadAsRequestBody(...BodyParameter): NoContentResponse;
+
+  @doc("This is a model only with `@body` property.")
+  model CompositeRequestOnlyWithBody {
+    @body body: BodyParameter;
+  }
+
+  @scenario
+  @scenarioDoc("""
+    Test case for spread model only with `@body` property. 
+    
+    Should generate request body model named `BodyParameter`.
+    Should not generate model named `CompositeRequestOnlyWithBody`.
+    Should generate an operation like below:
+    ```
+    spreadCompositeRequestOnlyWithBody(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("/composite-request-only-with-body")
+  @put
+  op spreadCompositeRequestOnlyWithBody(...CompositeRequestOnlyWithBody): NoContentResponse;
+
+  @doc("This is a model without `@body` property.")
+  model CompositeRequestWithoutBody {
+    @path
+    name: string;
+
+    @header
+    testHeader: string;
+  }
+
+  @scenario
+  @scenarioDoc("""
+    Test case for spread model without `@body` property. 
+    
+    Should not generate model named `CompositeRequestOnlyWithBody`.
+    Should generate an operation like below:
+    ```
+    spreadCompositeRequestWithoutBody(name: string, testHeader: string)
+    ```
+    
+    Expected path parameter: name="foo"
+    Expected header parameter: testHeader="bar"
+    """)
+  @route("/composite-request-without-body/{name}")
+  @put
+  op spreadCompositeRequestWithoutBody(...CompositeRequestWithoutBody): NoContentResponse;
+
+  @doc("This is a model with all http request decorator.")
+  model CompositeRequest {
+    @path
+    name: string;
+
+    @header
+    testHeader: string;
+
+    @body
+    body: BodyParameter;
+  }
+
+  @scenario
+  @scenarioDoc("""
+    Test case for spread model with all http request decorator. 
+    
+    Should generate request body model named `BodyParameter`.
+    Should not generate model named `CompositeRequest`.
+    Should generate an operation like below:
+    ```
+    spreadCompositeRequest(name: string, testHeader: string, bodyParameter: BodyParameter)
+    ```
+    Note the parameter name is guessed from the model name and it may vary by language.
+    
+    Expected path parameter: name="foo"
+    Expected header parameter: testHeader="bar"
+    Expected request body:
+    ```json
+    { "name": "foo" }
+    ```
+    """)
+  @route("/composite-request/{name}")
+  @put
+  op spreadCompositeRequest(...CompositeRequest): NoContentResponse;
+
+  @doc("This is a model with non-body http request decorator.")
+  model CompositeRequestMix {
+    @path
+    name: string;
+
+    @header
+    testHeader: string;
+
+    prop: string;
+  }
+
+  @scenario
+  @scenarioDoc("""
+    Test case for spread model with non-body http request decorator. 
+    
+    Should not generate model named `CompositeRequestMix`.
+    Should generate an operation like below:
+    ```
+    spreadCompositeRequestMix(name: string, testHeader: string, prop: string)
+    ```
+    Note the parameter name is guessed from the model name and it may vary by language.
+    
+    Expected path parameter: name="foo"
+    Expected header parameter: testHeader="bar"
+    Expected request body:
+    ```json
+    { "prop": "foo" }
+    ```
+    """)
+  @route("/composite-request-mix/{name}")
+  @put
+  op spreadCompositeRequestMix(...CompositeRequestMix): NoContentResponse;
+}
+
+@route("/alias")
+@operationGroup
+namespace Alias {
+  alias BodyParameter = {
+    name: string;
+  };
+
+  @scenario
+  @scenarioDoc("""
+    Test case for spread alias. 
+    
+    Should not generate any model named `BodyParameter`.
+    Should generate an operation like:
+    ```
+    spreadAsRequestBody(name: string)
+    ```
+    
+    Expected request body:
+    ```json
+    { "name": "foo" }
+    ```
+    """)
+  @route("/request-body")
+  @put
+  op spreadAsRequestBody(...BodyParameter): NoContentResponse;
+
+  model InnerModel {
+    name: string;
+  }
+
+  alias InnerModelParameter = {
+    @path
+    id: string;
+
+    ...InnerModel;
+
+    @header
+    `x-ms-test-header`: string;
+  };
+
+  @scenario
+  @scenarioDoc("""
+    Test case for spread alias. 
+    
+    Should not generate any model named `InnerModel`.
+    Should not generate any model named `InnerModelParameter`.
+    Should generate an operation like:
+    ```
+    spreadParameterWithInnerModel(id: string, x_ms_test_header: string, name: string)
+    ```
+    Note the parameter name is guessed from the model name and it may vary by language.
+    
+    Expected path parameter: id="1"
+    Expected header parameter: x-ms-test-header="bar"
+    Expected request body:
+    ```json
+    { "name": "foo" }
+    ```
+    """)
+  @route("/inner-model-parameter/{id}")
+  @post
+  op spreadParameterWithInnerModel(...InnerModelParameter): NoContentResponse;
+
+  alias RequestParameter = {
+    @path
+    id: string;
+
+    @header
+    `x-ms-test-header`: string;
+
+    name: string;
+  };
+
+  @scenario
+  @scenarioDoc("""
+    Test case for spread alias with path and header parameter. 
+    
+    Should not generate any model named `RequestParameter`.
+    Should generate an operation like below:
+    ```
+    spreadAsRequestParameter(id: string, x_ms_test_header: string, name: string)
+    ```
+    Note the parameter name may be normalized and vary by language.
+    
+    Expected path parameter: id="1"
+    Expected header parameter: x-ms-test-header="bar"
+    Expected request body:
+    ```json
+    { "name": "foo" }
+    ```
+    """)
+  @route("/request-parameter/{id}")
+  @put
+  op spreadAsRequestParameter(...RequestParameter): NoContentResponse;
+
+  alias MultipleRequestParameters = {
+    @path
+    id: string;
+
+    @header
+    `x-ms-test-header`: string;
+
+    /** required string */
+    requiredString: string;
+
+    /** optional int */
+    optionalInt?: int32;
+
+    /** required int */
+    requiredIntList: int32[];
+
+    /** optional string */
+    optionalStringList?: string[];
+  };
+
+  @scenario
+  @scenarioDoc("""
+    Test case for spread alias including 6 parameters. May handle as property bag for these parameters.
+    
+    Should not generate any model named `MultipleRequestParameters`.
+    Since it contains both optional properties and required properties, the method signature might vary across different languages.
+    Note it's also acceptable if some languages handle it as property bag.
+    
+    Expected path parameter: id="1"
+    Expected header parameter: x-ms-test-header="bar"
+    Expected request body:
+    ```json
+    {
+      "requiredString": "foo",
+      "optionalInt": 1,
+      "requiredIntList": [1, 2],
+      "optionalStringList": ["foo", "bar"]
+    }
+    ```
+    """)
+  @route("/multiple-parameters/{id}")
+  @put
+  op spreadWithMultipleParameters(...MultipleRequestParameters): NoContentResponse;
+
+  alias InnerAlias = {
+    @doc("name of the Thing")
+    name: string;
+
+    @doc("age of the Thing")
+    age: int32;
+  };
+
+  alias InnerAliasParameter = {
+    @path id: string;
+    ...InnerAlias;
+
+    @header
+    `x-ms-test-header`: string;
+  };
+
+  @scenario
+  @scenarioDoc("""
+    Test case for spread alias with contains another alias property as body.
+    
+    Should not generate any model named `InnerAlias` and `InnerAliasParameter`.
+    Should generate an operation like below:
+    ```
+    spreadParameterWithInnerAlias(id: string, name: string, age: int32, x_ms_test_header: string)
+    ```
+    Note the parameter name is guessed from the model name and it may vary by language.
+    Expected path parameter: id="1"
+    Expected header parameter: x-ms-test-header="bar"
+    Expected request body:
+    ```json
+    {
+      "name": "foo",
+      "age": 1
+    }
+    ```
+    """)
+  @route("/inner-alias-parameter")
+  @doc("spread an alias with contains another alias property as body.")
+  @post
+  op spreadParameterWithInnerAlias(...InnerAliasParameter): NoContentResponse;
+}