bv-ui-core 0.1.1

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

@@ -0,0 +1,271 @@
+/**
+ * @fileOverview
+ * Unit tests for the Pixels Displayed module.
+ */
+
+var module = require('../../../lib/pixelsDisplayed');
+
+describe('lib/pixelsDisplayed', function () {
+  var pixelsDisplayedVertical;
+  var pixelsDisplayedHorizontal;
+  var sinonSandbox, stub;
+
+  var rect = {};
+
+  var el = {
+    getBoundingClientRect: function () {
+      return rect;
+    }
+  };
+
+  function stubAccessor () {
+    sinonSandbox = sinon.sandbox.create();
+    stub = sinonSandbox.stub(module, 'getDimensions').callsFake(function () {
+      return {
+        width: 500,
+        height: 500
+      }
+    });
+  }
+
+  before(function () {
+    pixelsDisplayedVertical = module.pixelsDisplayedVertical;
+    pixelsDisplayedHorizontal = module.pixelsDisplayedHorizontal;
+  });
+
+  beforeEach(function () {
+    stubAccessor();
+    rect = {
+      height: 200,
+      top: 100,
+      width: 200,
+      left: 100
+    };
+  });
+
+  afterEach(function () {
+    // we do expect stubbed method to have been called during each test
+    sinon.assert.called(stub);
+    sinonSandbox.restore();
+  });
+
+  describe('element is hidden vertically', function () {
+    describe('element is smaller than viewport', function () {
+      it('should be hidden when element is way above viewport', function () {
+        rect.top = -9999;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(0);
+      });
+
+      it('should be hidden when element is right above viewport', function () {
+        rect.top = -200;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(0);
+      });
+
+      it('should be hidden when element is way below viewport', function () {
+        rect.top = 9999;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(0);
+      });
+
+      it('should be hidden when element is right below viewport', function () {
+        rect.top = 500;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(0);
+      });
+    });
+
+    describe('element is bigger than viewport', function () {
+      beforeEach(function () {
+        rect.height = 1000;
+      });
+
+      it('should be hidden when element is way above viewport', function () {
+        rect.top = -9999;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(0);
+      });
+
+      it('should be hidden when element is right above viewport', function () {
+        rect.top = -1000;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(0);
+      });
+
+      it('should be hidden when element is way below viewport', function () {
+        rect.top = 9999;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(0);
+      });
+
+      it('should be hidden when element is right below viewport', function () {
+        rect.top = 1000;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(0);
+      });
+    });
+  });
+
+  describe('element is hidden horizontally', function () {
+    describe('element is smaller than viewport', function () {
+      it('should be hidden when element is way to the left of the viewport', function () {
+        rect.left = -9999;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(0);
+      });
+
+      it('should be hidden when element is just to the left of the viewport', function () {
+        rect.left = -200;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(0);
+      });
+
+      it('should be hidden when element is way to the right of the viewport', function () {
+        rect.left = 9999;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(0);
+      });
+
+      it('should be hidden when element is just to the right of the viewport', function () {
+        rect.left = 500;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(0);
+      });
+    });
+
+    describe('element is bigger than viewport', function () {
+      beforeEach(function () {
+        rect.width = 1000;
+      });
+
+      it('should be hidden when element is way to the left of the viewport', function () {
+        rect.left = -9999;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(0);
+      });
+
+      it('should be hidden when element is just to the left of the viewport', function () {
+        rect.left = -1000;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(0);
+      });
+
+      it('should be hidden when element is way to the right of the viewport', function () {
+        rect.left = 9999;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(0);
+      });
+
+      it('should be hidden when element is just to the right of the viewport', function () {
+        rect.left = 1000;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(0);
+      });
+    });
+  });
+
+  describe('element is visible vertically', function () {
+    describe('element is smaller than viewport', function () {
+      it('element should be visible when top position is 0', function () {
+        rect.top = 0;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(200);
+      });
+
+      it('element should be visible when top position is greater than 0', function () {
+        rect.top = 499;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(1);
+      });
+
+      it('element should be visible when top position is less than 0', function () {
+        rect.top = -199;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(1);
+      });
+    });
+
+    describe('element is bigger than viewport', function () {
+      beforeEach(function () {
+        rect.height = 1000;
+      });
+
+      it('element should be visible when top position is 0', function () {
+        rect.top = 0;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(500);
+      });
+
+      it('element should be visible when top position is greater than 0', function () {
+        rect.top = 100;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(400);
+      });
+
+      it('element should be visible when top position is less than 0', function () {
+        rect.top = -600;
+
+        expect(pixelsDisplayedVertical(el)).to.eql(400);
+      });
+    });
+  });
+
+  describe('element is visible horizontally', function () {
+    describe('element is smaller than viewport', function () {
+      it('element should be visible when left position is 0', function () {
+        rect.left = 0;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(200);
+      });
+
+      it('element should be visible when left position is greater than 0', function () {
+        rect.left = 499;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(1);
+      });
+
+      it('element should be visible when left position is less than 0', function () {
+        rect.left = -199;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(1);
+      });
+    });
+
+    describe('element is bigger than viewport', function () {
+      beforeEach(function () {
+        rect.width = 1000;
+      });
+
+      it('element should be visible when left position is 0', function () {
+        rect.left = 0;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(500);
+      });
+
+      it('element should be visible when left position is greater than 0', function () {
+        rect.left = 100;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(400);
+      });
+
+      it('element should be visible when left position is less than 0', function () {
+        rect.left = -600;
+
+        expect(pixelsDisplayedHorizontal(el)).to.eql(400);
+      });
+    });
+  });
+
+  it('Accessor function is working correctly', function () {
+    // Special case, we actually want to call the real function, so restore
+    // sandbox
+    sinonSandbox.restore();
+    var dimensions = module.getDimensions();
+    expect(dimensions.width).to.equal(window.innerWidth);
+    expect(dimensions.height).to.equal(window.innerHeight);
+    // And then re-set-it-up again and call method
+    stubAccessor();
+    dimensions = module.getDimensions();
+  })
+});

