alpha-simprini-engine 0.0.1

data/app/assets/javascripts/test.coffee

@@ -0,0 +1,4 @@
+#= require alpha_simprini
+#= require qunit
+#= require_tree ./test
+  

data/app/assets/javascripts/test/alpha_simprini/coffee_kup/binding.coffee

@@ -0,0 +1,118 @@
+@module "AS.CK.Binding"
+render = (locals, template) ->
+  locals.hardcode = AS.TemplateHelpers
+  jQuery CoffeeKup.render template, locals
+
+add_remove_do = (elements..., fn) ->
+  element.appendTo(document.body) for element in elements
+  fn.call()
+  element.remove() for element in elements
+
+test "bind", ->
+  model = new AS.Model
+  model.set property:"value"
+  
+  bound = render model:model, ->
+    div -> bind @model, "property"
+    
+  bound_get = render model:model, ->
+    div -> bind @model, "property", -> "#{this}-GOT"
+    
+  add_remove_do bound, bound_get, =>
+    equal bound.find("span").text(), "value", "binds initial value to a span"
+    equal bound_get.find("span").text(), "value-GOT", "processes value through getter"
+    model.set property:"new"
+    equal bound.find("span").text(), "new", "updates value in place when bound property changes"
+    equal bound_get.find("span").text(), "new-GOT", "processes updated value in place through getter"
+    model.destroy()
+    ok bound.find("span").get(0) is undefined, "remove binding from dom when model is destroyed"
+    ok bound_get.find("span").get(0) is undefined, "removes binding from dom when model is destroyed"
+
+test "bound_input", ->
+  model = new AS.Model
+  model.set property:"value"
+  
+  bound = render model:model, ->
+    div -> bound_input @model, "property"
+  
+  add_remove_do bound, =>
+    input = bound.find("input")
+    equal input.val(), "value", "binds initial value to input"
+    
+    model.set property:"new"
+    equal input.val(), "new", "updates input when model changes"
+    
+    input.val("keyup")
+    input.trigger("keyup")
+    equal model.get("property"), "keyup", "updates model on keyup of input"
+    
+    input.val("change")
+    input.trigger("change")
+    equal model.get("property"), "change", "updates model on change of input"
+
+test "bound_select", ->
+  model = new AS.Model
+  options = new AS.Collection
+  option = new AS.Model value:"option1"
+  added_option = new AS.Model value:"option2"
+  options.add option
+  
+  bound = render model:model, options:options, ->
+    div -> bound_select @model, "property", @options, "value"
+  
+  add_remove_do bound, =>
+    select = bound.find("select")
+    equal select.find("[value=#{option.cid}]option").text(), "option1", "renders given options from collection"
+    
+    options.add added_option
+    added_option_node = select.find("[value=#{added_option.cid}]option")
+    equal added_option_node.text(), "option2", "adds option to select when item added to collection"
+    
+    select.val(added_option.cid)
+    select.trigger("change")
+    equal model.get("property"), added_option, "sets value on model when property chosen"
+    
+    model.set property:option
+    equal select.val(), option.cid, "changes value of select when property set on model"
+    
+    option.set value:"changed option"
+    equal select.find("[value=#{option.cid}]option").text(), "changed option", "changes select text when option model value changes"
+    
+    options.remove option
+    equal select.find("[value=#{option.cid}]option").get(0), undefined, "removes option from select when item added to collection"
+    equal model.get("property"), added_option, "reselects another option when option removed"
+  
+test "bound_select with blank", ->
+  model = new AS.Model
+  options = new AS.Collection
+  option = new AS.Model value:"option1"
+  options.add option
+
+  with_blank = render model:model, options:options, ->
+    div -> bound_select @model, "property", @options, "value", blank:"blank"
+
+  add_remove_do with_blank, =>
+    select = with_blank.find("select")
+    equal select.find("option:first").text(), "blank", "includes blank option"
+    equal select.val(), "blank", "starts out without selection selected"
+    equal model.get("property"), undefined, "leaves model property clear"
+  
+test "bound_select with preselect", ->
+  model = new AS.Model
+  options = new AS.Collection
+  option = new AS.Model value:"option1"
+  options.add option
+  model.set property:option
+  
+  with_preselect = render model:model, options:options, ->
+    div -> bound_select @model, "property", @options, "value", blank:"blank"
+  
+  add_remove_do with_preselect, =>
+    select = with_preselect.find("select")
+    equal select.find("option:first").text(), "blank", "includes blank option"
+    equal select.val(), option.cid, "starts out with selection selected"
+    
+    
+    
+  
+  

