joosy 0.1.0.RC1

data/spec/javascripts/joosy/core/modules/time_manager_spec.js.coffee

@@ -0,0 +1,25 @@
+describe "Joosy.Modules.TimeManager", ->
+
+  beforeEach ->
+    class @TestTimeManager extends Joosy.Module
+      @include Joosy.Modules.TimeManager
+    @box = new @TestTimeManager()
+
+
+  it "should keep timeouts list", ->
+    timer = @box.setTimeout 10000, ->
+    expect(@box.__timeouts).toEqual [timer]
+    window.clearTimeout timer
+
+  it "should keep intervals list", ->
+    timer = @box.setInterval 10000, ->
+    expect(@box.__intervals).toEqual [timer]
+    window.clearInterval timer
+
+  it "should stop intervals and timeouts", ->
+    callback = sinon.spy()
+    runs ->
+      @box.setTimeout 10, callback
+      @box.clearTime()
+    waits(10)
+    runs -> expect(callback.callCount).toEqual(0)

data/spec/javascripts/joosy/core/modules/widget_manager_spec.js.coffee

@@ -0,0 +1,75 @@
+describe "Joosy.Modules.WidgetsManager", ->
+
+  beforeEach ->
+    class @TestWidgetManager extends Joosy.Module
+      @include Joosy.Modules.WidgetsManager
+    @box = new @TestWidgetManager()
+    @widgetMock = Object.extended(
+      __load: sinon.stub()
+      __unload: sinon.spy()
+    )
+    @widgetMock.__load.returns @widgetMock
+
+
+  it "should register and unregister widget", ->
+    expect(@box.registerWidget @ground, @widgetMock).toBe @widgetMock
+    expect(@box.__activeWidgets).toEqual [@widgetMock]
+    expect(@widgetMock.__load.callCount).toEqual 1
+
+    expect(@box.unregisterWidget @widgetMock).toBeTruthy()
+    expect(@box.__activeWidgets).toEqual []
+    expect(@widgetMock.__unload.callCount).toEqual 1
+
+  it "should unload all widgets", ->
+    0.upto(2).each => @box.registerWidget(@ground, @widgetMock)
+    @box.__unloadWidgets()
+    expect(@widgetMock.__unload.callCount).toEqual 3
+
+  it "should inherit widget declarations", ->
+    @box.container = @ground
+    @TestWidgetManager::widgets =
+      'test': 'widget'
+    class SubWidgetManagerA extends @TestWidgetManager
+      widgets:
+        'selector': 'widget'
+    class SubWidgetManagerB extends SubWidgetManagerA
+      widgets:
+        'widgets': 'widget'
+        'selector': 'overriden'
+    subBox = new SubWidgetManagerB()
+    target = subBox.__collectWidgets()
+    expect(target).toEqual Object.extended
+      'test': 'widget'
+      'widgets':  'widget'
+      'selector': 'overriden'
+
+  it "should register widgets per declaration", ->
+    @seedGround()
+    @box.container = $('#application')
+    @box.elements = {footer: '.footer'}
+    @box.widgets =
+      '$container': Joosy.Widget
+      '$footer': Joosy.Widget
+      '.post': sinon.stub()
+    @box.widgets['.post'].returns @widgetMock
+    @box.__setupWidgets()
+    expect(@box.__activeWidgets.length).toEqual 5
+    expect(@box.widgets['.post'].callCount).toEqual 3
+    expect(@box.widgets['.post'].getCall(0).calledOn @box).toBeTruthy()
+
+  it "should bootstrap widget properly", ->
+    class TextWidget extends Joosy.Widget
+      @view -> 'fluffy'
+      constructor: (@tester) ->
+
+    @seedGround()
+    @box.container = $('#application')
+    @box.widgets =
+      '.post:first': TextWidget
+      '.widget:first': (i) -> new TextWidget i
+    @box.__setupWidgets()
+
+    expect(@ground.find('.post').html()).toEqual 'fluffy'
+    expect(@ground.find('.widget').html()).toEqual 'fluffy'
+    expect(@box.__activeWidgets[0].tester).toBeUndefined()
+    expect(@box.__activeWidgets[1].tester).toEqual 0