package/test/unit/polyfills/fetch/Headers.js

@@ -0,0 +1,12 @@
+/**
+ * @fileOverview
+ * Unit tests for the fetch Headers module.
+ */
+
+var Headers = require('../../../../lib/polyfills/fetch/Headers');
+
+describe('lib/polyfills/fetch/Headers', function () {
+  it('exports a function as its default export', function () {
+    expect(Headers).to.be.a('function');
+  });
+})

package/test/unit/polyfills/fetch/Request.js

@@ -0,0 +1,12 @@
+/**
+ * @fileOverview
+ * Unit tests for the fetch Request module.
+ */
+
+var Request = require('../../../../lib/polyfills/fetch/Request');
+
+describe('lib/polyfills/fetch/Request', function () {
+  it('exports a function as its default export', function () {
+    expect(Request).to.be.a('function');
+  });
+})

package/test/unit/polyfills/fetch/Response.js

@@ -0,0 +1,12 @@
+/**
+ * @fileOverview
+ * Unit tests for the fetch Response module.
+ */
+
+var Response = require('../../../../lib/polyfills/fetch/Response');
+
+describe('lib/polyfills/fetch/Response', function () {
+  it('exports a function as its default export', function () {
+    expect(Response).to.be.a('function');
+  });
+})

package/test/unit/polyfills/fetch/fetch.js

@@ -0,0 +1,12 @@
+/**
+ * @fileOverview
+ * Unit tests for the fetch function module.
+ */
+
+var fetch = require('../../../../lib/polyfills/fetch/fetch');
+
+describe('lib/polyfills/fetch/fetch', function () {
+  it('exports a function as its default export', function () {
+    expect(fetch).to.be.a('function');
+  });
+})

package/test/unit/polyfills/fetch/index.js

