hippo-fw 0.9.1

data/spec/hippo/models/QuerySpec.coffee

@@ -0,0 +1,19 @@
+describe "Hippo.Models.Query", ->
+
+    beforeEach ->
+        @query =
+            new Hippo.Models.Query({
+                syncOptions: @syncOptions
+                src: Hippo.Models.User, fields: [
+                    {id:'id',   visible: false}
+                    {id:'email', fixedWidth: 130 },
+                    {id:'login', },
+                    {id:'name', flex: 1}
+                ]
+            })
+
+
+    it "can be cloned unsaved attributes", ->
+        newQuery = @query.clone()
+        expect(newQuery).toBeDefined()
+        expect(newQuery.fields.pluck('id')).toEqual(@query.fields.pluck('id'))

data/spec/hippo/models/SyncSpec.coffee

@@ -0,0 +1,28 @@
+describe "Hippo.Models.Sync", ->
+
+    it "it can encode retreival options", (done) ->
+        calledWithUrl = ""
+        spyOn(Hippo.Vendor, 'xhr').and.callFake( (options, cb) ->
+            calledWithUrl = options.url
+            console.dir options
+            cb(false, {}, "{}")
+        )
+
+        options =
+            url: 'endpoint'
+            query: { foo: 'bar' }
+            fields: ['foo', 'bar']
+            with:   'bar_finder_method'
+            include: ['extra_special_values', 'secrets']
+            order: {'foo', 'desc'}
+            limit: 100
+            start: 2
+            format: 'array'
+
+        Hippo.Models.Sync.restorePerform ->
+            Hippo.Models.Sync.perform('GET', options).then (a,b,c)->
+                expect(Hippo.Vendor.xhr).toHaveBeenCalled()
+                expect(calledWithUrl)
+                    .toEqual("endpoint.json?q[foo]=bar&f[]=foo&f[]=bar&w=bar_finder_method&i[]=extra_special_values&i[]=secrets&o[foo]=foo&o[desc]=desc&l=100&s=2&df=array")
+
+                done()

data/spec/hippo/models/UserSpec.coffee

@@ -0,0 +1,17 @@
+describe "Hippo.Model.User", ->
+
+    it "saves callbacks across users", ->
+        spy = jasmine.createSpy('callbackSpy')
+        Hippo.current_user.on("change", spy)
+        #expect( _.keys(Hippo.Models.UserEvents.CALLBACKS).length ).toEqual(2)
+
+        testuser = Hippo.Test.makeModel({
+            session:
+                isLoggedIn: 'bool'
+            canRead: -> true
+        })
+        Hippo.current_user = testuser
+
+        Hippo.current_user.isLoggedIn = false
+
+        expect(spy).toHaveBeenCalled()

data/spec/hippo/react/mixins/DataSpec.coffee

