Merge release-v0.1.11 into master

Author: johnboxall

.circleci/config.yml

@@ -34,7 +34,8 @@ jobs:
       - deploy:
           command: |
             if [ "${CIRCLE_BRANCH}" == "master" ]; then
-              # NPM login based on env variables
-              echo -e "$NPM_USERNAME\n$NPM_PASSWORD\n$NPM_EMAIL" | npm login
+              # Add NPM token to allow publishing from Circle
+              echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" > ~/.npmrc
+
               npm publish
             fi

CHANGELOG.md

@@ -1,3 +1,7 @@
+## v0.1.11 (August 22, 2019)
+- Use NPM authentication token for circleci publishing.
+- Fix `callApi` JSON error parsing never settling its Promise.
+
 ## v0.1.10 (July 2, 2019)
 - Run security audit and upgrade offending npm dependencies. [#23](https://github.com/mobify/commercecloud-ocapi-client/pull/23)
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "commercecloud-ocapi-client",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "An ES6 JavaScript Client for Salesforce Open Commerce API",
   "repository": "https://github.com/mobify/commercecloud-ocapi-client",
   "license": "SEE LICENSE IN LICENSE",

src/ApiClient.js

@@ -494,15 +494,30 @@ export default class ApiClient {
             }
         }
 
+        return this.sendApiRequest(request, returnType)
+    }
+
+    /**
+     * Sends the generated superagent request and deserializes the response.
+     * @param {module:superagent.Request} request The superagent request to send.
+     * @param {String} returnType The type to deserialize the response into.
+     * @returns {Promise} A {@link https://www.promisejs.org/|Promise} object.
+     */
+    sendApiRequest(request, returnType) {
         return new Promise((resolve, reject) => {
             request.end((error, response) => {
                 if (error) {
 
                     // Looks like there was an fault returned from the API
                     const hasErrorMessage = error.response && error.response.text
                     if (hasErrorMessage) {
-                        const fault = Fault.constructFromObject(JSON.parse(error.response.text).fault)
-                        reject(fault)
+                        try {
+                            const fault = Fault.constructFromObject(JSON.parse(error.response.text).fault)
+                            reject(fault)
+                        } catch (err) {
+                            // Reject immediately on parsing error.
+                            reject(err)
+                        }
                     }
 
                     // Most likely a network error has happened here so include entire error.

test/api/ApiClient.spec.js

@@ -0,0 +1,113 @@
+/* * *  *  * *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  * */
+/* Copyright (c) 2019 Mobify Research & Development Inc. All rights reserved. */
+/* * *  *  * *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  * */
+
+import expect from 'expect.js'
+import sinon from 'sinon'
+
+import ShopApi from '../../src/index'
+import {clientId, baseUrl} from '../config.json'
+
+let client
+
+beforeEach(() => {
+    client = new ShopApi.ApiClient({
+        basePath: `${baseUrl}`,
+        defaultHeaders: {'x-dw-client-id': clientId}
+    })
+})
+
+describe('ApiClient', () => {
+    describe('sendApiRequest', () => {
+        let mockRequest
+
+        beforeEach(() => {
+            mockRequest = {end: sinon.stub()}
+        })
+
+        it('should deserialize a successful response into a string', () => {
+            const mockData = Symbol()
+            const mockResponse = Symbol()
+
+            client.deserialize = sinon.stub().returns(mockData)
+            mockRequest.end.callsArgWith(0, null, mockResponse)
+
+            return client.sendApiRequest(mockRequest, 'String')
+                .then((result) => {
+                    expect(result.data).to.be(mockData)
+                    expect(result.response).to.be(mockResponse)
+                    expect(client.deserialize.calledWith(mockResponse, 'String')).to.be(true)
+                })
+        })
+
+        it('should deserialize the response into a blob', () => {
+            const mockData = Symbol()
+            const mockResponse = Symbol()
+
+            client.deserialize = sinon.stub().returns(mockData)
+            mockRequest.end.callsArgWith(0, null, mockResponse)
+
+            return client.sendApiRequest(mockRequest, 'Blob')
+                .then((result) => {
+                    expect(result.data).to.be(mockData)
+                    expect(result.response).to.be(mockResponse)
+                    expect(client.deserialize.calledWith(mockResponse, 'Blob')).to.be(true)
+                })
+        })
+
+        it('should reject when deserializing the response throws an error', () => {
+            const mockError = Symbol()
+
+            client.deserialize = sinon.stub().throws(mockError)
+            mockRequest.end.callsArg(0)
+
+            return client.sendApiRequest(mockRequest, 'String')
+                .catch((error) => {
+                    expect(error).to.be(mockError)
+                })
+        })
+
+        it('should reject when the request fails with valid JSON', () => {
+            const mockError = {
+                response: {
+                    text: '{ "fault": { "message": "foo", "type": "bar" } }'
+                }
+            }
+
+            mockRequest.end.callsArgWith(0, mockError)
+
+            return client.sendApiRequest(mockRequest, 'String')
+                .catch((error) => {
+                    expect(error).to.be.a(ShopApi.Fault)
+                    expect(error.message).to.equal('foo')
+                    expect(error.type).to.equal('bar')
+                })
+        })
+
+        it('should reject when the request fails with HTML', () => {
+            const mockError = {
+                response: {
+                    text: '<html><head></head><body></body></html>'
+                }
+            }
+
+            mockRequest.end.callsArgWith(0, mockError)
+
+            return client.sendApiRequest(mockRequest, 'String')
+                .catch((error) => {
+                    expect(error).to.be.a(SyntaxError)
+                })
+        })
+
+        it('should reject when the request fails for any reason', () => {
+            const mockError = Symbol()
+
+            mockRequest.end.callsArgWith(0, mockError)
+
+            return client.sendApiRequest(mockRequest, 'String')
+                .catch((error) => {
+                    expect(error).to.be(mockError)
+                })
+        })
+    })
+})