lanes 0.1.9.5 → 0.3.0

data/spec/lanes/components/select-field/SelectFieldSpec.coffee

@@ -0,0 +1,99 @@
+#= require lanes/components/select-field
+
+Brand = Lanes.Test.defineModel(
+    props: {id: 'integer', code: 'string', name: 'string'}
+)
+
+BRAND_DATA = {total:3, success:true, message:"Retrieve succeeded", data:[
+    {id: 1, code: "GM",    name: "General Motors"}
+    {id: 2, code: "FORD",  name: "Ford Motor Co."}
+    {id: 3, code: "DODGE", name: "Chrysler/Dodge"}
+]}
+
+Car = Lanes.Test.defineModel(
+    props: {id: 'integer', code: 'string', brand_id: 'integer'}
+    session:
+        carTypes: 'array'
+
+    associations:
+        brand: {model: Brand}
+)
+
+describe "Lanes.Components.SelectField", ->
+    beforeEach (done) ->
+        @car = new Car
+        LT.syncRespondWith(BRAND_DATA)
+        @brands = new Brand.Collection
+        @brands.ensureLoaded().then(done)
+
+    it "renders read only", (done) ->
+        sf = LT.renderComponent(LC.SelectField,
+             props:{model: @car, name: 'brand', labelField: 'name'})
+        expect(_.dom(sf).qs('.value').text).toBe('')
+        @car.set(brand: @brands.at(0))
+        _.defer ->
+            expect(_.dom(sf).qs('.value').text).toBe('General Motors')
+            done()
+
+    it "renders as edit", ->
+        @car.set(brand: @brands.at(1))
+        sf = LT.renderComponent(LC.SelectField, props:{
+             model: @car, name: 'brand', labelField: 'name',
+             editOnly: true, collection: @brands })
+        expect(_.dom(sf).qs('input[type=text]').value).toEqual('Ford Motor Co.')
+
+    it 'uses a custom data source', ->
+        sf = LT.renderComponent(LC.SelectField, props:{
+            model: @car, name: 'brand', editOnly: true
+            getSelection: -> { label: 'Toyota', id: 4 }
+        })
+        expect(_.dom(sf).qs('input[type=text]').value).toEqual('Toyota')
+
+    it 'sets value when changed', ->
+        @car.set(brand: @brands.at(1))
+        sf = LT.renderComponent(LC.SelectField, props:{
+            model: @car, name: 'brand', labelField: 'name', editOnly: true, collection: @brands
+        })
+        _.dom(sf).qs('.rw-select').click()
+        _.dom(sf).qs('li.rw-list-option:last-child').click()
+        expect(@car.brand.code).toEqual('DODGE')
+
+    it 'can select multiple values', ->
+        sf = LT.renderComponent(LC.SelectField, props:{
+            multi: true, model: @car, name: 'carTypes',
+            labelField: 'name', editOnly: true, collection: @brands
+        })
+        spyOn(@brands, 'fetch').and.callThrough()
+        _.dom(sf).qs('.rw-input').focus()
+        expect(@brands.fetch).toHaveBeenCalled()
+
+        expect( _.dom(sf).qsa('.rw-list-option').length ).toEqual(@brands.length)
+        _.dom(sf).qs('.rw-list-option:nth-child(1)').click()
+        _.dom(sf).qs('.rw-input').focus()
+        _.dom(sf).qs('.rw-list-option:nth-child(3)').click()
+        expect(_.pluck(@car.carTypes, 'id')).toEqual([1, 3])
+
+    it 'renders label for multiple values', ->
+        @car.carTypes = [ @brands.at(0), @brands.at(2) ]
+        sf = LT.renderComponent(LC.SelectField, props:{
+            multi: true, model: @car, name: 'carTypes',
+            labelField: 'name', collection: @brands
+        })
+        expect(_.dom(sf).qs('.value').text).toEqual('General Motors and Chrysler/Dodge')
+
+    it "renders all choices", ->
+        sf = LT.renderComponent(LC.SelectField, props:{
+            model: @car, name: 'brand', labelField: 'name', editOnly: true, collection: @brands
+        })
+        _.dom(sf).qs('.rw-select').click()
+        labels = _.pluck _.dom(sf).qsa('li.rw-list-option'), 'textContent'
+        expect(labels).toEqual(["General Motors", "Ford Motor Co.", "Chrysler/Dodge"])
+
+    it "can render a blank row", ->
+        sf = LT.renderComponent(LC.SelectField, props:{
+            includeBlankRow: true, model: @car, name: 'brand',
+            labelField: 'name', editOnly: true, collection: @brands
+        })
+        _.dom(sf).qs('.rw-select').click()
+        labels = _.pluck _.dom(sf).qsa('li.rw-list-option'), 'textContent'
+        expect(labels).toEqual(["---------", "General Motors", "Ford Motor Co.", "Chrysler/Dodge"])

