@typespec/http-specs 0.37.2

package/specs/type/scalar/mockapi.ts

@@ -0,0 +1,280 @@
+import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.Type_Scalar_String_get = passOnSuccess({
+  uri: "/type/scalar/string",
+  method: `get`,
+  request: {},
+  response: {
+    status: 200,
+    body: json("test"),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json("test") };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Scalar_String_put = passOnSuccess({
+  uri: "/type/scalar/string",
+  method: `put`,
+  request: {
+    body: "test",
+    headers: {
+      "Content-Type": "text/plain",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals("test");
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Scalar_Boolean_get = passOnSuccess({
+  uri: "/type/scalar/boolean",
+  method: `get`,
+  request: {},
+  response: {
+    status: 200,
+    body: json(true),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json(true) };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Scalar_Boolean_put = passOnSuccess({
+  uri: "/type/scalar/boolean",
+  method: `put`,
+  request: {
+    body: true,
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(true);
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Scalar_Unknown_get = passOnSuccess({
+  uri: "/type/scalar/unknown",
+  method: `get`,
+  request: {},
+  response: {
+    status: 200,
+    body: json("test"),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json("test") };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Scalar_Unknown_put = passOnSuccess({
+  uri: "/type/scalar/unknown",
+  method: `put`,
+  request: {
+    body: "test",
+    headers: {
+      "Content-Type": "text/plain",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals("test");
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Scalar_DecimalType_responseBody = passOnSuccess({
+  uri: "/type/scalar/decimal/response_body",
+  method: `get`,
+  request: {},
+  response: {
+    status: 200,
+    body: json(0.33333),
+  },
+  handler: (req: MockRequest) => {
+    return {
+      status: 200,
+      body: json(0.33333),
+    };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Scalar_Decimal128Type_responseBody = passOnSuccess({
+  uri: "/type/scalar/decimal128/response_body",
+  method: `get`,
+  request: {},
+  response: {
+    status: 200,
+    body: json(0.33333),
+  },
+  handler: (req: MockRequest) => {
+    return {
+      status: 200,
+      body: json(0.33333),
+    };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Scalar_DecimalType_requestBody = passOnSuccess({
+  uri: "/type/scalar/decimal/resquest_body",
+  method: `put`,
+  request: {
+    body: 0.33333,
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(0.33333);
+    return {
+      status: 204,
+    };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Scalar_Decimal128Type_requestBody = passOnSuccess({
+  uri: "/type/scalar/decimal128/resquest_body",
+  method: `put`,
+  request: {
+    body: 0.33333,
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(0.33333);
+    return {
+      status: 204,
+    };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Scalar_DecimalType_requestParameter = passOnSuccess({
+  uri: "/type/scalar/decimal/request_parameter",
+  method: `get`,
+  request: {
+    params: { value: 0.33333 },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsQueryParam("value", "0.33333");
+    return {
+      status: 204,
+    };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Scalar_Decimal128Type_requestParameter = passOnSuccess({
+  uri: "/type/scalar/decimal128/request_parameter",
+  method: `get`,
+  request: {
+    params: { value: 0.33333 },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.containsQueryParam("value", "0.33333");
+    return {
+      status: 204,
+    };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Scalar_DecimalVerify_prepareVerify = passOnSuccess({
+  uri: "/type/scalar/decimal/prepare_verify",
+  method: `get`,
+  request: {},
+  response: {
+    status: 200,
+    body: json([0.1, 0.1, 0.1]),
+  },
+  handler: (req: MockRequest) => {
+    return {
+      status: 200,
+      body: json([0.1, 0.1, 0.1]),
+    };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Scalar_Decimal128Verify_prepareVerify = passOnSuccess({
+  uri: "/type/scalar/decimal128/prepare_verify",
+  method: `get`,
+  request: {},
+  response: {
+    status: 200,
+    body: json([0.1, 0.1, 0.1]),
+  },
+  handler: (req: MockRequest) => {
+    return {
+      status: 200,
+      body: json([0.1, 0.1, 0.1]),
+    };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Scalar_DecimalVerify_verify = passOnSuccess({
+  uri: "/type/scalar/decimal/verify",
+  method: `post`,
+  request: {
+    body: 0.3,
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(0.3);
+    return {
+      status: 204,
+    };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Scalar_Decimal128Verify_verify = passOnSuccess({
+  uri: "/type/scalar/decimal128/verify",
+  method: `post`,
+  request: {
+    body: 0.3,
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(0.3);
+    return {
+      status: 204,
+    };
+  },
+  kind: "MockApiDefinition",
+});

package/specs/type/union/main.tsp

@@ -0,0 +1,262 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+using Azure.ClientGenerator.Core;
+
+/**
+ * Describe scenarios for various combinations of unions.
+ */
+@supportedBy("dpg")
+@scenarioService("/type/union")
+namespace Type.Union;
+
+model Cat {
+  name: string;
+}
+
+model Dog {
+  bark: string;
+}
+
+enum LR {
+  left,
+  right,
+}
+enum UD {
+  up,
+  down,
+}
+
+/**
+ * Describe union of string "a" | "b" | "c"
+ */
+@route("/strings-only")
+@operationGroup
+interface StringsOnly extends GetAndSend<"a" | "b" | "c", "\"b\""> {}
+
+/**
+ * Describe union of string string | "b" | "c"
+ */
+@route("/string-extensible")
+@operationGroup
+interface StringExtensible extends GetAndSend<string | "b" | "c", "\"custom\""> {}
+
+union StringExtensibleNamedUnion {
+  string,
+  OptionB: "b",
+  "c",
+}
+/**
+ * Describe union of string string | "b" | "c" but where the union is named and some of the variants are named
+ */
+@route("/string-extensible-named")
+@operationGroup
+interface StringExtensibleNamed extends GetAndSend<StringExtensibleNamedUnion, "\"custom\""> {}
+
+/**
+ * Describe union of integer 1 | 2 | 3
+ */
+@route("/ints-only")
+@operationGroup
+interface IntsOnly extends GetAndSend<1 | 2 | 3, "2"> {}
+
+/**
+ * Describe union of floats 1.1 | 2.2 | 3.3
+ */
+@route("/floats-only")
+@operationGroup
+interface FloatsOnly extends GetAndSend<1.1 | 2.2 | 3.3, "2.2"> {}
+
+/**
+ * Describe union of models
+ */
+@route("/models-only")
+@operationGroup
+interface ModelsOnly
+  extends GetAndSend<
+      Cat | Dog,
+      """
+        {
+          "name": "test"
+        }
+        """
+    > {}
+
+model EnumsOnlyCases {
+  /** This should be receive/send the left variant */
+  lr: LR | UD;
+
+  /** This should be receive/send the up variant */
+  ud: UD | UD;
+}
+
+/**
+ * Describe union of 2 different enums
+ */
+@route("/enums-only")
+@operationGroup
+interface EnumsOnly
+  extends GetAndSend<
+      LR | UD,
+      """
+        {
+          "lr": "right",
+          "ud": "up"
+        }
+        """,
+      EnumsOnlyCases
+    > {}
+
+model StringAndArrayCases {
+  /** This should be receive/send the string variant */
+  string: string | string[];
+
+  /** This should be receive/send the array variant */
+  array: string | string[];
+}
+
+/**
+ * Describe union of a string and an array of strings
+ */
+@route("/string-and-array")
+@operationGroup
+interface StringAndArray
+  extends GetAndSend<
+      string | string[],
+      """
+        {
+          "string": "test",
+          "array": ["test1", "test2"]
+        }
+        """,
+      StringAndArrayCases
+    > {}
+
+alias MixedLiteralsUnion = "a" | 2 | 3.3 | true;
+model MixedLiteralsCases {
+  /** This should be receive/send the "a" variant */
+  stringLiteral: MixedLiteralsUnion;
+
+  /** This should be receive/send the 2 variant */
+  intLiteral: MixedLiteralsUnion;
+
+  /** This should be receive/send the 3.3 variant */
+  floatLiteral: MixedLiteralsUnion;
+
+  /** This should be receive/send the true variant */
+  booleanLiteral: MixedLiteralsUnion;
+}
+
+/**
+ * Describe union of floats "a" | 2 | 3.3
+ */
+@route("/mixed-literals")
+@operationGroup
+interface MixedLiterals
+  extends GetAndSend<
+      MixedLiteralsUnion,
+      """
+        {
+          "stringLiteral": "a",
+          "intLiteral": 2,
+          "floatLiteral": 3.3,
+          "booleanLiteral": true
+        }
+        """,
+      MixedLiteralsCases
+    > {}
+
+alias MixedTypesUnion = Cat | "a" | int32 | boolean;
+model MixedTypesCases {
+  /** This should be receive/send the Cat variant */
+  `model`: MixedTypesUnion;
+
+  /** This should be receive/send the "a" variant */
+  literal: MixedTypesUnion;
+
+  /** This should be receive/send the int variant */
+  int: MixedTypesUnion;
+
+  /** This should be receive/send the boolean variant */
+  boolean: MixedTypesUnion;
+
+  /** This should be receive/send 4 element with Cat, "a", int, and boolean */
+  array: MixedTypesUnion[];
+}
+
+/**
+ * Describe union of floats "a" | 2 | 3.3
+ */
+@route("/mixed-types")
+@operationGroup
+interface MixedTypes
+  extends GetAndSend<
+      MixedTypesUnion,
+      """
+        {
+          "model": {
+            "name": "test"
+          },
+          "literal": "a",
+          "int": 2,
+          "boolean": true,
+          "array": [
+            {
+              "name": "test"
+            },
+            "a",
+            2,
+            true
+          ]
+        }
+        """,
+      MixedTypesCases
+    > {}
+
+/**
+ * Helper interface to describe a test involving getting and sending a specific data
+ */
+interface GetAndSend<Union, Payload extends string, Cases = Union> {
+  @scenario
+  @scenarioDoc(
+    """
+      Verify a union can be processed in a response: 
+      ```tsp
+      {type}
+      ```
+      
+      Expected response body:
+      ```json
+      { "prop": {value}}
+      ```
+      """,
+    {
+      type: Union,
+      value: Payload,
+    }
+  )
+  get(): {
+    prop: Cases;
+  };
+
+  @scenario
+  @scenarioDoc(
+    """
+      Verify a union can be processed in a response: 
+      ```tsp
+      {type}
+      ```
+      
+      Expected request to send body:
+      ```json
+      { "prop": {value}}
+      ```
+      """,
+    {
+      type: Union,
+      value: Payload,
+    }
+  )
+  send(prop: Cases): void;
+}

package/specs/type/union/mockapi.ts

@@ -0,0 +1,137 @@
+import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+function createGetServerTests(url: string, value: unknown) {
+  return passOnSuccess({
+    uri: url,
+    method: `get`,
+    request: {},
+    response: {
+      status: 200,
+      body: json({ prop: value }),
+    },
+    handler: (req: MockRequest) => {
+      return { status: 200, body: json({ prop: value }) };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+
+function createPostServerTests(url: string, value: unknown) {
+  return passOnSuccess({
+    uri: url,
+    method: `post`,
+    request: {
+      body: {
+        prop: value,
+      },
+    },
+    response: {
+      status: 204,
+    },
+    handler: (req: MockRequest) => {
+      req.expect.bodyEquals({ prop: value });
+      return { status: 204 };
+    },
+    kind: "MockApiDefinition",
+  });
+}
+
+Scenarios.Type_Union_StringsOnly_get = createGetServerTests(`/type/union/strings-only`, "b");
+Scenarios.Type_Union_StringsOnly_send = createPostServerTests(`/type/union/strings-only`, "b");
+
+Scenarios.Type_Union_StringExtensible_get = createGetServerTests(
+  `/type/union/string-extensible`,
+  "custom",
+);
+Scenarios.Type_Union_StringExtensible_send = createPostServerTests(
+  `/type/union/string-extensible`,
+  "custom",
+);
+
+Scenarios.Type_Union_StringExtensibleNamed_get = createGetServerTests(
+  `/type/union/string-extensible-named`,
+  "custom",
+);
+Scenarios.Type_Union_StringExtensibleNamed_send = createPostServerTests(
+  `/type/union/string-extensible-named`,
+  "custom",
+);
+
+Scenarios.Type_Union_IntsOnly_get = createGetServerTests(`/type/union/ints-only`, 2);
+Scenarios.Type_Union_IntsOnly_send = createPostServerTests(`/type/union/ints-only`, 2);
+
+Scenarios.Type_Union_FloatsOnly_get = createGetServerTests(`/type/union/floats-only`, 2.2);
+Scenarios.Type_Union_FloatsOnly_send = createPostServerTests(`/type/union/floats-only`, 2.2);
+
+Scenarios.Type_Union_ModelsOnly_get = createGetServerTests(`/type/union/models-only`, {
+  name: "test",
+});
+Scenarios.Type_Union_ModelsOnly_send = createPostServerTests(`/type/union/models-only`, {
+  name: "test",
+});
+
+Scenarios.Type_Union_EnumsOnly_get = createGetServerTests(`/type/union/enums-only`, {
+  lr: "right",
+  ud: "up",
+});
+Scenarios.Type_Union_EnumsOnly_send = createPostServerTests(`/type/union/enums-only`, {
+  lr: "right",
+  ud: "up",
+});
+
+Scenarios.Type_Union_StringAndArray_get = createGetServerTests(`/type/union/string-and-array`, {
+  string: "test",
+  array: ["test1", "test2"],
+});
+Scenarios.Type_Union_StringAndArray_send = createPostServerTests(`/type/union/string-and-array`, {
+  string: "test",
+  array: ["test1", "test2"],
+});
+
+Scenarios.Type_Union_MixedLiterals_get = createGetServerTests(`/type/union/mixed-literals`, {
+  stringLiteral: "a",
+  intLiteral: 2,
+  floatLiteral: 3.3,
+  booleanLiteral: true,
+});
+Scenarios.Type_Union_MixedLiterals_send = createPostServerTests(`/type/union/mixed-literals`, {
+  stringLiteral: "a",
+  intLiteral: 2,
+  floatLiteral: 3.3,
+  booleanLiteral: true,
+});
+
+Scenarios.Type_Union_MixedTypes_get = createGetServerTests(`/type/union/mixed-types`, {
+  model: {
+    name: "test",
+  },
+  literal: "a",
+  int: 2,
+  boolean: true,
+  array: [
+    {
+      name: "test",
+    },
+    "a",
+    2,
+    true,
+  ],
+});
+Scenarios.Type_Union_MixedTypes_send = createPostServerTests(`/type/union/mixed-types`, {
+  model: {
+    name: "test",
+  },
+  literal: "a",
+  int: 2,
+  boolean: true,
+  array: [
+    {
+      name: "test",
+    },
+    "a",
+    2,
+    true,
+  ],
+});