joosy 0.1.0.RC1 → 0.1.0.RC2

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

@@ -3,7 +3,7 @@ describe "Joosy.Form", ->
   beforeEach ->
     @server = sinon.fakeServer.create()
     @seedGround()
-    @nudeForm = "<form id='nude'><input name='test[foo]'/><input name='test[bar]'/></form>"
+    @nudeForm = "<form id='nude'><input name='test[foo]'/><input name='test[bar]'/><input name='test[bool]' type='checkbox' value='1'/></form>"
     @putForm  = "<form id='put' method='put'><input name='test[camel_baz]'/></form>"
     @moreForm = "<form id='more' method='put'><input name='test[ololo]'/></form>"
 
@@ -20,6 +20,7 @@ describe "Joosy.Form", ->
       foo: 'foo',
       bar: 'bar'
       camelBaz: 'baz'
+      bool: true
 
   afterEach ->
     @server.restore()
@@ -36,7 +37,7 @@ describe "Joosy.Form", ->
       formWithProperties = new Joosy.Form @nudeForm, invalidationClass: 'fluffy'
       expect(formWithProperties.container).toEqual @nudeForm
       expect(formWithProperties.invalidationClass).toEqual 'fluffy'
-      expect(formWithProperties.fields.length).toEqual 2
+      expect(formWithProperties.fields.length).toEqual 3
 
       expect(@spy.callCount).toEqual 1
 
@@ -63,12 +64,15 @@ describe "Joosy.Form", ->
       @putForm  = new Joosy.Form @putForm
       @moreForm = new Joosy.Form @moreForm
 
-    it "should fill form and set propert action and method", ->
+    it "should fill form, set propert action and method and store resource", ->
       @nudeForm.fill @resource
       expect(@nudeForm.fields[0].value).toEqual 'foo'
       expect(@nudeForm.fields[1].value).toEqual 'bar'
+      expect(@nudeForm.fields[2].checked).toEqual true
+      expect(@nudeForm.fields[2].value).toEqual '1'
       expect(@nudeForm.container.attr('method').toLowerCase()).toEqual 'post'
       expect(@nudeForm.container.attr 'action').toEqual '/tests/'
+      expect(@nudeForm.__resource).toEqual @resource
 
     it "should fill form with camelized properties", ->
       @putForm.fill @resource
@@ -83,6 +87,7 @@ describe "Joosy.Form", ->
       expect(@moreForm.fields[0].value).toEqual 'baz'
 
   describe "Callbacks", ->
+
     beforeEach ->
       @nudeForm = new Joosy.Form @nudeForm, @spy=sinon.spy()
       @nudeForm.fill @resource
@@ -97,33 +102,33 @@ describe "Joosy.Form", ->
       expect(@spy.args[0][0]).toEqual {form: 'works'}
 
     it "should fill class for invalidated fields by default", ->
-      @target.respond 422, 'Content-Type': 'application/json', '{"test[foo]": "error!"}'
+      @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
       expect($(@nudeForm.fields[0]).attr 'class').toEqual 'field_with_errors'
 
     it "should trigger 'error' and complete default action if it returned true", ->
       @nudeForm.error = sinon.spy ->
         true
-      @target.respond 422, 'Content-Type': 'application/json', '{"test[foo]": "error!"}'
+      @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
       expect($(@nudeForm.fields[0]).attr 'class').toEqual 'field_with_errors'
       expect(@nudeForm.error.callCount).toEqual 1
-      expect(@nudeForm.error.args[0][0]).toEqual Object.extended
-        "test[foo]": "error!"
+      expect(@nudeForm.error.args[0][0]).toEqual
+        "foo": "error!"
 
     it "should trigger 'error' and skip default action if it returned false", ->
       @nudeForm.error = sinon.spy ->
         false
-      @target.respond 422, 'Content-Type': 'application/json', '{"test[foo]": "error!"}'
+      @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
       expect($(@nudeForm.fields[0]).attr 'class').toNotEqual 'field_with_errors'
       expect(@nudeForm.error.callCount).toEqual 1
 
     it "should clear fields before another submit", ->
