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

package/specs/type/scalar/main.tsp

@@ -14,14 +14,25 @@ interface String {
   @scenarioDoc("Expect to handle a string value. Mock api will return 'test'")
   @get
   @doc("get string value")
-  get(): string;
+  get(): {
+    @header
+    contentType: "application/json";
+
+    @body
+    body: string;
+  };
 
   #suppress "@azure-tools/typespec-azure-core/use-standard-operations" "For testing"
   @scenario
   @scenarioDoc("Expect to send a string value. Mock api expect to receive 'test'")
   @put
   @doc("put string value")
-  put(@body @doc("_") body: string): void;
+  put(
+    @header
+    contentType: "application/json",
+
+    @body @doc("_") body: string,
+  ): void;
 }
 
 @route("/boolean")
@@ -31,14 +42,25 @@ interface Boolean {
   @scenarioDoc("Expect to handle a boolean value. Mock api will return true ")
   @get
   @doc("get boolean value")
-  get(): boolean;
+  get(): {
+    @header
+    contentType: "application/json";
+
+    @body
+    body: boolean;
+  };
 
   #suppress "@azure-tools/typespec-azure-core/use-standard-operations" "For testing"
   @scenario
   @scenarioDoc("Expect to send a boolean value. Mock api expect to receive 'true'")
   @put
   @doc("put boolean value")
-  put(@body @doc("_") body: boolean): void;
+  put(
+    @header
+    contentType: "application/json",
+
+    @body @doc("_") body: boolean,
+  ): void;
 }
 
 @route("/unknown")
@@ -48,14 +70,25 @@ interface Unknown {
   @scenarioDoc("Expect to handle a unknown type value. Mock api will return 'test'")
   @get
   @doc("get unknown value")
-  get(): unknown;
+  get(): {
+    @header
+    contentType: "application/json";
+
+    @body
+    body: unknown;
+  };
 
   #suppress "@azure-tools/typespec-azure-core/use-standard-operations" "For testing"
   @scenario
   @scenarioDoc("Expect to send a string value. Mock api expect to receive 'test'")
   @put
   @doc("put unknown value")
-  put(@body @doc("_") body: unknown): void;
+  put(
+    @header
+    contentType: "application/json",
+
+    @body @doc("_") body: unknown,
+  ): void;
 }
 
 @doc("Template to have scalar types operations")
