bv-ui-core 0.1.1

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

@@ -0,0 +1,141 @@
+/**
+ * @fileOverview
+ * Unit tests for the logger module.
+ */
+
+var Logger = require('../../../lib/logger');
+var global = require('../../../lib/global');
+
+describe('lib/logger', function () {
+  var sandbox;
+  var debugStub;
+  var logStub;
+  var infoStub;
+  var groupStub;
+  var groupEndStub;
+
+  beforeEach(function () {
+    sandbox = sinon.sandbox.create();
+
+    debugStub = sandbox.stub(global.console, 'debug');
+    logStub = sandbox.stub(global.console, 'log');
+    infoStub = sandbox.stub(global.console, 'info');
+    groupStub = sandbox.stub(global.console, 'group');
+    groupEndStub = sandbox.stub(global.console, 'groupEnd');
+  });
+
+  afterEach(function () {
+    // reset the log level to the default
+    Logger.setLogLevel(Logger.INFO);
+    sandbox.restore();
+  });
+
+  it('works', function () {
+    Logger.info('Hello');
+    sinon.assert.notCalled(infoStub);
+    Logger.setLogLevel(Logger.INFO, true);
+    Logger.info('World');
+    sinon.assert.calledWith(infoStub, 'World');
+  });
+
+  it('does not log anything if off', function () {
+    Logger.setLogLevel(Logger.OFF);
+    Logger.debug('foo');
+    sinon.assert.notCalled(debugStub);
+  });
+
+  it('does not log if there is no console', function () {
+    var tempConsole = global.console;
+    global.console = false;
+
+    Logger.info('foo');
+    global.console = tempConsole;
+
+    sinon.assert.notCalled(infoStub);
+  });
+
+  it.skip('defaults to `log` in internet explorer', function () {
+    // TODO - fake IE
+    Logger.info('foo');
+    expect(logStub).to.have.been.calledWith('foo');
+  });
+
+  it('logs the result of a passed function', function () {
+    var funcToLog = function () {
+      return ['foo'];
+    };
+    Logger.info(funcToLog);
+    expect(infoStub).to.have.been.calledWith('foo');
+  });
+
+  describe('#setLogLevel', function () {
+    it('defaults to 0', function () {
+      Logger.setLogLevel();
+      expect(Logger.getLogLevel()).to.equal(Logger.LOG);
+    });
+
+    it('sets log level', function () {
+      Logger.setLogLevel(Logger.OFF)
+      expect(Logger.getLogLevel()).to.equal(Logger.OFF);
+    });
+  });
+
+  describe('#assert', function () {
+    it('does not do anything if Logger.OFF', function () {
+      Logger.setLogLevel(Logger.OFF);
+      expect(function () {
+        Logger.assert(false);
+      }).to.not.throw(Error, /Assertion failed/);
+    });
+
+    it('evaluates a function', function () {
+      var funcToAssert = function () {
+        // According to #assert, return an array
+        return [false];
+      };
+      expect(function () {
+        Logger.assert(funcToAssert);
+      }).to.throw(Error, /Assertion failed/);
+    });
+
+    it('throws if the assertion failed', function () {
+      expect(function () {
+        Logger.assert(false)
+      }).to.throw(Error, /Assertion failed/);
+    });
+  })
+
+  describe('#group', function () {
+    it('calls console.group if maxLevel is < the current log level', function () {
+      Logger.group(Logger.INFO);
+      expect(groupStub).to.have.been.called;
+    });
+
+    it('does not call console.group if maxLevel is < the current log level', function () {
+      Logger.group(Logger.DEBUG);
+      expect(groupStub).to.not.have.been.called;
+    });
+
+    it('passes arguments on to console.group', function () {
+      Logger.group(Logger.INFO, 'Test Group');
+      expect(groupStub).to.have.been.calledWith('Test Group');
+    });
+  });
+
+  describe('#groupEnd', function () {
+    it('calls console.groupEnd if maxLevel is < the current log level', function () {
+      Logger.groupEnd(Logger.INFO);
+      expect(groupEndStub).to.have.been.called;
+    });
+
+    it('does not call console.groupEnd if maxLevel is < the current log level', function () {
+      Logger.groupEnd(Logger.DEBUG);
+      expect(groupEndStub).to.not.have.been.called;
+    });
+
+    it('passes arguments on to console.groupEnd', function () {
+      Logger.groupEnd(Logger.INFO, 'Test GroupEnd');
+      expect(groupEndStub).to.have.been.calledWith('Test GroupEnd');
+    });
+  });
+})

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

