Merge pull request Azure#165 from Azure/daschult/xmlStreamBodies

Fix bug where we were stringifying XML stream request bodies
bterlson · Jul 9, 2018 · e04821f · e04821f
2 parents 8748897 + cd42407
commit e04821f
Show file tree

Hide file tree

Showing 4 changed files with 212 additions and 14 deletions.
diff --git a/lib/serviceClient.ts b/lib/serviceClient.ts
@@ -303,7 +303,7 @@ export class ServiceClient {
   }
 }
 
-function serializeRequestBody(httpRequest: WebResource, operationArguments: OperationArguments, operationSpec: OperationSpec): void {
+export function serializeRequestBody(httpRequest: WebResource, operationArguments: OperationArguments, operationSpec: OperationSpec): void {
   if (operationSpec.requestBody && operationSpec.requestBody.mapper) {
     httpRequest.body = getOperationArgumentValueFromParameter(operationArguments, operationSpec.requestBody, operationSpec.serializer);
 
@@ -314,14 +314,15 @@ function serializeRequestBody(httpRequest: WebResource, operationArguments: Oper
       if (httpRequest.body != undefined || required) {
         const requestBodyParameterPathString: string = getPathStringFromParameter(operationSpec.requestBody);
         httpRequest.body = operationSpec.serializer.serialize(bodyMapper, httpRequest.body, requestBodyParameterPathString);
+        const isStream = typeName === MapperType.Stream;
         if (operationSpec.isXML) {
           if (typeName === MapperType.Sequence) {
             httpRequest.body = utils.stringifyXML(utils.prepareXMLRootList(httpRequest.body, xmlElementName || xmlName || serializedName), { rootName: xmlName || serializedName });
           }
-          else {
+          else if (!isStream) {
             httpRequest.body = utils.stringifyXML(httpRequest.body, { rootName: xmlName || serializedName });
           }
-        } else if (typeName !== MapperType.Stream) {
+        } else if (!isStream) {
           httpRequest.body = JSON.stringify(httpRequest.body);
         }
       }

diff --git a/lib/util/utils.ts b/lib/util/utils.ts
@@ -229,7 +229,10 @@ export function stringifyXML(obj: any, opts?: { rootName?: string }) {
   const builder = new xml2js.Builder({
     explicitArray: false,
     explicitCharkey: false,
-    rootName: (opts || {}).rootName
+    rootName: (opts || {}).rootName,
+    renderOpts: {
+      pretty: false
+    }
   });
   return builder.buildObject(obj);
 }

diff --git a/package-lock.json b/package-lock.json
diff --git a/test/shared/serviceClientTests.ts b/test/shared/serviceClientTests.ts
@@ -1,4 +1,5 @@
-import { ServiceClient, WebResource, Serializer, HttpOperationResponse, DictionaryMapper, QueryCollectionFormat, SequenceMapper, HttpClient } from "../../lib/msRest";
+import { ServiceClient, WebResource, Serializer, HttpOperationResponse, DictionaryMapper, QueryCollectionFormat, SequenceMapper, HttpClient, MapperType } from "../../lib/msRest";
+import { serializeRequestBody } from "../../lib/serviceClient";
 import * as assert from "assert";
 
 describe("ServiceClient", function () {
@@ -156,4 +157,183 @@ describe("ServiceClient", function () {
       });
     assert.strictEqual(request!.withCredentials, true);
   });
-});
+
+  describe("serializeRequestBody()", () => {
+    it("should serialize a JSON String request body", () => {
+      const httpRequest = new WebResource();
+      serializeRequestBody(
+        httpRequest,
+        {
+          arguments: {
+            bodyArg: "body value"
+          }
+        },
+        {
+          httpMethod: "POST",
+          requestBody: {
+            parameterPath: "bodyArg",
+            mapper: {
+              required: true,
+              serializedName: "bodyArg",
+              type: {
+                name: MapperType.String
+              }
+            }
+          },
+          responses: { 200: {} },
+          serializer: new Serializer()
+        });
+      assert.strictEqual(httpRequest.body, `"body value"`);
+    });
+
+    it("should serialize a JSON ByteArray request body", () => {
+      const httpRequest = new WebResource();
+      serializeRequestBody(
+        httpRequest,
+        {
+          arguments: {
+            bodyArg: stringToByteArray("Javascript")
+          }
+        },
+        {
+          httpMethod: "POST",
+          requestBody: {
+            parameterPath: "bodyArg",
+            mapper: {
+              required: true,
+              serializedName: "bodyArg",
+              type: {
+                name: MapperType.ByteArray
+              }
+            }
+          },
+          responses: { 200: {} },
+          serializer: new Serializer()
+        });
+      assert.strictEqual(httpRequest.body, `"SmF2YXNjcmlwdA=="`);
+    });
+
+    it("should serialize a JSON Stream request body", () => {
+      const httpRequest = new WebResource();
+      serializeRequestBody(
+        httpRequest,
+        {
+          arguments: {
+            bodyArg: "body value"
+          }
+        },
+        {
+          httpMethod: "POST",
+          requestBody: {
+            parameterPath: "bodyArg",
+            mapper: {
+              required: true,
+              serializedName: "bodyArg",
+              type: {
+                name: MapperType.Stream
+              }
+            }
+          },
+          responses: { 200: {} },
+          serializer: new Serializer()
+        });
+      assert.strictEqual(httpRequest.body, "body value");
+    });
+
+    it("should serialize an XML String request body", () => {
+      const httpRequest = new WebResource();
+      serializeRequestBody(
+        httpRequest,
+        {
+          arguments: {
+            bodyArg: "body value"
+          }
+        },
+        {
+          httpMethod: "POST",
+          requestBody: {
+            parameterPath: "bodyArg",
+            mapper: {
+              required: true,
+              serializedName: "bodyArg",
+              type: {
+                name: MapperType.String
+              }
+            }
+          },
+          responses: { 200: {} },
+          serializer: new Serializer(),
+          isXML: true
+        });
+      assert.strictEqual(
+        httpRequest.body,
+        `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><bodyArg>body value</bodyArg>`);
+    });
+
+    it("should serialize an XML ByteArray request body", () => {
+      const httpRequest = new WebResource();
+      serializeRequestBody(
+        httpRequest,
+        {
+          arguments: {
+            bodyArg: stringToByteArray("Javascript")
+          }
+        },
+        {
+          httpMethod: "POST",
+          requestBody: {
+            parameterPath: "bodyArg",
+            mapper: {
+              required: true,
+              serializedName: "bodyArg",
+              type: {
+                name: MapperType.ByteArray
+              }
+            }
+          },
+          responses: { 200: {} },
+          serializer: new Serializer(),
+          isXML: true
+        });
+        assert.strictEqual(
+          httpRequest.body,
+          `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><bodyArg>SmF2YXNjcmlwdA==</bodyArg>`);
+    });
+
+    it("should serialize an XML Stream request body", () => {
+      const httpRequest = new WebResource();
+      serializeRequestBody(
+        httpRequest,
+        {
+          arguments: {
+            bodyArg: "body value"
+          }
+        },
+        {
+          httpMethod: "POST",
+          requestBody: {
+            parameterPath: "bodyArg",
+            mapper: {
+              required: true,
+              serializedName: "bodyArg",
+              type: {
+                name: MapperType.Stream
+              }
+            }
+          },
+          responses: { 200: {} },
+          serializer: new Serializer(),
+          isXML: true
+        });
+        assert.strictEqual(httpRequest.body, "body value");
+    });
+  });
+});
+
+function stringToByteArray(str: string): Uint8Array {
+  if (typeof Buffer === "function") {
+    return Buffer.from(str, "utf-8");
+  } else {
+    return new TextEncoder().encode(str);
+  }
+}