data/spec/javascripts/joosy/core/page_spec.js.coffee

@@ -0,0 +1,175 @@
+describe "Joosy.Page", ->
+
+  beforeEach ->
+    window.JST = 'app/templates/layouts/default': (->)
+    class window.ApplicationLayout extends Joosy.Layout
+    class @TestPage extends Joosy.Page
+
+
+  describe "not rendered page", ->
+
+    beforeEach ->
+      sinon.stub @TestPage.prototype, '__bootstrap'
+      sinon.stub @TestPage.prototype, '__bootstrapLayout'
+      @box = new @TestPage()
+      expect(@TestPage::__bootstrap.callCount).toEqual 0
+      expect(@TestPage::__bootstrapLayout.callCount).toEqual 1
+
+
+    it "should have appropriate accessors", ->
+      callback_names = ['fetch', 'beforePaint', 'paint', 'afterPaint', 'erase']
+      callback_names.each (func) =>
+        @TestPage[func] 'callback'
+        expect(@TestPage::['__' + func]).toEqual 'callback'
+
+      @TestPage.scroll '#here'
+      expect(@TestPage::__scrollElement).toEqual '#here'
+      expect(@TestPage::__scrollSpeed).toEqual 500
+      expect(@TestPage::__scrollMargin).toEqual 0
+
+      @TestPage.scroll '#there', speed: 1000, margin: -5
+      expect(@TestPage::__scrollElement).toEqual '#there'
+      expect(@TestPage::__scrollSpeed).toEqual 1000
+      expect(@TestPage::__scrollMargin).toEqual -5
+
+      @TestPage.layout 'test'
+      expect(@TestPage::__layoutClass).toEqual 'test'
+
+    it "should not render layout if it not changes", ->
+      @box.layout = new ApplicationLayout()
+      @box.layout.yield()
+      new @TestPage {}, @box
+      expect(@TestPage::__bootstrap.callCount).toEqual 1
+      expect(@TestPage::__bootstrapLayout.callCount).toEqual 1
+
+    it "should render layout if it changes", ->
+      class SubLayout extends Joosy.Layout
+      @box = new @TestPage()
+      new @TestPage {}, @box
+      expect(@TestPage::__bootstrap.callCount).toEqual 0
+      expect(@TestPage::__bootstrapLayout.callCount).toEqual 3
+
+    it "should stop render on beforeFilter result", ->
+      sinon.stub @TestPage.prototype, '__runBeforeLoads'
+      @TestPage::__runBeforeLoads.returns(false)
+      new @TestPage()
+      expect(@TestPage::__bootstrap.callCount).toEqual 0
+      expect(@TestPage::__bootstrapLayout.callCount).toEqual 1
+
+    it "should use Router", ->
+      target = sinon.stub Joosy.Router, 'navigate'
+      @box.navigate 'there'
+      expect(target.callCount).toEqual 1
+      expect(target.alwaysCalledWithExactly 'there').toBeTruthy()
+      Joosy.Router.navigate.restore()
+
+    it "should load itself", ->
+      spies = []
+      spies.push sinon.spy(@box, 'refreshElements')
+      spies.push sinon.spy(@box, '__delegateEvents')
+      spies.push sinon.spy(@box, '__setupWidgets')
+      spies.push sinon.spy(@box, '__runAfterLoads')
+      @box.__load()
+      expect(spies).toBeSequenced()
+
+    it "should unload itself", ->
+      spies = []
+      spies.push sinon.spy(@box, 'clearTime')
+      spies.push sinon.spy(@box, '__unloadWidgets')
+      spies.push sinon.spy(@box, '__removeMetamorphs')
+      spies.push sinon.spy(@box, '__runAfterUnloads')
+      @box.__unload()
+      expect(spies).toBeSequenced()
+
+    describe "rendered page", ->
+
+      beforeEach ->
+        @box.previous = new @TestPage()
+        @box.previous.layout = new @box.previous.__layoutClass
+        @box.__renderer = sinon.spy()
+        @box.__layoutClass.prototype.__renderer = sinon.spy()
+        @TestPage::__bootstrap.restore()
+        @TestPage::__bootstrapLayout.restore()
+
+
+      it "should wait stageClear and dataReceived event to start render", ->
+        spies = []
+
+        spies.push @box.previous.__erase = sinon.spy (stage, callback) ->
+          expect(stage.selector).toEqual @layout.content().selector
+          callback()
+
+        spies.push sinon.spy(@box.previous, '__unload')
+
+        spies.push @box.__beforePaint = sinon.spy (stage, callback) ->
+          expect(stage.selector).toEqual @layout.content().selector
+          expect(@__oneShotEvents[0][0]).toEqual ['stageClear', 'dataReceived']
+          callback()
+          expect(@__oneShotEvents[0][0]).toEqual ['dataReceived']
+
+        spies.push @box.__fetch = sinon.spy (callback) ->
+          expect(@__oneShotEvents[0][0]).toEqual ['dataReceived']
+          callback()
+          expect(@__oneShotEvents).toEqual []
+
+        spies.push @box.__paint = sinon.spy (stage, callback) ->
+          expect(stage.selector).toEqual @layout.content().selector
+          expect(typeof callback).toEqual 'function'
+          # callback()  - start rendering
+
+        @box.__bootstrap()
+
+        expect(spies).toBeSequenced()
+
+      it "should render page", ->
+        spies = []
+
+        spies.push @box.__renderer
+        spies.push sinon.spy(@box, 'swapContainer')
+        spies.push sinon.spy(@box, '__load')
+
+        @box.__bootstrap()
+        expect(spies).toBeSequenced()
+
+      it "should wait stageClear and dataReceived event to start layout render", ->
+        spies = []
+
+        spies.push ApplicationLayout::__erase = sinon.spy (stage, page, callback) ->
+          expect(stage.selector).toEqual Joosy.Application.content().selector
+          callback()
+
+        spies.push sinon.spy(@box.previous.layout, '__unload')
+        spies.push sinon.spy(@box.previous, '__unload')
+
+        spies.push ApplicationLayout::__beforePaint = sinon.spy (stage, page, callback) =>
+          expect(stage.selector).toEqual Joosy.Application.content().selector
+          expect(@box.__oneShotEvents[0][0]).toEqual ['stageClear', 'dataReceived']
+          callback()
+          expect(@box.__oneShotEvents[0][0]).toEqual ['dataReceived']
+
+        spies.push @box.__fetch = sinon.spy (callback) ->
+          expect(@__oneShotEvents[0][0]).toEqual ['dataReceived']
+          callback()
+          expect(@__oneShotEvents).toEqual []
+
+        spies.push ApplicationLayout::__paint = sinon.spy (stage, page, callback) ->
+          expect(stage.selector).toEqual Joosy.Application.content().selector
+          expect(typeof callback).toEqual 'function'
+          # callback()  - start rendering
+
+        @box.__bootstrapLayout()
+
+        expect(spies).toBeSequenced()
+
+      it "should render layout and page", ->
+        spies = []
+
+        spies.push @box.__layoutClass.prototype.__renderer
+        spies.push @box.__renderer
+        swapContainer = sinon.spy(@box, 'swapContainer')
+        spies.push @box.__layoutClass.prototype.__load = sinon.spy()
+        spies.push sinon.spy(@box, '__load')
+
+        @box.__bootstrapLayout()
+        expect(spies).toBeSequenced()
+        expect(swapContainer.callCount).toEqual 2

