assert on unformatted body including in the res.send case when no formatter found

Author: Julien Gilli

lib/response.js

@@ -346,6 +346,11 @@ function patch(Response) {
             };
         }
 
+        assert.ok(
+            typeof sendArgs.body === 'string' || Buffer.isBuffer(sendArgs.body),
+            'res.sendRaw() accepts only strings or buffers'
+        );
+
         sendArgs.format = false;
         return self.__send(sendArgs);
     };
@@ -417,71 +422,66 @@ function patch(Response) {
             return flush(self);
         }
 
-        // if no formatting, assert that the value to be written is a string
-        // or a buffer, then send it.
-        if (opts.format === false) {
-            assert.ok(
-                typeof body === 'string' || Buffer.isBuffer(body),
-                'res.sendRaw() accepts only strings or buffers'
-            );
-            return flush(self, body);
-        }
-
-        // if no body, then no need to format. if this was an error caught by a
-        // domain, don't send the domain error either.
-        if (body === undefined || (body instanceof Error && body.domain)) {
-            return flush(self);
-        }
+        if (opts.format === true) {
+            // if no body, then no need to format. if this was an error caught
+            // by a domain, don't send the domain error either.
+            if (body === undefined || (body instanceof Error && body.domain)) {
+                return flush(self);
+            }
 
-        // At this point we know we have a body that needs to be formatted, so
-        // lets derive the formatter based on the response object's properties
+            // At this point we know we have a body that needs to be formatted,
+            // so lets derive the formatter based on the response object's
+            // properties
 
-        var formatter;
-        var type = self.contentType || self.getHeader('Content-Type');
+            var formatter;
+            var type = self.contentType || self.getHeader('Content-Type');
 
-        // Set Content-Type to application/json when
-        // res.send is called with an Object instead of calling res.json
-        if (!type && typeof body === 'object' && !Buffer.isBuffer(body)) {
-            type = 'application/json';
-        }
+            // Set Content-Type to application/json when
+            // res.send is called with an Object instead of calling res.json
+            if (!type && typeof body === 'object' && !Buffer.isBuffer(body)) {
+                type = 'application/json';
+            }
 
-        // Derive type if not provided by the user
-        type = type || self.req.accepts(self.acceptable);
-
-        // Check to see if we could find a content type to use for the response.
-        if (!type) {
-            return formatterError(
-                self,
-                new errors.NotAcceptableError({
-                    message:
-                        'could not find suitable content-type to use ' +
-                        'for the response'
-                })
-            );
-        }
+            // Derive type if not provided by the user
+            type = type || self.req.accepts(self.acceptable);
+
+            // Check to see if we could find a content type to use for the
+            // response.
+            if (!type) {
+                return formatterError(
+                    self,
+                    new errors.NotAcceptableError({
+                        message:
+                            'could not find suitable content-type to use ' +
+                            'for the response'
+                    })
+                );
+            }
 
-        type = type.split(';')[0];
+            type = type.split(';')[0];
 
-        if (!self.formatters[type] && type.indexOf('/') === -1) {
-            type = mime.lookup(type);
-        }
+            if (!self.formatters[type] && type.indexOf('/') === -1) {
+                type = mime.lookup(type);
+            }
 
-        formatter = self.formatters[type] || self.formatters['*/*'];
+            formatter = self.formatters[type] || self.formatters['*/*'];
 
-        if (self._charSet) {
-            type = type + '; charset=' + self._charSet;
-        }
+            if (self._charSet) {
+                type = type + '; charset=' + self._charSet;
+            }
 
-        // Update Content-Type header to the one originally set or to the type
-        // inferred from the most relevant formatter found.
-        self.setHeader('Content-Type', type);
+            // Update Content-Type header to the one originally set or to the
+            // type inferred from the most relevant formatter found.
+            self.setHeader('Content-Type', type);
 
-        if (!formatter) {
-            return flush(self, body);
+            if (formatter) {
+                // Finally, invoke the formatter and flush the request with it's
+                // results
+                return flush(self, formatter(self.req, self, body));
+            }
         }
 
-        // Finally, invoke the formatter and flush the request with it's results
-        return flush(self, formatter(self.req, self, body));
+        return flush(self, body);
     };
 
     /**
@@ -802,11 +802,19 @@ function patch(Response) {
  * @private
  * @function flush
  * @param {Response} res - response
- * @param {String|Buffer} formattedBody - formatted body
+ * @param {String|Buffer} body - response body
  * @returns {Response} response
  */
-function flush(res, formattedBody) {
-    res._data = formattedBody;
+function flush(res, body) {
+    assert.ok(
+        body === null ||
+            body === undefined ||
+            typeof body === 'string' ||
+            Buffer.isBuffer(body),
+        'body must be a string or a Buffer instance'
+    );
+
+    res._data = body;
 
     // Flush headers
     res.writeHead(res.statusCode);