Partial test cleanup

src/utils/deprecate.js

@@ -23,6 +23,7 @@ const deprecate = function(message, test) {
   }
 };
 
+/* istanbul ignore next: can't clear console */
 deprecate._console = typeof console !== 'undefined' ? console : {};
 deprecate._warn = function() {
   const warn = deprecate._console.warn || deprecate._console.log || _.noop;

test/unit/behaviors.spec.js → test/unit/config/behaviors.spec.js

@@ -1,11 +1,11 @@
 'use strict';
 
-import Error from '../../src/error';
-import Behavior from '../../src/behavior';
-import Region from '../../src/region';
-import View from '../../src/view';
-import CollectionView from '../../src/collection-view';
-import behaviorsLookup from '../../src/config/behaviors-lookup';
+import Error from '../../../src/error';
+import Behavior from '../../../src/behavior';
+import Region from '../../../src/region';
+import View from '../../../src/view';
+import CollectionView from '../../../src/collection-view';
+import behaviorsLookup from '../../../src/config/behaviors-lookup';
 
 describe('Behaviors', function() {
 

test/unit/utils/deprecate.spec.js

@@ -1,103 +1,129 @@
-describe('Marionette.deprecate', function() {
+import deprecate from '../../../src/utils/deprecate';
+
+import Marionette from '../../../src/backbone.marionette';
+
+describe('deprecate', function() {
   beforeEach(function() {
     Marionette.DEV_MODE = true;
-    this.sinon.spy(Marionette.deprecate, '_warn');
-    this.sinon.stub(Marionette.deprecate, '_console', {
-      warn: this.sinon.stub()
+    this.sinon.spy(deprecate, '_warn');
+    this.sinon.stub(deprecate, '_console', {
+      warn: this.sinon.stub(),
+      log: this.sinon.stub()
     });
-    Marionette.deprecate._cache = {};
+    deprecate._cache = {};
   });
 
   afterEach(function() {
     Marionette.DEV_MODE = false;
   });
 
-  describe('Marionette.deprecate._warn', function() {
-    beforeEach(function() {
-      Marionette.deprecate._warn('foo');
-    });
-
+  describe('#_warn', function() {
     it('should `console.warn` the message', function() {
-      expect(Marionette.deprecate._console.warn)
+      deprecate._warn('foo');
+      expect(deprecate._console.warn)
         .to.have.been.calledOnce
-        .and.calledOn(Marionette.deprecate._console)
+        .and.calledOn(deprecate._console)
         .and.calledWith('foo');
     });
+
+    describe('when `console.warn` does not exist', function() {
+      beforeEach(function() {
+        deprecate._console.warn = null;
+      });
+
+      it('should `console.log` the message', function() {
+        deprecate._warn('foo');
+        expect(deprecate._console.log)
+          .to.have.been.calledOnce
+          .and.calledOn(deprecate._console)
+          .and.calledWith('foo');
+      });
+
+      describe('when `console.log` does not exist', function() {
+        it('should call `_.noop`', function() {
+          deprecate._console.log = null;
+          this.sinon.spy(_, 'noop');
+          deprecate._warn('foo');
+
+          expect(_.noop).to.have.been.calledOnce;
+        });
+      });
+    });
   });
 
   describe('when calling with a message', function() {
     beforeEach(function() {
-      Marionette.deprecate('foo');
+      deprecate('foo');
     });
 
     it('should `console.warn` the message', function() {
-      expect(Marionette.deprecate._warn)
+      expect(deprecate._warn)
         .to.have.been.calledOnce
         .and.calledWith('Deprecation warning: foo');
     });
   });
 
   describe('when calling with an object', function() {
     beforeEach(function() {
-      Marionette.deprecate({
+      deprecate({
         prev: 'foo',
         next: 'bar'
       });
     });
 
     it('should `console.warn` the message', function() {
-      expect(Marionette.deprecate._warn)
+      expect(deprecate._warn)
         .to.have.been.calledOnce
         .and.calledWith('Deprecation warning: foo is going to be removed in the future. Please use bar instead.');
     });
   });
 
   describe('when calling with an object with a url', function() {
     beforeEach(function() {
-      Marionette.deprecate({
+      deprecate({
         prev: 'foo',
         next: 'bar',
         url: 'baz'
       });
     });
 
     it('should `console.warn` the message', function() {
-      expect(Marionette.deprecate._warn)
+      expect(deprecate._warn)
         .to.have.been.calledOnce
         .and.calledWith('Deprecation warning: foo is going to be removed in the future. Please use bar instead. See: baz');
     });
   });
 
   describe('when calling with a message and a falsy test', function() {
     beforeEach(function() {
-      Marionette.deprecate('bar', false);
+      deprecate('bar', false);
     });
 
     it('should `console.warn` the message', function() {
-      expect(Marionette.deprecate._warn)
+      expect(deprecate._warn)
         .to.have.been.calledOnce
         .and.calledWith('Deprecation warning: bar');
     });
   });
 
   describe('when calling with a message and a truthy test', function() {
     beforeEach(function() {
-      Marionette.deprecate('Foo', true);
+      deprecate('Foo', true);
     });
 
     it('should not `console.warn` the message', function() {
-      expect(Marionette.deprecate._warn).not.to.have.been.called;
+      expect(deprecate._warn).not.to.have.been.called;
     });
   });
 
   describe('when calling with the same message twice', function() {
     beforeEach(function() {
-      Marionette.deprecate('baz');
-      Marionette.deprecate('baz');
+      deprecate('baz');
+      deprecate('baz');
     });
 
     it('should `console.warn` the message', function() {
-      expect(Marionette.deprecate._warn)
+      expect(deprecate._warn)
         .to.have.been.calledOnce
         .and.calledWith('Deprecation warning: baz');
     });
@@ -106,11 +132,11 @@ describe('Marionette.deprecate', function() {
   describe('when calling in production mode', function() {
     beforeEach(function() {
       Marionette.DEV_MODE = false;
-      Marionette.deprecate('baz');
+      deprecate('baz');
     });
 
     it('should `console.warn` the message', function() {
-      expect(Marionette.deprecate._warn).to.not.have.been.called;
+      expect(deprecate._warn).to.not.have.been.called;
     });
   });
 });

test/unit/utils/emulate-collection.spec.js

@@ -0,0 +1,11 @@
+import emulateCollection from '../../../src/utils/emulate-collection';
+
+describe('emulateCollection', function() {
+  it('should be able to map over list', function() {
+    const target = { list: [1, 2, 3] };
+
+    emulateCollection(target, 'list');
+
+    expect(target.map(v => v * 2)).to.eql([2, 4, 6]);
+  });
+});

test/unit/utils/get-unique-event-name.spec.js

@@ -0,0 +1,8 @@
+import getUniqueEventName from '../../../src/utils/get-unique-event-name';
+
+describe('getUniqueEventName', function() {
+  it('should postfix a unique id to the event', function() {
+    const matcher = /^(click\.evt\d+\sa\.name)$/;
+    expect(getUniqueEventName('click a.name')).to.match(matcher);
+  });
+});

test/unit/utils/proxy.spec.js

@@ -0,0 +1,24 @@
+import proxy from '../../../src/utils/proxy';
+
+describe('proxy', function() {
+  let method;
+
+  beforeEach(function() {
+    method = this.sinon.stub();
+  });
+
+  it('should return a function', function() {
+    expect(proxy(method)).to.be.a('function');
+  });
+
+  describe('when calling the returned function', function() {
+    it('should call the method on context with all arguments', function() {
+      const context = {};
+      const proxiedMethod = proxy(method);
+
+      proxiedMethod(context, 1, 2, 3);
+
+      expect(method).to.be.calledOn(context).and.calledWith(1,2,3);
+    });
+  });
+});

test/unit/utils/set-options.spec.js

@@ -0,0 +1,38 @@
+import setOptions from '../../../src/utils/set-options';
+
+describe('setOptions', function() {
+  let object;
+  const options = {
+    foo: 'baz',
+    baz: 'baz'
+  };
+
+  beforeEach(function() {
+    object = {
+      options() {
+        return {
+          foo: 'bar',
+          bar: 'baz'
+        };
+      }
+    };
+
+    setOptions.call(object, options);
+  });
+
+  it('should not mutate the options argument', function() {
+    expect(options).to.eql({
+      foo: 'baz',
+      baz: 'baz'
+    })
+  });
+
+  // This test covers merge order and options as a function
+  it('should set options on the context', function() {
+    expect(object.options).to.eql({
+      foo: 'baz',
+      bar: 'baz',
+      baz: 'baz'
+    });
+  });
+});