lanes 0.1.0 → 0.1.2

data/spec/helpers/lanes-helpers.coffee

@@ -1,17 +1,15 @@
-Lanes.namespace 'Testing'
+Lanes.namespace 'Test'
 
-class Lanes.Testing.View extends Lanes.Views.Base
+View       = undefined
+Model      = undefined
+Collection = undefined
+
+class Lanes.Test.DummyView extends Lanes.Views.Base
     template: "<p>hi</p"
     events: { "click #mylink": 'onClick' }
     onClick: Lanes.emptyFn
 
-Lanes.Vendor.MessageBus = {
-    subscribe:   jasmine.createSpy('subscribe')
-    unsubscribe: jasmine.createSpy('unsubscribe')
-    start: Lanes.emptyFn
-}
-    
-class Lanes.Testing.Model extends Lanes.Models.Base
+class Lanes.Test.DummyModel extends Lanes.Models.Base
     api_path: "test"
     props:
         id: 'number',
@@ -29,23 +27,49 @@ class Lanes.Testing.Model extends Lanes.Models.Base
             deps: ['something', 'fireDanger', 'active'],
             fn: -> this.something + this.active;
 
-class Lanes.Testing.Collection extends Lanes.Models.Collection
-    model: Lanes.Testing.Model
+Lanes.Test.makeModel = (props={}, args={})->
+    _.extend(Model.prototype, props)
+    Lanes.Models.Base.extend(Model)
+    Collection::model = Model
+    Lanes.Models.Collection.extend(Collection)
+    collection = new Collection
+    return collection.add(new Model(args))
+
+Lanes.Test.makeView = (props={}, args={})->
+    _.extend(View.prototype, props)
+    Lanes.Views.Base.extend(View)
+    return new View(args)
 
-syncResponse = (method,model,options)->
-    if options.success && syncReply.success
-        options.success(model, syncReply, {})
-    if options.failure && !syncReply.success
-        options.failure(model, syncReply, {})
-    _.Promise.resolve(model,options)
+syncResponse = (method, model, options)->
+    _.defer ->
+        if options.success && syncReply.success
+            options.success(syncReply, "success", {})
+        if options.failure && !syncReply.success
+            options.failure(syncReply, "failure", {})
+        _.Promise.resolve(model, options)
 
 syncReply = {}
 
+Lanes.Vendor.MessageBus = {
+    subscribe:   jasmine.createSpy('subscribe')
+    unsubscribe: jasmine.createSpy('unsubscribe')
+    start: Lanes.emptyFn
+}
+
 window.syncSucceedWith = (data)->
     syncReply.success = true
     syncReply.data = data
-    
+
 beforeEach ->
+    class TestModel
+        constructor: -> super
+    Model = TestModel
+    class TestCollection
+        constructor: -> super
+    Collection = TestCollection
+    class TestView
+        constructor: -> super
+    View = TestView
 
     syncReply = {
         success: true
@@ -53,10 +77,10 @@ beforeEach ->
         data: {}
     }
     
-    Lanes.Testing.syncSpy = jasmine.createSpy('sync').and.callFake(syncResponse)
-    Lanes.Testing.syncSpy.lastOptions = ->
+    Lanes.Test.syncSpy = jasmine.createSpy('sync').and.callFake(syncResponse)
+    Lanes.Test.syncSpy.lastOptions = ->
         this.calls.mostRecent().args[2]
-    Lanes.Models.Base::sync       = Lanes.Testing.syncSpy
-    Lanes.Models.Collection::sync = Lanes.Testing.syncSpy
+    Lanes.Models.Base::sync       = Lanes.Test.syncSpy
+    Lanes.Models.Collection::sync = Lanes.Test.syncSpy
 
 

data/spec/helpers/minitest_assertions.rb

