joosy 0.1.0.alpha → 1.0.0.RC1

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

@@ -0,0 +1,178 @@
+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 = []
+        
+        @box.params = {tested: true}
+
+        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
+        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].data.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].data.name).toEqual 'test1'
+
+  it "should load", ->
+    @collection.load $.parseJSON(data)
+    checkData @collection
+  
+  it "should trigger changes", ->
+    @collection.bind 'changed', callback = sinon.spy()
+    @collection.load $.parseJSON(data)
+    expect(callback.callCount).toEqual 1
+
+  it "should not trigger changes", ->
+    @collection.bind 'changed', callback = sinon.spy()
+    @collection.load $.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.load $.parseJSON(data)
+
+    expect(collection.at(0)('tested')).toBeTruthy()
+
+  it "should remove item from collection", ->
+    @collection.load $.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.load $.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.load $.parseJSON(data)
+    @collection.bind 'changed', callback = sinon.spy()
+    @collection.add new Test {'rocking': 'mocking'}
+    expect(@collection.data.length).toEqual 3
+    expect(@collection.at(2).data).toEqual {'rocking': 'mocking'}
+    @collection.add new Test({'rocking': 'mocking'}), 1
+    expect(@collection.data.length).toEqual 4
+    expect(@collection.at(1).data).toEqual {'rocking': 'mocking'}
+    expect(@collection.at(3).data).toEqual {'rocking': 'mocking'}
+    
+  it "should find items by id", ->
+    @collection.load $.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