@@ -0,0 +1,74 @@
+describe "Hippo.React.DataMixin", ->
+
+    it "fires forceUpdate for a model", ->
+        model = Hippo.Test.makeModel
+            props:
+                id: 'integer'
+                foo: 'string'
+        comp = Hippo.Test.makeComponent({}, model: model)
+        spyOn(comp, 'forceUpdate')
+        model.foo = "bar"
+        expect(comp.forceUpdate).toHaveBeenCalled()
+
+    it "fires forceUpdate for a collection", ->
+        collection = Hippo.Test.makeCollection()
+        comp = Hippo.Test.makeComponent({}, collection: collection)
+        spyOn(comp, 'forceUpdate')
+        collection.add([{}])
+        expect(comp.forceUpdate).toHaveBeenCalled()
+
+    it "obeys global pubsub settings", ->
+        spyOn(Hippo.Models.PubSub, 'add').and.callThrough()
+        model = Hippo.Test.makeModel({
+            props: { id: 'integer', foo: 'string' }
+        }, { id: 1, foo: 'bar' })
+        component = Hippo.Test.makeComponent({pubsub: false}, model: model)
+        expect(Hippo.Models.PubSub.add).not.toHaveBeenCalled()
+
+    it "obeys per-object pubsub settings", ->
+        spyOn(Hippo.Models.PubSub, 'add').and.callThrough()
+        model = Hippo.Test.makeModel({
+            props: { id: 'integer', foo: 'string' }
+        }, {id: 1, foo: 'bar' })
+
+        component = Hippo.Test.makeComponent({pubsub: {model: false}}, model: model)
+        expect(Hippo.Models.PubSub.add).not.toHaveBeenCalled()
+
+    it "can listen to only specific events", ->
+        model = Hippo.Test.makeModel
+            props:
+                foo: 'string'
+                bar: 'string'
+
+        comp = Hippo.Test.makeComponent({
+            bindEvents:
+                model: 'change:bar'
+        }, {
+            model: model
+        })
+        spyOn(comp, 'forceUpdate')
+        model.foo = "bar"
+        expect(comp.forceUpdate).not.toHaveBeenCalled()
+        model.bar = "foo"
+        expect(comp.forceUpdate).toHaveBeenCalled()
+
+    it "can rebind events", ->
+        Model = Hippo.Test.defineModel
+            props:
+                foo: 'string', bar: 'string'
+        m1 = new Model
+        m2 = new Model
+        comp = Hippo.Test.makeComponent({}, {
+            model: m1
+        })
+        spyOn(comp, 'forceUpdate')
+        m1.foo = "bar"
+        expect(comp.forceUpdate).toHaveBeenCalled()
+
+        comp.modelBindings.reset(model: m2)
+        comp.forceUpdate.calls.reset()
+
+        m1.foo = "a different bar"
+        expect(comp.forceUpdate).not.toHaveBeenCalled()
+        m2.foo = "bar"
+        expect(comp.forceUpdate).toHaveBeenCalled()

data/spec/hippo/screens/DefinitionsSpec.coffee

@@ -0,0 +1,33 @@
+describe "Hippo.Screens.Definitions", ->
+    orig_user = Hippo.current_user
+    afterEach ->
+        Hippo.current_user = orig_user
+        delete Hippo.Test.DefinitionTestModel
+
+    it "resets caches when user login status changes", ->
+
+        testuser = Hippo.Test.makeModel({
+            session:
+                isLoggedIn: 'bool'
+            hasAccess: -> true
+        })
+        Hippo.current_user = testuser
+        Hippo.Test.DefinitionTestModel = Hippo.Test.defineModel({
+            props: { id: 'integer', foo: 'string' }
+        })
+        expect(Hippo.current_user).not.toBe(null)
+        Hippo.Screens.Definitions.groups.add( id: 'foo' )
+        Hippo.Screens.Definitions.register(
+            group_id: 'foo', model: 'Hippo.Test.DefinitionTestModel', id: 'screen'
+        )
+        group = Hippo.Screens.Definitions.groups.first()
+        expect(group).not.toBe(null)
+
+        expect(Hippo.Screens.Definitions.groups.available().length).toEqual(1)
+        expect( group.screens().length ).toEqual(1)
+
+        Hippo.current_user.hasAccess = -> false
+        Hippo.current_user.isLoggedIn = false
+
+        expect( group.screens().length ).toEqual(0)
+        expect( Hippo.Screens.Definitions.groups.available().length ).toEqual(0)

data/spec/hippo/views/BaseSpec.coffee

