bv-ui-core 0.1.1

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

@@ -0,0 +1,191 @@
+/**
+ * @fileOverview
+ * Unit tests for the cookie module.
+ */
+
+// Imports.
+var cookie = require('../../../lib/cookie');
+var global = require('../../../lib/global');
+var cookieConsent = require('../../../lib/cookieConsent');
+
+function deleteCookie (name) {
+  global.document.cookie = name + '=;expires=Thu, 01 Jan 1970 00:00:00 GMT';
+}
+
+describe('lib/cookie', function () {
+
+  it('cookie.create', function () {
+    cookieConsent.initConsent({
+      'test create': true
+    });
+    cookie.create('test create', 'cookie monster', 3);
+    expect(global.document.cookie).to.have.string('test%20create=cookie%20monster');
+
+    // Clean up.
+    deleteCookie('test%20create');
+  });
+
+  it('cookie.read', function () {
+    global.document.cookie = 'test%20read=Hello%20World';
+    expect(cookie.read('test read')).to.equal('Hello World');
+
+    // Clean up.
+    deleteCookie('test%20read');
+  });
+
+  it('cookie.remove', function () {
+    global.document.cookie = 'test%20delete=1';
+    cookie.remove('test delete');
+    expect(global.document.cookie).to.not.have.string('test%20delete');
+
+    // Clean up.
+    deleteCookie('test%20delete');
+  });
+
+});
+
+describe('lib/cookie secure flag behavior', function () {
+  var originalProtocol;
+
+  beforeEach(function () {
+    // Store original protocol to restore after each test
+    originalProtocol = global.location && global.location.protocol;
+  });
+
+  afterEach(function () {
+    // Restore original protocol
+    if (global.location) {
+      // Some browsers don't allow direct assignment to location.protocol
+      // so we use Object.defineProperty where possible
+      try {
+        Object.defineProperty(global.location, 'protocol', {
+          value: originalProtocol,
+          writable: true,
+          configurable: true
+        });
+      } 
+      catch (e) {
+        // If we can't restore, tests may need to run in isolation
+      }
+    }
+    // Clean up test cookies
+    deleteCookie('test%20secure');
+    deleteCookie('test%20https');
+    deleteCookie('test%20http');
+  });
+
+  it('should set secure flag when secure=true is explicitly passed', function () {
+    cookieConsent.initConsent({
+      'test secure': true
+    });
+    
+    // Create cookie with explicit secure=true
+    cookie.create('test secure', 'securevalue', 1, null, true);
+    
+    // Note: We can't directly check if secure flag was set via document.cookie
+    // because secure cookies are not visible in document.cookie on http pages.
+    // This test verifies the function doesn't throw when secure=true is passed.
+    expect(true).to.equal(true);
+    
+    // Clean up
+    deleteCookie('test%20secure');
+  });
+
+  it('should automatically set secure flag on HTTPS pages', function () {
+    // Skip if we can't modify location.protocol
+    if (!global.location) {
+      this.skip();
+      return;
+    }
+
+    try {
+      Object.defineProperty(global.location, 'protocol', {
+        value: 'https:',
+        writable: true,
+        configurable: true
+      });
+    } 
+    catch (e) {
+      // Browser doesn't allow protocol modification, skip test
+      this.skip();
+      return;
+    }
+
+    cookieConsent.initConsent({
+      'test https': true
+    });
+
+    // Create cookie without explicit secure flag - should auto-secure on HTTPS
+    cookie.create('test https', 'httpsvalue', 1);
+    
+    // The cookie creation should succeed without errors
+    // On actual HTTPS, the secure flag would be set automatically
+    expect(true).to.equal(true);
+    
+    // Clean up
+    deleteCookie('test%20https');
+  });
+
+  it('should NOT set secure flag on HTTP pages when secure param is not passed', function () {
+    // Skip if we can't modify location.protocol
+    if (!global.location) {
+      this.skip();
+      return;
+    }
+
+    try {
+      Object.defineProperty(global.location, 'protocol', {
+        value: 'http:',
+        writable: true,
+        configurable: true
+      });
+    } 
+    catch (e) {
+      // Browser doesn't allow protocol modification, skip test
+      this.skip();
+      return;
+    }
+
+    cookieConsent.initConsent({
+      'test http': true
+    });
+
+    // Create cookie without secure flag on HTTP
+    cookie.create('test http', 'httpvalue', 1);
+    
+    // Cookie should be readable (not secure, so visible on HTTP)
+    expect(global.document.cookie).to.have.string('test%20http=httpvalue');
+    
+    // Clean up
+    deleteCookie('test%20http');
+  });
+
+  it('should handle missing global.location gracefully', function () {
+    var originalLocation = global.location;
+    
+    // Temporarily remove location
+    try {
+      delete global.location;
+    } 
+    catch (e) {
+      // Can't delete location in some environments, skip
+      this.skip();
+      return;
+    }
+
+    cookieConsent.initConsent({
+      'test nolocation': true
+    });
+
+    // Should not throw when global.location is undefined
+    expect(function () {
+      cookie.create('test nolocation', 'value', 1);
+    }).to.not.throw();
+
+    // Restore location
+    global.location = originalLocation;
+    
+    // Clean up
+    deleteCookie('test%20nolocation');
+  });
+});

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