@@ -0,0 +1,31 @@
+/**
+ * @fileOverview
+ * Unit tests for the messageFormat module 
+ */
+var messageFormat = require('../../../lib/messageFormat');
+
+describe('lib/messageFormat', function () {
+  it('messageFormat.generateCountryFromLocale', function () {
+    function test1 () {  
+      return  messageFormat.generateCountryFromLocale('en_US');
+    }
+
+    expect(test1()).to.be.equal('United States');
+
+    function test2 () {
+      return messageFormat.generateCountryFromLocale('en_DE');
+    }
+
+    expect(test2()).to.be.equal('Germany')
+
+    function test3 () {
+      return messageFormat.generateCountryFromLocale('de_DE');
+    }
+    expect(test3()).to.be.equal('Deutschland')
+
+    function test4 () {
+      return messageFormat.generateCountryFromLocale()
+    }
+    expect(test4()).to.be.empty
+  });
+});

package/test/unit/mochaInit.js

@@ -0,0 +1,8 @@
+/**
+ * @fileOverview
+ * Set up mocha.
+ */
+
+window.mocha.setup({
+  ui: 'bdd'
+});

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

@@ -0,0 +1,100 @@
+/**
+ * @fileOverview
+ * Tests for the namespacer module.
+ */
+
+var global = require('../../../lib/global');
+var namespacer = require('../../../lib/namespacer');
+
+describe('lib/namespacer', function () {
+  var nameA = 'nameA';
+  var nameB = 'nameB';
+
+  function hasNamespaceProperties (name, obj) {
+    expect(obj.name).to.equal(name);
+    expect(obj.registerProperty).to.be.a('function');
+  }
+
+  beforeEach(function () {
+    global[nameA] = undefined;
+    global[nameB] = undefined;
+  });
+
+  it('creates a namespace', function () {
+    var namespace = namespacer.namespace(nameA);
+    expect(namespace).to.be.an('object');
+    expect(global[nameA]).to.equal(namespace);
+    hasNamespaceProperties(nameA, namespace);
+  });
+
+  it('adds the namespace to the global object', function () {
+    var namespace = namespacer.namespace(nameA);
+    expect(global[nameA]).to.equal(namespace);
+  });
+
+  it('returns the same namespace instance on second invocation', function () {
+    var namespace1 = namespacer.namespace(nameA);
+    var namespace2 = namespacer.namespace(nameA);
+    expect(namespace1).to.equal(namespace2);
+  });
+
+  it('creates distinct namespace instances', function () {
+    var namespaceA = namespacer.namespace(nameA);
+    var namespaceB = namespacer.namespace(nameB);
+    expect(namespaceA).to.not.equal(namespaceB);
+  });
+
+  it('throws when non-object property is already assigned to global', function () {
+    expect(function () {
+      global[nameA] = false;
+      namespacer.namespace(nameA);
+    }).to.throw(Error);
+
+    expect(function () {
+      global[nameA] = null;
+      namespacer.namespace(nameA);
+    }).to.throw(Error);
+
+    expect(function () {
+      global[nameA] = '';
+      namespacer.namespace(nameA);
+    }).to.throw(Error);
+  });
+
+  it('decorates existing object property assigned to global', function () {
+    global[nameA] = {};
+    namespacer.namespace(nameA);
+    hasNamespaceProperties(nameA, global[nameA]);
+  });
+
+  describe('namespace', function () {
+    var propA = 'propA';
+    var propB = 'propB';
+    var valueA = {};
+    var valueB = {};
+    var namespace;
+
+    beforeEach(function () {
+      namespace = namespacer.namespace(nameA);
+    });
+
+    describe('registerProperty', function () {
+
+      it('registers properties', function () {
+        namespace.registerProperty(propA, valueA);
+        namespace.registerProperty(propB, valueB);
+
+        expect(namespace[propA]).to.equal(valueA);
+        expect(namespace[propB]).to.equal(valueB);
+      });
+
+      it('throws on reregistering a property', function () {
+        expect(function () {
+          namespace.registerProperty(propA, valueA);
+          namespace.registerProperty(propA, valueA);
+        }).to.throw(Error);
+      });
+
+    });
+  });
+});