@@ -0,0 +1,147 @@
+# describe "Hippo.Views.Base", ->
+
+#     it "fires el change on render", ->
+#         spy = jasmine.createSpy()
+#         view = Hippo.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>"
+#         Hippo.Templates['/view-test'] = spy
+
+#         view = Hippo.Test.makeView({
+#             templatePrefix: ''
+#             templateName: "view-test"
+#         }, { model: new Hippo.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 = Hippo.Test.makeView({
+#             template: "<p>hello test</p"
+#         })
+#         expect(view.template).toEqual "<p>hello test</p"
+#         view.render()
+#         expect(view.el.tagName).toEqual("P")
+#         expect(view.el.innerHTML).toEqual("hello test")
+
+#     it "listens to domEvents", ->
+#         spy = jasmine.createSpy('onClick')
+#         el = _.el( 'div',{id: 'testdiv'} )
+#         view = Hippo.Test.makeView({
+#             domEvents: { "click #mylink": 'onClick' }
+#             template: "<div>text,text,text<a id='mylink'>click me</a>mor text</div>"
+#             onClick: spy
+#         },{el: el})
+#         expect(view.domEvents["click #mylink"]).toEqual('onClick')
+#         view.render()
+#         view.$('a').trigger('click',22)
+#         expect(spy).toHaveBeenCalledWith(jasmine.any(Object),22)
+
+#     it "updates from bindings", ->
+#         model = new Hippo.Test.DummyModel({ name: "Bob" })
+#         view = Hippo.Test.makeView({
+#             bindings: {
+#                 "model.name": { hook: 'link' }
+#                 "model.url":  { type:'attribute', name: 'href', hook: 'link' }
+#             }
+#             template: "<div>text,text,text<a data-hook='link'>click me</a>mor text</div>"
+#         }, { model: model })
+#         view.render()
+#         expect( view.$('a').text() ).toEqual("Bob")
+#         model.name="Ralph"
+#         model.url = 'http://hippoframework.org/'
+#         expect( view.$('a').text() ).toEqual("Ralph")
+#         expect( view.$('a').attr('href') ).toEqual( model.url )
+
+#     it "renders subviews", ->
+#         class LowerView
+#             template: "<h1>Hello from Lower View</h1>"
+#             constructor: -> super
+#             session: { answer: 'string' }
+#         Hippo.Views.Base.extend(LowerView)
+#         model = new Hippo.Test.DummyModel
+#         view = Hippo.Test.makeView({
+#             subviews:
+#                 lower:
+#                     hook: 'lower'
+#                     waitFor: 'model.name'
+#                     view: LowerView
+#             template: "<div>text,text,text<div data-hook='lower'>unmodified</div>More text</div>"
+#             subviewOptions: ->{ answer: '42' }
+#         }, { model: model })
+#         view.render()
+#         expect(view.$('[data-hook]').text()).toEqual("unmodified")
+#         expect( view.$el.text() ).not.toMatch(/Hello from Lower View/)
+#         model.name="Ralph"
+#         expect( view.$el.text() ).toMatch(/Hello from Lower View/)
+#         expect(view.lower.answer).toEqual('42')
+
+#     it "renders collection views", ->
+#         class LowerView
+#             template: "<h1>Hello from Lower View</h1>"
+#             constructor: -> super
+#             bindings: { "model.name": { type: "text" } }
+#         Hippo.Views.Base.extend(LowerView)
+#         collection = new Hippo.Test.DummyModel.Collection
+#         view = Hippo.Test.makeView({
+#             subviews:
+#                 lower:
+#                     hook: 'lower'
+#                     collection: 'collection'
+#                     view: LowerView
+#             template: "<div>text,text,text<div data-hook='lower'>unmodified</div>More text</div>"
+#         }, { collection: collection})
+#         view.render()
+#         expect(view.$('h1').length).toEqual(0)
+#         collection.add([{ name: "One"}, {name: "Two"},{name:"Three"}])
+#         expect(view.$('h1').length).toEqual(3)
+#         expect(view.$('h1:first').text()).toMatch('One')
+
+#     it "caches elements in ui", ->
+#         spy = jasmine.createSpy('onClick')
+#         view = Hippo.Test.makeView({
+#             ui:
+#                 link: '#linky'
+#             domEvents:
+#                 'click @ui.link': spy
+#             template: "<div>text,text,text<a id='linky'>unmodified</a>More text</div>"
+#         })
+#         view.render()
+#         expect(view.ui.link.length).toEqual(1)
+#         view.$('a').click()
+#         expect(spy).toHaveBeenCalled()
+
+
+#     it "invokes model events", ->
+#         nameSpy = jasmine.createSpy()
+#         urlSpy  = jasmine.createSpy()
+#         model   = new Hippo.Test.DummyModel
+#         view = Hippo.Test.makeView({
+#             modelEvents:
+#                 'change:name': nameSpy
+#                 'change:url' : 'onURLChange'
+#             onURLChange: urlSpy
+#         },{ model: model })
+
+#         model.name="Ralph"
+#         expect(nameSpy).toHaveBeenCalled()
+
+
+#     it "invokes collection events", ->
+#         eventSpy = jasmine.createSpy('event')
+#         view = Hippo.Test.makeView({
+#             collectionEvents:
+#                 all: 'onEvent'
+#             onEvent: eventSpy
+#             initialize: -> this.collection = new Hippo.Test.DummyModel.Collection
+#         })
+#         expect(eventSpy).not.toHaveBeenCalled()
+#         view.collection.add(new Hippo.Test.DummyModel)
+#         expect(eventSpy).toHaveBeenCalled()

