bv-ui-core 0.1.1

package/lib/waitForBody/README.md

@@ -0,0 +1,21 @@
+# waitForBody
+
+This file exposes a utility function that will invoke its callback once the
+`document.body` tag has been created by the runtime environment. It is
+intended to be used in the case of scripts that execute synchronously in the
+head of a document, prior to document.body being available, yet having a
+dependency on document.body for some reason (e.g. appending DOM nodes). This
+function uses a MutationObserver in order to function, so requires that level
+of support in order to function.
+
+## Usage
+```javascript
+var waitForBody = require('bv-ui-core/lib/waitForBody');
+
+var div = document.createElement('div');
+div.id = 'modalContainer';
+
+waitForBody(function () {
+  document.body.appendChild(div);
+});
+```

package/lib/waitForBody/index.js

@@ -0,0 +1,36 @@
+/**
+ * This file exposes a single function that can be used to monitor for
+ * document.body to come into existence. It does not mean that its DOM
+ * is loaded, it only means that the document.body node has been created.
+ */
+
+function checkForBody (callback, documentMutationObserver) {
+  if (document.body) {
+    // Stop observing the root documentElement
+    documentMutationObserver.disconnect()
+
+    // Invoke the callback
+    callback()
+  }
+}
+
+module.exports = function waitForBody (callback) {
+  // If document.body is ready, bail early
+  if (document.body) {
+    callback()
+    return
+  }
+
+  // In case the document.body element doesn't exist yet, set up a mutation
+  // observer on document.documentElement, and each time it's triggered,
+  // check for document.body... When it exists, stop observing this.
+  var documentMutationObserver = new MutationObserver(function () {
+    checkForBody(callback, documentMutationObserver)
+  })
+
+  // Attach to document.documentElement for monitoring
+  documentMutationObserver.observe(document.documentElement, { childList: true, subtree: true })
+
+  // Invoke once, in case document.body already exists
+  checkForBody(callback, documentMutationObserver)
+}

package/mkdocs.yaml

@@ -0,0 +1,5 @@
+site_name: bv-ui-core
+docs_dir: lib
+plugins:
+  - techdocs-core
+repo_url: https://github.com/bazaarvoice/bv-ui-core/

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "bv-ui-core",
+  "version": "0.1.1",
+  "license": "Apache 2.0",
+  "description": "Bazaarvoice UI-related JavaScript",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/bazaarvoice/bv-ui-core"
+  },
+  "engines": {
+    "node": ">=10.*"
+  },
+  "scripts": {
+    "lint": "eslint karma.conf.js lib test",
+    "test": "./node_modules/karma/bin/karma start --single-run --browsers ChromeHeadless",
+    "dev": "./node_modules/karma/bin/karma start --browsers Chrome"
+  },
+  "devDependencies": {
+    "babel-core": "^6.26.3",
+    "babel-loader": "^6.4.1",
+    "babel-plugin-lodash": "^3.3.4",
+    "babel-polyfill": "^6.26.0",
+    "babel-preset-es2015": "^6.24.1",
+    "chai": "^3.5.0",
+    "eslint": "2.2.0",
+    "ghooks": "1.0.3",
+    "istanbul-instrumenter-loader": "0.2.0",
+    "json-loader": "^0.5.7",
+    "karma": "^3.0.0",
+    "karma-chai": "^0.1.0",
+    "karma-chrome-launcher": "^2.0.0",
+    "karma-coverage": "^1.1.2",
+    "karma-firefox-launcher": "^1.1.0",
+    "karma-htmlfile-reporter": "^0.3.6",
+    "karma-mocha": "^1.3.0",
+    "karma-sinon": "^1.0.5",
+    "karma-sinon-chai": "^1.3.4",
+    "karma-webpack": "^1.7.0",
+    "lodash": "^4.17.10",
+    "mocha": "^5.2.0",
+    "node-libs-browser": "1.0.0",
+    "sinon": "^4.5.0",
+    "sinon-chai": "^2.14.0",
+    "webpack": "^1.15.0"
+  },
+  "config": {
+    "ghooks": {
+      "pre-commit": "npm run lint",
+      "pre-push": "npm run lint && npm test"
+    }
+  },
+  "dependencies": {
+    "whatwg-fetch": "^2.0.3"
+  }
+}

package/test/.eslintrc

@@ -0,0 +1,5 @@
+{
+  "env": {
+    "mocha": true
+  }
+}

package/test/fixtures/lib.loader.document-is-wrong-in-ie8.js

@@ -0,0 +1,5 @@
+/* global libLoaderTestCallback: false, document: false */
+
+setTimeout(function () {
+  libLoaderTestCallback(document);
+}, 10);

