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

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,

package/specs/versioning/added/mockapi.ts

@@ -6,11 +6,11 @@ Scenarios.Versioning_Added_v1 = passOnSuccess({
   uri: `/versioning/added/api-version:v2/v1`,
   method: `post`,
   request: {
-    body: {
+    body: json({
       prop: "foo",
       enumProp: "enumMemberV2",
       unionProp: 10,
-    },
+    }),
     headers: {
       "header-v2": "bar",
     },
@@ -26,11 +26,11 @@ Scenarios.Versioning_Added_v2 = passOnSuccess({
   uri: `/versioning/added/api-version:v2/v2`,
   method: `post`,
   request: {
-    body: {
+    body: json({
       prop: "foo",
       enumProp: "enumMember",
       unionProp: "bar",
-    },
+    }),
   },
   response: {
     status: 200,
@@ -43,11 +43,11 @@ Scenarios.Versioning_Added_InterfaceV2 = passOnSuccess({
   uri: `/versioning/added/api-version:v2/interface-v2/v2`,
   method: `post`,
   request: {
-    body: {
+    body: json({
       prop: "foo",
       enumProp: "enumMember",
       unionProp: "bar",
-    },
+    }),
   },
   response: {
     status: 200,

package/specs/versioning/madeOptional/mockapi.ts

@@ -6,9 +6,9 @@ Scenarios.Versioning_MadeOptional_test = passOnSuccess({
   uri: `/versioning/made-optional/api-version:v2/test`,
   method: `post`,
   request: {
-    body: {
+    body: json({
       prop: "foo",
-    },
+    }),
   },
   response: {
     status: 200,

package/specs/versioning/removed/main.tsp

@@ -115,7 +115,7 @@ scalar V1Scalar extends int32;
 /**
  * This operation should not be generated with latest version's signature.
  */
-#suppress "@azure-tools/cadl-ranch-expect/missing-scenario" "by design"
+#suppress "@typespec/spector/missing-scenario" "by design"
 @route("/v1")
 @post
 @removed(Versions.v2)
@@ -140,7 +140,7 @@ op v2(@body body: ModelV2, @removed(Versions.v2) @query param: string): ModelV2;
 @route("/interface-v1")
 @removed(Versions.v2)
 interface InterfaceV1 {
-  #suppress "@azure-tools/cadl-ranch-expect/missing-scenario" "by design"
+  #suppress "@typespec/spector/missing-scenario" "by design"
   @post
   @route("/v1")
   v1InInterface(@body body: ModelV1): ModelV1;
@@ -149,7 +149,7 @@ interface InterfaceV1 {
 /** This operation will pass different paths and different request bodies based on different versions. */
 @scenario
 @scenarioDoc("""
-  path: "/versioning/removed/api-version[:]v1/v3"
+  path: "/versioning/removed/api-version:v1/v3"
   Expected request body:
   ```json
   { "id": "123", "enumProp": "enumMemberV1" }
@@ -160,7 +160,7 @@ interface InterfaceV1 {
   { "id": "123", "enumProp": "enumMemberV1" }
   ```
   
-  path: "/versioning/removed/api-version[:]v2preview/v3"
+  path: "/versioning/removed/api-version:v2preview/v3"
   Expected request body:
   ```json
   { "id": "123"}
@@ -171,7 +171,7 @@ interface InterfaceV1 {
   { "id": "123"}
   ```
   
-  path: "/versioning/removed/api-version[:]v2/v3"
+  path: "/versioning/removed/api-version:v2/v3"
   Expected request body:
   ```json
   { "id": "123", "enumProp": "enumMemberV1" }

package/specs/versioning/removed/mockapi.ts

@@ -6,11 +6,11 @@ Scenarios.Versioning_Removed_v2 = passOnSuccess({
   uri: `/versioning/removed/api-version:v2/v2`,
   method: `post`,
   request: {
-    body: {
+    body: json({
       prop: "foo",
       enumProp: "enumMemberV2",
       unionProp: "bar",
-    },
+    }),
   },
   response: {
     status: 200,
@@ -20,13 +20,13 @@ Scenarios.Versioning_Removed_v2 = passOnSuccess({
 });
 
 Scenarios.Versioning_Removed_modelV3 = passOnSuccess({
-  uri: `/versioning/removed/api-version[:]v1/v3`,
+  uri: `/versioning/removed/api-version\\:v1/v3`,
   method: "post",
   request: {
-    body: {
+    body: json({
       id: "123",
       enumProp: "enumMemberV1",
-    },
+    }),
   },
   response: {
     status: 200,
@@ -36,13 +36,13 @@ Scenarios.Versioning_Removed_modelV3 = passOnSuccess({
 });
 
 Scenarios.Versioning_Removed_modelV3_V2 = passOnSuccess({
-  uri: `/versioning/removed/api-version[:]v2/v3`,
+  uri: `/versioning/removed/api-version\\:v2/v3`,
   method: "post",
   request: {
-    body: {
+    body: json({
       id: "123",
       enumProp: "enumMemberV1",
-    },
+    }),
   },
   response: {
     status: 200,
@@ -52,12 +52,12 @@ Scenarios.Versioning_Removed_modelV3_V2 = passOnSuccess({
 });
 
 Scenarios.Versioning_Removed_modelV3_V2preview = passOnSuccess({
-  uri: `/versioning/removed/api-version[:]v2preview/v3`,
+  uri: `/versioning/removed/api-version\\:v2preview/v3`,
   method: "post",
   request: {
-    body: {
+    body: json({
       id: "123",
-    },
+    }),
   },
   response: {
     status: 200,

package/specs/versioning/renamedFrom/mockapi.ts

@@ -6,12 +6,12 @@ Scenarios.Versioning_RenamedFrom_newOp = passOnSuccess({
   uri: `/versioning/renamed-from/api-version:v2/test`,
   method: `post`,
   request: {
-    body: {
+    body: json({
       newProp: "foo",
       enumProp: "newEnumMember",
       unionProp: 10,
-    },
-    params: {
+    }),
+    query: {
       newQuery: "bar",
     },
   },
@@ -26,11 +26,11 @@ Scenarios.Versioning_RenamedFrom_NewInterface = passOnSuccess({
   uri: `/versioning/renamed-from/api-version:v2/interface/test`,
   method: `post`,
   request: {
-    body: {
+    body: json({
       newProp: "foo",
       enumProp: "newEnumMember",
       unionProp: 10,
-    },
+    }),
   },
   response: {
     status: 200,

package/specs/versioning/returnTypeChangedFrom/main.tsp

@@ -53,5 +53,20 @@ enum Versions {
   """)
 @route("/test")
 @post
-@returnTypeChangedFrom(Versions.v2, int32)
-op test(@body body: string): string;
+@returnTypeChangedFrom(
+  Versions.v2,
+  {
+    @header
+    contentType: "application/json",
+
+    @body
+    body: int32,
+  }
+)
+op test(@header contentType: "application/json", @body body: string): {
+  @header
+  contentType: "application/json";
+
+  @body
+  body: string;
+};