data/spec/hippo/views/FormBindingsSpec.coffee

@@ -0,0 +1,32 @@
+# describe "Hippo.Views.FormBindings", ->
+
+#     it "updates inputs", ->
+#         model = new Hippo.Test.DummyModel({name: 'start'})
+#         view  = Hippo.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 Hippo.Test.DummyModel({name: 'start'})
+#         view  = Hippo.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')

data/spec/server/api/controller_base_spec.rb

@@ -0,0 +1,101 @@
+require_relative "../spec_helper"
+require 'hippo/access/user'
+
+
+class GodUser
+    def can_read?(*args)
+    end
+    def can_write?(*args)
+        true
+    end
+    def can_delete?(*args)
+        true
+    end
+end
+
+class NullAuthProvider
+    def current_user
+        @user ||= GodUser.new
+    end
+end
+
+describe "ControllerBase" do # < Hippo::TestCase
+    include TestingModels
+
+    around(:each) do |example|
+        with_testing_models do
+            example.run
+        end
+    end
+
+
+    it "can retrieve" do
+        1.upto(10){|i| TestModel.create!(id: i, name:'test') }
+        controller = Hippo::API::ControllerBase.new(TestModel,
+                                                    Hippo::API::AuthenticationProvider.new({}),
+                                                    {id: 1})
+        expect(controller.send(:perform_retrieval))
+            .to match(
+                    success: true, message: "Retrieve succeeded",
+                    data: a_hash_including({"id"=>1, "bt_id"=>nil, "name"=>"test", "number"=>nil})
+                )
+    end
+
+    it "can make a single update" do
+        person = TestModel.create!(id: 21, name:'Joe')
+        controller = Hippo::API::ControllerBase.new(TestModel,
+                                                    NullAuthProvider.new,
+                                                    {id: person.id}, {name:'Bob'})
+        expect(controller.send(:perform_single_update))
+            .to match(
+                    :success=>true, :message=>"Update succeeded",
+                    data: a_hash_including("id"=>person.id, "bt_id"=>nil, "name"=>"Bob", "number"=>nil)
+                )
+
+        expect(person.reload.name).to eq('Bob')
+    end
+
+    it 'can update multiple records' do
+        TestModel.create!(id: 1, name:'Joe')
+        TestModel.create!(id: 2, name:'Bob')
+        def TestModel.access_limits_for_query(query, user, params)
+            query.where(name:'Joe')
+        end
+        controller = Hippo::API::ControllerBase.new(TestModel,
+                                                    NullAuthProvider.new,
+                                                    {},
+                                                    [{'id'=>1}, {'id'=>2}])
+
+        expect(controller.send(:perform_multiple_updates))
+              .to match(success: true, message: "Update succeeded",
+                        data: array_including(
+                            a_hash_including("id"=>1, "bt_id"=>nil, "name"=>"Joe", "number"=>nil)
+                        )
+                       )
+    end
+
+    it 'can destroy a single record' do
+        TestModel.create!(id: 1, name:'Joe')
+        controller = Hippo::API::ControllerBase.new(TestModel,
+                                                    NullAuthProvider.new,
+                                                    {id: 1}, {})
+        expect(controller.send(:perform_single_destroy))
+            .to eq(success: true, message: "Destroy succeeded", data: [])
+        expect(TestModel.where(id: 1).first).to be_nil
+    end
+
+
+    it 'can destroy a multiple records' do
+        TestModel.create!(id: 1, name:'Joe')
+        TestModel.create!(id: 2, name:'Bob')
+
+        controller = Hippo::API::ControllerBase.new(TestModel,
+                                                    NullAuthProvider.new,
+                                                    {},
+                                                    [{'id'=>1}, {'id'=>2}])
+        expect( controller.send(:perform_multiple_destroy))
+            .to match(success: true, message: "Destroy succeeded", data: [])
+        expect(TestModel.all.to_a).to be_empty
+    end
+
+end