@@ -0,0 +1,61 @@
+/**
+ * @fileOverview
+ * Unit tests for the fetch polyfill module.
+ */
+
+var global = require('../../../../lib/global');
+
+describe('lib/polyfills/fetch', function () {
+  var nativeSupport = function () {
+    console.log('[native code]');
+  };
+
+  it('does not polyfill when natively supported', function () {
+    var fetch = global.fetch;
+
+    global.fetch = nativeSupport;
+
+    var fetchModule = require('../../../../lib/polyfills/fetch');
+
+    // Test named exports
+    expect(fetchModule.fetch).to.equal(nativeSupport);
+
+    // If we have native fetch support, we can also check these
+    if (fetch) {
+      expect(fetchModule.fetch).to.be.a('function');
+      expect(fetchModule.Headers).to.be.a('function');
+      expect(fetchModule.Request).to.be.a('function');
+      expect(fetchModule.Response).to.be.a('function');
+    }
+
+    global.fetch = fetch;
+
+    // Clear the require cache for the next time it's required
+    delete require.cache[require.resolve('../../../../lib/polyfills/fetch')];
+  });
+
+  it('polyfills when not natively supported', function () {
+    var fetch = global.fetch;
+
+    global.fetch = undefined;
+
+    var fetchModule = require('../../../../lib/polyfills/fetch');
+
+    // Test named exports
+    expect(fetchModule.fetch).not.to.equal(nativeSupport);
+
+    // Verify that we didn't pollute the global namespace
+    expect(global.fetch).to.equal(undefined);
+
+    // Now that we've polyfilled, we can check these
+    expect(fetchModule.fetch).to.be.a('function');
+    expect(fetchModule.Headers).to.be.a('function');
+    expect(fetchModule.Request).to.be.a('function');
+    expect(fetchModule.Response).to.be.a('function');
+
+    global.fetch = fetch;
+
+    // Clear the require cache for the next time it's required
+    delete require.cache[require.resolve('../../../../lib/polyfills/fetch')];
+  });
+})

package/test/unit/polyfills/promise.spec.js

@@ -0,0 +1,48 @@
+/**
+ * @fileOverview
+ * Unit tests for the Promise polyfill module.
+ */
+
+var global = require('../../../lib/global');
+
+describe('lib/polyfills/promise', function () {
+  var nativeSupport = function () {
+    console.log('[native code]');
+  };
+
+  it('does not polyfill when natively supported', function () {
+    var Promise = global.Promise;
+
+    global.Promise = nativeSupport;
+
+    var PromiseModule = require('../../../lib/polyfills/promise');
+
+    expect(PromiseModule).to.equal(nativeSupport);
+
+    global.Promise = Promise;
+
+    // Clear the require cache for the next time it's required
+    delete require.cache[require.resolve('../../../lib/polyfills/promise')];
+  });
+
+  it('polyfills when not natively supported', function () {
+    var Promise = global.Promise;
+
+    global.Promise = undefined;
+
+    var PromiseModule = require('../../../lib/polyfills/promise');
+
+    expect(PromiseModule).not.to.equal(nativeSupport);
+
+    // Verify that we didn't pollute the global namespace
+    expect(global.Promise).to.equal(undefined);
+
+    // Now that we've polyfilled, we can check this
+    expect(PromiseModule).to.be.a('function');
+
+    global.Promise = Promise;
+
+    // Clear the require cache for the next time it's required
+    delete require.cache[require.resolve('../../../lib/polyfills/promise')];
+  });
+})

package/test/unit/region/europe/index.spec.js