@@ -0,0 +1,23 @@
+require 'minitest/assertions'
+
+module Minitest::Assertions
+    #
+    #  Fails unless +expected and +actual have the same items.
+    #
+    def assert_executes(cmd)
+        assert execute_cmd(cmd),
+          "Expected #{cmd} exited with status #{$?.exitstatus}"
+    end
+
+    def last_cmd_execution_output
+        @cmd_last_output
+    end
+
+    private
+
+    def execute_cmd(cmd)
+        @cmd_last_output = `#{cmd} 2>&1`
+        $?.exitstatus == 0
+    end
+
+end

data/spec/lanes/models/BaseSpec.coffee

@@ -1,31 +1,31 @@
 
-describe "Base Model Suite", ->
-    Model = undefined
-    Collection = undefined
+describe "Lanes.Models.Base", ->
+    # Model = undefined
+    # Collection = undefined
     class Color
         constructor: -> super
         props: { id: 'integer', rgb: 'string' }
     Lanes.Models.Base.extend(Color)
 
-    makeModel = (props,args={})->
-        _.extend(Model.prototype, props)
-        Lanes.Models.Base.extend(Model)
-        Collection::model = Model
-        Lanes.Models.Collection.extend(Collection)
-        collection = new Collection
-        return collection.add(new Model(args))
+    # makeModel = (props,args={})->
+    #     _.extend(Model.prototype, props)
+    #     Lanes.Models.Base.extend(Model)
+    #     Collection::model = Model
+    #     Lanes.Models.Collection.extend(Collection)
+    #     collection = new Collection
+    #     return collection.add(new Model(args))
 
-    beforeEach ->
-        class TestModel
-            constructor: -> super
-        Model = TestModel
-        class TestCollection
-            constructor: -> super
-        Collection = TestCollection
+    # beforeEach ->
+    #     class TestModel
+    #         constructor: -> super
+    #     Model = TestModel
+    #     class TestCollection
+    #         constructor: -> super
+    #     Collection = TestCollection
 
         
     it "tracks unsaved attributes", ->
