Update vendor/backbone and vendor/underscore.

vendor/backbone/test/view.js

@@ -2,9 +2,9 @@
 
   var view;
 
-  module("Backbone.View", {
+  QUnit.module("Backbone.View", {
 
-    setup: function() {
+    beforeEach: function(assert) {
       $('#qunit-fixture').append(
         '<div id="testElement"><h1>Test</h1></div>'
       );
@@ -18,46 +18,52 @@
 
   });
 
-  test("constructor", 3, function() {
-    equal(view.el.id, 'test-view');
-    equal(view.el.className, 'test-view');
-    equal(view.el.other, void 0);
+  QUnit.test("constructor", function(assert) {
+    assert.expect(3);
+    assert.equal(view.el.id, 'test-view');
+    assert.equal(view.el.className, 'test-view');
+    assert.equal(view.el.other, void 0);
   });
 
-  test("$", 2, function() {
+  QUnit.test("$", function(assert) {
+    assert.expect(2);
     var view = new Backbone.View;
     view.setElement('<p><a><b>test</b></a></p>');
     var result = view.$('a b');
 
-    strictEqual(result[0].innerHTML, 'test');
-    ok(result.length === +result.length);
+    assert.strictEqual(result[0].innerHTML, 'test');
+    assert.ok(result.length === +result.length);
   });
 
-  test("$el", 3, function() {
+  QUnit.test("$el", function(assert) {
+    assert.expect(3);
     var view = new Backbone.View;
     view.setElement('<p><a><b>test</b></a></p>');
-    strictEqual(view.el.nodeType, 1);
+    assert.strictEqual(view.el.nodeType, 1);
 
-    ok(view.$el instanceof Backbone.$);
-    strictEqual(view.$el[0], view.el);
+    assert.ok(view.$el instanceof Backbone.$);
+    assert.strictEqual(view.$el[0], view.el);
   });
 
-  test("initialize", 1, function() {
+  QUnit.test("initialize", function(assert) {
+    assert.expect(1);
     var View = Backbone.View.extend({
       initialize: function() {
         this.one = 1;
       }
     });
 
-    strictEqual(new View().one, 1);
+    assert.strictEqual(new View().one, 1);
   });
 
-  test("render", 1, function() {
+  QUnit.test("render", function(assert) {
+    assert.expect(1);
     var view = new Backbone.View;
-    equal(view.render(), view, '#render returns the view instance');
+    assert.equal(view.render(), view, '#render returns the view instance');
   });
 
-  test("delegateEvents", 6, function() {
+  QUnit.test("delegateEvents", function(assert) {
+    assert.expect(6);
     var counter1 = 0, counter2 = 0;
 
     var view = new Backbone.View({el: '#testElement'});
@@ -68,33 +74,35 @@
 
     view.delegateEvents(events);
     view.$('h1').trigger('click');
-    equal(counter1, 1);
-    equal(counter2, 1);
+    assert.equal(counter1, 1);
+    assert.equal(counter2, 1);
 
     view.$('h1').trigger('click');
-    equal(counter1, 2);
-    equal(counter2, 2);
+    assert.equal(counter1, 2);
+    assert.equal(counter2, 2);
 
     view.delegateEvents(events);
     view.$('h1').trigger('click');
-    equal(counter1, 3);
-    equal(counter2, 3);
+    assert.equal(counter1, 3);
+    assert.equal(counter2, 3);
   });
 
-  test("delegate", 3, function() {
+  QUnit.test("delegate", function(assert) {
+    assert.expect(3);
     var view = new Backbone.View({el: '#testElement'});
     view.delegate('click', 'h1', function() {
-      ok(true);
+      assert.ok(true);
     });
     view.delegate('click', function() {
-      ok(true);
+      assert.ok(true);
     });
     view.$('h1').trigger('click');
 
-    equal(view.delegate(), view, '#delegate returns the view instance');
+    assert.equal(view.delegate(), view, '#delegate returns the view instance');
   });
 
-  test("delegateEvents allows functions for callbacks", 3, function() {
+  QUnit.test("delegateEvents allows functions for callbacks", function(assert) {
+    assert.expect(3);
     var view = new Backbone.View({el: '<p></p>'});
     view.counter = 0;
 
@@ -106,24 +114,26 @@
 
     view.delegateEvents(events);
     view.$el.trigger('click');
-    equal(view.counter, 1);
+    assert.equal(view.counter, 1);
 
     view.$el.trigger('click');
-    equal(view.counter, 2);
+    assert.equal(view.counter, 2);
 
     view.delegateEvents(events);
     view.$el.trigger('click');
-    equal(view.counter, 3);
+    assert.equal(view.counter, 3);
   });
 
 
-  test("delegateEvents ignore undefined methods", 0, function() {
+  QUnit.test("delegateEvents ignore undefined methods", function(assert) {
+    assert.expect(0);
     var view = new Backbone.View({el: '<p></p>'});
     view.delegateEvents({'click': 'undefinedMethod'});
     view.$el.trigger('click');
   });
 
-  test("undelegateEvents", 7, function() {
+  QUnit.test("undelegateEvents", function(assert) {
+    assert.expect(7);
     var counter1 = 0, counter2 = 0;
 
     var view = new Backbone.View({el: '#testElement'});
@@ -134,107 +144,116 @@
 
     view.delegateEvents(events);
     view.$('h1').trigger('click');
-    equal(counter1, 1);
-    equal(counter2, 1);
+    assert.equal(counter1, 1);
+    assert.equal(counter2, 1);
 
     view.undelegateEvents();
     view.$('h1').trigger('click');
-    equal(counter1, 1);
-    equal(counter2, 2);
+    assert.equal(counter1, 1);
+    assert.equal(counter2, 2);
 
     view.delegateEvents(events);
     view.$('h1').trigger('click');
-    equal(counter1, 2);
-    equal(counter2, 3);
+    assert.equal(counter1, 2);
+    assert.equal(counter2, 3);
 
-    equal(view.undelegateEvents(), view, '#undelegateEvents returns the view instance');
+    assert.equal(view.undelegateEvents(), view, '#undelegateEvents returns the view instance');
   });
 
-  test("undelegate", 1, function() {
+  QUnit.test("undelegate", function(assert) {
+    assert.expect(1);
     view = new Backbone.View({el: '#testElement'});
-    view.delegate('click', function() { ok(false); });
-    view.delegate('click', 'h1', function() { ok(false); });
+    view.delegate('click', function() { assert.ok(false); });
+    view.delegate('click', 'h1', function() { assert.ok(false); });
 
     view.undelegate('click');
 
     view.$('h1').trigger('click');
     view.$el.trigger('click');
 
-    equal(view.undelegate(), view, '#undelegate returns the view instance');
+    assert.equal(view.undelegate(), view, '#undelegate returns the view instance');
   });
 
-  test("undelegate with passed handler", 1, function() {
+  QUnit.test("undelegate with passed handler", function(assert) {
+    assert.expect(1);
     view = new Backbone.View({el: '#testElement'});
-    var listener = function() { ok(false); };
+    var listener = function() { assert.ok(false); };
     view.delegate('click', listener);
-    view.delegate('click', function() { ok(true); });
+    view.delegate('click', function() { assert.ok(true); });
     view.undelegate('click', listener);
     view.$el.trigger('click');
   });
 
-  test("undelegate with selector", 2, function() {
+  QUnit.test("undelegate with selector", function(assert) {
+    assert.expect(2);
     view = new Backbone.View({el: '#testElement'});
-    view.delegate('click', function() { ok(true); });
-    view.delegate('click', 'h1', function() { ok(false); });
+    view.delegate('click', function() { assert.ok(true); });
+    view.delegate('click', 'h1', function() { assert.ok(false); });
     view.undelegate('click', 'h1');
     view.$('h1').trigger('click');
     view.$el.trigger('click');
   });
 
-  test("undelegate with handler and selector", 2, function() {
+  QUnit.test("undelegate with handler and selector", function(assert) {
+    assert.expect(2);
     view = new Backbone.View({el: '#testElement'});
-    view.delegate('click', function() { ok(true); });
-    var handler = function(){ ok(false); };
+    view.delegate('click', function() { assert.ok(true); });
+    var handler = function(){ assert.ok(false); };
     view.delegate('click', 'h1', handler);
     view.undelegate('click', 'h1', handler);
     view.$('h1').trigger('click');
     view.$el.trigger('click');
   });
 
-  test("tagName can be provided as a string", 1, function() {
+  QUnit.test("tagName can be provided as a string", function(assert) {
+    assert.expect(1);
     var View = Backbone.View.extend({
       tagName: 'span'
     });
 
-    equal(new View().el.tagName, 'SPAN');
+    assert.equal(new View().el.tagName, 'SPAN');
   });
 
-  test("tagName can be provided as a function", 1, function() {
+  QUnit.test("tagName can be provided as a function", function(assert) {
+    assert.expect(1);
     var View = Backbone.View.extend({
       tagName: function() {
         return 'p';
       }
     });
 
-    ok(new View().$el.is('p'));
+    assert.ok(new View().$el.is('p'));
   });
 
-  test("_ensureElement with DOM node el", 1, function() {
+  QUnit.test("_ensureElement with DOM node el", function(assert) {
+    assert.expect(1);
     var View = Backbone.View.extend({
       el: document.body
     });
 
-    equal(new View().el, document.body);
+    assert.equal(new View().el, document.body);
   });
 
-  test("_ensureElement with string el", 3, function() {
+  QUnit.test("_ensureElement with string el", function(assert) {
+    assert.expect(3);
     var View = Backbone.View.extend({
       el: "body"
     });
-    strictEqual(new View().el, document.body);
+    assert.strictEqual(new View().el, document.body);
 
     View = Backbone.View.extend({
       el: "#testElement > h1"
     });
-    strictEqual(new View().el, $("#testElement > h1").get(0));
+    assert.strictEqual(new View().el, $("#testElement > h1").get(0));
 
     View = Backbone.View.extend({
       el: "#nonexistent"
     });
-    ok(!new View().el);
+    assert.ok(!new View().el);
   });
 
-  test("with className and id functions", 2, function() {
+  QUnit.test("with className and id functions", function(assert) {
+    assert.expect(2);
     var View = Backbone.View.extend({
       className: function() {
         return 'className';
@@ -244,11 +263,12 @@
       }
     });
 
-    strictEqual(new View().el.className, 'className');
-    strictEqual(new View().el.id, 'id');
+    assert.strictEqual(new View().el.className, 'className');
+    assert.strictEqual(new View().el.id, 'id');
   });
 
-  test("with attributes", 2, function() {
+  QUnit.test("with attributes", function(assert) {
+    assert.expect(2);
     var View = Backbone.View.extend({
       attributes: {
         id: 'id',
@@ -256,21 +276,41 @@
       }
     });
 
-    strictEqual(new View().el.className, 'class');
-    strictEqual(new View().el.id, 'id');
+    assert.strictEqual(new View().el.className, 'class');
+    assert.strictEqual(new View().el.id, 'id');
   });
 
-  test("with attributes as a function", 1, function() {
+  QUnit.test("with attributes as a function", function(assert) {
+    assert.expect(1);
     var View = Backbone.View.extend({
       attributes: function() {
         return {'class': 'dynamic'};
       }
     });
 
-    strictEqual(new View().el.className, 'dynamic');
+    assert.strictEqual(new View().el.className, 'dynamic');
   });
 
-  test("multiple views per element", 3, function() {
+  QUnit.test("should default to className/id properties", function(assert) {
+    assert.expect(4);
+    var View = Backbone.View.extend({
+      className: 'backboneClass',
+      id: 'backboneId',
+      attributes: {
+        'class': 'attributeClass',
+        'id': 'attributeId'
+      }
+    });
+
+    var view = new View;
+    assert.strictEqual(view.el.className, 'backboneClass');
+    assert.strictEqual(view.el.id, 'backboneId');
+    assert.strictEqual(view.$el.attr('class'), 'backboneClass');
+    assert.strictEqual(view.$el.attr('id'), 'backboneId');
+  });
+
+  QUnit.test("multiple views per element", function(assert) {
+    assert.expect(3);
     var count = 0;
     var $el = $('<p></p>');
 
@@ -285,22 +325,23 @@
 
     var view1 = new View;
     $el.trigger("click");
-    equal(1, count);
+    assert.equal(1, count);
 
     var view2 = new View;
     $el.trigger("click");
-    equal(3, count);
+    assert.equal(3, count);
 
     view1.delegateEvents();
     $el.trigger("click");
-    equal(5, count);
+    assert.equal(5, count);
   });
 
-  test("custom events", 2, function() {
+  QUnit.test("custom events", function(assert) {
+    assert.expect(2);
     var View = Backbone.View.extend({
       el: $('body'),
       events: {
-        "fake$event": function() { ok(true); }
+        "fake$event": function() { assert.ok(true); }
       }
     });
 
@@ -311,24 +352,26 @@
     $('body').trigger('fake$event');
   });
 
-  test("#1048 - setElement uses provided object.", 2, function() {
+  QUnit.test("#1048 - setElement uses provided object.", function(assert) {
+    assert.expect(2);
     var $el = $('body');
 
     var view = new Backbone.View({el: $el});
-    ok(view.$el === $el);
+    assert.ok(view.$el === $el);
 
     view.setElement($el = $($el));
-    ok(view.$el === $el);
+    assert.ok(view.$el === $el);
   });
 
-  test("#986 - Undelegate before changing element.", 1, function() {
+  QUnit.test("#986 - Undelegate before changing element.", function(assert) {
+    assert.expect(1);
     var button1 = $('<button></button>');
     var button2 = $('<button></button>');
 
     var View = Backbone.View.extend({
       events: {
         click: function(e) {
-          ok(view.el === e.target);
+          assert.ok(view.el === e.target);
         }
       }
     });
@@ -340,23 +383,25 @@
     button2.trigger('click');
   });
 
-  test("#1172 - Clone attributes object", 2, function() {
+  QUnit.test("#1172 - Clone attributes object", function(assert) {
+    assert.expect(2);
     var View = Backbone.View.extend({
       attributes: {foo: 'bar'}
     });
 
     var view1 = new View({id: 'foo'});
-    strictEqual(view1.el.id, 'foo');
+    assert.strictEqual(view1.el.id, 'foo');
 
     var view2 = new View();
-    ok(!view2.el.id);
+    assert.ok(!view2.el.id);
   });
 
-  test("views stopListening", 0, function() {
+  QUnit.test("views stopListening", function(assert) {
+    assert.expect(0);
     var View = Backbone.View.extend({
       initialize: function() {
-        this.listenTo(this.model, 'all x', function(){ ok(false); });
-        this.listenTo(this.collection, 'all x', function(){ ok(false); });
+        this.listenTo(this.model, 'all x', function(){ assert.ok(false); });
+        this.listenTo(this.collection, 'all x', function(){ assert.ok(false); });
       }
     });
 
@@ -370,7 +415,8 @@
     view.collection.trigger('x');
   });
 
-  test("Provide function for el.", 2, function() {
+  QUnit.test("Provide function for el.", function(assert) {
+    assert.expect(2);
     var View = Backbone.View.extend({
       el: function() {
         return "<p><a></a></p>";
@@ -378,11 +424,12 @@
     });
 
     var view = new View;
-    ok(view.$el.is('p'));
-    ok(view.$el.has('a'));
+    assert.ok(view.$el.is('p'));
+    assert.ok(view.$el.has('a'));
   });
 
-  test("events passed in options", 1, function() {
+  QUnit.test("events passed in options", function(assert) {
+    assert.expect(1);
     var counter = 0;
 
     var View = Backbone.View.extend({
@@ -399,32 +446,34 @@
     });
 
     view.$('h1').trigger('click').trigger('click');
-    equal(counter, 2);
+    assert.equal(counter, 2);
   });
 
-  test("remove", 2, function() {
+  QUnit.test("remove", function(assert) {
+    assert.expect(2);
     var view = new Backbone.View;
     document.body.appendChild(view.el);
 
-    view.delegate('click', function() { ok(false); });
-    view.listenTo(view, 'all x', function() { ok(false); });
+    view.delegate('click', function() { assert.ok(false); });
+    view.listenTo(view, 'all x', function() { assert.ok(false); });
 
-    equal(view.remove(), view, '#remove returns the view instance');
+    assert.equal(view.remove(), view, '#remove returns the view instance');
     view.$el.trigger('click');
     view.trigger('x');
 
     // In IE8 and below, parentNode still exists but is not document.body.
-    notEqual(view.el.parentNode, document.body);
+    assert.notEqual(view.el.parentNode, document.body);
   });
 
-  test("setElement", 3, function() {
+  QUnit.test("setElement", function(assert) {
+    assert.expect(3);
     var view = new Backbone.View({
       events: {
-        click: function() { ok(false); }
+        click: function() { assert.ok(false); }
       }
     });
     view.events = {
-      click: function() { ok(true); }
+      click: function() { assert.ok(true); }
     };
     var oldEl = view.el;
     var $oldEl = view.$el;
@@ -434,8 +483,8 @@
     $oldEl.click();
     view.$el.click();
 
-    notEqual(oldEl, view.el);
-    notEqual($oldEl, view.$el);
+    assert.notEqual(oldEl, view.el);
+    assert.notEqual($oldEl, view.$el);
   });
 
 })();