@typespec/http-specs 0.37.2

package/specs/payload/multipart/mockapi.ts

@@ -0,0 +1,226 @@
+import {
+  mockapi,
+  MockApi,
+  MockRequest,
+  passOnSuccess,
+  ScenarioMockApi,
+  ValidationError,
+  withKeys,
+} from "@typespec/spec-api";
+import { jpgFile, pngFile } from "../../helper.js";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+function checkId(req: MockRequest) {
+  req.expect.deepEqual(req.body.id, "123");
+}
+
+function checkAddress(req: MockRequest) {
+  req.expect.deepEqual(JSON.parse(req.body.address), { city: "X" });
+}
+
+function checkPreviousAddresses(req: MockRequest) {
+  req.expect.deepEqual(JSON.parse(req.body.previousAddresses), [{ city: "Y" }, { city: "Z" }]);
+}
+
+function checkFile(
+  req: MockRequest,
+  file: Record<string, any>,
+  expected: Buffer,
+  contentType: string = "application/octet-stream",
+  fileName: string | undefined = undefined,
+  mustCheckContentType: boolean = true,
+) {
+  // cadl-ranch depends on multer, which sets the mimetype to "text/plain" if this part has no content-type header
+  if (mustCheckContentType || file.mimetype !== "text/plain") {
+    req.expect.deepEqual(file.mimetype, contentType);
+  }
+  req.expect.deepEqual(file.buffer, expected);
+  if (fileName) {
+    req.expect.deepEqual(file.originalname, fileName);
+  }
+}
+
+function checkJpgFile(
+  req: MockRequest,
+  file: Record<string, any>,
+  contentType: string = "application/octet-stream",
+  fileName: string | undefined = undefined,
+  mustCheckContentType: boolean = true,
+) {
+  req.expect.deepEqual(file.fieldname, "profileImage");
+  checkFile(req, file, jpgFile, contentType, fileName, mustCheckContentType);
+}
+
+function checkOptionalContentType(req: MockRequest) {
+  if (req.files instanceof Array && req.files?.length > 0) {
+    checkJpgFile(req, req.files[0], "application/octet-stream", undefined, false);
+  } else {
+    throw new ValidationError("No profileImage found", "jpg file is expected", req.body);
+  }
+}
+
+function checkPngFile(req: MockRequest, file: Record<string, any>, fieldName: string = "pictures") {
+  req.expect.deepEqual(file.fieldname, fieldName);
+  checkFile(req, file, pngFile);
+}
+
+function checkProfileImage(req: MockRequest) {
+  if (req.files instanceof Array && req.files?.length > 0) {
+    checkJpgFile(req, req.files[0]);
+  } else {
+    throw new ValidationError("No profileImage found", "jpg file is expected", req.body);
+  }
+}
+
+function checkFileNameAndContentType(req: MockRequest) {
+  if (req.files instanceof Array && req.files?.length > 0) {
+    checkJpgFile(req, req.files[0], "image/jpg", "hello.jpg");
+  } else {
+    throw new ValidationError("No profileImage found", "jpg file is expected", req.body);
+  }
+}
+
+function checkAllFiles(req: MockRequest) {
+  if (req.files instanceof Array && req.files?.length === 3) {
+    for (const file of req.files) {
+      if (file.fieldname === "profileImage") {
+        checkJpgFile(req, file);
+      } else if (file.fieldname === "pictures") {
+        checkPngFile(req, file);
+      } else {
+        throw new ValidationError(
+          "unexpected fieldname",
+          "profileImage or pictures",
+          file.fieldname,
+        );
+      }
+    }
+  } else {
+    throw new ValidationError(
+      "Can't parse files from request",
+      "jpg/png files are expected",
+      req.body,
+    );
+  }
+}
+function checkPictures(req: MockRequest) {
+  if (req.files instanceof Array && req.files?.length === 2) {
+    for (const file of req.files) {
+      checkPngFile(req, file);
+    }
+  } else {
+    throw new ValidationError("No pictures found", "png files are expected", req.body);
+  }
+}
+function checkFloat(req: MockRequest) {
+  req.expect.deepEqual(parseFloat(req.body.temperature), 0.5);
+}
+function createMockApis(route: string, checkList: ((param: MockRequest) => void)[]): MockApi {
+  const url = `/multipart/form-data/${route}`;
+  return mockapi.post(url, (req) => {
+    for (const callback of checkList) {
+      callback(req);
+    }
+    return { status: 204 };
+  });
+}
+
+Scenarios.Payload_MultiPart_FormData_basic = passOnSuccess(
+  createMockApis("mixed-parts", [checkId, checkProfileImage]),
+);
+
+Scenarios.Payload_MultiPart_FormData_fileArrayAndBasic = passOnSuccess(
+  createMockApis("complex-parts", [checkId, checkAddress, checkAllFiles]),
+);
+
+Scenarios.Payload_MultiPart_FormData_jsonPart = passOnSuccess(
+  createMockApis("json-part", [checkAddress, checkProfileImage]),
+);
+
+Scenarios.Payload_MultiPart_FormData_binaryArrayParts = passOnSuccess(
+  createMockApis("binary-array-parts", [checkId, checkPictures]),
+);
+
+Scenarios.Payload_MultiPart_FormData_multiBinaryParts = withKeys([
+  "profileImage",
+  "profileImage,picture",
+]).pass(
+  mockapi.post("/multipart/form-data/multi-binary-parts", (req) => {
+    if (req.files instanceof Array) {
+      switch (req.files.length) {
+        case 1:
+          checkJpgFile(req, req.files[0]);
+          return { pass: "profileImage", status: 204 } as const;
+        case 2:
+          let profileImage = false;
+          let picture = false;
+          for (const file of req.files) {
+            if (file.fieldname === "profileImage") {
+              checkJpgFile(req, file);
+              profileImage = true;
+            } else if (file.fieldname === "picture") {
+              checkPngFile(req, file, "picture");
+              picture = true;
+            } else {
+              throw new ValidationError(
+                "unexpected fieldname",
+                "profileImage or picture",
+                file.fieldname,
+              );
+            }
+          }
+          if (!profileImage) {
+            throw new ValidationError("No profileImage found", "jpg file is expected", req.body);
+          } else if (!picture) {
+            throw new ValidationError("No picture found", "png file are expected", req.body);
+          }
+          return { pass: "profileImage,picture", status: 204 } as const;
+        default:
+          throw new ValidationError(
+            "number of files is incorrect",
+            "1 or 2 files are expected",
+            req.body,
+          );
+      }
+    } else {
+      throw new ValidationError(
+        "Can't parse files from request",
+        "jpg/png files are expected",
+        req.body,
+      );
+    }
+  }),
+);
+
+Scenarios.Payload_MultiPart_FormData_checkFileNameAndContentType = passOnSuccess(
+  createMockApis("check-filename-and-content-type", [checkId, checkFileNameAndContentType]),
+);
+
+Scenarios.Payload_MultiPart_FormData_anonymousModel = passOnSuccess(
+  createMockApis("anonymous-model", [checkProfileImage]),
+);
+
+Scenarios.Payload_MultiPart_FormData_HttpParts_ContentType_imageJpegContentType = passOnSuccess(
+  createMockApis("check-filename-and-specific-content-type-with-httppart", [
+    checkFileNameAndContentType,
+  ]),
+);
+
+Scenarios.Payload_MultiPart_FormData_HttpParts_ContentType_requiredContentType = passOnSuccess(
+  createMockApis("check-filename-and-required-content-type-with-httppart", [checkProfileImage]),
+);
+Scenarios.Payload_MultiPart_FormData_HttpParts_ContentType_optionalContentType = passOnSuccess(
+  createMockApis("file-with-http-part-optional-content-type", [checkOptionalContentType]),
+);
+Scenarios.Payload_MultiPart_FormData_HttpParts_jsonArrayAndFileArray = passOnSuccess(
+  createMockApis("complex-parts-with-httppart", [
+    checkId,
+    checkAddress,
+    checkPreviousAddresses,
+    checkAllFiles,
+  ]),
+);
+Scenarios.Payload_MultiPart_FormData_HttpParts_NonString_float = passOnSuccess(
+  createMockApis("non-string-float", [checkFloat]),
+);