-        model = makeModel({
+        model = Lanes.Test.makeModel({
             session:
                 foo: 'string'
                 bar: 'integer'
@@ -35,13 +35,13 @@ describe "Base Model Suite", ->
         expect(model.isDirty()).toBeFalse()
         model.foo = 'baz' # session prop
         expect(model.isDirty()).toBeFalse()
-        expect(model.unsavedModels()).toBeEmptyObject()
+        expect(model.unsavedAttributes()).toBeEmptyObject()
         model.set( saved: 'true' )
         expect(model.isDirty()).toBeTrue()
 
         
     it "can tell if it has attributes", ->
-        model = makeModel({
+        model = Lanes.Test.makeModel({
             session:
                 foo: 'string'
             props:
@@ -53,7 +53,7 @@ describe "Base Model Suite", ->
 
     it "provides data for saving", ->
         # model with other types of data, but should only save "props"
-        model = makeModel({
+        model = Lanes.Test.makeModel({
             associations:
                 color:{ model: Color }
             session:
@@ -74,8 +74,8 @@ describe "Base Model Suite", ->
         a=model.changeMonitor.changedAttributes()
         expect( model.dataForSave() ).toEqual( id: 10, foo: 'a value', color: { rgb: '99FFFF' } )
 
-    it "can be saved", ->
-        model = makeModel({
+    it "can be saved", (done)->
+        model = Lanes.Test.makeModel({
             props:
                 id: 'integer'
                 foo: 'string'
@@ -83,7 +83,7 @@ describe "Base Model Suite", ->
                 
         }, { foo: 'one, two, three'} )
         expect(model.isDirty()).toBeTrue()
-        expect(model.unsavedModels()).toEqual( foo: 'one, two, three' )
+        expect(model.unsavedAttributes()).toEqual( foo: 'one, two, three' )
         model.save()
         expect(model.sync).toHaveBeenCalledWith('create', model, jasmine.any(Object))
         model.id=11
@@ -92,56 +92,57 @@ describe "Base Model Suite", ->
         syncSucceedWith({
             foo: 'a new foo value'
         })
-        model.save()
-        expect(model.sync).toHaveBeenCalledWith('patch', model, jasmine.any(Object))
-        expect(model.foo).toEqual('a new foo value')
-
-    it "can be fetched",->
-        model = makeModel({
+        model.save().then ->
+            expect(model.sync).toHaveBeenCalledWith('patch', model, jasmine.any(Object))
+            expect(model.foo).toEqual('a new foo value')
+            done()
+            
+    it "can be fetched", (done)->
+        model = Lanes.Test.makeModel({
             props:
                 { id: 'integer', foo: 'string' }
         })
         syncSucceedWith({
             foo: 'foo value'
         })
-        model.fetch()
-        expect(model.sync).toHaveBeenCalledWith('read', model, jasmine.any(Object))
-        expect(model.foo).toEqual('foo value')
-        options = model.sync.lastOptions()
-        expect(options).toHaveTrue('ignoreUnsaved')
-        expect(options).toHaveNumberWithinRange('limit',1,1)
+        model.fetch().then ->
+            expect(model.sync).toHaveBeenCalledWith('read', model, jasmine.any(Object))
+            expect(model.foo).toEqual('foo value')
+            options = model.sync.lastOptions()
+            expect(options).toHaveTrue('ignoreUnsaved')
+            expect(options).toHaveNumberWithinRange('limit',1,1)
+            done()
 
     it "creates a Collection property", ->
-        model = makeModel({})
+        Model = Lanes.Test.DummyModel
         expect(Model.Collection::model).toEqual(Model)
     
-    it "loads using where", ->
-        model = makeModel({
-            props:
-                { id: 'integer', title: 'string' }
-        })
+    it "loads using where", (done)->
+        Model = Lanes.Test.DummyModel
         syncSucceedWith([
-            { id: 1, title: 'first value' }
+            { id: 1, title: 'first value'  }
             { id: 2, title: 'second value' }
         ])
-        collection = model.where(title: 'first value')
-        options = model.sync.lastOptions()
-        expect(options.query).toEqual({title:'first value'})
-        expect(collection.length).toEqual(2)
+        Model.where(title: 'first value').whenLoaded (collection)->
+            options = Model::sync.lastOptions()
+            expect(options.query).toEqual({title:'first value'})
+            expect(collection.length).toEqual(2)
+            done()
 
-    it "can be destroyed", ->
-        model = makeModel({
+    it "can be destroyed", (done)->
+        model = Lanes.Test.makeModel({
             props: { id: 'integer' }
         },{ id: 1 })
         collection = model.collection
         expect(collection.length).toEqual(1)
-        model.destroy()
-        expect(model.sync)
-            .toHaveBeenCalledWith('delete', model, jasmine.any(Object))
-        expect(collection.length).toEqual(0)
+        model.destroy().then ->
+            expect(model.sync)
+                .toHaveBeenCalledWith('delete', model, jasmine.any(Object))
+            expect(collection.length).toEqual(0)
+            done()
 
     it "sets associations", ->
-        model = makeModel({
+        model = Lanes.Test.makeModel({
             associations:
                 color:{ model: Color }
             props: { id: 'integer', foo: 'string' }
@@ -149,11 +150,11 @@ describe "Base Model Suite", ->
         expect(model.color).toBeObject()
         model.set(color: { rgb: '99FFFF' })
         expect(model.color.rgb).toEqual('99FFFF')
-        model.setFromResponse(color:{ rgb: 'FFA500' })
+        model.setFromServer(color:{ rgb: 'FFA500' })
         expect(model.color.rgb).toEqual('FFA500')
 
     it "can fetch associations", ->
-        model = makeModel({
+        model = Lanes.Test.makeModel({
             associations:
                 color:{ model: Color }
             props: { id: 'integer', foo: 'string' }

data/spec/lanes/models/CollectionSpec.coffee

@@ -0,0 +1,14 @@
+describe "Lanes.Models.Collection", ->
+
+        
+    it "it triggers promise on loading", (done)->
+        Model = Lanes.Test.DummyModel
+        syncSucceedWith([
+            { id: 1, title: 'first value'  }
+            { id: 2, title: 'second value' }
+        ])
+        collection = Model.where( name: 'foo' )
+        collection.whenLoaded ->
+            expect( collection.isLoaded() ).toBeTrue()
+            done()
+

data/spec/lanes/models/PubSubSpec.coffee

@@ -1,9 +1,9 @@
 
-describe "PubSub Suite", ->
+describe "Lanes.Model.PubSub", ->
         
     it "checks in/out a model when it binds to a view", ->
-        view  = new Lanes.Testing.View
-        model = new Lanes.Testing.Model(id:1)
+        view  = new Lanes.Test.DummyView
+        model = new Lanes.Test.DummyModel(id:1)
         spyOn(Lanes.Models.PubSub,'add').and.callThrough()
         spyOn(Lanes.Models.PubSub,'remove')
         view.model = model
@@ -14,8 +14,8 @@ describe "PubSub Suite", ->
         expect(Lanes.Models.PubSub.remove).toHaveBeenCalledWith(model)
 
     it "can retrieve a model after checkin", ->
-        model = new Lanes.Testing.Model(id: 11, name:'bar')
+        model = new Lanes.Test.DummyModel(id: 11, name:'bar')
         Lanes.Models.PubSub.add(model)
-        checkin = Lanes.Models.PubSub.instanceFor(Lanes.Testing.Model, 11)
+        checkin = Lanes.Models.PubSub.instanceFor(Lanes.Test.DummyModel, 11)
         expect(checkin).toEqual(model)
         

data/spec/lanes/views/BaseSpec.coffee

@@ -1,39 +1,40 @@
-
-
-describe "BaseView Suite", ->
-    View = undefined
-    makeView = (props,args={})->
-        _.extend(View.prototype, props)
-        Lanes.Views.Base.extend(View)
-        return new View(args)
-
-    beforeEach ->
-        class TestView
-            constructor: -> super
-        View = TestView
+describe "Lanes.Views.Base", ->
 
     it "fires el change on render", ->
         spy = jasmine.createSpy()
-        view = makeView({
+        view = Lanes.Test.makeView({
             template: "<p>hi</p"
         })
         view.on("change:el", spy)
         view.render()
         expect(spy).toHaveBeenCalled()
 
+    it "renders a template file", ->
+        spy = jasmine.createSpy('view-test').and.callFake ->
+            "<p>a test</p>"
+        Lanes.Templates['view-test'] = spy
+
+        view = Lanes.Test.makeView({
+            templatePrefix: ''
+            templateName: "view-test"
+        }, { model: new Lanes.Test.DummyModel({name: 'foo'}) } )
+        view.render()
+        expect(spy).toHaveBeenCalledWith( model: { name: 'foo' }, collection: undefined )
+        expect(view.el.innerHTML).toEqual("a test")
+
     it "renders a template string", ->
-        view = makeView({
-            template: "<p>hi</p"
+        view = Lanes.Test.makeView({
+            template: "<p>hello test</p"
         })
-        expect(view.template).toEqual "<p>hi</p"
+        expect(view.template).toEqual "<p>hello test</p"
         view.render()
         expect(view.el.tagName).toEqual("P")
-        expect(view.el.innerHTML).toEqual("hi")
+        expect(view.el.innerHTML).toEqual("hello test")
 
     it "listens to events", ->
         spy = jasmine.createSpy('onClick')
         el = _.el( 'div',{id: 'testdiv'} )
-        view = makeView({
+        view = Lanes.Test.makeView({
             events: { "click #mylink": 'onClick' }
             template: "<div>text,text,text<a id='mylink'>click me</a>mor text</div>"
             onClick: spy
@@ -44,8 +45,8 @@ describe "BaseView Suite", ->
         expect(spy).toHaveBeenCalledWith(jasmine.any(Object),22)
 
     it "updates from bindings", ->
-        model = new Lanes.Testing.Model({ name: "Bob" })
-        view = makeView({
+        model = new Lanes.Test.DummyModel({ name: "Bob" })
+        view = Lanes.Test.makeView({
             bindings: {
                 "model.name": { hook: 'link' }
                 "model.url":  { type:'attribute', name: 'href', hook: 'link' }
@@ -65,8 +66,8 @@ describe "BaseView Suite", ->
             constructor: -> super
             session: { answer: 'string' }
         Lanes.Views.Base.extend(LowerView)
-        model = new Lanes.Testing.Model
-        view = makeView({
+        model = new Lanes.Test.DummyModel
+        view = Lanes.Test.makeView({
             subviews:
                 lower:
                     hook: 'lower'
@@ -88,8 +89,8 @@ describe "BaseView Suite", ->
             constructor: -> super
             bindings: { "model.name": { type: "text" } }
         Lanes.Views.Base.extend(LowerView)
-        collection = new Lanes.Testing.Collection
-        view = makeView({
+        collection = new Lanes.Test.DummyModel.Collection
+        view = Lanes.Test.makeView({
             subviews:
                 lower:
                     hook: 'lower'
@@ -105,7 +106,7 @@ describe "BaseView Suite", ->
 
     it "caches elements in ui", ->
         spy = jasmine.createSpy('onClick')
-        view = makeView({
+        view = Lanes.Test.makeView({
             ui:
                 link: '#linky'
             events:
@@ -121,8 +122,8 @@ describe "BaseView Suite", ->
     it "invokes model events", ->
         nameSpy = jasmine.createSpy()
         urlSpy  = jasmine.createSpy()
-        model   = new Lanes.Testing.Model
-        view = makeView({
+        model   = new Lanes.Test.DummyModel
+        view = Lanes.Test.makeView({
             modelEvents:
                 'change:name': nameSpy
                 'change:url' : 'onURLChange'
@@ -135,12 +136,12 @@ describe "BaseView Suite", ->
 
     it "invokes collection events", ->
         eventSpy = jasmine.createSpy('event')
-        view = makeView({
+        view = Lanes.Test.makeView({
             collectionEvents:
                 all: 'onEvent'
             onEvent: eventSpy
-            initialize: -> this.collection = new Lanes.Testing.Collection
+            initialize: -> this.collection = new Lanes.Test.DummyModel.Collection
         })
         expect(eventSpy).not.toHaveBeenCalled()
-        view.collection.add(new Lanes.Testing.Model)
+        view.collection.add(new Lanes.Test.DummyModel)
         expect(eventSpy).toHaveBeenCalled()

data/spec/lanes/views/FormBindingsSpec.coffee

@@ -0,0 +1,32 @@
+describe "Lanes.Views.FormBindings", ->
+
+    it "updates inputs", ->
+        model = new Lanes.Test.DummyModel({name: 'start'})
+        view  = Lanes.Test.makeView({
+            template: '<div><h1>foo</h1><input type="text" name="name"></div>'
+        }, { formBindings: true, model: model })
+        view.render()
+        input = view.$('input')
+        expect(input.val()).toEqual('start')
+        input.val('test')
+        input.trigger('change')
+        expect(model.name).toEqual('test')
+
+    it "updates radio fields", ->
+        model = new Lanes.Test.DummyModel({name: 'start'})
+        view  = Lanes.Test.makeView({
+            template: """
+                <div>
+                    <input id="a" type="radio" name="name" value="one">One
+                    <input id="b" type="radio" name="name" value="two">Two
+                    <input id="c" type="radio" name="name" value="three">Three
+                </div>
+                """
+        }, { formBindings: true, model: model })
+        view.render()
+            .$("#b")
+            .attr('checked', true)
+            .trigger('change')
+        expect(model.name).toEqual('two')
+        model.name="three"
+        expect(view.$("input:checked").attr("id")).toEqual('c')