package/test/fixtures/lib.loader.loadscript-attribute.js

@@ -0,0 +1,3 @@
+/* global libLoaderAttributeTestCallback: false */
+
+libLoaderAttributeTestCallback();

package/test/fixtures/lib.loader.loadscript.js

@@ -0,0 +1,3 @@
+/* global libLoaderTestCallback: false */
+
+libLoaderTestCallback();

package/test/fixtures/lib.loader.loadstylesheet.css

@@ -0,0 +1,3 @@
+#canary {
+    width: 100px;
+}

package/test/unit/api/.eslintrc

@@ -0,0 +1,6 @@
+{
+  "env": {
+    "es6": true,
+    "browser": true
+  }
+}

package/test/unit/api/index.spec.js

@@ -0,0 +1,37 @@
+var api = require('../../../lib/api')
+
+describe('api', function () {
+  let oldFetch
+
+  before(() => {
+    oldFetch = window.fetch
+    window.fetch = () => Promise.resolve({
+      json: () => ({
+        Results: [],
+      }),
+    })
+  })
+
+  after(() => {
+    window.fetch = oldFetch
+  })
+
+  describe('get', () => {
+    it('should throw if unsupported type', () => {
+      expect(function () {
+        api.get('foo')
+      }).to.throw('Unsupported method: foo')
+    })
+    it('should works for statistics', () => {
+      api.get('statistics', {
+        productIds: ['product1', 'product2', 'product3'],
+        environment: 'qa',
+        key: 'clients_api_key',
+        type: 'Reviews',
+        filters: {
+          ContentLocale: 'en_US'
+        }
+      })
+    })
+  })
+})

package/test/unit/api/response.json

@@ -0,0 +1,67 @@
+{
+  "Includes":{
+
+  },
+  "HasErrors":false,
+  "Offset":0,
+  "TotalResults":4,
+  "Locale":"en_US",
+  "Errors":[
+
+  ],
+  "Results":[
+    {
+      "ProductStatistics":{
+        "NativeReviewStatistics":{
+
+        },
+        "ReviewStatistics":{
+          "TotalReviewCount":0,
+          "AverageOverallRating":null,
+          "OverallRatingRange":5
+        },
+        "ProductId":"Product4"
+      }
+    },
+    {
+      "ProductStatistics":{
+        "NativeReviewStatistics":{
+
+        },
+        "ReviewStatistics":{
+          "TotalReviewCount":2,
+          "AverageOverallRating":2.0,
+          "OverallRatingRange":5
+        },
+        "ProductId":"Product3"
+      }
+    },
+    {
+      "ProductStatistics":{
+        "NativeReviewStatistics":{
+
+        },
+        "ReviewStatistics":{
+          "TotalReviewCount":1,
+          "AverageOverallRating":5.0,
+          "OverallRatingRange":5
+        },
+        "ProductId":"Product2"
+      }
+    },
+    {
+      "ProductStatistics":{
+        "NativeReviewStatistics":{
+
+        },
+        "ReviewStatistics":{
+          "TotalReviewCount":48,
+          "AverageOverallRating":4.0208,
+          "OverallRatingRange":5
+        },
+        "ProductId":"Product1"
+      }
+    }
+  ],
+  "Limit":4
+}

package/test/unit/api/statistics.spec.js