data/spec/lanes/components/shared/NetworkActivityOverlaySpec.coffee

@@ -0,0 +1,34 @@
+Model = Lanes.Test.defineModel(
+    props: {id: 'integer', code: 'string', name: 'string', notes: 'string'}
+)
+
+describe "Lanes.Components.NetworkActivityOverlay", ->
+
+    it "doesn't render unless requesting", ->
+        na = LT.renderComponent(LC.NetworkActivityOverlay, props:{message: 'Lookout 4 Bears'})
+        expect(_.dom(na).el).toBe(null)
+
+    it "renders message", ->
+        na = LT.renderComponent(LC.NetworkActivityOverlay, props:{
+            visible: true, message: 'Lookout 4 Bears'})
+        expect(_.dom(na).qs('.message').text).toBe('Lookout 4 Bears')
+
+    it 'chooses message based on request type', ->
+        na = LT.renderComponent(LC.NetworkActivityOverlay, props:{visible:true})
+        na.setState(isRequesting: 'GET')
+        expect(_.dom(na).qs('.message').text).toBe('Loading…')
+        na.setState(isRequesting: 'POST')
+        expect(_.dom(na).qs('.message').text).toBe('Saving…')
+        na.setState(isRequesting: 'DELETE')
+        expect(_.dom(na).qs('.message').text).toBe('Deleting…')
+
+    it 'briefly displays an error message', (done) ->
+        model = new Model
+        na = LT.renderComponent(LC.NetworkActivityOverlay, props:{
+            errorTimeout: 2, model:model})
+        na.setDataState(hasError: true)
+        expect(_.dom(na).qs('.message').text).toBe('Error')
+        _.delay( ->
+            expect(_.dom(na).el).toBe(null)
+            done()
+        , 3)

data/spec/lanes/models/AssociationMapSpec.coffee

@@ -1,4 +1,8 @@
+#=require lanes/access/User
+#=require lanes/access/Roles
+
 describe "Lanes.Models.AssociationMap", ->
+
     class Color
         constructor: -> super
         api_path: -> 'test'
@@ -25,7 +29,12 @@ describe "Lanes.Models.AssociationMap", ->
                 colors: { collection: Color, fk: 'model_fk_id' }
             props: { id: 'integer', foo: 'string' }
         }, { id: 123 })
+
+        expect(model.associations.isCreated(model, 'colors')).toBe(false)
+
         color = model.colors.add({ rgb:'#ffffff' })
+
+        expect(model.associations.isCreated(model, 'colors')).toBe(true)
         expect(color).toEqual(jasmine.any(Color))
         expect(color.model_fk_id).toEqual(123)
 
@@ -44,8 +53,33 @@ describe "Lanes.Models.AssociationMap", ->
             associations:
                 color:{ model: Color }
             props: { id: 'integer', foo: 'string', color_id: 'integer' }
-        }, { id: 123, color: { rgb: 'red' } })
+        }, { id: 123, color: {} })
+
+        expect(model.associations.isCreated(model, 'color')).toBe(false)
         color = model.color
-        expect(model.color).toEqual(jasmine.any(Color))
+        expect(model.associations.isCreated(model, 'color')).toBe(true)
+
 
+        model.set(color: {rgb: 'red'})
         expect(model.color.rgb).toEqual('red')