@@ -0,0 +1,70 @@
+/**
+ * @file Unit tests for EU region module
+ */
+
+var europe = require('../../../../lib/region/europe');
+
+describe('lib/region/europe', function () {
+
+  describe('#hasTerritory', function () {
+
+    it('should throw an error for en_US', function () {
+      expect(function () {
+        europe.hasTerritory('en_US');
+      }).to.throw();
+    });
+
+    it('should throw an error for fr', function () {
+      expect(function () {
+        europe.hasTerritory('fr');
+      }).to.throw();
+    });
+
+    it('should return false for US', function () {
+      var result = europe.hasTerritory('US');
+      expect(result).to.equal(false);
+    });
+
+    it('should return true for GB', function () {
+      var result = europe.hasTerritory('GB');
+      expect(result).to.equal(true);
+    });
+  });
+
+  describe('#hasLocale', function () {
+
+    it('should throw an error for US', function () {
+      expect(function () {
+        europe.hasLocale('US');
+      }).to.throw();
+    });
+
+    it('should return false for en_US', function () {
+      var result = europe.hasLocale('en_US');
+      expect(result).to.equal(false);
+    });
+
+    it('should return false for en-US', function () {
+      var result = europe.hasLocale('en-US');
+      expect(result).to.equal(false);
+    });
+
+    it('should return true for en_GB', function () {
+      var result = europe.hasLocale('en_GB');
+      expect(result).to.equal(true);
+    });
+
+    it('should return true for en-GB', function () {
+      var result = europe.hasLocale('en-GB');
+      expect(result).to.equal(true);
+    });
+  });
+
+  describe('#listTerritories', function () {
+
+    it('should return an array', function () {
+      var result = europe.listTerritories();
+      expect(result).to.be.an('array');
+    });
+  });
+});

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

@@ -0,0 +1,113 @@
+/**
+ * @file Unit tests for region module
+ */
+
+var region = require('../../../lib/region');
+
+
+describe('lib/region', function () {
+
+  describe('#hasTerritory', function () {
+
+    it('should throw an error for en_US and europe', function () {
+      expect(function () {
+        region.hasTerritory('europe', 'en_US');
+      }).to.throw();
+    });
+
+    it('should throw an error for US and bananarama', function () {
+      expect(function () {
+        region.hasTerritory('bananarama', 'US');
+      }).to.throw();
+    });
+
+    it('should throw an error for fr and europe', function () {
+      expect(function () {
+        region.hasTerritory('europe', 'fr');
+      }).to.throw();
+    });
+
+    it('should return false for US and europe', function () {
+      var result = region.hasTerritory('europe', 'US');
+      expect(result).to.equal(false);
+    });
+
+    it('should return true for GB and europe', function () {
+      var result = region.hasTerritory('europe', 'GB');
+      expect(result).to.equal(true);
+    });
+  });
+
+  describe('#hasLocale', function () {
+
+    it('should throw an error for US and europe', function () {
+      expect(function () {
+        region.hasLocale('europe', 'US');
+      }).to.throw();
+    });
+
+    it('should throw an error for en_US and bananarama', function () {
+      expect(function () {
+        region.hasLocale('bananarama', 'en_US');
+      }).to.throw();
+    });
+
+    it('should return false for en_US and europe', function () {
+      var result = region.hasLocale('europe', 'en_US');
+      expect(result).to.equal(false);
+    });
+
+    it('should return false for en-US and europe', function () {
+      var result = region.hasLocale('europe', 'en-US');
+      expect(result).to.equal(false);
+    });
+
+    it('should return true for en_GB and europe', function () {
+      var result = region.hasLocale('europe', 'en_GB');
+      expect(result).to.equal(true);
+    });
+
+    it('should return true for en-GB and europe', function () {
+      var result = region.hasLocale('europe', 'en-GB');
+      expect(result).to.equal(true);
+    });
+  });
+
+  describe('#lookupTerritory', function () {
+
+    it('should throw an error for en_US', function () {
+      expect(function () {
+        region.lookupTerritory('en_US');
+      }).to.throw();
+    });
+
+    it('should return europe for GB', function () {
+      var result = region.lookupTerritory('GB');
+      expect(result).to.eql('europe');
+    });
+
+    it('should return "unsupported" for US', function () {
+      var result = region.lookupTerritory('US');
+      expect(result).to.eql('unsupported');
+    });
+  });
+
+  describe('#lookupLocale', function () {
+
+    it('should throw an error for US', function () {
+      expect(function () {
+        region.lookupLocale('US');
+      }).to.throw();
+    });
+
+    it('should return europe for en_GB', function () {
+      var result = region.lookupLocale('en_GB');
+      expect(result).to.eql('europe');
+    });
+
+    it('should return "unsupported" for en_US', function () {
+      var result = region.lookupLocale('en_US');
+      expect(result).to.eql('unsupported');
+    });
+  });
+});