data/app/assets/javascripts/test/alpha_simprini/coffee_kup/helpers.coffee

@@ -0,0 +1,10 @@
+module "AS.CK.Helpers"
+test "autoId", ->
+  id = AS.CK.Helpers.autoId()
+  ok id.string != "", "selector is not blank"
+  ok id.string != undefined, "selector is defined"
+  equal id.query().selector, "##{id.string}", "gives id as a string and a selector"
+
+test "shy", ->
+  shy = AS.CK.Helpers.shy("ThisShallShy")
+  equal shy, "This­Shall­Shy", "adds shy markers to titlecase text"

data/app/assets/javascripts/test/alpha_simprini/coffee_kup/tags.coffee

@@ -0,0 +1,18 @@
+@module "AS.CK.Tags"
+render = (locals, template) ->
+  locals.hardcode = AS.TemplateHelpers
+  jQuery CoffeeKup.render template, locals
+
+test "model tag", ->
+  model = new AS.Model
+  defaults = render model:model, -> model_tag @model
+  tagnamed = render model:model, -> model_tag @model, tagname: "ul"
+  content = render model:model, -> 
+    model_tag @model, -> p "content"
+  optioned = render model:model, ->
+    model_tag @model, key:"value"
+  
+  ok defaults.is("div##{model.cid}"), "renders div with model cid by default"
+  ok tagnamed.is("ul##{model.cid}"), "renders tagname when given as an option"
+  equal content.find("p").text(), "content", "renders nested content when given as a function"
+  ok optioned.is("[key=value]"), "renders other options passed"

data/app/assets/javascripts/test/alpha_simprini/collection.coffee

@@ -0,0 +1,7 @@
+module "AS.Collection"
+test "adding a model to a collection with @inverse and @source property specified", ->
+  collection = new (AS.Collection.extend(inverse: "inverse", source: "source"))
+  model = new AS.Model
+  
+  collection.add model
+  equal model.get('inverse'), "source", "sets collection to property on model"

data/app/assets/javascripts/test/alpha_simprini/event.coffee

@@ -0,0 +1,43 @@
+for klass in [AS.Model, AS.Collection, AS.View]
+  module "#{klass.name} Event Extensions"
+  class of_prototype
+  of_prototype.prototype = klass.prototype
+  
+  test "events bound are triggered by event with and without namespace", ->
+    proof = false
+    object = new of_prototype
+    object.bind "event.namespace", -> proof = true
+    object.trigger "event"
+    ok proof, "triggers without namespace"
+  
+    proof = false
+    object.trigger "event.namespace"
+    ok proof, "triggers with namespace"
+
+  test "events bound without namespace are not triggered by namespace", ->
+    proof = false
+    all_proof = false
+    object = new of_prototype
+    object.bind "all", -> all_proof = true
+    object.bind "event", -> proof = true
+    object.trigger "event.namespace"
+    ok !proof, "doesn't trigger with namespace"
+    ok all_proof, "triggers all event"
+
+  test "unbind with namespace", ->
+    proof = false
+    other_proof = false
+    none_proof = false
+    object = new of_prototype
+    object.bind "event.namespace", -> proof = true
+    object.bind "event.other_namespace", -> other_proof = true
+    object.bind "event", -> none_proof = true
+  
+    object.unbind "event.namespace"
+  
+    object.trigger "event"
+  
+    ok !proof, "clears binding for namespace"
+    ok other_proof, "doesn't clear binding for other namespace"
+    ok none_proof, "doesn't clear binding for no namespace"
+

data/app/assets/javascripts/test/alpha_simprini/model.coffee