@@ -69,7 +102,13 @@ interface ScalarTypesOperations<T, TDoc extends valueof string> {
     """)
   @get
   @route("/response_body")
-  responseBody(): T;
+  responseBody(): {
+    @header
+    contentType: "application/json";
+
+    @body
+    body: T;
+  };
 
   @scenario
   @scenarioDoc("""
@@ -80,7 +119,12 @@ interface ScalarTypesOperations<T, TDoc extends valueof string> {
     """)
   @put
   @route("/resquest_body")
-  requestBody(@body body: T): void;
+  requestBody(
+    @header
+    contentType: "application/json",
+
+    @body body: T,
+  ): void;
 
   @scenario
   @scenarioDoc("""
@@ -124,7 +168,12 @@ interface NumberTypesVerifyOperations<
     """)
   @post
   @route("/verify")
-  verify(@body body: T): void;
+  verify(
+    @header
+    contentType: "application/json",
+
+    @body body: T,
+  ): void;
 }
 
 @doc("Decimal type verification")

package/specs/type/scalar/mockapi.ts

@@ -17,7 +17,7 @@ Scenarios.Type_Scalar_String_put = passOnSuccess({
   uri: "/type/scalar/string",
   method: `put`,
   request: {
-    body: "test",
+    body: json("test"),
     headers: {
       "Content-Type": "text/plain",
     },
@@ -43,7 +43,7 @@ Scenarios.Type_Scalar_Boolean_put = passOnSuccess({
   uri: "/type/scalar/boolean",
   method: `put`,
   request: {
-    body: true,
+    body: json(true),
     headers: {
       "Content-Type": "application/json; charset=utf-8",
     },
@@ -68,7 +68,7 @@ Scenarios.Type_Scalar_Unknown_put = passOnSuccess({
   uri: "/type/scalar/unknown",
   method: `put`,
   request: {
-    body: "test",
+    body: json("test"),
     headers: {
       "Content-Type": "text/plain",
     },
@@ -103,7 +103,7 @@ Scenarios.Type_Scalar_DecimalType_requestBody = passOnSuccess({
   uri: "/type/scalar/decimal/resquest_body",
   method: `put`,
   request: {
-    body: 0.33333,
+    body: json(0.33333),
     headers: {
       "Content-Type": "application/json; charset=utf-8",
     },
@@ -117,7 +117,7 @@ Scenarios.Type_Scalar_Decimal128Type_requestBody = passOnSuccess({
   uri: "/type/scalar/decimal128/resquest_body",
   method: `put`,
   request: {
-    body: 0.33333,
+    body: json(0.33333),
     headers: {
       "Content-Type": "application/json; charset=utf-8",
     },
@@ -131,7 +131,7 @@ Scenarios.Type_Scalar_DecimalType_requestParameter = passOnSuccess({
   uri: "/type/scalar/decimal/request_parameter",
   method: `get`,
   request: {
-    params: { value: "0.33333" },
+    query: { value: "0.33333" },
   },
   response: {
     status: 204,
@@ -142,7 +142,7 @@ Scenarios.Type_Scalar_Decimal128Type_requestParameter = passOnSuccess({
   uri: "/type/scalar/decimal128/request_parameter",
   method: `get`,
   request: {
-    params: { value: "0.33333" },
+    query: { value: "0.33333" },
   },
   response: {
     status: 204,
@@ -173,7 +173,7 @@ Scenarios.Type_Scalar_DecimalVerify_verify = passOnSuccess({
   uri: "/type/scalar/decimal/verify",
   method: `post`,
   request: {
-    body: 0.3,
+    body: json(0.3),
     headers: {
       "Content-Type": "application/json; charset=utf-8",
     },
@@ -187,7 +187,7 @@ Scenarios.Type_Scalar_Decimal128Verify_verify = passOnSuccess({
   uri: "/type/scalar/decimal128/verify",
   method: `post`,
   request: {
-    body: 0.3,
+    body: json(0.3),
     headers: {
       "Content-Type": "application/json; charset=utf-8",
     },

package/specs/type/union/discriminated/main.tsp

@@ -0,0 +1,251 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+/**
+ * Describe scenarios for discriminated unions.
+ */
+@scenarioService("/type/union/discriminated")
+namespace Type.Union.Discriminated;
+
+// Models for discriminated unions
+model Cat {
+  name: string;
+  meow: boolean;
+}
+
+model Dog {
+  name: string;
+  bark: boolean;
+}
+
+/**
+ * Test discriminated union with default envelope serialization.
+ * The discriminated union should serialize with "kind" as discriminator
+ * and "value" as envelope property.
+ */
+@discriminated
+union PetWithEnvelope {
+  cat: Cat,
+  dog: Dog,
+}
+
+@route("/envelope")
+namespace Envelope {
+  @route("/object")
+  namespace Object {
+    @route("/default")
+    interface Default {
+      @scenario
+      @scenarioDoc("""
+        Test discriminated union with envelope serialization.
+        When value of query parameter "kind" is "cat" or no query parameter input, the expected response is:
+        ```json
+        {
+          "kind": "cat",
+          "value": {
+            "name": "Whiskers",
+            "meow": true
+          }
+        }
+        ```
+        When it is "dog", expected response is:
+        ```json
+        {
+          "kind": "dog",
+          "value": {
+            "name": "Rex",
+            "bark": false
+          }
+        }
+        ```
+        """)
+      @get
+      get(@query kind?: string): PetWithEnvelope;
+
+      @scenario
+      @scenarioDoc("""
+        Test discriminated union with envelope serialization.
+        Send the union as:
+        ```json
+        {
+          "kind": "cat", 
+          "value": {
+            "name": "Whiskers",
+            "meow": true
+          }
+        }
+        ```
+        """)
+      @put
+      put(@body input: PetWithEnvelope): PetWithEnvelope;
+    }
+
+    @route("/custom-properties")
+    interface CustomProperties {
+      @scenario
+      @scenarioDoc("""
+        Test discriminated union with custom property names.
+        When value of query parameter "petType" is "cat" or no query parameter input, the expected response is:
+        ```json
+        {
+          "petType": "cat",
+          "petData": {
+            "name": "Whiskers", 
+            "meow": true
+          }
+        }
+        ```
+        When it is "dog", expected response is:
+        ```json
+        {
+          "petType": "dog",
+          "petData": {
+            "name": "Rex",
+            "bark": false
+          }
+        }
+        ```
+        """)
+      @get
+      get(@query petType?: string): PetWithCustomNames;
+
+      @scenario
+      @scenarioDoc("""
+        Test discriminated union with custom property names.
+        Send the union as:
+        ```json
+        {
+          "petType": "cat",
+          "petData": {
+            "name": "Whiskers",
+            "meow": true
+          }
+        }
+        ```
+        """)
+      @put
+      put(@body input: PetWithCustomNames): PetWithCustomNames;
+    }
+  }
+}
+
+/**
+ * Test discriminated union with custom property names.
+ * The discriminated union should serialize with custom discriminator
+ * and envelope property names.
+ */
+@discriminated(#{ discriminatorPropertyName: "petType", envelopePropertyName: "petData" })
+union PetWithCustomNames {
+  cat: Cat,
+  dog: Dog,
+}
+
+/**
+ * Test discriminated union with inline discriminator (no envelope).
+ * The discriminated union should serialize with discriminator property
+ * injected directly into the variant object.
+ */
+@discriminated(#{ envelope: "none" })
+union PetInline {
+  cat: Cat,
+  dog: Dog,
+}
+
+/**
+ * Test discriminated union with inline discriminator and custom discriminator property name.
+ * The discriminated union should serialize with custom discriminator property
+ * injected directly into the variant object.
+ */
+@discriminated(#{ envelope: "none", discriminatorPropertyName: "type" })
+union PetInlineWithCustomDiscriminator {
+  cat: Cat,
+  dog: Dog,
+}
+
+@route("/no-envelope")
+namespace NoEnvelope {
+  @route("/default")
+  interface Default {
+    @scenario
+    @scenarioDoc("""
+      Test discriminated union with inline discriminator.
+      When value of query parameter "kind" is "cat" or no query parameter input, the expected response is:
+      ```json
+      {
+        "kind": "cat",
+        "name": "Whiskers",
+        "meow": true
+      }
+      ```
+      When it is "dog", expected response is:
+      ```json
+      {
+        "kind": "dog",
+        "name": "Rex",
+        "bark": false
+      }
+      ```
+      """)
+    @get
+    get(@query kind?: string): PetInline;
+
+    @scenario
+    @scenarioDoc("""
+      Test discriminated union with inline discriminator.
+      Send the union as:
+      ```json
+      {
+        "kind": "cat",
+        "name": "Whiskers", 
+        "meow": true
+      }
+      ```
+      """)
+    @put
+    put(@body input: PetInline): PetInline;
+  }
+
+  @route("/custom-discriminator")
+  interface CustomDiscriminator {
+    @scenario
+    @scenarioDoc("""
+      Test discriminated union with inline discriminator and custom discriminator property name.
+      When value of query parameter "type" is "cat" or no query parameter input, the expected response is:
+      ```json
+      {
+        "type": "cat",
+        "name": "Whiskers",
+        "meow": true
+      }
+      ```
+      When it is "dog", expected response is:
+      ```json
+      {
+        "type": "dog",
+        "name": "Rex",
+        "bark": false
+      }
+      ```
+      """)
+    @get
+    get(@query type?: string): PetInlineWithCustomDiscriminator;
+
+    @scenario
+    @scenarioDoc("""
+      Test discriminated union with inline discriminator and custom discriminator property name.
+      Send the union as:
+      ```json
+      {
+        "type": "cat",
+        "name": "Whiskers", 
+        "meow": true
+      }
+      ```
+      """)
+    @put
+    put(@body input: PetInlineWithCustomDiscriminator): PetInlineWithCustomDiscriminator;
+  }
+}

package/specs/type/union/discriminated/mockapi.ts

@@ -0,0 +1,230 @@
+import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+// Test data for discriminated union scenarios
+const catData = {
+  name: "Whiskers",
+  meow: true,
+};
+
+const dogData = {
+  name: "Rex",
+  bark: false,
+};
+
+// Envelope discriminated union (default serialization)
+const envelopeCatBody = {
+  kind: "cat",
+  value: catData,
+};
+
+const envelopeDogBody = {
+  kind: "dog",
+  value: dogData,
+};
+
+Scenarios.Type_Union_Discriminated_Envelope_Object_Default_get = passOnSuccess({
+  uri: "/type/union/discriminated/envelope/object/default",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json(envelopeCatBody),
+  },
+  handler: (req: MockRequest) => {
+    const kind = req.query.kind as string | undefined;
+
+    // When kind is null or "cat", return response for "cat"
+    // When kind is "dog", return response for "dog"
+    if (kind === "dog") {
+      return {
+        status: 200,
+        body: json(envelopeDogBody),
+      };
+    } else {
+      // Default case: when kind is null, undefined, or "cat"
+      return {
+        status: 200,
+        body: json(envelopeCatBody),
+      };
+    }
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Union_Discriminated_Envelope_Object_Default_put = passOnSuccess({
+  uri: "/type/union/discriminated/envelope/object/default",
+  method: "put",
+  request: {
+    body: json(envelopeCatBody),
+  },
+  response: {
+    status: 200,
+    body: json(envelopeCatBody),
+  },
+  kind: "MockApiDefinition",
+});
+
+// Custom names discriminated union
+const customNamesCatBody = {
+  petType: "cat",
+  petData: catData,
+};
+
+const customNamesDogBody = {
+  petType: "dog",
+  petData: dogData,
+};
+
+Scenarios.Type_Union_Discriminated_Envelope_Object_CustomProperties_get = passOnSuccess({
+  uri: "/type/union/discriminated/envelope/object/custom-properties",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json(customNamesCatBody),
+  },
+  handler: (req: MockRequest) => {
+    const petType = req.query.petType as string | undefined;
+
+    // When petType is null or "cat", return response for "cat"
+    // When petType is "dog", return response for "dog"
+    if (petType === "dog") {
+      return {
+        status: 200,
+        body: json(customNamesDogBody),
+      };
+    } else {
+      // Default case: when petType is null, undefined, or "cat"
+      return {
+        status: 200,
+        body: json(customNamesCatBody),
+      };
+    }
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Union_Discriminated_Envelope_Object_CustomProperties_put = passOnSuccess({
+  uri: "/type/union/discriminated/envelope/object/custom-properties",
+  method: "put",
+  request: {
+    body: json(customNamesCatBody),
+  },
+  response: {
+    status: 200,
+    body: json(customNamesCatBody),
+  },
+  kind: "MockApiDefinition",
+});
+
+// Inline discriminated union (no envelope)
+const inlineCatBody = {
+  kind: "cat",
+  name: "Whiskers",
+  meow: true,
+};
+
+const inlineDogBody = {
+  kind: "dog",
+  name: "Rex",
+  bark: false,
+};
+
+Scenarios.Type_Union_Discriminated_NoEnvelope_Default_get = passOnSuccess({
+  uri: "/type/union/discriminated/no-envelope/default",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json(inlineCatBody),
+  },
+  handler: (req: MockRequest) => {
+    const kind = req.query.kind as string | undefined;
+
+    // When kind is null or "cat", return response for "cat"
+    // When kind is "dog", return response for "dog"
+    if (kind === "dog") {
+      return {
+        status: 200,
+        body: json(inlineDogBody),
+      };
+    } else {
+      // Default case: when kind is null, undefined, or "cat"
+      return {
+        status: 200,
+        body: json(inlineCatBody),
+      };
+    }
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Union_Discriminated_NoEnvelope_Default_put = passOnSuccess({
+  uri: "/type/union/discriminated/no-envelope/default",
+  method: "put",
+  request: {
+    body: json(inlineCatBody),
+  },
+  response: {
+    status: 200,
+    body: json(inlineCatBody),
+  },
+  kind: "MockApiDefinition",
+});
+
+// Inline discriminated union with custom discriminator property name
+const inlineCustomCatBody = {
+  type: "cat",
+  name: "Whiskers",
+  meow: true,
+};
+
+const inlineCustomDogBody = {
+  type: "dog",
+  name: "Rex",
+  bark: false,
+};
+
+Scenarios.Type_Union_Discriminated_NoEnvelope_CustomDiscriminator_get = passOnSuccess({
+  uri: "/type/union/discriminated/no-envelope/custom-discriminator",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json(inlineCustomCatBody),
+  },
+  handler: (req: MockRequest) => {
+    const type = req.query.type as string | undefined;
+
+    // When type is null or "cat", return response for "cat"
+    // When type is "dog", return response for "dog"
+    if (type === "dog") {
+      return {
+        status: 200,
+        body: json(inlineCustomDogBody),
+      };
+    } else {
+      // Default case: when type is null, undefined, or "cat"
+      return {
+        status: 200,
+        body: json(inlineCustomCatBody),
+      };
+    }
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Union_Discriminated_NoEnvelope_CustomDiscriminator_put = passOnSuccess({
+  uri: "/type/union/discriminated/no-envelope/custom-discriminator",
+  method: "put",
+  request: {
+    body: json(inlineCustomCatBody),
+  },
+  response: {
+    status: 200,
+    body: json(inlineCustomCatBody),
+  },
+  kind: "MockApiDefinition",
+});

package/specs/type/union/mockapi.ts

@@ -20,9 +20,9 @@ function createPostServerTests(url: string, value: unknown) {
     uri: url,
     method: `post`,
     request: {
-      body: {
+      body: json({
         prop: value,
-      },
+      }),
     },
     response: {
       status: 204,