@@ -0,0 +1,119 @@
+/**
+ * @fileOverview
+ * Unit tests for the cookieConsent module.
+ */
+var cookieConsent = require('../../../lib/cookieConsent');
+
+describe('lib/cookieConsent', function () {
+  it('cookieConsent.initConsent', function () {
+    function test1 () {
+      cookieConsent.initConsent(true);
+    }
+
+    expect(test1).to.throw(TypeError, 'cookieConsent (init): consent should be an object.');
+
+    function test2 () {
+      cookieConsent.initConsent({
+        key1: 1
+      });
+    }
+
+    expect(test2).to.throw(TypeError, 'cookieConsent (init): consent values for key1 should be of type boolean.');
+
+    function test3 () {
+      return cookieConsent.initConsent({
+        key1: false
+      });
+    }
+
+    expect(test3()).to.be.true;
+  });
+
+  it('cookieConsent.getConsent', function () {
+    expect(cookieConsent.getConsent('key1')).to.be.false;
+    cookieConsent.setConsent({ key1: true });
+    expect(cookieConsent.getConsent('key1')).to.be.true;
+  });
+
+  it('cookieConsent.setConsent', function () {
+    function test1 () {
+      cookieConsent.setConsent(null);
+    }
+
+    expect(test1).to.throw(TypeError, 'cookieConsent (setConsent): consent should be an object.');
+
+    function test2 () {
+      cookieConsent.setConsent({ key2: 1 });
+    }
+
+    expect(test2).to.throw(TypeError, 'cookieConsent (setConsent): consent values should be of type boolean. Check value for key2.');
+
+    function test3 () {
+      return cookieConsent.setConsent({ key2: false });
+    }
+
+    expect(test3()).to.be.true;
+  });
+
+  it('cookieConsent.subscribe', function () {
+    function test1 () {
+      cookieConsent.subscribe(1, 2, null);
+    }
+
+    expect(test1).to.throw(TypeError, 'cookieConsent (subscribe): consent key should be of type string.');
+
+    function test2 () {
+      cookieConsent.subscribe('key1', 2, null);
+    }
+
+    expect(test2).to.throw(TypeError, 'cookieConsent (subscribe): event name should be of type string.');
+
+    function test3 () {
+      cookieConsent.subscribe('key1', 'delete', null);
+    }
+
+    var events = ['add', 'enable', 'disable', 'change'];
+    expect(test3).to.throw(TypeError, 'cookieConsent (subscribe): event name should be one of ' + events.join(', ') + '.');
+
+    function test4 () {
+      cookieConsent.subscribe('key1', 'enable', null);
+    }
+
+    expect(test4).to.throw(TypeError, 'cookieConsent (subscribe): callback should be a function.');
+
+    function test5 () {
+      return cookieConsent.subscribe('key1', 'enable', function () {});
+    }
+    expect(test5()).to.be.an('object');
+  });
+  it('cookieConsent.subscribeToConsentStore', function () {
+    // Error checks - Correct errors are thrown
+    function test6 () {
+      cookieConsent.subscribeToConsentStore('Callback')
+    }
+    expect(test6).to.throw(TypeError,'cookieConsent (subscribeToConsentStore): callback should be a function.');
+    // Subscriber creation test - The subscription gets created correctly
+    function test7 () {
+      return cookieConsent.subscribeToConsentStore(function () {});
+    }
+    expect(test7()).to.be.an('object');
+
+    // Event listener test - The subscriber callback fires on store change
+    var fn = sinon.spy()
+    function test8 () {
+      cookieConsent.subscribeToConsentStore(fn)
+      cookieConsent.setConsent({ cookie4: true })
+    }
+    test8 ()
+    sinon.assert.calledOnce(fn)
+    // Unsubscribe test - Should be able to unsubscribe successfully (Should not fire the callback after unsubscription)
+    var fn2 = sinon.spy()
+    function test9 () {
+      var event = cookieConsent.subscribeToConsentStore(fn2)
+      event.unsubscribe()
+      cookieConsent.setConsent({ cookie5: true })
+    } 
+    test9()
+    sinon.assert.notCalled(fn2)
+  });
+});

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