package/specs/payload/xml/main.tsp

@@ -0,0 +1,312 @@
+import "@typespec/http";
+import "@typespec/xml";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+using TypeSpec.Xml;
+using Azure.ClientGenerator.Core;
+
+@doc("Sends and receives bodies in XML format.")
+@scenarioService("/payload/xml")
+namespace Payload.Xml;
+
+@doc("Contains fields of primitive types.")
+model SimpleModel {
+  name: string;
+  age: int32;
+}
+
+@doc("Contains fields of arrays of primitive types.")
+model ModelWithSimpleArrays {
+  colors: string[];
+  counts: int32[];
+}
+
+@doc("Contains an array of models.")
+model ModelWithArrayOfModel {
+  items: SimpleModel[];
+}
+
+@doc("Contains an optional field.")
+model ModelWithOptionalField {
+  item: string;
+  value?: int32;
+}
+
+@doc("Contains fields that are XML attributes.")
+model ModelWithAttributes {
+  @attribute id1: int32;
+  @attribute id2: string;
+  enabled: boolean;
+}
+
+@doc("Contains fields of wrapped and unwrapped arrays of primitive types.")
+model ModelWithUnwrappedArray {
+  @unwrapped colors: string[];
+  counts: int32[];
+}
+
+@doc("Contains fields of wrapped and unwrapped arrays of primitive types that have different XML representations.")
+model ModelWithRenamedArrays {
+  @name("Colors") @unwrapped colors: string[];
+  @name("Counts") counts: int32[];
+}
+
+@doc("Contains fields of the same type that have different XML representation.")
+@name("ModelWithRenamedFieldsSrc")
+model ModelWithRenamedFields {
+  @name("InputData") inputData: SimpleModel;
+  @name("OutputData") outputData: SimpleModel;
+}
+
+@doc("Contains an array of models that's supposed to be sent/received as an empty XML element.")
+model ModelWithEmptyArray {
+  items: SimpleModel[];
+}
+
+@doc("Contains an attribute and text.")
+model ModelWithText {
+  @attribute language: string;
+  @unwrapped content: string;
+}
+
+@doc("Contains a dictionary of key value pairs.")
+model ModelWithDictionary {
+  metadata: Record<string>;
+}
+
+@doc("Uses encodedName instead of Xml.Name which is functionally equivalent.")
+@encodedName("application/xml", "ModelWithEncodedNamesSrc")
+model ModelWithEncodedNames {
+  @encodedName("application/xml", "SimpleModelData") modelData: SimpleModel;
+  @encodedName("application/xml", "PossibleColors") colors: string[];
+}
+
+@doc("Template for XML operations")
+interface XmlOperations<TModel, TDoc extends string> {
+  @scenario
+  @scenarioDoc(
+    """
+      Expected response body:
+      ```xml
+      {doc}
+      ```
+      """,
+    {
+      doc: TDoc,
+    }
+  )
+  @get
+  get(): {
+    @header("content-type") contentType: "application/xml";
+    @body body: TModel;
+  };
+
+  @scenario
+  @scenarioDoc(
+    """
+      Expected request body:
+      ```xml
+      {doc}
+      ```
+      """,
+    {
+      doc: TDoc,
+    }
+  )
+  @put
+  put(@header("content-type") contentType: "application/xml", @body input: TModel): void;
+}
+
+@doc("Operations for the SimpleModel type.")
+@route("/simpleModel")
+interface SimpleModelValue
+  extends XmlOperations<
+      SimpleModel,
+      """
+        <SimpleModel>
+          <name>foo</name>
+          <age>123</age>
+        </SimpleModel>
+        """
+    > {}
+
+@doc("Operations for the ModelWithSimpleArrays type.")
+@route("/modelWithSimpleArrays")
+interface ModelWithSimpleArraysValue
+  extends XmlOperations<
+      ModelWithSimpleArrays,
+      """
+        <ModelWithSimpleArrays>
+          <colors>
+            <string>red</string>
+            <string>green</string>
+            <string>blue</string>
+          </colors>
+          <counts>
+            <int32>1</int32>
+            <int32>2</int32>
+          </counts>
+        </ModelWithSimpleArrays>
+        """
+    > {}
+
+@doc("Operations for the ModelWithArrayOfModel type.")
+@route("/modelWithArrayOfModel")
+interface ModelWithArrayOfModelValue
+  extends XmlOperations<
+      ModelWithArrayOfModel,
+      """
+        <ModelWithArrayOfModel>
+          <items>
+            <SimpleModel>
+              <name>foo</name>
+              <age>123</age>
+            </SimpleModel>
+            <SimpleModel>
+              <name>bar</name>
+              <age>456</age>
+            </SimpleModel>
+          </items>
+        </ModelWithArrayOfModel>
+        """
+    > {}
+
+@doc("Operations for the ModelWithOptionalField type.")
+@route("/modelWithOptionalField")
+interface ModelWithOptionalFieldValue
+  extends XmlOperations<
+      ModelWithOptionalField,
+      """
+        <ModelWithOptionalField>
+          <item>widget</item>
+        </ModelWithOptionalField>
+        """
+    > {}
+
+@doc("Operations for the ModelWithAttributes type.")
+@route("/modelWithAttributes")
+interface ModelWithAttributesValue
+  extends XmlOperations<
+      ModelWithAttributes,
+      """
+        <ModelWithAttributes id1="123" id2="foo">
+          <enabled>true</enabled>
+        </ModelWithAttributes>
+        """
+    > {}
+
+@doc("Operations for the ModelWithUnwrappedArray type.")
+@route("/modelWithUnwrappedArray")
+interface ModelWithUnwrappedArrayValue
+  extends XmlOperations<
+      ModelWithUnwrappedArray,
+      """
+        <ModelWithUnwrappedArray>
+          <colors>red</colors>
+          <colors>green</colors>
+          <colors>blue</colors>
+          <counts>
+            <int32>1</int32>
+            <int32>2</int32>
+          </counts>
+        </ModelWithUnwrappedArray>
+        """
+    > {}
+
+@doc("Operations for the ModelWithRenamedArrays type.")
+@route("/modelWithRenamedArrays")
+interface ModelWithRenamedArraysValue
+  extends XmlOperations<
+      ModelWithRenamedArrays,
+      """
+        <ModelWithRenamedArrays>
+          <Colors>red</Colors>
+          <Colors>green</Colors>
+          <Colors>blue</Colors>
+          <Counts>
+            <int32>1</int32>
+            <int32>2</int32>
+          </Counts>
+        </ModelWithRenamedArrays>
+        """
+    > {}
+
+@doc("Operations for the ModelWithRenamedFields type.")
+@route("/modelWithRenamedFields")
+interface ModelWithRenamedFieldsValue
+  extends XmlOperations<
+      ModelWithRenamedFields,
+      """
+        <ModelWithRenamedFieldsSrc>
+          <InputData>
+            <name>foo</name>
+            <age>123</age>
+          </InputData>
+          <OutputData>
+            <name>bar</name>
+            <age>456</age>
+          </OutputData>
+        </ModelWithRenamedFieldsSrc>
+        """
+    > {}
+
+@doc("Operations for the ModelWithEmptyArray type.")
+@route("/modelWithEmptyArray")
+interface ModelWithEmptyArrayValue
+  extends XmlOperations<
+      ModelWithEmptyArray,
+      """
+        <ModelWithEmptyArray>
+          <items />
+        </ModelWithEmptyArray>
+        """
+    > {}
+
+@doc("Operations for the ModelWithText type.")
+@route("/modelWithText")
+interface ModelWithTextValue
+  extends XmlOperations<
+      ModelWithText,
+      """
+        <ModelWithText language="foo">
+          This is some text.
+        </ModelWithText>
+        """
+    > {}
+
+@doc("Operations for the ModelWithDictionary type.")
+@route("/modelWithDictionary")
+interface ModelWithDictionaryValue
+  extends XmlOperations<
+      ModelWithDictionary,
+      """
+        <ModelWithDictionary>
+          <metadata>
+            <Color>blue</Color>
+            <Count>123</Count>
+            <Enabled>false</Enabled>
+          </metadata>
+        </ModelWithDictionary>
+        """
+    > {}
+
+@doc("Operations for the ModelWithEncodedNames type.")
+@route("/modelWithEncodedNames")
+interface ModelWithEncodedNamesValue
+  extends XmlOperations<
+      ModelWithEncodedNames,
+      """
+        <ModelWithEncodedNamesSrc>
+          <SimpleModelData>
+            <name>foo</name>
+            <age>123</age>
+          </SimpleModelData>
+          <PossibleColors>
+            <string>red</string>
+            <string>green</string>
+            <string>blue</string>
+          </PossibleColors>
+        </ModelWithEncodedNamesSrc>
+        """
+    > {}