data/spec/javascripts/joosy/core/resource/generic_spec.js.coffee

@@ -0,0 +1,35 @@
+describe "Joosy.Resource.Generic", ->
+
+  beforeEach ->
+    @resource = Joosy.Resource.Generic.create @data =
+      foo: 'bar'
+      bar: 'baz'
+      very:
+        deep:
+          value: 'boo!'
+
+
+  it "should remember where it belongs", ->
+    resource = new Joosy.Resource.Generic foo: 'bar'
+    expect(resource.e).toEqual Object.extended(foo: 'bar')
+    
+  it "should produce magic function", ->
+    expect(Object.isFunction @resource).toBeTruthy()
+    expect(@resource.e).toEqual Object.extended(@data)
+    
+  it "should get values", ->
+    expect(@resource 'foo').toEqual 'bar'
+    expect(@resource 'very.deep').toEqual value: 'boo!'
+    expect(@resource 'very.deep.value').toEqual 'boo!'
+    
+  it "should set values", ->
+    expect(@resource 'foo').toEqual 'bar'
+    @resource 'foo', 'baz'
+    expect(@resource 'foo').toEqual 'baz'
+
+    expect(@resource 'very.deep').toEqual value: 'boo!'
+    @resource 'very.deep', 'banana!'
+    expect(@resource 'very.deep').toEqual 'banana!'
+    
+    @resource 'another.deep.value', 'banana strikes back'
+    expect(@resource 'another.deep').toEqual value: 'banana strikes back'