-      @target.respond 422, 'Content-Type': 'application/json', '{"test[foo]": "error!"}'
+      @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
       expect($(@nudeForm.fields[0]).attr 'class').toEqual 'field_with_errors'
       @nudeForm.container.submit()
       expect($(@nudeForm.fields[0]).attr 'class').toNotEqual 'field_with_errors'
 
     it "should trigger 'before' and do default action if it returns true", ->
-      @target.respond 422, 'Content-Type': 'application/json', '{"test[foo]": "error!"}'
+      @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
       expect($(@nudeForm.fields[0]).attr 'class').toEqual 'field_with_errors'
       @nudeForm.before = sinon.spy ->
         true
@@ -132,10 +137,48 @@ describe "Joosy.Form", ->
       expect(@nudeForm.before.callCount).toEqual 1
 
     it "should trigger 'before' and skip default action if it returns false", ->
-      @target.respond 422, 'Content-Type': 'application/json', '{"test[foo]": "error!"}'
+      @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
       expect($(@nudeForm.fields[0]).attr 'class').toEqual 'field_with_errors'
       @nudeForm.before = sinon.spy ->
         false
       @nudeForm.container.submit()
       expect($(@nudeForm.fields[0]).attr 'class').toEqual 'field_with_errors'
-      expect(@nudeForm.before.callCount).toEqual 1
+      expect(@nudeForm.before.callCount).toEqual 1
+      
+  describe "Error response handling", ->
+    
+    beforeEach ->
+      @nudeForm = new Joosy.Form @nudeForm, @spy=sinon.spy()
+    
+    it "should prepare simple response", ->
+      errors = {zombie: ['suck'], puppies: ['rock']}
+      result = @nudeForm.__stringifyErrors(errors)
+      
+      expect(result).toEqual zombie: ['suck'], puppies: ['rock']
+      
+    it "should prepare inline response", ->
+      errors = {"zombie.in1.subin1": ['suck'], "zombie.in2": ['rock']}
+      result = @nudeForm.__stringifyErrors(errors)
+      
+      expect(result).toEqual {"zombie[in1][subin1]": ['suck'], "zombie[in2]": ['rock']}
+      
+    it "should prepare inline response with resource attached", ->
+      @nudeForm.fill @resource
+      errors = {"zombie.in1.subin1": ['suck'], "zombie.in2": ['rock']}
+      result = @nudeForm.__stringifyErrors(errors)
+
+      expect(result).toEqual {"test[zombie][in1][subin1]": ['suck'], "test[zombie][in2]": ['rock']}
+      
+    it "should prepare simple response with resource attached", ->
+      @nudeForm.fill @resource
+      errors = {zombie: ['suck'], puppies: ['rock']}
+      result = @nudeForm.__stringifyErrors(errors)
+
+      expect(result).toEqual { "test[zombie]": ['suck'], "test[puppies]": ['rock'] }
+      
+    it "should prepare complexe response", ->
+      @nudeForm.fill @resource
+      errors = {fluffies: {zombie: {mumbas: ['ololo']}}}
+      result = @nudeForm.__stringifyErrors(errors)
+
+      expect(result).toEqual { "fluffies[zombie][mumbas]": ['ololo'] }

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

@@ -32,7 +32,7 @@ describe "Joosy.Layout", ->
 
   it "should unload itself", ->
     spies = []
-    spies.push sinon.spy(@box, 'clearTime')
+    spies.push sinon.spy(@box, '__clearTime')
     spies.push sinon.spy(@box, '__unloadWidgets')
     spies.push sinon.spy(@box, '__runAfterUnloads')
     @box.__unload()

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

@@ -30,7 +30,6 @@ describe "Joosy.Modules.Container", ->
     new_container.trigger 'test'
     expect(new_container.html()).toEqual 'new content'
     expect(new_container.parent().get(0)).toBe parent.get 0
-    expect(old_container.parent().get(0)).toBeUndefined()
     expect(callback.callCount).toEqual 1
 
   it "should inherit element declarations", ->

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

@@ -43,5 +43,5 @@ describe "Joosy.Module", ->
       expect(TestModule[callback].getCall(0).calledOn(Klass)).toBeTruthy()
 
   it "should have minimal set of properties", ->
