Let superagent handle request body

src/adapters/superagent.js

@@ -1,29 +1,27 @@
 import superagent from 'superagent';
 import * as httpMethods from '../constants/http-methods';
 
-export const createRequest = (url, method) => {
+const createRequest = (url, method, body) => {
     switch (method) {
+        case httpMethods.HEAD:
+            return superagent.head(url, body);
         case httpMethods.GET:
-            return superagent.get(url);
+            return superagent.get(url, body);
         case httpMethods.POST:
-            return superagent.post(url);
+            return superagent.post(url, body);
         case httpMethods.PUT:
-            return superagent.put(url);
+            return superagent.put(url, body);
         case httpMethods.PATCH:
-            return superagent.patch(url);
+            return superagent.patch(url, body);
         case httpMethods.DELETE:
-            return superagent.del(url);
+            return superagent.del(url, body);
         default:
             throw new Error(`Unsupported HTTP method: ${method}`);
     }
 };
 
 const superagentNetworkAdapter = (url, method, { body, headers, credentials } = {}) => {
-    const request = createRequest(url, method);
-
-    if (body) {
-        request.send(body);
-    }
+    const request = createRequest(url, method, body);
 
     if (headers) {
         request.set(headers);

test/adapters/superagent.test.js

@@ -1,43 +1,47 @@
 import { assert } from 'chai';
 import * as HTTPMethods from '../../src/constants/http-methods';
-import superagentAdapter, { createRequest } from '../../src/adapters/superagent';
+import superagentAdapter from '../../src/adapters/superagent';
 
 describe('superagent adapter', () => {
-    it('must return an object with both execute and abort functions', () => {
+    it('must return an object with both execute and abort functions, as well as the request instance', () => {
         const adapter = superagentAdapter('http://localhost', HTTPMethods.GET);
         assert.isFunction(adapter.execute);
         assert.isFunction(adapter.abort);
+        assert(adapter.instance);
     });
 
-    describe('createRequest', () => {
-        it('must return a DELETE request when supplied a DELETE method', () => {
-            const request = createRequest('http://localhost', HTTPMethods.DELETE);
-            assert.equal(request.method, HTTPMethods.DELETE);
-        });
-
-        it('must return a GET request when supplied a GET method', () => {
-            const request = createRequest('http://localhost', HTTPMethods.GET);
-            assert.equal(request.method, HTTPMethods.GET);
-        });
-
-        it('must return a PATCH request when supplied a PATCH method', () => {
-            const request = createRequest('http://localhost', HTTPMethods.PATCH);
-            assert.equal(request.method, HTTPMethods.PATCH);
-        });
-
-        it('must return a POST request when supplied a POST method', () => {
-            const request = createRequest('http://localhost', HTTPMethods.POST);
-            assert.equal(request.method, HTTPMethods.POST);
-        });
-
-        it('must return a PUT request when supplied a PUT method', () => {
-            const request = createRequest('http://localhost', HTTPMethods.PUT);
-            assert.equal(request.method, HTTPMethods.PUT);
-        });
-
-        it('must throw an error when supplied an invalid HTTP method', () => {
-            const request = () => createRequest('http://localhost', 'abc');
-            assert.throws(request, /Unsupported HTTP method/);
-        });
+    it('must return a HEAD request when supplied a HEAD method', () => {
+        const { instance } = superagentAdapter('http://localhost', HTTPMethods.HEAD);
+        assert.equal(instance.method, HTTPMethods.HEAD);
+    });
+
+    it('must return a DELETE request when supplied a DELETE method', () => {
+        const { instance } = superagentAdapter('http://localhost', HTTPMethods.DELETE);
+        assert.equal(instance.method, HTTPMethods.DELETE);
+    });
+
+    it('must return a GET request when supplied a GET method', () => {
+        const { instance } = superagentAdapter('http://localhost', HTTPMethods.GET);
+        assert.equal(instance.method, HTTPMethods.GET);
+    });
+
+    it('must return a PATCH request when supplied a PATCH method', () => {
+        const { instance } = superagentAdapter('http://localhost', HTTPMethods.PATCH);
+        assert.equal(instance.method, HTTPMethods.PATCH);
+    });
+
+    it('must return a POST request when supplied a POST method', () => {
+        const { instance } = superagentAdapter('http://localhost', HTTPMethods.POST);
+        assert.equal(instance.method, HTTPMethods.POST);
+    });
+
+    it('must return a PUT request when supplied a PUT method', () => {
+        const { instance } = superagentAdapter('http://localhost', HTTPMethods.PUT);
+        assert.equal(instance.method, HTTPMethods.PUT);
+    });
+
+    it('must throw an error when supplied an invalid HTTP method', () => {
+        const invalid = () => superagentAdapter('http://localhost', 'abc');
+        assert.throws(invalid, /Unsupported HTTP method/);
     });
 });