data/spec/javascripts/joosy/core/resource/rest_collection_spec.js.coffee

@@ -0,0 +1,65 @@
+describe "Joosy.Resource.RESTCollection", ->
+
+  class Test extends Joosy.Resource.REST
+    @entity 'test'
+
+  data = '[{"id": 1, "name": "test1"}, {"id": 2, "name": "test2"}]'
+
+  checkData = (collection) ->
+    expect(collection.data.length).toEqual 2
+    expect(collection.pages[1]).toEqual collection.data
+    expect(collection.data[0].constructor == Test).toBeTruthy()
+    expect(collection.data[0].e.name).toEqual 'test1'
+
+  spoofData = (server) ->
+    target = server.requests.last()
+    expect(target.method).toEqual 'GET'
+    expect(target.url).toMatch /^\/tests\/\?(page=\d+&)?_=\d+/
+    target.respond 200, 'Content-Type': 'application/json', data
+
+  beforeEach ->
+    @server = sinon.fakeServer.create()
+    @collection = new Joosy.Resource.RESTCollection(Test)
+
+  afterEach ->
+    @server.restore()
+
+  it "should initialize", ->
+    expect(@collection.model).toEqual Test
+    expect(@collection.params).toEqual Object.extended()
+    expect(@collection.data).toEqual []
+    expect(@collection.pages).toEqual Object.extended()
+
+  it "should modelize", ->
+    result = @collection.modelize $.parseJSON(data)
+    expect(result[0].constructor == Test).toBeTruthy()
+    expect(result[0].e.name).toEqual 'test1'
+
+  it "should reset", ->
+    @collection.reset $.parseJSON(data)
+    checkData @collection
+
+  it "should fetch", ->
+    @collection.fetch()
+    spoofData @server
+    checkData @collection
+
+  it "should paginate", ->
+    @collection.fetch()
+    spoofData @server
+    checkData @collection
+
+    @collection.page 2, callback=sinon.spy()
+    spoofData @server
+    expect(callback.callCount).toEqual 1
+    expect(@collection.data.length).toEqual 4
+    expect(@collection.data[2].constructor == Test).toBeTruthy()
+    expect(@collection.data[2].e.name).toEqual 'test1'
+
+    # Again from cache
+    @collection.page 2, callback=sinon.spy()
+    spoofData @server
+    expect(callback.callCount).toEqual 1
+    expect(@collection.data.length).toEqual 4
+    expect(@collection.data[2].constructor == Test).toBeTruthy()
+    expect(@collection.data[2].e.name).toEqual 'test1'

data/spec/javascripts/joosy/core/resource/rest_spec.js.coffee

