bv-ui-core 0.1.1

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

@@ -0,0 +1,313 @@
+/**
+ * @fileOverview
+ * Unit tests for the application module.
+ */
+
+// Imports.
+var Application = require('../../../lib/application');
+var global = require('../../../lib/global');
+
+describe('lib/application', function () {
+
+  var config;
+  var application;
+  var sandbox;
+
+  beforeEach(function () {
+    config = { foo: 'bar' };
+    application = new Application(config);
+    sandbox = sinon.sandbox.create();
+  });
+
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  describe('ready method', function () {
+
+    it('queues calls to ready', function () {
+      var fn = sandbox.spy();
+
+      expect(application._readyQueue.length).to.equal(0);
+      application.ready(fn);
+      expect(application._readyQueue.length).to.equal(1);
+    });
+
+    it('original ready method always gets replaced', function () {
+      application.originalReady = application.ready;
+      application.processReady();
+
+      expect(application.originalRender).to.not.equal(application.ready);
+    });
+
+    it('automatically processes callbacks after processReady is called', function () {
+      var fn = sandbox.spy();
+
+      application.ready(fn);
+      sinon.assert.notCalled(fn);
+
+      application.processReady();
+      sinon.assert.calledOnce(fn);
+
+      application.ready(fn);
+      sinon.assert.calledTwice(fn);
+    });
+
+    it('returns a Promise', function () {
+      if (typeof global.Promise === 'function') {
+        var returnVal = application.ready();
+        expect(returnVal).to.not.be.a('number');
+        expect(returnVal.then).to.be.a('function');
+      }
+      else {
+        // Auto-pass in this environment
+        expect(true).to.equal(true);
+      }
+    });
+
+    it('automatically processes Promise chain callbacks after processReady is called', function () {
+      if (typeof global.Promise === 'function') {
+        var fn = sandbox.spy();
+
+        application.ready().then(fn);
+        sinon.assert.notCalled(fn);
+
+        application.processReady();
+
+        /**
+         * Apparently, Promises get processed asynchronously, even when
+         * they're not asynchronous processes, e.g., the following code
+         * fails its assertions:
+         *
+         * var fn = sandbox.spy();
+         * var promise = Promise.resolve();
+         * promise.then(fn);
+         * sinon.assert.calledOnce(fn);
+         *
+         * Because of this, we have to wrap our below assertions in a
+         * double layer of setTimeout(0) statements, to defer to the
+         * next event loop before we check the status of our spies.
+         */
+        setTimeout(function () {
+          sinon.assert.calledOnce(fn);
+
+          application.ready().then(fn);
+
+          setTimeout(function () {
+            sinon.assert.calledTwice(fn);
+          }, 0);
+        }, 0);
+      }
+      else {
+        // Auto-pass in this environment
+        expect(true).to.equal(true);
+      }
+    });
+
+  });
+
+  describe('processReady method', function () {
+
+    it('processes the queue sync', function () {
+      var fn = sandbox.spy();
+
+      application.ready(fn);
+      application.processReady();
+
+      sinon.assert.calledOnce(fn);
+
+      application.ready(fn);
+
+      sinon.assert.calledTwice(fn);
+    });
+
+    it('injects its callbacks with its own instance when invoked with no error', function () {
+      if (typeof global.Promise === 'function') {
+        // Auto-pass in this environment
+        expect(true).to.equal(true);
+      }
+      else {
+        var fn = sandbox.spy();
+
+        application.ready(fn);
+        application.processReady();
+
+        sinon.assert.calledWith(fn, [null, application]);
+      }
+    });
+
+    it('injects its callbacks with an error when invoked with an error', function () {
+      if (typeof global.Promise === 'function') {
+        // Auto-pass in this environment
+        expect(true).to.equal(true);
+      }
+      else {
+        var error = new Error('Test Error');
+        var fn = sandbox.spy();
+
+        application.ready(fn);
+        application.processReady(error);
+
+        sinon.assert.calledWith(fn, [error, application]);
+      }
+    });
+
+    it('resolves its promise with its own instance when invoked with no error', function (done) {
+      if (typeof global.Promise === 'function') {
+        application.ready()
+          .then(function (app) {
+            expect(application).to.equal(app);
+          })
+          .catch(function (err) {
+            expect(false).to.equal(true);
+          })
+          .then(function () {
+            done();
+          });
+
+        application.processReady();
+      }
+      else {
+        // Auto-pass in this environment
+        expect(true).to.equal(true);
+      }
+    });
+
+    it('rejects its promise with an error when invoked with an error', function (done) {
+      if (typeof global.Promise === 'function') {
+        var error = new Error('Test Error');
+
+        application.ready()
+          .then(function (app) {
+            expect(false).to.equal(true);
+          })
+          .catch(function (err) {
+            expect(error).to.equal(err);
+          })
+          .then(function () {
+            done();
+          });
+
+        application.processReady(error);
+      }
+      else {
+        // Auto-pass in this environment
+        expect(true).to.equal(true);
+      }
+    });
+
+  });
+
+  describe('render method', function () {
+
+    it('queues calls to render', function () {
+      expect(application._renderQueue.length).to.equal(0);
+      application.render(config);
+      expect(application._renderQueue.length).to.equal(1);
+    });
+
+    it('original render method always gets replaced', function () {
+      var fn = sandbox.spy();
+
+      application.originalRender = application.render;
+      application.processQueue(fn);
+
+      // Even calling application's original definition of render
+      // should call the new function.
+      application.originalRender();
+      application.originalRender();
+      application.originalRender();
+
+      sinon.assert.calledThrice(fn);
+    });
+
+  });
+
+  describe('processQueue method', function () {
+
+    it('processes the queue async', function (done) {
+      var fn = sandbox.spy();
+
+      application.render(config);
+      application.render(config);
+      application.processQueue(fn);
+
+      sinon.assert.notCalled(fn);
+
+      setTimeout(function () {
+        sinon.assert.calledTwice(fn);
+        done();
+      }, 100);
+    });
+
+    it('redefines the render method', function (done) {
+      var fn = function () {};
+
+      application.processQueue(fn);
+
+      setTimeout(function () {
+        expect(application.render).to.equal(fn);
+        done();
+      }, 100);
+    });
+
+    it('throws if handler is not provided', function () {
+      expect(function () {
+        application.processQueue();
+      }).to.throw(Error);
+    });
+
+  });
+
+  describe('configure method', function () {
+
+    it('queues calls to configure', function () {
+      expect(application._configQueue.length).to.equal(0);
+      application.configure(config);
+      expect(application._configQueue.length).to.equal(1);
+    });
+
+    it('original configure method always gets replaced', function () {
+      var fn = sandbox.spy();
+
+      application.originalConfigure = application.configure;
+      application.processConfig(fn);
+
+      // Even calling application's original definition of configure
+      // should call the new function.
+      application.originalConfigure();
+      application.originalConfigure();
+      application.originalConfigure();
+
+      sinon.assert.calledThrice(fn);
+    });
+
+  });
+
+  describe('processConfig method', function () {
+
+    it('processes the queue', function () {
+      var fn = sandbox.spy();
+
+      application.configure(config);
+      application.configure(config);
+      application.processConfig(fn);
+
+      sinon.assert.calledTwice(fn);
+    });
+
+    it('redefines the configure method', function () {
+      var fn = function () {};
+
+      application.processConfig(fn);
+      expect(application.configure).to.equal(fn);
+    });
+
+    it('throws if handler is not provided', function () {
+      expect(function () {
+        application.processConfig();
+      }).to.throw(Error);
+    });
+
+  });
+});

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

