hippo-fw 0.9.1

data/spec/hippo/models/AssociationMapSpec.coffee

@@ -0,0 +1,85 @@
+#=require hippo/access/User
+#=require hippo/access/Roles
+
+describe "Hippo.Models.AssociationMap", ->
+
+    class Color
+        constructor: -> super
+        api_path: -> 'test'
+        props: { id: 'integer', model_fk_id: 'integer', rgb: 'string' }
+    Hippo.Models.Base.extend(Color)
+
+    DATA = {total:1, success:true, message:"Retrieve succeeded", data:[
+        [1, "TEST", "Nathan Stitt", null, "0.0"]
+    ]}
+    RESPONSE = {
+        status:200,
+        contentType: "application/json"
+        responseText: JSON.stringify(DATA)
+    }
+    beforeEach ->
+        jasmine.Ajax.install()
+    afterEach ->
+        jasmine.Ajax.uninstall()
+
+    it "sets up has_many associations", ->
+        model = LT.makeModel({
+            associations:
+                color:{ model: Color }
+                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)
+
+        spy = jasmine.createSpy('sync')
+        model.colors.sync = spy
+
+        model.colors.fetch(force:true)
+
+        expect(spy).toHaveBeenCalledWith('read', model.colors, jasmine.any(Object))
+        call_options = spy.calls.mostRecent().args[2]
+        expect(call_options.query).toEqual( model_fk_id: 123 )
+
+
+    it "sets up belongs_to associations", ->
+        model = LT.makeModel({
+            associations:
+                color:{ model: Color }
+            props: { id: 'integer', foo: 'string', color_id: 'integer' }
+        }, { id: 123, color: {} })
+
+        expect(model.associations.isCreated(model, 'color')).toBe(false)
+        color = model.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/hippo/models/AssociationProxySpec.coffee

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

data/spec/hippo/models/BaseSpec.coffee

@@ -0,0 +1,155 @@
+describe "Hippo.Models.Base", ->
+    class Color
+        constructor: -> super
+        props: { id: 'integer', rgb: 'string' }
+    Hippo.Models.Base.extend(Color)
+
+    it "tracks unsaved attributes", ->
+        model = Hippo.Test.makeModel({
+            session:
+                foo: 'string'
+                bar: 'integer'
+            props:
+                saved: 'string'
+        }, {bar: 'baz'}, {xhr: {}}) # it comes from xhr
+        expect(model.isDirty).toBe(false)
+        model.foo = 'baz' # session prop
+        expect(model.isDirty).toBe(false)
+        expect(model.unsavedAttributes()).toBeEmptyObject()
+        model.saved = 'bar'
+        expect(model.isDirty).toBe(true)
+        model.setFromServer( foo: 'bar' )
+        expect(model.isDirty).toBe(false)
+
+
+    it "can tell if it has attributes", ->
+        model = Hippo.Test.makeModel({
+            session:
+                foo: 'string'
+            props:
+                bar: 'string'
+        })
+        expect(model.hasAttribute('missing')).toBe(false)
+        expect(model.hasAttribute('foo')).toBe(true)
+        expect(model.hasAttribute('bar')).toBe(true)
+
+    it "provides data for saving", ->
+        # model with other types of data, but should only save "props"
+        model = Hippo.Test.makeModel({
+            associations:
+                color:{ model: Color }
+            session:
+                unsaved: 'string'
+            props:
+                id: 'integer'
+                foo: 'string'
+                bar: 'string'
+                color_id: 'integer'
+            derived:
+                atest:
+                    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()
+        expect( model.dataForSave() ).toEqual( id: 10, foo: 'a value', color: { rgb: '99FFFF' } )
+
+    it "can be saved", (done) ->
+        model = Hippo.Test.makeModel({
+            props:
+                id: 'integer'
+                foo: 'string'
+                bar: 'string'
+
+        }, { foo: 'one, two, three'} )
+        expect(model.isDirty).toBe(true)
+        expect(model.unsavedAttributes()).toEqual( foo: 'one, two, three' )
+        model.save()
+        expect(Hippo.Models.Sync.perform).toHaveBeenCalledWith('create', jasmine.any(Object))
+        model.id = 11
+        expect(model.isNew()).toBe(false)
+        Hippo.Models.Sync.perform.calls.reset()
+        LT.syncSucceedWith({
+            foo: 'a new foo value'
+        })
+        model.save().then ->
+            expect(Hippo.Models.Sync.perform).toHaveBeenCalledWith('patch', jasmine.any(Object))
+            expect(model.foo).toEqual('a new foo value')
+            done()
+
+    it "can be fetched", (done) ->
+        model = Hippo.Test.makeModel({
+            props:
+                { id: 'integer', foo: 'string' }
+        })
+        LT.syncSucceedWith({
+            foo: 'foo value'
+        })
+        model.fetch().then ->
+            expect(Hippo.Models.Sync.perform).toHaveBeenCalledWith('read', jasmine.any(Object))
+            expect(model.foo).toEqual('foo value')
+            options = Hippo.Models.Sync.perform.lastOptions()
+            expect(options).toHaveTrue('ignoreUnsaved')
+            expect(options).toHaveNumberWithinRange('limit', 1, 1)
+            done()
+
+    it "creates a Collection property even when the base is abstract", ->
+        class Base
+            constructor: -> super
+            abstractClass: true
+        Hippo.Models.Base.extend(Base)
+        class Model
+            constructor: -> super
+        Model = Base.extend(Model)
+        expect(Model.Collection::model).toEqual(Model)
+
+
+    it "loads using where", (done) ->
+        LT.syncSucceedWith([
+            { id: 1, title: 'first value'  }
+            { id: 2, title: 'second value' }
+        ])
+
+        Model = LT.defineModel
+            props: { id: 'integer', title: 'string' }
+
+        Model.where(title: 'first value').whenLoaded (collection) ->
+            options = Hippo.Models.Sync.perform.lastOptions()
+            expect(options.query).toEqual({title:'first value'})
+            expect(collection.length).toEqual(2)
+            done()
+
+    it "can be destroyed", (done) ->
+        model = Hippo.Test.makeModel({
+            props: { id: 'integer' }
+        }, { id: 1 })
+        collection = model.constructor.Collection
+        model.destroy().then ->
+            expect(Hippo.Models.Sync.perform)
+                .toHaveBeenCalledWith('delete', jasmine.any(Object))
+            done()
+
+    it "sets associations", ->
+        model = Hippo.Test.makeModel({
+            associations:
+                color:{ model: Color }
+            props: { id: 'integer', foo: 'string' }
+        }, { id: 1 })
+        expect(model.color).toBeObject()
+        model.set(color: { rgb: '99FFFF' })
+        expect(model.color.rgb).toEqual('99FFFF')
+        model.setFromServer(color:{ rgb: 'FFA500' })
+        expect(model.color.rgb).toEqual('FFA500')
+
+    it "can fetch associations", ->
+        model = Hippo.Test.makeModel({
+            associations:
+                color:{ model: Color }
+            props: { id: 'integer', foo: 'string' }
+        }, { id: 1 })
+        model.withAssociations(['color'])
+        expect(Hippo.Models.Sync.perform).toHaveBeenCalledWith('read', jasmine.any(Object))
+        options = Hippo.Models.Sync.perform.lastOptions()
+        expect(options.include).toEqual(['color'])

data/spec/hippo/models/CollectionSpec.coffee

@@ -0,0 +1,32 @@
+describe "Hippo.Models.Collection", ->
+
+
+    it "it triggers promise on loading", (done) ->
+        Model = Hippo.Test.defineModel
+            props: { id: 'integer', title: 'string' }
+
+        LT.syncSucceedWith([
+            { id: 1, title: 'first value'  }
+            { id: 2, title: 'second value' }
+        ])
+        collection = Model.where(name: 'foo')
+        expect(collection.requestInProgress).toBeDefined()
+        collection.whenLoaded ->
+            expect( collection.isLoaded() ).toBe(true)
+            done()
+
+    it "triggers length when changed", ->
+        Model = Hippo.Test.defineModel
+            props: { id: 'integer', title: 'string' }
+
+        collection = new Model.Collection
+        spy = jasmine.createSpy('onLengthChange')
+        collection.on("change:length", spy)
+        model = collection.add({ id: 1, title: 'first' })
+        expect(spy).toHaveBeenCalled()
+        spy.calls.reset()
+        collection.remove(model)
+        expect(spy).toHaveBeenCalled()
+        spy.calls.reset()
+        collection.reset([{ id:11, title: 'last'}])
+        expect(spy).toHaveBeenCalled()

data/spec/hippo/models/EnumMapSpec.coffee

@@ -0,0 +1,26 @@
+describe "Hippo.Models.EnumMap", ->
+    model = null
+
+    beforeEach ->
+        model = Hippo.Test.makeModel({
+            enums:
+                state:
+                    open: 1
+                    complete: 5
+                    canceled: 9
+
+            props:
+                state: {"type":"integer"}
+
+        },{ id: 123 })
+
+    it "sets up enums", ->
+        expect(model.is_open).toEqual(false)
+        model.state = 1
+        expect(model.is_open).toEqual(true)
+        model.is_open="some crazy value"
+        expect(model.is_open).toEqual(true)
+
+    it "reads the enum's value from the field", ->
+        model.state = 1
+        expect(model.state_value).toEqual("open")

data/spec/hippo/models/PubSubSpec.coffee

@@ -0,0 +1,71 @@
+describe "Hippo.Model.PubSub", ->
+
+    beforeEach ->
+        @Model = Hippo.Test.defineModel({
+            props: { id: 'integer', foo: 'string' }
+        })
+        @model = new @Model({ id: 1, foo: 'bar' })
+        @getModelConfig = ->
+            Hippo.Models.PubSub.types.get('/s').records[1]
+
+    it "checks in/out a model when it binds to a view", (done) ->
+        spyOn(Hippo.Models.PubSub, 'add').and.callThrough()
+        spyOn(Hippo.Models.PubSub, 'remove')
+        component = Hippo.Test.makeComponent({}, model: @model)
+        _.defer =>
+            expect(Hippo.Models.PubSub.add).toHaveBeenCalledWith(@model)
+            component.modelBindings.destroy()
+            expect(Hippo.Models.PubSub.remove).toHaveBeenCalledWith(@model)
+            done()
+
+    it "can retrieve a model after checkin", ->
+        record = new @Model(id: 11, foo: 'bar')
+        Hippo.Models.PubSub.add(record)
+        checkin = Hippo.Models.PubSub.instanceFor(@Model, 11)
+        expect(checkin).toEqual(record)
+
+    it 'only adds an identical model once', ->
+        Hippo.Models.PubSub.add(@model)
+        Hippo.Models.PubSub.add(@model)
+        configs = @getModelConfig()
+        expect(configs.models.length).toEqual(1)
+        expect(configs.models[0].count).toEqual(2)
+
+    it 'does not cause errors to remove a non-added model', ->
+        expect( =>
+            Hippo.Models.PubSub.remove(@model)
+        ).not.toThrowError()
+
+    it 'removes models', ->
+        Hippo.Models.PubSub.add(@model)
+        configs = Hippo.Models.PubSub.types.get('/s').records[1].models
+        expect(configs.length).toEqual(1)
+        Hippo.Models.PubSub.remove(@model)
+        expect(configs[0].count).toEqual(1)
+        Hippo.Models.PubSub.remove(@model)
+        expect( Hippo.Models.PubSub.types.get('/s').records[1] ).toBeUndefined()
+
+    it 'subscribes only once when models are added', ->
+        Hippo.Models.PubSub.add(@model)
+        expect(Hippo.Models.PubSub.mb.subscribe).toHaveBeenCalledWith(
+            '/s/1', jasmine.any(Function)
+        )
+        Hippo.Models.PubSub.add( new @Model({ id: 1, foo: 'foo' }) )
+        Hippo.Models.PubSub.add( new @Model({ id: 1, foo: 'baz' }) )
+        expect(Hippo.Models.PubSub.mb.subscribe.calls.count()).toEqual(1)
+
+    it 'unsubcribes only when all models are removed', ->
+        for i in [0..2]
+            Hippo.Models.PubSub.add(@model)
+        newModel = new @Model({ id: 1, foo: 'foo' })
+        Hippo.Models.PubSub.add( newModel )
+        # note - over unsubscribed
+        for i in [0..3]
+            Hippo.Models.PubSub.remove(@model)
+        expect(@getModelConfig().models.length).toEqual(1)
+        expect(Hippo.Models.PubSub.mb.subscribe.calls.count()).toEqual(1)
+        expect(Hippo.Models.PubSub.mb.unsubscribe.calls.count()).toEqual(0)
+        Hippo.Models.PubSub.remove(newModel)
+        Hippo.Models.PubSub.remove(newModel)
+        expect(@getModelConfig()).toBeUndefined()
+        expect(Hippo.Models.PubSub.mb.unsubscribe.calls.count()).toEqual(1)