+
+
+    it "serializes associations", ->
+        modelData = {
+            id: 123, title: 'Colors', color: { rgb: 'red' },
+            colors: [
+                { id: 1, rgb: '123' }
+                { id: 2, rgb: '1234' }
+                { id: 3, rgb: '12345' }
+            ]
+        }
+        model = LT.makeModel({
+            props: { id: 'integer', title: 'string' }
+            associations:
+                color:{ model: Color }
+                colors: { collection: Color, fk: 'model_fk_id' }
+        }, modelData)
+
+        expect(model.serialize()).toEqual(
+            modelData
+        )

data/spec/lanes/models/AssociationProxySpec.coffee

@@ -0,0 +1,77 @@
+describe "Lanes.Models.AssocationProxy", ->
+
+    class Color
+        constructor: -> super
+        api_path: -> 'test'
+        props: { id: 'integer', model_fk_id: 'integer', rgb: 'string' }
+        testFunc: (arg) -> @rgb = arg
+    Lanes.Models.Base.extend(Color)
+
+    beforeEach ->
+        @Model = Lanes.Test.defineModel({
+            associations:
+                color:{ model: Color }
+                colors: { collection: Color, fk: 'model_fk_id' }
+            props: { id: 'integer', property: 'string' }
+            session: { session: 'string' }
+            derived:
+                dr: { fn: -> 'dr' }
+        })
+        @Proxy = Lanes.Models.AssocationProxy.construct(@Model)
+
+    it "proxies the associations with other proxies", ->
+        instance = new @Proxy
+        expect(instance.color.isProxy).toBe(true)
+        expect(instance.color.id).toBeNull()
+
+    it 'can create a real association and return it if needed', ->
+        instance = new @Proxy
+        expect(instance.color.isProxy).toBe(true)
+        instance.color.rgb = 'foo'
+        expect(instance.color.isProxy).toBeUndefined()
+        expect(instance.color).toEqual(jasmine.any(Color))
+
+    it 'can proxy derived properties', ->
+        instance = new @Proxy
+        expect(instance.dr).toBeNull()
+
+    it 'raises error when writing to derived properties', ->
+        instance = new @Proxy
+        expect(->
+            instance.dr = 'foo'
+        ).toThrowError(TypeError)
+
+    it 'instantiates and forwards function calls', ->
+        instance = new @Proxy
+        instance.color.testFunc('1234')
+        expect(instance.color).toEqual(jasmine.any(Color))
+        expect(instance.color.rgb).toEqual('1234')
+
+    it 'intercepts dataForSave', ->
+        instance = new @Proxy
+        instance.color.rgb = 'mycolor'
+        expect(instance.dataForSave()).toEqual(color: {rgb: 'mycolor'})
+
+    it 'provides api_key', ->
+        instance = new @Proxy
+        expect(instance.api_path()).toEqual('/s')
+
+    it 'stores events and eventually sets them on model', ->
+        spy1 = jasmine.createSpy()
+        spy2 = jasmine.createSpy()
+        instance = new @Proxy
+        instance.color.on('change:rgb', spy1)
+        instance.color.once('change:rgb', spy2)
+        expect(instance.color.isProxy).toBe(true)
+        instance.color.rgb = 'newcolor'
+        expect(instance.color.isProxy).toBeUndefined()
+
+        expect(spy1).toHaveBeenCalled()
+        expect(spy2).toHaveBeenCalled()
+
+    it 'fires onreplace', ->
+        spy = jasmine.createSpy()
+        instance = new @Proxy
+        instance.on('proxyreplace', spy)
+        instance.session = 'foo'
+        expect(spy).toHaveBeenCalled()

data/spec/lanes/models/BaseSpec.coffee

@@ -50,6 +50,7 @@ describe "Lanes.Models.Base", ->
                     fn: -> 'blarg'
         })
         model.set( id: 10, foo:'bar', unsaved: 'falsify', color: { rgb: '99FFFF' } )
+        expect(model.color.rgb).toEqual('99FFFF')
         expect(id: 10, foo:'bar', color: { rgb: '99FFFF' }).toEqual( model.dataForSave()  )
         model.foo = 'a value'
         a = model.changeMonitor.changedAttributes()