@@ -0,0 +1,15 @@
+/**
+ * @fileOverview
+ * Unit tests for the body module.
+ */
+
+// Imports.
+var body = require('../../../lib/body');
+
+describe('lib/body', function () {
+
+  it('Should return the body', function () {
+    expect(body().tagName).to.equal('BODY');
+  });
+
+});

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

@@ -0,0 +1,246 @@
+//Imports
+
+var BvFetch = require('../../../lib/bvFetch');
+
+describe('BvFetch', function () {
+  let bvFetchInstance;
+  let cacheStub;
+  let cacheStorage;
+  
+  beforeEach(function () {
+    bvFetchInstance = new BvFetch({
+      shouldCache: null,
+      cacheName: 'testCache'
+    });
+
+    // Define cacheStorage as a Map
+    cacheStorage = new Map();
+
+    // Stubbing caches.open
+    cacheStub = sinon.stub(caches, 'open').resolves({
+      match: key => {
+        const cachedResponse = cacheStorage.get(key);
+        return Promise.resolve(cachedResponse);
+      },
+      put: (key, response) => {
+        cacheStorage.set(key, response);
+        return Promise.resolve();
+      }
+    });
+
+  });
+  
+  afterEach(function () {
+    bvFetchInstance = null;
+    // Restore the original method after each test
+    caches.open.restore();
+  });
+  
+  it('should generate correct cache key', function () {
+    const url = 'https://jsonplaceholder.typicode.com/todos';
+    const options = {
+      method: 'GET',
+      headers: {
+        'X-Header-1': 'Value 1',
+      }
+    };
+    const expectedKey = new Request(url, options)
+    const generatedKey = bvFetchInstance.generateCacheKey(url, options);
+    expect(generatedKey.url).to.equal(expectedKey.url);
+    expect(generatedKey.headers).to.deep.equal(expectedKey.headers);
+  });
+
+  
+  it('should fetch from cache when the response is cached', function (done) {
+    const url = 'https://jsonplaceholder.typicode.com/todos';
+    const options = {
+      method: 'GET',
+      headers: {
+        'X-Header-1': 'Value 1',
+      }
+    };
+  
+    // Mocking cache response
+    const mockResponse = new Response('Mock Data', {
+      status: 200,
+      statusText: 'OK',
+      headers: {
+        'Cache-Control': 'max-age=3600',
+        'X-Bazaarvoice-Cached-Time': Date.now()
+      }
+    });
+
+    const cacheKey = bvFetchInstance.generateCacheKey(url, options);
+  
+    // Overriding the stub for this specific test case
+    caches.open.resolves({
+      match: (key) => {
+        expect(key.url).to.equal(cacheKey.url); 
+        expect(key.headers).to.deep.equal(cacheKey.headers);
+        return Promise.resolve(mockResponse)
+      },
+      put: (key, response) => {
+        cacheStorage.set(key, response);
+        return Promise.resolve();
+      }
+    });
+  
+    // Simulate that the response is cached
+    bvFetchInstance.cachedRequests.add(cacheKey);
+    
+    // Call the function under test
+    bvFetchInstance.bvFetchFunc(url, options)
+    .then(response => {
+      // Check if response is fetched from cache
+      expect(response).to.not.be.null;
+
+       // Check if response is cached
+      const cachedResponse = cacheStorage.get(cacheKey);
+      expect(cachedResponse).to.not.be.null;
+
+      // Check if caches.open was called
+      expect(cacheStub.called).to.be.true;
+
+      done();
+    })
+    .catch(error => {
+      done(error); // Call done with error if any
+    })
+  });
+
+  
+  it('should fetch from network when response is not cached', function (done) {
+    const url = 'https://jsonplaceholder.typicode.com/todos';
+    const options = {};
+
+    const matchSpy = sinon.spy((key) => {
+      expect(key).to.equal(cacheKey); 
+      Promise.resolve(null)
+    });
+    caches.open.resolves({
+      match: matchSpy,
+      put: (key, response) => {
+        cacheStorage.set(key, response);
+        return Promise.resolve();
+      }
+    });
+   
+
+    bvFetchInstance.bvFetchFunc(url, options)
+      .then(response => {
+        // Check if response is fetched from network
+        expect(response).to.not.be.null;
+        console.log(response.body)
+        
+        // Check if caches.match was called
+        expect(matchSpy.called).to.be.false;
+
+        done();
+      })
+      .catch(done);
+  });
+
+  it('should not cache response when there is an error', function (done) {
+    const url = 'https://jsonplaceholder.typicode.com/todos';
+    const options = {};
+
+    // Define shouldCache directly in bvFetchInstance
+    bvFetchInstance.shouldCache = (res) => {
+      return false
+    };
+ 
+    bvFetchInstance.bvFetchFunc(url, options)
+    .then(response => {
+      // Check if response is fetched from network
+      setTimeout(() => { 
+        expect(response).to.not.be.null;
+        console.log(response.body)
+
+      // Check if caches.match was called
+        expect(cacheStub.calledOnce).to.be.false;
+
+      // Check if response is not cached
+        const cachedResponse = cacheStorage.get(url);
+        expect(cachedResponse).to.be.undefined; 
+      }, 500)
+      done();
+    })
+    .catch(done);
+  });
+
+  it('should handle a 204 response without a JSON parse error', function (done) {
+    const cacheKey = bvFetchInstance.generateCacheKey('https://example.com/empty', {});
+    const shouldCache = sinon.spy();
+    const response = new Response(null, {
+      status: 204,
+      headers: {
+        'Cache-Control': 'max-age=3600'
+      }
+    });
+
+    bvFetchInstance.shouldCache = shouldCache;
+    expect(() => bvFetchInstance.cacheData(response, cacheKey)).to.not.throw();
+
+    setTimeout(() => {
+      expect(shouldCache.called).to.be.false;
+      expect(cacheStorage.get(cacheKey)).to.be.undefined;
+      done();
+    }, 0);
+  });
+
+  it('should delete cache when size is greater than 10 MB', function (done) {
+    // Mock cache entries exceeding 10 MB
+    const mockCacheEntries = [
+      { key: 'key1', size: 6000000 }, // 6 MB
+      { key: 'key2', size: 6000000 }  // 6 MB
+      // Add more entries as needed to exceed 10 MB
+    ];
+  
+    // Stub cache operations
+    const deleteSpy = sinon.spy(
+      (key) => {
+        const index = mockCacheEntries.findIndex(entry => entry.key === key);
+        if (index !== -1) {
+          mockCacheEntries.splice(index, 1); // Delete entry from mock cache entries
+        }
+        return Promise.resolve(true);
+      }
+    )
+    caches.open.resolves({
+      keys: () => Promise.resolve(mockCacheEntries.map(entry => entry.key)),
+      match: (key) => {
+        const entry = mockCacheEntries.find(entry => entry.key === key);
+        if (entry) {
+          return Promise.resolve({
+            headers: new Headers({
+              'X-Bazaarvoice-Response-Size': entry.size.toString(),
+              'X-Bazaarvoice-Cached-Time': Date.now(),
+              'Cache-Control': 'max-age=3600'
+            })
+          });
+        } 
+        else {
+          return Promise.resolve(null);
+        }
+      },
+      delete: deleteSpy
+    });
+  
+    // Create a new instance of BvFetch
+    const bvFetchInstance = new BvFetch({ shouldCache: true });
+  
+    // Call manageCache function
+    bvFetchInstance.manageCache()
+    setTimeout(() => {
+      // Ensure cache deletion occurred until the total size is under 10 MB
+      const totalSizeAfterDeletion = mockCacheEntries.reduce((acc, entry) => acc + entry.size, 0);
+      expect(totalSizeAfterDeletion).to.be.at.most(10 * 1024 * 1024); // Total size should be under 10 MB
+      // Ensure cache.delete was called for each deleted entry
+      expect(deleteSpy.called).to.be.true;
+      expect(deleteSpy.callCount).to.equal(mockCacheEntries.length);
+      done();
+    }, 500);
+      
+  });  
+  
+});

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

@@ -0,0 +1,16 @@
+/**
+ * @fileOverview
+ * Unit tests for the checkHighContrast utility.
+ */
+
+// Imports.
+var global = require('../../../lib/global');
+var checkHighContrast = require('../../../lib/checkHighContrast');
+
+describe('lib/checkHighContrast', function () {
+
+  it('normally returns false', function () {
+    expect(checkHighContrast(global.document.body)).to.equal(false);
+  });
+
+});