@@ -0,0 +1,108 @@
+describe "Joosy.Resource.REST", ->
+
+  beforeEach ->
+    @server = sinon.fakeServer.create()
+    class @Test extends Joosy.Resource.REST
+      @entity 'test'
+
+  afterEach ->
+    @server.restore()
+
+  it "should have default primary key", ->
+    expect(@Test::__primaryKey).toEqual 'id'
+
+  it "should have appropriate accessors", ->
+    @Test.entity 'tada'
+    expect(@Test::__entityName).toEqual 'tada'
+    expect(@Test.entityName()).toEqual 'tada'
+    @Test.source 'uri'
+    expect(@Test::__source).toEqual 'uri'
+    expect(@Test.__buildSource()).toEqual 'uri/'
+    @Test.primary 'uid'
+    expect(@Test::__primaryKey).toEqual 'uid'
+    @Test.beforeLoad 'function'
+    expect(@Test::__beforeLoad).toEqual 'function'
+
+  it "should build source url based on entity name", ->
+    options =
+      extension: 'id'
+      params:
+        test: 1
+    expect(@Test.__buildSource(options)).toEqual '/tests/id?test=1'
+
+  it "should have overloaded constructor", ->
+    resource = @Test.create 'someId'
+    expect(resource.id).toEqual 'someId'
+
+    data = {id: 'someId', field: 'value'}
+
+    rooted   = @Test.create {test: data}
+    unrooted = @Test.create data
+
+    expect(rooted.e).toEqual unrooted.e
+    expect(rooted.id).toEqual 'someId'
+    expect(rooted.e.id).toEqual 'someId'
+    expect(rooted.e.field).toEqual 'value'
+
+  it 'should find single object', ->
+    @Test.beforeLoad beforeLoadCallback = sinon.spy (data) ->
+      expect(data.id).toEqual 1
+      expect(data.name).toEqual 'test1'
+      Object.extended(test: data)
+    @Test.find 1, callback = sinon.spy (target) ->
+      expect(target.id).toEqual 1
+      expect(target.e?.name).toEqual 'test1'
+    target = @server.requests[0]
+    expect(target.method).toEqual 'GET'
+    expect(target.url).toMatch /^\/tests\/1\?_=\d+/
+    target.respond 200, 'Content-Type': 'application/json',
+      '{"id": 1, "name": "test1"}'
+    expect(callback.callCount).toEqual 1
+    expect(beforeLoadCallback.callCount).toEqual 1
+
+  it 'should find objects collection with params', ->
+    callback = sinon.spy (collection) ->
+      i = 1
+      collection.data.each (target) ->
+        expect(target.id).toEqual i
+        expect(target.e?.name).toEqual 'test' + i
+        i += 1
+    @Test.find null, callback
+    target = @server.requests[0]
+    expect(target.method).toEqual 'GET'
+    expect(target.url).toMatch /^\/tests\/\?_=\d+/
+    target.respond 200, 'Content-Type': 'application/json',
+      '[{"id": 1, "name": "test1"}, {"id": 2, "name": "test2"}]'
+    expect(callback.callCount).toEqual 1
+
+  it 'should find all objects collection', ->
+    callback = sinon.spy (collection) ->
+      i = 1
+      collection.data.each (target) ->
+        expect(target.id).toEqual i
+        expect(target.e?.name).toEqual 'test' + i
+        i += 1
+    @Test.find callback
+    target = @server.requests[0]
+    expect(target.method).toEqual 'GET'
+    expect(target.url).toMatch /^\/tests\/\?_=\d+/
+    target.respond 200, 'Content-Type': 'application/json',
+      '[{"id": 1, "name": "test1"}, {"id": 2, "name": "test2"}]'
+    expect(callback.callCount).toEqual 1
+
+  it 'should destroy single object', ->
+    obj = @Test.create 1
+    callback = sinon.spy (target) ->
+      expect(target).toBe obj
+    obj.destroy callback
+    target = @server.requests[0]
+    expect(target.method).toEqual 'DELETE'
+    expect(target.url).toEqual '/tests/1'
+    target.respond 200
+    expect(callback.callCount).toEqual 1
+
+  it "should identify identifiers", ->
+    [0, 123, -5, '123abd', 'whatever'].each (variant) =>
+      expect(@Test.__isId variant).toBeTruthy()
+    [(->) , [], {}, null, undefined, true, false].each (variant) =>
+      expect(@Test.__isId variant).toBeFalsy()