@@ -70,7 +71,7 @@ describe "Lanes.Models.Base", ->
         model.id = 11
         expect(model.isNew()).toBe(false)
         Lanes.Models.Sync.perform.calls.reset()
-        syncSucceedWith({
+        LT.syncSucceedWith({
             foo: 'a new foo value'
         })
         model.save().then ->
@@ -83,7 +84,7 @@ describe "Lanes.Models.Base", ->
             props:
                 { id: 'integer', foo: 'string' }
         })
-        syncSucceedWith({
+        LT.syncSucceedWith({
             foo: 'foo value'
         })
         model.fetch().then ->
@@ -106,7 +107,7 @@ describe "Lanes.Models.Base", ->
 
 
     it "loads using where", (done) ->
-        syncSucceedWith([
+        LT.syncSucceedWith([
             { id: 1, title: 'first value'  }
             { id: 2, title: 'second value' }
         ])
@@ -148,7 +149,39 @@ describe "Lanes.Models.Base", ->
                 color:{ model: Color }
             props: { id: 'integer', foo: 'string' }
         }, { id: 1 })
-        model.withAssociations('color')
+        model.withAssociations(['color'])
         expect(Lanes.Models.Sync.perform).toHaveBeenCalledWith('read', jasmine.any(Object))
         options = Lanes.Models.Sync.perform.lastOptions()
         expect(options.include).toEqual(['color'])
+
+    it "can copy attributes from another model", ->
+        Model = LT.defineModel
+            props: { id: 'integer', title: 'string' }
+            associations:
+                color:{ model: Color }
+        a = new Model({ id: 23, title: 'Foo', color: { rgb: '123456' } })
+        b = new Model()
+        b.copyFrom(a)
+        expect( b.id ).toEqual(23)
+        expect( b.title ).toEqual('Foo')
+        expect( b.color.rgb ).toEqual('123456')
+
+    it 'can copy associations', (done) ->
+        Model = LT.defineModel
+            props: { id: 'integer', title: 'string' }
+            associations:
+                color:{ model: Color }
+                colors: { collection: Color, fk: 'model_fk_id' }
+
+        model = new Model(id: 1, title: 'Foo')
+        model.color.rgb = 'mycolor'
+        color = model.colors.add({ rgb:'1' })
+        color = model.colors.add({ rgb:'2' })
+        color = model.colors.add({ rgb:'3' })
+
+        copy = new Model
+        copy.copyAssociationsFrom(model, ['color', 'colors']).then ->
+            expect(copy.color.rgb).toEqual('mycolor')
+            expect(copy.colors.length).toEqual(3)
+            expect(copy.colors.pluck('rgb')).toEqual(['1', '2', '3'])
+            done()

data/spec/lanes/models/CollectionSpec.coffee

@@ -5,14 +5,14 @@ describe "Lanes.Models.Collection", ->
         Model = Lanes.Test.defineModel
             props: { id: 'integer', title: 'string' }
 
-        syncSucceedWith([
+        LT.syncSucceedWith([
             { id: 1, title: 'first value'  }
             { id: 2, title: 'second value' }
         ])
         collection = Model.where(name: 'foo')
-        expect(collection.requestInProgress).toBe(true)
+        expect(collection.requestInProgress).toBeDefined()
         collection.whenLoaded ->
-            expect( collection.isLoaded() ).toEqual( true )
+            expect( collection.isLoaded() ).toBe(true)
             done()
 
     it "triggers length when changed", ->
@@ -31,18 +31,12 @@ describe "Lanes.Models.Collection", ->
         collection.reset([{ id:11, title: 'last'}])
         expect(spy).toHaveBeenCalled()
 
-    it "reads from caches", (done) ->
-        model = Lanes.Test.makeModel({
-            cacheDuration: [1, 'day']
-            api_path: 'model-cache'
+    it 'prevents duplicates when copying from', ->
+        Model = Lanes.Test.defineModel
             props: { id: 'integer', title: 'string' }
-        }, {id: 1})
-        Lanes.Models.ServerCache.CACHE["/model-cache"] = [
-            { id: 1, title: 'first value'  }
-            { id: 2, title: 'second value' }
-        ]
-        collection = new model.constructor.Collection
-        collection.fetch().then ->
-            expect(collection.length).toEqual(2)
-            expect(collection.first().title).toEqual('first value')
-            done()
+        collection = new Model.Collection
+        a = collection.add({ id: 1, title: 'first'  })
+        b = collection.add({ id: 2, title: 'second' })
+        c = collection.add({ id: 3, title: 'third'  })
+        a.copyFrom(c)
+        expect(collection.pluck('id')).toEqual([2, 3, 1])

data/spec/lanes/models/PubSubSpec.coffee

@@ -8,7 +8,7 @@ describe "Lanes.Model.PubSub", ->
         }, { id: 1, foo: 'bar' })
         component = Lanes.Test.makeComponent({}, model: model)
         expect(Lanes.Models.PubSub.add).toHaveBeenCalledWith(model)
-        component.wrapper.destroy()
+        component.data.destroy()
         expect(Lanes.Models.PubSub.remove).toHaveBeenCalledWith(model)
 
     it "can retrieve a model after checkin", ->

data/spec/lanes/models/ServerCacheSpec.coffee

@@ -0,0 +1,65 @@
+describe "Lanes.Models.ServerCache", ->
+
+    it "caches models", (done) ->
+        record = LT.makeModel({
+            cacheDuration: [5, 'seconds']
+            props: { id: 'integer', name: 'string' }
+        }, { id: 123 })
+
+        LT.syncSucceedWith(name: 'bob')
+
+        Lanes.Models.ServerCache.fetchRecord(record).then ->
+            expect(Lanes.Models.Sync.perform).toHaveBeenCalledWith('read', jasmine.any(Object))
+            expect(record.name).toEqual('bob')
+
+            Lanes.Models.Sync.perform.calls.reset()
+            record.clear()
+            record.id = 123
+            expect(record.name).toBeUndefined()
+            Lanes.Models.ServerCache.fetchRecord(record).then ->
+                expect(Lanes.Models.Sync.perform).not.toHaveBeenCalled()
+                expect(record.name).toEqual('bob')
+                done()
+
+
+    it "caches collections", (done) ->
+        record = LT.makeModel({
+            cacheDuration: [5, 'seconds']
+            props: { id: 'integer', name: 'string' }
+        }, { id: 123 })
+
+        collection = Lanes.Test.makeCollection
+            cacheDuration: [5, 'milliseconds']
+            model: LT.defineModel
+                props: { id: 'integer', name: 'string' }
+
+        LT.syncSucceedWith([{id:1, name: 'bob'}, {id:2, name: 'joe'}])
+
+        Lanes.Models.ServerCache.fetchCollection(collection).then ->
+            expect(Lanes.Models.Sync.perform).toHaveBeenCalledWith('read', jasmine.any(Object))
+            expect(collection.length).toEqual(3)
+            Lanes.Models.Sync.perform.calls.reset()
+            Lanes.Models.ServerCache.fetchCollection(collection).then ->
+                expect(Lanes.Models.Sync.perform).not.toHaveBeenCalled()
+                done()
+
+    it "expires the cache", (done) ->
+        record = LT.makeModel({
+            cacheDuration: [5, 'milliseconds']
+            props: { id: 'integer', name: 'string' }
+        }, { id: 123 })
+
+        LT.syncSucceedWith(name: 'bob')
+
+        Lanes.Models.ServerCache.fetchRecord(record).then ->
+            expect(Lanes.Models.Sync.perform).toHaveBeenCalled()
+            Lanes.Models.Sync.perform.calls.reset()
+
+            Lanes.Models.ServerCache.fetchRecord(record).then ->
+                expect(Lanes.Models.Sync.perform).not.toHaveBeenCalled()
+
+                _.delay( ->
+                    Lanes.Models.ServerCache.fetchRecord(record).then ->
+                        expect(Lanes.Models.Sync.perform).toHaveBeenCalled()
+                        done()
+                , 10)