-    expect(Object.extended(Joosy.Module).keys()).toEqual ['__namespace__', '__className__', 'hasAncestor', 'include', 'extend']
+    expect(Object.extended(Joosy.Module).keys()).toEqual ['__namespace__', '__className', 'hasAncestor', 'merge', 'include', 'extend']
     expect(Object.extended(Joosy.Module.prototype).keys()).toEqual []

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

@@ -27,7 +27,7 @@ describe "Joosy.Modules.Renderer", ->
       template = (locals) ->
         "#{locals.object.value}"
 
-      @render(template, locals)
+      @renderDynamic(template, locals)
 
     elem = $("<div></div>")
     @ground.append elem
@@ -60,7 +60,7 @@ describe "Joosy.Modules.Renderer", ->
       template = (locals) -> 
         "#{locals.zombie}"
 
-      @render(template, locals)
+      @renderDynamic(template, locals)
 
     elem = $("<div></div>")
     @ground.append elem
@@ -80,12 +80,48 @@ describe "Joosy.Modules.Renderer", ->
     runs ->
       expect(elem.text()).toBe "suck"
 
+  it "should render collections and keep html up2date", ->
+    class Foo extends Joosy.Resource.Generic
+      @entity 'foo'
+
+    data = new Joosy.Resource.Collection(Foo)
+    
+    data.reset [
+        { zombie: 'rock' },
+        { zombie: 'never sleep' }
+      ]
+
+    @TestContainer.view (locals) ->
+      template = (locals) ->
+        "#{locals.data[1] 'zombie'}"
+
+      @renderDynamic(template, locals)
+
+    elem = $("<div></div>")
+    @ground.append elem
+
+    elem.html @dummyContainer.__renderer(data)
+
+    waits 0
+
+    runs -> 
+      expect(elem.text()).toBe "never sleep"
+
+    runs ->
+      data.data[1] 'zombie', 'suck'
+    
+    waits 0 
+    
+    runs ->
+      expect(elem.text()).toBe "suck"
+
+
   it "should debounce morpher updates", ->
     @TestContainer.view (locals) ->
       template = (locals) ->
         "#{locals.object.value}"
   
-      @render(template, locals)
+      @renderDynamic(template, locals)
   
     elem = $("<div></div>")
     @ground.append elem

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

@@ -20,6 +20,6 @@ describe "Joosy.Modules.TimeManager", ->
     callback = sinon.spy()
     runs ->
       @box.setTimeout 10, callback
-      @box.clearTime()
+      @box.__clearTime()
     waits(10)
     runs -> expect(callback.callCount).toEqual(0)

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

@@ -74,7 +74,7 @@ describe "Joosy.Page", ->
 
     it "should unload itself", ->
       spies = []
-      spies.push sinon.spy(@box, 'clearTime')
+      spies.push sinon.spy(@box, '__clearTime')
       spies.push sinon.spy(@box, '__unloadWidgets')
       spies.push sinon.spy(@box, '__removeMetamorphs')
       spies.push sinon.spy(@box, '__runAfterUnloads')
@@ -163,6 +163,8 @@ describe "Joosy.Page", ->
 
       it "should render layout and page", ->
         spies = []
+        
+        @box.params = {tested: true}
 
         spies.push @box.__layoutClass.prototype.__renderer
         spies.push @box.__renderer
@@ -173,3 +175,4 @@ describe "Joosy.Page", ->
         @box.__bootstrapLayout()
         expect(spies).toBeSequenced()
         expect(swapContainer.callCount).toEqual 2
+        expect(@box.layout.params).toEqual {tested: true}

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