@@ -0,0 +1,63 @@
+module "AS.Model"
+test "All", ->
+  model = new AS.Model
+  equal AS.All.getByCid(model.cid), model, "All models are automatically addded to the All collection"
+  
+test "has_many", ->
+  class AS.HasManyModel extends AS.Model
+    @has_many 'things', model: -> "AS.HadModel"
+  class AS.HadModel extends AS.Model
+  
+  deepEqual AS.HasManyModel.associations, ["things"], "stores the association in the association list"
+  ok AS.HasManyModel.has_manys.things, "stores a configuration for the association"
+
+  equal AS.HasManyModel.has_manys.things.model, undefined, "association collection configuration is lazy to allow associated class to load"  
+  model = new AS.HasManyModel
+  equal AS.HasManyModel.has_manys.things.model, AS.HadModel, "configures the collection class properly when needed"
+  
+  equal model.get("things").model, AS.HadModel, "association collection is auto-created"
+  
+  model.get("things").add {}
+  
+  equal model.get("things").at(0).constructor, AS.HadModel, "items added to the association are properly instantiated"
+  
+  model2 = new AS.HasManyModel
+    things: [{}]
+    
+  equal model2.get("things").at(0).constructor, AS.HadModel, "items passed to constructor for the association are properly instantiated"
+
+test "belongs to", ->
+  class AS.Belonging extends AS.Model
+    @belongs_to "parent"
+  class AS.Owner extends AS.Model
+    
+  deepEqual AS.Belonging.associations, ["parent"], "stores the association on the class"
+  
+  ok AS.Belonging.belongs_to.parent, "stores a configuration object for the association on the class"
+  
+  owner = new AS.Owner id:"OWNERID"
+  model = new AS.Belonging
+  
+  model.set parent:owner
+  
+  equal model.get("parent"), owner, "correctly sets the owner"
+  
+  model = new AS.Belonging
+  
+  model.set parent:owner.get("id")
+  equal model.get("parent"), owner, "correctly sets the from a string id"
+  
+  proof = false
+  model.bind "change:parent", -> proof = true
+  owner.set some:"value"
+  
+  ok proof, "association changes trigger on the child"
+
+  proof = false  
+  new_owner = new AS.Owner
+  model.set parent: new_owner
+  new_owner.set some:"other value"
+  
+  ok proof, "changes trigger when associated model is changed"
+  
+  

data/app/assets/javascripts/test/alpha_simprini/view.coffee

@@ -0,0 +1,72 @@
+module "AS.View"
+test "::klass_string()", ->
+  equal new AS.View().klass_string(), "ASView", "basic klass_string is ASView"
+  
+  class SomeView extends AS.View
+  
+  equal new SomeView().klass_string(), "ASView.SomeView", "subclasses include parent class string"
+    
+test "::element_string()", ->
+  equal new AS.View().element_string(), "div.ASView", "defaults to a div + klass_string"
+  equal new AS.View(tagName:"tagname").element_string(), "tagname.ASView", "allows setting of a tag"
+  
+  model = {cid: "cid"}
+  
+  equal new AS.View(model:model).element_string(), "div.ASView#cid.Object", "uses the cid/class of an associated model as the dom id/class"
+
+test "::build_element()", ->
+  ok new AS.View().build_element().is(new AS.View().element_string()), "uses jQuery.satisfy to build the element"
+  model = {cid: "cid"}
+  ok new AS.View(model:model).build_element().is(new AS.View(model:model).element_string()), "with more complex element"
+
+test "element is jquery wrapped", ->
+  equal new AS.View().el.constructor, jQuery
+
+test "configuration", ->
+  view = new AS.View option:"OPTION"
+  equal view.option, "OPTION", "allow setting of arbitrary options from constructor"
+
+test "event delegation", ->
+  click_proof = false
+  member_proof = false
+  button_proof = false
+  guard_pass_proof = false
+  guard_fail_proof = false
+  
+  class BoundView extends AS.View
+    constructor: -> 
+      @member = new AS.Model
+      super
+      @el.append @button = jQuery.satisfy("button")
+      @render()
+    
+    events:
+      "click": "click_handler"
+      "click button": "button_handler"
+      "event @member": "member_handler"
+      "pass{pass:true} @member": "guard_pass_handler"
+      "fail{pass:false} @member": "guard_fail_handler"
+    
+    click_handler: -> click_proof = true
+    member_handler: -> member_proof = true
+    button_handler: -> button_proof = true
+    guard_fail_handler: -> guard_fail_proof = true
+    guard_pass_handler: -> guard_pass_proof = true
+    
+    render: -> @el.appendTo(document.body)
+    
+  view = new BoundView
+  
+  view.el.click()
+  view.member.trigger("event")
+  view.button.click()
+  view.member.trigger("pass", pass: true)
+  view.member.trigger("fail", pass: true)
+  
+  ok click_proof, "binds simple dom events to view element"
+  ok member_proof, "binds to events of member objects"
+  ok button_proof, "binds to events of elements inside view"
+  ok guard_pass_proof, "correct values get past the guard"
+  ok !guard_fail_proof, "incorrect values blocked by the guard"
+  
+  view.el.remove()

data/app/assets/javascripts/test/alpha_simprini/views/canvas.coffee