@@ -0,0 +1,149 @@
+describe "Joosy.Resource.Generic", ->
+
+  class TestInline extends Joosy.Resource.Generic
+    @entity 'test_inline'
+
+  class Test extends Joosy.Resource.REST
+    @entity 'test'
+    @map 'test_inlines', TestInline
+
+  beforeEach ->
+    @resource = Joosy.Resource.Generic.build @data =
+      foo: 'bar'
+      bar: 'baz'
+      very:
+        deep:
+          value: 'boo!'
+
+  it "has primary key", ->
+    expect(Test::__primaryKey).toEqual 'id'
+
+  it "remembers where it belongs", ->
+    resource = new Joosy.Resource.Generic foo: 'bar'
+    expect(resource.data).toEqual foo: 'bar'
+    
+  it "produces magic function", ->
+    expect(Object.isFunction @resource).toBeTruthy()
+    expect(@resource.data).toEqual @data
+    
+  it "gets values", ->
+    expect(@resource 'foo').toEqual 'bar'
+    expect(@resource 'very.deep').toEqual value: 'boo!'
+    expect(@resource 'very.deep.value').toEqual 'boo!'
+    
+  it "sets 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'
+    
+  it "handles @at", ->
+    class Fluffy extends Joosy.Resource.Generic
+
+    clone = Fluffy.at('rumbas!')
+    
+    expect(clone.__source).toEqual 'rumbas!'
+    expect(Joosy.Module.hasAncestor clone, Fluffy).toBeTruthy()
+    # clone won't be instanceof Fluffy in IE
+    #expect(clone.build({}) instanceof Fluffy).toBeTruthy()
+    
+  it "triggers 'changed' right", ->
+    callback = sinon.spy()
+    @resource.bind 'changed', callback
+    @resource 'foo', 'baz'
+    @resource 'foo', 'baz2'
+    
+    expect(callback.callCount).toEqual(2)
+    
+  it "handles the before filter", ->
+    class R extends Joosy.Resource.Generic
+      @beforeLoad (data) ->
+        data ||= {}
+        data.tested = true
+        data
+        
+      resource = R.build()
+      
+      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
+
+    class S extends Joosy.Resource.Generic
+      @map 'rumbaMumba', RumbaMumba
+
+    resource = R.build
+      rumbaMumbas: [
+        {foo: 'bar'},
+        {bar: 'baz'}
+      ]
+    expect(resource('rumbaMumbas') instanceof Joosy.Resource.Collection).toBeTruthy()
+    expect(resource('rumbaMumbas').at(0)('foo')).toEqual 'bar'
+
+    resource = S.build
+      rumbaMumba: {foo: 'bar'}
+    expect(resource('rumbaMumba') instanceof Joosy.Resource.Generic).toBeTruthy()
+    expect(resource('rumbaMumba.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.build
+      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.build
+      rumbaMumbas: [
+        {foo: 'bar'},
+        {bar: 'baz'}
+      ]
+    expect(resource('rumbaMumbas') instanceof OloCollection).toBeTruthy()
+    expect(resource('rumbaMumbas').at(0)('foo')).toEqual 'bar'
+
+  describe "identity map", ->
+
+    it "handles builds", ->
+      foo = Test.build 1
+      bar = Test.build 1
+
+      expect(foo).toEqual bar
+
+    it "handles maps", ->
+      inline = TestInline.build(1)
+      root   = Test.build
+        id: 1
+        test_inlines: [{id: 1}, {id: 2}]
+
+      inline('foo', 'bar')
+
+      expect(root('test_inlines').at(0)('foo')).toEqual 'bar'

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

@@ -0,0 +1,31 @@
+describe "Joosy.Resource.RESTCollection", ->
+
+  class Test extends Joosy.Resource.REST
+    @entity 'test'
+
+  beforeEach ->
+    @server = sinon.fakeServer.create()
+    @collection = new Joosy.Resource.RESTCollection(Test)
+
+  afterEach ->
+    @server.restore()
+
+  it "loads", ->
+    @collection.load [{"id": 1, "name": "test1"}, {"id": 2, "name": "test2"}]
+    console.log @collection.data[0].constructor
+    expect(@collection.data.length).toEqual 2
+    expect(@collection.data[0] instanceof Test).toBeTruthy()
+    expect(@collection.data[0].data.name).toEqual 'test1'
+
+  it "reloads", ->
+    @collection.load [{"id": 1, "name": "test1"}, {"id": 2, "name": "test2"}]
+    @collection.reload from: 'test'
+
+    target = @server.requests.last()
+    expect(target.method).toEqual 'GET'
+    expect(target.url).toMatch /^\/tests\/test\?_=\d+/
+    target.respond 200, 'Content-Type': 'application/json', '[{"id": 3, "name": "test3"}, {"id": 4, "name": "test4"}, {"id": 5, "name": "test5"}]'
+
+    expect(@collection.data.length).toEqual 3
+    expect(@collection.data[0].constructor == Test).toBeTruthy()
+    expect(@collection.data[0].data.name).toEqual 'test3'

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

@@ -0,0 +1,171 @@
+describe "Joosy.Resource.REST", ->
+
+  class FluffyInline extends Joosy.Resource.REST
+    @entity 'fluffy_inline'
+
+  class FluffyParent extends Joosy.Resource.REST
+    @entity 'fluffy_parent'
+
+  class Fluffy extends Joosy.Resource.REST
+    @entity 'fluffy'
+    @map 'fluffy_inlines', FluffyInline
+
+  beforeEach ->
+    @server = sinon.fakeServer.create()
+
+  afterEach ->
+    @server.restore()
+
+  checkAndRespond = (target, method, url, data) ->
+    expect(target.method).toEqual method
+    expect(target.url).toMatch url
+    target.respond 200, 'Content-Type': 'application/json', data
+
+  it "builds member path", ->
+    parent = FluffyParent.build 1
+
+    expect(Fluffy.memberPath 1).toEqual '/fluffies/1'
+    expect(Fluffy.memberPath 1, parent: parent).toEqual '/fluffy_parents/1/fluffies/1'
+    expect(Fluffy.memberPath 1, parent: parent, from: 'test').toEqual '/fluffy_parents/1/fluffies/1/test'
+    expect(Fluffy.memberPath 1, parent: parent, from: 'test', params: {foo: 'bar'}).toEqual '/fluffy_parents/1/fluffies/1/test'
+
+  it "builds collection path", ->
+    parent = FluffyParent.build 1
+
+    expect(Fluffy.collectionPath()).toEqual '/fluffies'
+    expect(Fluffy.collectionPath parent: parent).toEqual '/fluffy_parents/1/fluffies'
+    expect(Fluffy.collectionPath parent: parent, from: 'test').toEqual '/fluffy_parents/1/fluffies/test'
+    expect(Fluffy.collectionPath parent: parent, from: 'test', params: {foo: 'bar'}).toEqual '/fluffy_parents/1/fluffies/test'
+
+
+  describe "finds resource", ->
+    rawData = '{"fluffy": {"id": 1, "name": "test1"}}'
+
+    callback = sinon.spy (target) ->
+      expect(target instanceof Fluffy).toEqual true
+      expect(target.id()).toEqual 1
+      expect(target 'name').toEqual 'test1'
+
+    it "without params", ->
+      resource = Fluffy.find 1, callback
+      checkAndRespond @server.requests[0], 'GET', /^\/fluffies\/1\?_=\d+/, rawData
+      expect(callback.callCount).toEqual 1
+
+    it "with from", ->
+      resource = Fluffy.find 1, {from: 'action'}, callback
+      checkAndRespond @server.requests[0], 'GET', /^\/fluffies\/1\/action\?_=\d+/, rawData
+      expect(callback.callCount).toEqual 2
+
+    it "with from and parent", ->
+      resource = Fluffy.find 1, {parent: FluffyParent.build(1), from: 'action'}, callback
+      checkAndRespond @server.requests[0], 'GET', /^\/fluffy_parents\/1\/fluffies\/1\/action\?_=\d+/, rawData
+      expect(callback.callCount).toEqual 3
+
+    it "with params", ->
+      resource = Fluffy.find 1, params: {foo: 'bar'}, callback
+      checkAndRespond @server.requests[0], 'GET', /^\/fluffies\/1\?foo=bar&_=\d+/, rawData
+      expect(callback.callCount).toEqual 4
+
+    it "with direct assignation", ->
+      resource = Fluffy.find 1, ->
+        expect(resource instanceof Fluffy).toEqual true
+        expect(resource.id()).toEqual 1
+        expect(resource 'name').toEqual 'test1'
+
+      checkAndRespond @server.requests[0], 'GET', /^\/fluffies\/1\?_=\d+/, rawData
+
+  describe "finds collection", ->
+    rawData = '{"fluffies": [{"id": 1, "name": "test1"}, {"id": 2, "name": "test2"}]}'
+
+    callback = sinon.spy (target) ->
+      expect(target instanceof Joosy.Resource.RESTCollection).toEqual true
+      expect(target.size()).toEqual 2
+      expect(target.at(0) instanceof Fluffy).toEqual true
+
+    it "without params", ->
+      resource = Fluffy.find 'all', callback
+      checkAndRespond @server.requests[0], 'GET', /^\/fluffies\?_=\d+/, rawData
+      expect(callback.callCount).toEqual 1
+
+    it "with from", ->
+      resource = Fluffy.find 'all', {from: 'action'}, callback
+      checkAndRespond @server.requests[0], 'GET', /^\/fluffies\/action\?_=\d+/, rawData
+      expect(callback.callCount).toEqual 2
+
+    it "with from and parent", ->
+      resource = Fluffy.find 'all', {parent: FluffyParent.build(1), from: 'action'}, callback
+      checkAndRespond @server.requests[0], 'GET', /^\/fluffy_parents\/1\/fluffies\/action\?_=\d+/, rawData
+      expect(callback.callCount).toEqual 3
+
+    it "with params", ->
+      resource = Fluffy.find 'all', params: {foo: 'bar'}, callback
+      checkAndRespond @server.requests[0], 'GET', /^\/fluffies\?foo=bar&_=\d+/, rawData
+      expect(callback.callCount).toEqual 4
+
+  it "reloads resource", ->
+    rawData  = '{"fluffy": {"id": 1, "name": "test1"}}'
+    resource = Fluffy.find 1
+    callback = sinon.spy()
+
+    checkAndRespond @server.requests[0], 'GET', /^\/fluffies\/1\?_=\d+/, rawData
+    resource.bind 'changed', callback = sinon.spy()
+    resource.reload()
+    checkAndRespond @server.requests[1], 'GET', /^\/fluffies\/1\?_=\d+/, rawData
+    expect(callback.callCount).toEqual 1
+
+  describe "requests", ->
+    rawData  = '{"foo": "bar"}'
+    callback = sinon.spy (data) ->
+      expect(data).toEqual {foo: 'bar'}
+
+    describe "member", ->
+      resource = Fluffy.build 1
+
+      it "with get", ->
+        resource.get {from: 'foo', params: {foo: 'bar'}}, callback
+        checkAndRespond @server.requests[0], 'GET', /^\/fluffies\/1\/foo\?foo=bar&_=\d+/, rawData
+
+      it "with post", ->
+        resource.post callback
+        checkAndRespond @server.requests[0], 'POST', /^\/fluffies\/1/, rawData
+
+      it "with put", ->
+        resource.put callback
+        checkAndRespond @server.requests[0], 'PUT', /^\/fluffies\/1/, rawData
+
+      it "with delete", ->
+        resource.delete callback
+        checkAndRespond @server.requests[0], 'DELETE', /^\/fluffies\/1/, rawData
+
+    describe "collection", ->
+      resource = Fluffy
+
+      it "with get", ->
+        resource.get {from: 'foo', params: {foo: 'bar'}}, callback
+        checkAndRespond @server.requests[0], 'GET', /^\/fluffies\/foo\?foo=bar&_=\d+/, rawData
+
+      it "with post", ->
+        resource.post callback
+        checkAndRespond @server.requests[0], 'POST', /^\/fluffies/, rawData
+
+      it "with put", ->
+        resource.put callback
+        checkAndRespond @server.requests[0], 'PUT', /^\/fluffies/, rawData
+
+      it "with delete", ->
+        resource.delete callback
+        checkAndRespond @server.requests[0], 'DELETE', /^\/fluffies/, rawData
+
+  describe "identity map", ->
+
+    it "handles finds", ->
+      inline = FluffyInline.build(1)
+      root   = Fluffy.find 1
+
+      inline.bind 'changed', callback = sinon.spy()
+
+      checkAndRespond @server.requests[0], 'GET', /^\/fluffies\/1\?_=\d+/,
+        '{"id": 1, "fluffy_inlines": [{"id": 1, "name": 1}, {"id": 2, "name": 2}]}'
+
+      expect(inline 'name').toEqual 1
+      expect(callback.callCount).toEqual 1