@@ -0,0 +1,84 @@
+describe "Joosy.Resource.Collection", ->
+
+  class Test extends Joosy.Resource.Generic
+    @entity 'test'
+
+  data = '[{"id": 1, "name": "test1"}, {"id": 2, "name": "test2"}]'
+
+  checkData = (collection) ->
+    expect(collection.data.length).toEqual 2
+    expect(collection.data[0].constructor == Test).toBeTruthy()
+    expect(collection.data[0].e.name).toEqual 'test1'
+
+  beforeEach ->
+    @collection = new Joosy.Resource.Collection(Test)
+
+  it "should initialize", ->
+    expect(@collection.model).toEqual Test
+    expect(@collection.data).toEqual []
+
+  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 trigger changes", ->
+    @collection.bind 'changed', callback = sinon.spy()
+    @collection.reset $.parseJSON(data)
+    expect(callback.callCount).toEqual 1
+
+  it "should not trigger changes", ->
+    @collection.bind 'changed', callback = sinon.spy()
+    @collection.reset $.parseJSON(data), false
+    expect(callback.callCount).toEqual 0
+
+  it "should properly handle the before filter", ->
+    class RC extends Joosy.Resource.Collection
+      @beforeLoad (data) ->
+        data.each (entry, i) ->
+          data[i].tested = true
+        data
+      
+    collection = new RC(Test)
+    collection.reset $.parseJSON(data)
+
+    expect(collection.at(0)('tested')).toBeTruthy()
+
+  it "should remove item from collection", ->
+    @collection.reset $.parseJSON(data)
+    @collection.bind 'changed', callback = sinon.spy()
+    @collection.remove @collection.data[1]
+    expect(@collection.data.length).toEqual 1
+    @collection.remove 0
+    expect(@collection.data.length).toEqual 0
+    expect(callback.callCount).toEqual 2
+
+  it "should silently remove item from collection", ->
+    @collection.reset $.parseJSON(data)
+    @collection.bind 'changed', callback = sinon.spy()
+    @collection.remove @collection.data[1], false
+    expect(@collection.data.length).toEqual 1
+    @collection.remove 0, false
+    expect(@collection.data.length).toEqual 0
+    expect(callback.callCount).toEqual 0
+    
+  it "should add item from collection", ->
+    @collection.reset $.parseJSON(data)
+    @collection.bind 'changed', callback = sinon.spy()
+    @collection.add new Test {'rocking': 'mocking'}
+    expect(@collection.data.length).toEqual 3
+    expect(@collection.at(2).e).toEqual {'rocking': 'mocking'}
+    @collection.add new Test({'rocking': 'mocking'}), 1
+    expect(@collection.data.length).toEqual 4
+    expect(@collection.at(1).e).toEqual {'rocking': 'mocking'}
+    expect(@collection.at(3).e).toEqual {'rocking': 'mocking'}
+    
+  it "should find items by id", ->
+    @collection.reset $.parseJSON(data)
+    
+    expect(@collection.findById 1).toEqual @collection.data[0]
+    expect(@collection.findById 2).toEqual @collection.data[1]

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

@@ -11,11 +11,11 @@ describe "Joosy.Resource.Generic", ->
 
   it "should remember where it belongs", ->
     resource = new Joosy.Resource.Generic foo: 'bar'
-    expect(resource.e).toEqual Object.extended(foo: 'bar')
+    expect(resource.e).toEqual foo: 'bar'
     
   it "should produce magic function", ->
     expect(Object.isFunction @resource).toBeTruthy()
-    expect(@resource.e).toEqual Object.extended(@data)
+    expect(@resource.e).toEqual @data
     
   it "should get values", ->
     expect(@resource 'foo').toEqual 'bar'
@@ -32,4 +32,87 @@ describe "Joosy.Resource.Generic", ->
     expect(@resource 'very.deep').toEqual 'banana!'
     
     @resource 'another.deep.value', 'banana strikes back'