@@ -0,0 +1,8 @@
+module "AS.Views.Stage"
+test "is a Panel", -> 
+  ok (new AS.Views.Stage).el.is(".Panel")
+test "Comes with a canvas inside it", ->
+  view = new AS.Views.Stage
+  ok view.el.find(".Canvas").is(".ASView")
+test "allows setting any canvas", ->
+  equal (new AS.Views.Stage canvas:"canvas").canvas, "canvas"

data/app/assets/javascripts/test/alpha_simprini/views/horizontal_split.coffee

@@ -0,0 +1,13 @@
+module "AS.Views.HorizontalSplit"
+test "contains left, right and splitter elemens", ->
+  view = new AS.Views.HorizontalSplit()
+  
+  equal view.el.find(".Panel").length, 2, "contains two panels"
+  ok view.el.find(":nth-child(2)").is(".Splitter"), "with a splitter in the middle"
+
+test "allows configurable left, right and splitter elements", ->
+  view = new AS.Views.HorizontalSplit
+    left: 'left', right: 'right', splitter: 'splitter'
+  
+  deepEqual [view.left, view.right, view.splitter], 'left right splitter'.split(" "), "lets you set them"
+

data/app/assets/javascripts/test/alpha_simprini/views/vertical_split.coffee

@@ -0,0 +1,13 @@
+module "AS.Views.VerticalSplit"
+test "contains top, bottom and splitter elemens", ->
+  view = new AS.Views.VerticalSplit()
+  
+  equal view.el.find(".Panel").length, 2, "contains two panels"
+  ok view.el.find(":nth-child(2)").is(".Splitter"), "with a splitter in the middle"
+
+test "allows configurable top, bottom and splitter elements", ->
+  view = new AS.Views.VerticalSplit
+    top: 'top', bottom: 'bottom', splitter: 'splitter'
+  
+  deepEqual [view.top, view.bottom, view.splitter], 'top bottom splitter'.split(" "), "lets you set them"
+

data/app/assets/javascripts/test/backbone/collection.js