@@ -0,0 +1,75 @@
+/**
+ * @fileOverview
+ * Unit tests for the cssLoadChecker module.
+ */
+
+// Imports.
+var global = require('../../../lib/global');
+var cssLoadChecker = require('../../../lib/cssLoadChecker');
+
+/**
+ * Helper function to add a test style sheet to the page
+ *
+ * @param {string} className - The class name used to check if the css file has loaded yet.
+ * @return {object} The style element that was added to the page.
+ */
+var addCss = function (className) {
+  var cssStyles = global.document.createElement('style');
+  cssStyles.type = 'text/css';
+  cssStyles.innerHTML = '.' + className + ' { display: none; }';
+  global.document.getElementsByTagName('head')[0].appendChild(cssStyles);
+  return cssStyles;
+};
+
+/**
+ * Helper function to remove a test style sheet from the page
+ *
+ * @param {object} cssStyles - the style element that was added to the page.
+ */
+var removeCss = function (cssStyles) {
+  if (cssStyles) {
+    cssStyles.parentNode.removeChild(cssStyles);
+  }
+};
+
+
+describe('lib/cssLoadChecker', function () {
+
+  var sandbox;
+  var cssStyles;
+  var className = 'bv-verify-css-loaded';
+
+  beforeEach(function () {
+    sandbox = sinon.sandbox.create();
+  });
+
+  afterEach(function () {
+    sandbox.restore();
+    removeCss(cssStyles);
+    cssStyles = undefined;
+  });
+
+
+  describe('isCssLoaded', function () {
+
+    it('CSS is not loaded', function () {
+      var test = cssLoadChecker.isCssLoaded(className);
+      expect(test).to.equal(false);
+    });
+
+    it('CSS is loaded', function () {
+      cssStyles = addCss(className);
+      var test = cssLoadChecker.isCssLoaded(className);
+      expect(test).to.equal(true);
+    });
+
+    it('After checking for CSS, test div should be removed', function () {
+      cssLoadChecker.isCssLoaded(className);
+
+      var allTestDivs = global.document.getElementsByClassName(className);
+      expect(allTestDivs.length).to.equal(0);
+    });
+
+  });
+
+});

package/test/unit/date.now/index.spec.js

@@ -0,0 +1,21 @@
+/**
+ * @fileOverview
+ * Unit tests for the date.now module.
+ */
+
+// Imports.
+var dateNow = require('../../../lib/date.now');
+
+describe('lib/date.now', function () {
+
+  it('returns a non-negative number', function () {
+    var result = dateNow.now();
+
+    // Test 1: it returns a number.
+    expect(result).to.be.a('number');
+
+    // Test 2: the number is non-negative.
+    expect(result).to.be.above(0);
+  });
+
+});

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