-    expect(@resource 'another.deep').toEqual value: 'banana strikes back'
+    expect(@resource 'another.deep').toEqual value: 'banana strikes back'
+    
+  it "should handle lambdas in @source properly", ->
+    class Fluffy extends Joosy.Resource.Generic
+      @source (rumbas) -> "#{rumbas}!"
+
+    clone = Fluffy.at('rumbas')    
+    
+    expect(-> clone.at 'kutuzka').toThrow(new Error 'clone> should be created directly (without `at\')')
+    expect(clone.__source).toEqual 'rumbas!'
+    
+    expect(Joosy.Module.hasAncestor clone, Fluffy).toBeTruthy()
+    # clone won't be instanceof Fluffy in IE
+    #expect(clone.create({}) instanceof Fluffy).toBeTruthy()
+    
+  it "should trigger 'changed' right", ->
+    callback = sinon.spy()
+    @resource.bind 'changed', callback
+    @resource 'foo', 'baz'
+    @resource 'foo', 'baz2'
+    
+    expect(callback.callCount).toEqual(2)
+    
+  it "should properly handle the before filter", ->
+    class R extends Joosy.Resource.Generic
+      @beforeLoad (data) ->
+        data ||= {}
+        data.tested = true
+        data
+        
+      resource = R.create()
+      
+      expect(resource 'tested').toBeTruthy()
+      
+  it "should map inlines", ->
+    class RumbaMumba extends Joosy.Resource.Generic   
+      @entity 'rumba_mumba'
+ 
+    class R extends Joosy.Resource.Generic
+      @map 'rumbaMumbas', RumbaMumba
+
+    resource = R.create
+      rumbaMumbas: [
+        {foo: 'bar'},
+        {bar: 'baz'}
+      ]
+    expect(resource.rumbaMumbas instanceof Joosy.Resource.Collection).toBeTruthy()
+    expect(resource.rumbaMumbas.at(0)('foo')).toEqual 'bar'
+    
+    
+  it "should use magic collections", ->
+    class window.RumbaMumbasCollection extends Joosy.Resource.Collection
+      
+    class RumbaMumba extends Joosy.Resource.Generic
+      @entity 'rumba_mumba'
+    class R extends Joosy.Resource.Generic
+      @map 'rumbaMumbas', RumbaMumba
+
+    resource = R.create
+      rumbaMumbas: [
+        {foo: 'bar'},
+        {bar: 'baz'}
+      ]
+    expect(resource.rumbaMumbas instanceof RumbaMumbasCollection).toBeTruthy()
+    expect(resource.rumbaMumbas.at(0)('foo')).toEqual 'bar'
+    
+    window.RumbaMumbasCollection = undefined
+    
+  it "should use manually set collections", ->
+    class OloCollection extends Joosy.Resource.Collection
+
+    class RumbaMumba extends Joosy.Resource.Generic
+      @entity 'rumba_mumba'
+      @collection OloCollection
+    class R extends Joosy.Resource.Generic
+      @map 'rumbaMumbas', RumbaMumba
+
+    resource = R.create
+      rumbaMumbas: [
+        {foo: 'bar'},
+        {bar: 'baz'}
+      ]
+    expect(resource.rumbaMumbas instanceof OloCollection).toBeTruthy()
+    expect(resource.rumbaMumbas.at(0)('foo')).toEqual 'bar'

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

@@ -7,7 +7,6 @@ describe "Joosy.Resource.RESTCollection", ->
 
   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'
 
@@ -24,21 +23,6 @@ describe "Joosy.Resource.RESTCollection", ->
   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
@@ -52,14 +36,23 @@ describe "Joosy.Resource.RESTCollection", ->
     @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'
+    expect(@collection.data.length).toEqual 2
+    expect(@collection.data[0].constructor == Test).toBeTruthy()
+    expect(@collection.data[0].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'
+    expect(@collection.data.length).toEqual 2
+    expect(@collection.data[0].constructor == Test).toBeTruthy()
+    expect(@collection.data[0].e.name).toEqual 'test1'
+    
+  it "should trigger changes", ->
+    @collection.bind 'changed', callback = sinon.spy()
+    @collection.fetch()
+    spoofData @server
+    expect(callback.callCount).toEqual 1
+    @collection.page 2
+    spoofData @server
+    expect(callback.callCount).toEqual 2

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

@@ -14,9 +14,8 @@ describe "Joosy.Resource.REST", ->
   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.__source).toEqual 'uri'
     expect(@Test.__buildSource()).toEqual 'uri/'
     @Test.primary 'uid'
     expect(@Test::__primaryKey).toEqual 'uid'
@@ -48,7 +47,7 @@ describe "Joosy.Resource.REST", ->
     @Test.beforeLoad beforeLoadCallback = sinon.spy (data) ->
       expect(data.id).toEqual 1
       expect(data.name).toEqual 'test1'