@@ -0,0 +1,345 @@
+$(document).ready(function() {
+
+  module("Backbone.Collection");
+
+  window.lastRequest = null;
+
+  Backbone.sync = function() {
+    lastRequest = _.toArray(arguments);
+  };
+
+  var a         = new Backbone.Model({id: 3, label: 'a'});
+  var b         = new Backbone.Model({id: 2, label: 'b'});
+  var c         = new Backbone.Model({id: 1, label: 'c'});
+  var d         = new Backbone.Model({id: 0, label: 'd'});
+  var e         = null;
+  var col       = new Backbone.Collection([a,b,c,d]);
+  var otherCol  = new Backbone.Collection();
+
+  test("Collection: new and sort", function() {
+    equals(col.first(), a, "a should be first");
+    equals(col.last(), d, "d should be last");
+    col.comparator = function(model) { return model.id; };
+    col.sort();
+    equals(col.first(), d, "d should be first");
+    equals(col.last(), a, "a should be last");
+    equals(col.length, 4);
+  });
+
+  test("Collection: get, getByCid", function() {
+    equals(col.get(0), d);
+    equals(col.get(2), b);
+    equals(col.getByCid(col.first().cid), col.first());
+  });
+
+  test("Collection: get with non-default ids", function() {
+    var col = new Backbone.Collection();
+    var MongoModel = Backbone.Model.extend({
+      idAttribute: '_id'
+    });
+    var model = new MongoModel({_id: 100});
+    col.add(model);
+    equals(col.get(100), model);
+    model.set({_id: 101});
+    equals(col.get(101), model);
+  });
+
+  test("Collection: update index when id changes", function() {
+    var col = new Backbone.Collection();
+    col.add([
+      {id : 0, name : 'one'},
+      {id : 1, name : 'two'}
+    ]);
+    var one = col.get(0);
+    equals(one.get('name'), 'one');
+    one.set({id : 101});
+    equals(col.get(0), null);
+    equals(col.get(101).get('name'), 'one');
+  });
+
+  test("Collection: at", function() {
+    equals(col.at(2), b);
+  });
+
+  test("Collection: pluck", function() {
+    equals(col.pluck('label').join(' '), 'd c b a');
+  });
+
+  test("Collection: add", function() {
+    var added = opts = secondAdded = null;
+    e = new Backbone.Model({id: 10, label : 'e'});
+    otherCol.add(e);
+    otherCol.bind('add', function() {
+      secondAdded = true;
+    });
+    col.bind('add', function(model, collection, options){
+      added = model.get('label');
+      opts = options;
+    });
+    col.add(e, {amazing: true});
+    equals(added, 'e');
+    equals(col.length, 5);
+    equals(col.last(), e);
+    equals(otherCol.length, 1);
+    equals(secondAdded, null);
+    ok(opts.amazing);
+
+    var f = new Backbone.Model({id: 20, label : 'f'});
+    var g = new Backbone.Model({id: 21, label : 'g'});
+    var h = new Backbone.Model({id: 22, label : 'h'});
+    var atCol = new Backbone.Collection([f, g, h]);
+    equals(atCol.length, 3);
+    atCol.add(e, {at: 1});
+    equals(atCol.length, 4);
+    equals(atCol.at(1), e);
+    equals(atCol.last(), h);
+  });
+
+  test("Collection: add model to collection twice", function() {
+    try {
+      // no id, same cid
+      var a2 = new Backbone.Model({label: a.label});
+      a2.cid = a.cid;
+      col.add(a2);
+      ok(false, "duplicate; expected add to fail");
+    } catch (e) {
+      equals(e.message, "Can't add the same model to a set twice,3");
+    }
+  });
+
+  test("Collection: add model to multiple collections", function() {
+    var counter = 0;
+    var e = new Backbone.Model({id: 10, label : 'e'});
+    e.bind('add', function(model, collection) {
+      counter++;
+      equals(e, model);
+      if (counter > 1) {
+        equals(collection, colF);
+      } else {
+        equals(collection, colE);
+      }
+    });
+    var colE = new Backbone.Collection([]);
+    colE.bind('add', function(model, collection) {
+      equals(e, model);
+      equals(colE, collection);
+    });
+    var colF = new Backbone.Collection([]);
+    colF.bind('add', function(model, collection) {
+      equals(e, model);
+      equals(colF, collection);
+    });
+    colE.add(e);
+    equals(e.collection, colE);
+    colF.add(e);
+    equals(e.collection, colE);
+  });
+
+  test("Collection: remove", function() {
+    var removed = otherRemoved = null;
+    col.bind('remove', function(model){ removed = model.get('label'); });
+    otherCol.bind('remove', function(){ otherRemoved = true; });
+    col.remove(e);
+    equals(removed, 'e');
+    equals(col.length, 4);
+    equals(col.first(), d);
+    equals(otherRemoved, null);
+  });
+
+  test("Collection: events are unbound on remove", function() {
+    var counter = 0;
+    var dj = new Backbone.Model();
+    var emcees = new Backbone.Collection([dj]);
+    emcees.bind('change', function(){ counter++; });
+    dj.set({name : 'Kool'});
+    equals(counter, 1);
+    emcees.reset([]);
+    equals(dj.collection, undefined);
+    dj.set({name : 'Shadow'});
+    equals(counter, 1);
+  });
+
+  test("Collection: remove in multiple collections", function() {
+    var modelData = {
+      id : 5,
+      title : 'Othello'
+    };
+    var passed = false;
+    var e = new Backbone.Model(modelData);
+    var f = new Backbone.Model(modelData);
+    f.bind('remove', function() {
+      passed = true;
+    });
+    var colE = new Backbone.Collection([e]);
+    var colF = new Backbone.Collection([f]);
+    ok(e != f);
+    ok(colE.length == 1);
+    ok(colF.length == 1);
+    colE.remove(e);
+    equals(passed, false);
+    ok(colE.length == 0);
+    colF.remove(e);
+    ok(colF.length == 0);
+    equals(passed, true);
+  });
+
+  test("Collection: remove same model in multiple collection", function() {
+    var counter = 0;
+    var e = new Backbone.Model({id: 5, title: 'Othello'});
+    e.bind('remove', function(model, collection) {
+      counter++;
+      equals(e, model);
+      if (counter > 1) {
+        equals(collection, colE);
+      } else {
+        equals(collection, colF);
+      }
+    });
+    var colE = new Backbone.Collection([e]);
+    colE.bind('remove', function(model, collection) {
+      equals(e, model);
+      equals(colE, collection);
+    });
+    var colF = new Backbone.Collection([e]);
+    colF.bind('remove', function(model, collection) {
+      equals(e, model);
+      equals(colF, collection);
+    });
+    equals(colE, e.collection);
+    colF.remove(e);
+    ok(colF.length == 0);
+    ok(colE.length == 1);
+    equals(counter, 1);
+    equals(colE, e.collection);
+    colE.remove(e);
+    equals(null, e.collection);
+    ok(colE.length == 0);
+    equals(counter, 2);
+  });
+
+  test("Collection: model destroy removes from all collections", function() {
+    var e = new Backbone.Model({id: 5, title: 'Othello'});
+    e.sync = function(method, model, options) { options.success({}); };
+    var colE = new Backbone.Collection([e]);
+    var colF = new Backbone.Collection([e]);
+    e.destroy();
+    ok(colE.length == 0);
+    ok(colF.length == 0);
+    equals(null, e.collection);
+  });
+
+  test("Colllection: non-persisted model destroy removes from all collections", function() {
+    var e = new Backbone.Model({title: 'Othello'});
+    e.sync = function(method, model, options) { throw "should not be called"; };
+    var colE = new Backbone.Collection([e]);
+    var colF = new Backbone.Collection([e]);
+    e.destroy();
+    ok(colE.length == 0);
+    ok(colF.length == 0);
+    equals(null, e.collection);
+  });
+
+  test("Collection: fetch", function() {
+    col.fetch();
+    equals(lastRequest[0], 'read');
+    equals(lastRequest[1], col);
+  });
+
+  test("Collection: create", function() {
+    var model = col.create({label: 'f'});
+    equals(lastRequest[0], 'create');
+    equals(lastRequest[1], model);
+    equals(model.get('label'), 'f');
+    equals(model.collection, col);
+  });
+
+  test("Collection: create enforces validation", function() {
+    var ValidatingModel = Backbone.Model.extend({
+      validate: function(attrs) {
+        return "fail";
+      }
+    });
+    var ValidatingCollection = Backbone.Collection.extend({
+      model: ValidatingModel
+    });
+    var col = new ValidatingCollection();
+    equals(col.create({"foo":"bar"}),false);
+  });
+
+  test("Collection: a failing create runs the error callback", function() {
+    var ValidatingModel = Backbone.Model.extend({
+      validate: function(attrs) {
+        return "fail";
+      }
+    });
+    var ValidatingCollection = Backbone.Collection.extend({
+      model: ValidatingModel
+    });
+    var flag = false;
+    var callback = function(model, error) { flag = true; };
+    var col = new ValidatingCollection();
+    col.create({"foo":"bar"}, { error: callback });
+    equals(flag, true);
+  });
+
+  test("collection: initialize", function() {
+    var Collection = Backbone.Collection.extend({
+      initialize: function() {
+        this.one = 1;
+      }
+    });
+    var coll = new Collection;
+    equals(coll.one, 1);
+  });
+
+  test("Collection: toJSON", function() {
+    equals(JSON.stringify(col), '[{"id":0,"label":"d"},{"id":1,"label":"c"},{"id":2,"label":"b"},{"id":3,"label":"a"}]');
+  });
+
+  test("Collection: Underscore methods", function() {
+    equals(col.map(function(model){ return model.get('label'); }).join(' '), 'd c b a');
+    equals(col.any(function(model){ return model.id === 100; }), false);
+    equals(col.any(function(model){ return model.id === 0; }), true);
+    equals(col.indexOf(b), 2);
+    equals(col.size(), 4);
+    equals(col.rest().length, 3);
+    ok(!_.include(col.rest()), a);
+    ok(!_.include(col.rest()), d);
+    ok(!col.isEmpty());
+    ok(!_.include(col.without(d)), d);
+    equals(col.max(function(model){ return model.id; }).id, 3);
+    equals(col.min(function(model){ return model.id; }).id, 0);
+    same(col.chain()
+            .filter(function(o){ return o.id % 2 === 0; })
+            .map(function(o){ return o.id * 2; })
+            .value(),
+         [0, 4]);
+  });
+
+  test("Collection: reset", function() {
+    var resetCount = 0;
+    var models = col.models;
+    col.bind('reset', function() { resetCount += 1; });
+    col.reset([]);
+    equals(resetCount, 1);
+    equals(col.length, 0);
+    equals(col.last(), null);
+    col.reset(models);
+    equals(resetCount, 2);
+    equals(col.length, 4);
+    equals(col.last(), a);
+    col.reset(_.map(models, function(m){ return m.attributes; }));
+    equals(resetCount, 3);
+    equals(col.length, 4);
+    ok(col.last() !== a);
+    ok(_.isEqual(col.last().attributes, a.attributes));
+  });
+
+  test("Collection: trigger custom events on models", function() {
+    var fired = null;
+    a.bind("custom", function() { fired = true; });
+    a.trigger("custom");
+    equals(fired, true);
+  });
+
+});