package/test/unit/performance/getEntries.spec.js

@@ -0,0 +1,30 @@
+/**
+ * @fileOverview
+ * Unit tests for the performance/getEntries.js module.
+ */
+
+// Imports.
+var perfGetEntries = require('../../../lib/performance/getEntries.js');
+var perfMark = require('../../../lib/performance/mark.js');
+
+describe('lib/performance/getEntries', function () {
+  before(function () {
+    perfMark.mark('test1');
+    perfMark.mark('test2');
+  });
+
+  it('returns an array of all performance marks', function () {
+    var result = perfGetEntries.getEntries();
+
+    // Test 1: it returns an array.
+    expect(result).to.be.an('array');
+
+    // Test 2: the array contains the relevant performance marks themselves.
+    // In order to make sure we're only checking marks created
+    // in *this* test, we use the *last* 2 marks, rather than
+    // hardcoding indexes 0 and 1, in case other tests make marks.
+    expect(result[result.length-2].name).to.equal('test1');
+    expect(result[result.length-1].name).to.equal('test2');
+  });
+
+});

package/test/unit/performance/getEntriesByName.spec.js

@@ -0,0 +1,88 @@
+/**
+ * @fileOverview
+ * Unit tests for the performance/getEntriesByName.js module.
+ */
+
+// Imports.
+var perfGetEntriesByName = require('../../../lib/performance/getEntriesByName.js');
+var perfMark = require('../../../lib/performance/mark.js');
+
+describe('lib/performance/getEntriesByName', function () {
+  before(function () {
+    perfMark.mark('test-by-name1');
+    perfMark.mark('test-by-name2');
+    perfMark.mark('test-by-name2');
+  });
+
+  it('returns an array of all matching performance marks by name', function () {
+    var result1 = perfGetEntriesByName.getEntriesByName('test-by-name1');
+    var result2 = perfGetEntriesByName.getEntriesByName('test-by-name2');
+
+    // Test 1: it returns an array.
+    expect(result1).to.be.an('array');
+    expect(result2).to.be.an('array');
+
+    // Test 2: the arrays contain the relevant number of performance marks.
+    expect(result1.length).to.equal(1);
+    expect(result2.length).to.equal(2);
+
+    // Test 3: the arrays contain the relevant performance marks themselves.
+    // In order to make sure we're only checking marks created
+    // in *this* test, we use the *last* 2 marks, rather than
+    // hardcoding indexes 0 and 1, in case other tests make marks.
+    expect(result1[result1.length-1].name).to.equal('test-by-name1');
+    expect(result2[result2.length-2].name).to.equal('test-by-name2');
+    expect(result2[result2.length-1].name).to.equal('test-by-name2');
+  });
+
+  it('returns an array of all matching performance marks by name and entryType', function () {
+    var result1 = perfGetEntriesByName.getEntriesByName('test-by-name1', 'mark');
+    var result2 = perfGetEntriesByName.getEntriesByName('test-by-name2', 'mark');
+
+    // Test 1: it returns an array.
+    expect(result1).to.be.an('array');
+    expect(result2).to.be.an('array');
+
+    // Test 2: the arrays contain the relevant number of performance marks.
+    expect(result1.length).to.equal(1);
+    expect(result2.length).to.equal(2);
+
+    // Test 3: the arrays contain the relevant performance marks themselves.
+    // In order to make sure we're only checking marks created
+    // in *this* test, we use the *last* 2 marks, rather than
+    // hardcoding indexes 0 and 1, in case other tests make marks.
+    expect(result1[result1.length-1].name).to.equal('test-by-name1');
+    expect(result2[result2.length-2].name).to.equal('test-by-name2');
+    expect(result2[result2.length-1].name).to.equal('test-by-name2');
+  });
+
+  it('returns an empty array if no name match is found', function () {
+    var result = perfGetEntriesByName.getEntriesByName('test-by-name3');
+
+    // Test 1: it returns an array.
+    expect(result).to.be.an('array');
+
+    // Test 2: the array contains no performance marks.
+    expect(result.length).to.equal(0);
+  });
+
+  it('returns an empty array if no entryType match is found', function () {
+    var result = perfGetEntriesByName.getEntriesByName('test-by-name1', 'paint');
+
+    // Test 1: it returns an array.
+    expect(result).to.be.an('array');
+
+    // Test 2: the array contains no performance marks.
+    expect(result.length).to.equal(0);
+  });
+
+ 
+  it('throws an error if no arguments are passed', function () {
+    //name is passed to the nativeImplementation which is undefined and returns an empty array 
+    function test () {
+      return perfGetEntriesByName.getEntriesByName()
+    }
+    expect(test()).to.be.empty;
+  });
+
+});