-      Object.extended(test: data)
+      Object.extended(data)
     @Test.find 1, callback = sinon.spy (target) ->
       expect(target.id).toEqual 1
       expect(target.e?.name).toEqual 'test1'
@@ -56,13 +55,14 @@ describe "Joosy.Resource.REST", ->
     expect(target.method).toEqual 'GET'
     expect(target.url).toMatch /^\/tests\/1\?_=\d+/
     target.respond 200, 'Content-Type': 'application/json',
-      '{"id": 1, "name": "test1"}'
+      '{"test": {"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
+      expect(collection instanceof Joosy.Resource.RESTCollection).toBeTruthy()
       collection.data.each (target) ->
         expect(target.id).toEqual i
         expect(target.e?.name).toEqual 'test' + i
@@ -78,6 +78,7 @@ describe "Joosy.Resource.REST", ->
   it 'should find all objects collection', ->
     callback = sinon.spy (collection) ->
       i = 1
+      expect(collection instanceof Joosy.Resource.RESTCollection).toBeTruthy()
       collection.data.each (target) ->
         expect(target.id).toEqual i
         expect(target.e?.name).toEqual 'test' + i
@@ -106,3 +107,25 @@ describe "Joosy.Resource.REST", ->
       expect(@Test.__isId variant).toBeTruthy()
     [(->) , [], {}, null, undefined, true, false].each (variant) =>
       expect(@Test.__isId variant).toBeFalsy()
+
+  it "should trigger 'changed' on fetch", ->
+    resource = @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',
+      '{"test": {"id": 1, "name": "test1"}}'
+    expect(callback.callCount).toEqual 1
+    
+    resource.bind 'changed', callback = sinon.spy()
+    resource.fetch()
+    
+    target = @server.requests[1]
+    expect(target.method).toEqual 'GET'
+    expect(target.url).toMatch /^\/tests\/1\?_=\d+/
+    target.respond 200, 'Content-Type': 'application/json',
+      '{"test": {"id": 1, "name": "test1"}}'
+      
+    expect(callback.callCount).toEqual 1

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

@@ -11,19 +11,6 @@ describe "Joosy.Widget", ->
     @TestWidget.view 'test'
     expect(@TestWidget::__renderer instanceof Function).toBeTruthy()
 
-  it "should use parent's TimeManager", ->
-    @box.parent =
-      setInterval: sinon.spy()
-      setTimeout: sinon.spy()
-    @box.setInterval 1, 2, 3
-    @box.setTimeout 1, 2, 3
-    target = @box.parent.setInterval
-    expect(target.callCount).toEqual 1
-    expect(target.alwaysCalledWithExactly 1, 2, 3).toBeTruthy()
-    target = @box.parent.setTimeout
-    expect(target.callCount).toEqual 1
-    expect(target.alwaysCalledWithExactly 1, 2, 3).toBeTruthy()
-
   it "should use Router", ->
     target = sinon.stub Joosy.Router, 'navigate'
     @box.navigate 'there'
@@ -32,6 +19,7 @@ describe "Joosy.Widget", ->
     Joosy.Router.navigate.restore()
 
   it "should load itself", ->
+    @box.data = {tested: true}
     spies = [sinon.spy()]
     @TestWidget.view spies[0]
     @parent = new Joosy.Layout()
@@ -41,6 +29,7 @@ describe "Joosy.Widget", ->
     target = @box.__load @parent, @ground
     expect(target).toBe @box
     expect(@box.__renderer.getCall(0).calledOn()).toBeFalsy()
+    expect(@box.__renderer.getCall(0).args[0]).toEqual {tested: true}
     expect(spies).toBeSequenced()
 
   it "should unload itself", ->
@@ -48,4 +37,4 @@ describe "Joosy.Widget", ->
     @box.__unload()
     target = @box.__runAfterUnloads
     expect(target.callCount).toEqual 1
-    expect(target.getCall(0).calledOn()).toBeFalsy()
+    expect(target.getCall(0).calledOn()).toBeFalsy()