@@ -0,0 +1,141 @@
+/**
+ * @fileOverview
+ * Unit tests for the Domain Police module.
+ */
+
+// Includes.
+var domainPolice = require('../../../lib/domainPolice');
+
+describe('lib/domainPolice', function () {
+
+  // For each of these domains:
+  // - domain: The domain to test against.
+  // - matchedDomain: The expected return value of 'domain'
+  // - isValid: The expected return value from domainPolice.
+  var domainsToTest = [
+    {
+      domain: 'localhost.bazaarvoice.com',
+      matchedDomain: '.bazaarvoice.com',
+      isValid: true,
+      thirdPartyCookieEnabled: true,
+      commentsEnabled: true
+    },
+    {
+      domain: 'foo.localhost.bazaarvoice.com',
+      matchedDomain: '.bazaarvoice.com',
+      isValid: true,
+      thirdPartyCookieEnabled: true,
+      commentsEnabled: true
+    },
+    {
+      domain: 'no-prefixing-dot.foo.com',
+      matchedDomain: 'no-prefixing-dot.foo.com',
+      isValid: true,
+      thirdPartyCookieEnabled: true
+    },
+    {
+      domain: 'www.no-prefixing-dot.foo.com',
+      matchedDomain: 'no-prefixing-dot.foo.com',
+      isValid: true,
+      thirdPartyCookieEnabled: true
+    },
+    {
+      domain: 'foo.com',
+      matchedDomain: undefined,
+      isValid: false
+    },
+    {
+      domain: 'bar.com',
+      matchedDomain: undefined,
+      isValid: false
+    },
+    {
+      domain: 'ec2-54-234-131-1.compute-1.amazonaws.com',
+      matchedDomain: '.ec2-54-234-131-1.compute-1.amazonaws.com',
+      isValid: true,
+      thirdPartyCookieEnabled: false,
+      commentsEnabled: true
+    },
+    {
+      domain: 'www.ec2-54-234-131-1.compute-1.amazonaws.com',
+      matchedDomain: '.ec2-54-234-131-1.compute-1.amazonaws.com',
+      isValid: true,
+      thirdPartyCookieEnabled: false,
+      commentsEnabled: true
+    },
+    {
+      domain: 'compute-1.amazonaws.com',
+      matchedDomain: undefined,
+      isValid: false
+    },
+    {
+      domain: 'localhost',
+      matchedDomain: '.localhost',
+      isValid: true,
+      thirdPartyCookieEnabled: false
+    },
+    {
+      domain: '172.16.0.5',
+      matchedDomain: '172.16.0.5',
+      isValid: true,
+      thirdPartyCookieEnabled: true,
+      commentsEnabled: false
+    },
+    {
+      domain: '192.168.10.10',
+      matchedDomain: undefined,
+      isValid: false
+    }
+  ];
+
+  // There is very intentional variation on what each domain in the allowedDomains set includes,
+  // in order to make testing more interesting
+  var allowedDomains = [
+    {
+      domain: '.bazaarvoice.com',
+      thirdPartyCookieEnabled: true,
+      commentsEnabled: true
+    },
+    {
+      domain: '.ec2-54-234-131-1.compute-1.amazonaws.com',
+      thirdPartyCookieEnabled: false,
+      commentsEnabled: true
+    },
+    {
+      domain: '.172.16.0.5',
+      thirdPartyCookieEnabled: true,
+      commentsEnabled: false
+    },
+    {
+      domain: '.localhost',
+      thirdPartyCookieEnabled: false
+    },
+    {
+      domain: 'no-prefixing-dot.foo.com',
+      thirdPartyCookieEnabled: true
+    }
+  ];
+
+  it('produces correct results for all test domains', function () {
+
+    /**
+     * A utility function used to test a domain.
+     */
+    function testDomain (domainUnderTest) {
+      var domain = domainUnderTest.domain;
+
+      var dp = domainPolice(allowedDomains.slice(0), domain);
+
+      expect(dp.isValid).to.equal(domainUnderTest.isValid);
+      expect(dp.get('domain')).to.equal(domainUnderTest.matchedDomain);
+      expect(dp.get('thirdPartyCookieEnabled')).to.equal(domainUnderTest.thirdPartyCookieEnabled);
+      expect(dp.get('commentsEnabled')).to.equal(domainUnderTest.commentsEnabled);
+    }
+
+    // Run the tests on each domain
+    for (var i = 0, l = domainsToTest.length; i < l; i++) {
+      testDomain(domainsToTest[i]);
+    }
+  });
+
+});

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