package/test/unit/performance/getEntriesByType.spec.js

@@ -0,0 +1,48 @@
+/**
+ * @fileOverview
+ * Unit tests for the performance/getEntriesByType.js module.
+ */
+
+// Imports.
+var perfGetEntriesByType = require('../../../lib/performance/getEntriesByType.js');
+var perfMark = require('../../../lib/performance/mark.js');
+
+describe('lib/performance/getEntriesByType', function () {
+  before(function () {
+    //Clearing all the marks as marks from other tests were being added
+    performance.clearMarks()
+    perfMark.mark('test-by-name1');
+    perfMark.mark('test-by-name2');
+  });
+
+  it('returns an array of all matching performance marks by type', function () {
+    var result = perfGetEntriesByType.getEntriesByType('mark');
+    // Test 1: it returns an array.
+    expect(result).to.be.an('array');
+
+    // Test 2: the array contains the relevant number of performance marks.
+    expect(result.length).to.equal(2);
+
+    // Test 3: the arrays contain the relevant performance marks themselves.
+    // In order to make sure we're only checking marks created
+    // in *this* test, we use the *last* 2 marks, rather than
+    // hardcoding indexes 0 and 1, in case other tests make marks.
+    expect(result[result.length-2].name).to.equal('test-by-name1');
+    expect(result[result.length-1].name).to.equal('test-by-name2');
+  });
+
+  it('returns an empty array if no entryType match is found', function () {
+    var result = perfGetEntriesByType.getEntriesByType('unknown-type');
+
+    // Test 1: it returns an array.
+    expect(result).to.be.an('array');
+
+    // Test 2: the array contains no performance marks.
+    expect(result.length).to.equal(0);
+  });
+
+  it('throws an error if no arguments are passed', function () {
+    expect(perfGetEntriesByType.getEntriesByType()).to.be.empty;
+  });
+
+});

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

@@ -0,0 +1,35 @@
+/**
+ * @fileOverview
+ * Unit tests for the performance/index.js module.
+ */
+
+// Imports.
+var perfModule = require('../../../lib/performance');
+
+describe('lib/performance', function () {
+
+  it('exposes a getEntries function', function () {
+    expect(perfModule.getEntries).to.be.a('function');
+  });
+
+  it('exposes a getEntriesByName function', function () {
+    expect(perfModule.getEntriesByName).to.be.a('function');
+  });
+
+  it('exposes a getEntriesByType function', function () {
+    expect(perfModule.getEntriesByType).to.be.a('function');
+  });
+
+  it('exposes a now function', function () {
+    expect(perfModule.now).to.be.a('function');
+  });
+
+  it('exposes a mark function', function () {
+    expect(perfModule.mark).to.be.a('function');
+  });
+
+  it('exposes a measure function', function () {
+    expect(perfModule.measure).to.be.a('function');
+  });
+
+});