@@ -0,0 +1,218 @@
+/**
+ * @fileOverview Tests for API.
+ *
+ * These tests will fail unless run in a browser due to whatwg-fetch polyfill.
+ *
+ * @module test/apicacherequest
+ */
+let _ = require('lodash')
+
+const API_RESULT_SUCCESS = require('json!./response.json')
+
+const mockFetchSuccess = () => {
+  return {
+    then: () => {
+      return {
+        then: (callback) => {
+          let apiResult = API_RESULT_SUCCESS
+          callback(apiResult)
+        }
+      }
+    }
+  }
+}
+
+const mockFetchFail = () => {
+  return {
+    then: () => {
+      return {
+        then: (callback) => {
+          let apiResult = {
+            HasErrors: true,
+            Errors: [{
+              Message: 'An error occurred.'
+            }]
+          }
+          callback(apiResult)
+        }
+      }
+    }
+  }
+}
+
+const mockFetchFailMissingError = () => {
+  return {
+    then: () => {
+      return {
+        then: (callback) => {
+          let apiResult = {
+            HasErrors: true
+          }
+          callback(apiResult)
+        }
+      }
+    }
+  }
+}
+
+let getStatistics = require('../../../lib/api/statistics')
+
+describe('getStatistics', () => {
+  const oldFetch = window.fetch
+
+  after(() => {
+    window.fetch = oldFetch
+  })
+
+  beforeEach(() => {
+    window.fetch = mockFetchSuccess
+  })
+
+  describe('parameter validation', () => {
+    it('should throw if not provided productIds', () => {
+      expect(() => getStatistics({
+        environment: 'qa',
+        key: 'clients_api_key',
+        type: 'Reviews',
+        filters: {
+          ContentLocale: 'en_US'
+        }
+      })).to.throw('productIds must be an array')
+    })
+
+    it('should throw if provided non-array productIds', () => {
+      let invalids = ['product1', { id: 'product1' }]
+      for (let productId in invalids) {
+        expect(() => getStatistics({
+          productIds: productId,
+          environment: 'qa',
+          key: 'clients_api_key',
+          type: 'Reviews',
+          filters: {
+            ContentLocale: 'en_US'
+          }
+        })).to.throw('productIds must be an array')
+      }
+    })
+
+    it('should throw if not provided environment', () => {
+      expect(() => getStatistics({
+        productIds: ['product1', 'product2', 'product3'],
+        key: 'clients_api_key',
+        type: 'Reviews',
+        filters: {
+          ContentLocale: 'en_US'
+        }
+      })).to.throw('environment must be "qa", "staging", or "production"')
+    })
+
+    it('should throw if provided invalid environment', () => {
+      let invalids = ['dev', 'stg', 'prod']
+
+      for (let environment in invalids) {
+        expect(() => getStatistics({
+          productIds: ['product1', 'product2', 'product3'],
+          environment: environment,
+          key: 'clients_api_key',
+          type: 'Reviews',
+          filters: {
+            ContentLocale: 'en_US'
+          }
+        })).to.throw('environment must be "qa", "staging", or "production"')
+      }
+    })
+
+    it('should throw if not provided key', () => {
+      expect(() => getStatistics({
+        productIds: ['product1', 'product2', 'product3'],
+        environment: 'qa',
+        type: 'Reviews',
+        filters: {
+          ContentLocale: 'en_US'
+        }
+      })).to.throw('key must be provided')
+    })
+
+    it('should throw if not provided type', () => {
+      expect(() => getStatistics({
+        productIds: ['product1', 'product2', 'product3'],
+        environment: 'qa',
+        key: 'clients_api_key',
+        filters: {
+          ContentLocale: 'en_US'
+        }
+      })).to.throw('type must be "Reviews" or "NativeReviews"')
+    })
+
+    it('should throw if provided invalid type', () => {
+      expect(() => getStatistics({
+        productIds: ['product1', 'product2', 'product3'],
+        environment: 'qa',
+        key: 'clients_api_key',
+        filters: {
+          ContentLocale: 'en_US'
+        },
+        type: 'reviews'
+      })).to.throw('type must be "Reviews" or "NativeReviews"')
+    })
+  })
+
+  it('should work in general', () => {
+    return getStatistics({
+      productIds: ['product1', 'product2', 'product3'],
+      environment: 'qa',
+      key: 'clients_api_key',
+      type: 'Reviews',
+      filters: {
+        ContentLocale: 'en_US'
+      }
+    })
+  })
+
+  it('should work for requests over 100', () => {
+    const products = _.range(1, 300).map(id => `product${id}`)
+
+    return getStatistics({
+      productIds: products,
+      environment: 'qa',
+      key: 'clients_api_key',
+      type: 'Reviews',
+      filters: {
+        ContentLocale: 'en_US'
+      }
+    })
+  })
+
+  it('should return an error', (done) => {
+    window.fetch = mockFetchFail
+    getStatistics({
+      productIds: ['product1', 'product2', 'product3'],
+      environment: 'qa',
+      key: 'clients_api_key',
+      type: 'Reviews',
+      filters: {
+        ContentLocale: 'en_US'
+      }
+    }).then(() => {}, error => {
+      expect(error.Message).to.equal('An error occurred.')
+      done()
+    })
+  })
+
+  it('should return ERROR_UNKNOWN error if error is missing from response', (done) => {
+    window.fetch = mockFetchFailMissingError
+    getStatistics({
+      productIds: ['product1', 'product2', 'product3'],
+      environment: 'qa',
+      key: 'clients_api_key',
+      type: 'Reviews',
+      filters: {
+        ContentLocale: 'en_US'
+      }
+    }).then(() => {}, error => {
+      expect(error.Message).to.equal('An unknown error occurred.')
+      expect(error.Code).to.equal('ERROR_UNKNOWN')
+      done()
+    })
+  })
+})