@@ -0,0 +1,59 @@
+/**
+ * @fileOverview
+ * Unit tests for the evented module.
+ *
+ * The tests in this file are minimal because the module is covered by the tests
+ * in the original asEvented repo (https://github.com/mkuklis/asEvented). With
+ * that in mind, this file just aims to test that we expose the interface we
+ * promise to expose.
+ */
+
+// Imports.
+var evented = require('../../../lib/evented');
+
+describe('lib/import', function () {
+
+  it('exports a function that creates an event emitter', function () {
+    function M () {}
+
+    evented.call(M.prototype);
+    var m = new M();
+
+    expect(m.on).to.be.a('function');
+    expect(m.off).to.be.a('function');
+    expect(m.trigger).to.be.a('function');
+    expect(m.one).to.be.a('function');
+    expect(m.once).to.be.a('function');
+  });
+
+  it('invokes an errorHandler function correctly', function () {
+    function M () {}
+
+    evented.call(M.prototype);
+    var m = new M();
+
+    // Ensure that errors escaping from listeners are caught
+    var error = new Error('test error 1');
+    m.on('test_event', function () {
+      throw error;
+    });
+    m.trigger('test_event'); // should NOT throw
+
+    // Ensure that errors are provided to custom error handler
+    error = new Error('test error 2');
+    var spy = sinon.spy();
+    m.setErrorHandler(spy);
+    m.trigger('test_event');
+    expect(spy).to.have.been.calledWith(error, sinon.match.has('event', 'test_event'));
+
+    // Ensure that errors can be rethrown from custom error handler
+    error = new Error('test error 3');
+    m.setErrorHandler(function (theError) {
+      throw theError;
+    });
+    expect(function () {
+      m.trigger('test_event');
+    }).to.throw(error);
+  })
+
+});

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

@@ -0,0 +1,60 @@
+/**
+ * @fileOverview
+ * Unit tests for the getOriginalConstructor module.
+ */
+
+// Imports.
+var getOriginalConstructor = require('../../../lib/getOriginalConstructor');
+
+describe('lib/getOriginalConstructor', function () {
+  var originalPush = Array.prototype.push;
+  var push = function push () {
+    originalPush.apply(this, arguments);
+  }
+
+  Array.prototype.push = push;
+
+  getOriginalConstructor(Array).then(function (originalArray) {
+    it('Should return an unaltered constructor', function () {
+      // Verify that the original push function matches '[native code]'
+      expect(!!originalPush.toString().match(/\[native code]/)).to.equal(true);
+      // Verify that the overridden push function doesn't match '[native code]'
+      expect(!!Array.prototype.push.toString().match(/\[native code]/)).to.equal(false);
+
+      // Verify that the getOriginalConstructor function returns a reset
+      // constructor and that its prototype push function matches '[native code]'
+      expect(!!originalArray.prototype.push.toString().match(/\[native code]/)).to.equal(true);
+    });
+
+    it('Should cache the returned constructor for future lookups', function (done) {
+      getOriginalConstructor(Array).then(function (newArray) {
+        expect(newArray).to.equal(originalArray);
+        done();
+      });
+    });
+
+    it('Should return the definition for constructor.name when constructor.name exists', function (done) {
+      var constructor = function Array () {};
+
+      Object.defineProperty(constructor, 'name', {
+        value: 'Array'
+      });
+
+      // We should pull the Array constructor, with prototype, if this is working properly
+      getOriginalConstructor(constructor).then(function (newArray) {
+        expect(newArray).to.have.property('prototype');
+        done();
+      });
+    });
+
+    it('Should return the definition for the function name where constructor.name doesn\'t exist', function (done) {
+      var constructor = function Array () {};
+
+      // We should pull the Array constructor, with prototype, if this is working properly
+      getOriginalConstructor(constructor).then(function (newArray) {
+        expect(newArray).to.have.property('prototype');
+        done();
+      });
+    });
+  });
+});