package/test/unit/performance/mark.spec.js

@@ -0,0 +1,40 @@
+/**
+ * @fileOverview
+ * Unit tests for the performance/mark.js module.
+ */
+
+// Imports.
+var perfMark = require('../../../lib/performance/mark.js');
+
+describe('lib/performance/mark', function () {
+
+  it('can create a mark', function () {
+    var markName = 'test-mark';
+
+    expect(function () { perfMark.mark(markName); }).to.not.throw(Error);
+  });
+
+  it('can create multiple marks', function () {
+    var markName1 = 'test-mark-1';
+    var markName2 = 'test-mark-2';
+
+    expect(function () { perfMark.mark(markName1); }).to.not.throw(Error);
+    expect(function () { perfMark.mark(markName2); }).to.not.throw(Error);
+  });
+
+  it('can create multiple marks of the same name', function () {
+    var markName = 'test-mark';
+
+    expect(function () { perfMark.mark(markName); }).to.not.throw(Error);
+    expect(function () { perfMark.mark(markName); }).to.not.throw(Error);
+    expect(function () { perfMark.mark(markName); }).to.not.throw(Error);
+  });
+
+  it('throws an error if the mark name is a reserved name', function () {
+    // 'navigationStart' is part of the PerformanceTiming interface.
+    var markName = 'navigationStart';
+
+    expect(function () { perfMark.mark(markName); }).to.throw(Error);
+  });
+
+});

package/test/unit/performance/measure.spec.js

@@ -0,0 +1,50 @@
+/**
+ * @fileOverview
+ * Unit tests for the performance/measure.js module.
+ */
+
+// Imports.
+var perfMark = require('../../../lib/performance/mark.js');
+var perfMeasure = require('../../../lib/performance/measure.js');
+
+describe('lib/performance/measure', function () {
+
+  it('can create a measure', function () {
+    var measureName = 'test-measure';
+
+    expect(function () { perfMeasure.measure(measureName); }).to.not.throw(Error);
+  });
+
+  it('can create multiple measures', function () {
+    var measureName1 = 'test-measure-1';
+    var measureName2 = 'test-measure-2';
+
+    expect(function () { perfMeasure.measure(measureName1); }).to.not.throw(Error);
+    expect(function () { perfMeasure.measure(measureName2); }).to.not.throw(Error);
+  });
+
+  it('can create multiple measures of the same name', function () {
+    var measureName = 'test-measure';
+
+    expect(function () { perfMeasure.measure(measureName); }).to.not.throw(Error);
+    expect(function () { perfMeasure.measure(measureName); }).to.not.throw(Error);
+    expect(function () { perfMeasure.measure(measureName); }).to.not.throw(Error);
+  });
+
+  it('throws an error if the measure name is omitted', function () {
+    expect(perfMeasure.measure()).to.be.empty;
+  });
+
+  it('throws an error if the startMark or endMark name is supplied, but is invalid', function () {
+    var measureName = 'test-measure';
+    var invalidMark = 'lskdjflskdjflskjdflskdjflsdkjflskdjflskfjlskdfjslkdfj';
+
+    expect(function () { perfMeasure.measure(measureName, invalidMark); }).to.throw(Error);
+
+    var validMark = 'valid-mark-name';
+    perfMark.mark(validMark)
+
+    expect(function () { perfMeasure.measure(measureName, validMark, invalidMark); }).to.throw(Error);
+  });
+
+});

package/test/unit/performance/now.spec.js

@@ -0,0 +1,21 @@
+/**
+ * @fileOverview
+ * Unit tests for the performance/now.js module.
+ */
+
+// Imports.
+var perfNow = require('../../../lib/performance/now.js');
+
+describe('lib/performance/now', function () {
+
+  it('returns a non-negative number', function () {
+    var result = perfNow.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);
+  });
+
+});