brainstem-js 0.2.1 → 0.3.0

data/spec/brainstem-utils-spec.coffee

@@ -1,5 +1,5 @@
 describe 'Brainstem Utils', ->
-  describe "matches", ->
+  describe ".matches", ->
     it "should recursively compare objects and arrays", ->
       expect(Brainstem.Utils.matches(2, 2)).toBe true
       expect(Brainstem.Utils.matches([2], [2])).toBe true, '[2], [2]'
@@ -10,3 +10,13 @@ describe 'Brainstem Utils', ->
       expect(Brainstem.Utils.matches([2, { hi: "there" }], [2, { hi: "there" }])).toBe true, '[2, { hi: "there" }], [2, { hi: "there" }]'
       expect(Brainstem.Utils.matches([2, { hi: ["there", 3] }], [2, { hi: ["there", 2] }])).toBe false
       expect(Brainstem.Utils.matches([2, { hi: ["there", 2] }], [2, { hi: ["there", 2] }])).toBe true, '[2, { hi: ["there", 2] }], [2, { hi: ["there", 2] }]'
+
+  describe ".wrapObjects", ->
+    it "wraps elements in an array with objects unless they are already objects", ->
+      expect(Brainstem.Utils.wrapObjects([])).toEqual []
+      expect(Brainstem.Utils.wrapObjects(['a', 'b'])).toEqual [{a: []}, {b: []}]
+      expect(Brainstem.Utils.wrapObjects(['a', 'b': []])).toEqual [{a: []}, {b: []}]
+      expect(Brainstem.Utils.wrapObjects(['a', 'b': 'c'])).toEqual [{a: []}, {b: [{c: []}]}]
+      expect(Brainstem.Utils.wrapObjects([{'a':[], b: 'c', d: 'e' }])).toEqual [{a: []}, {b: [{c: []}]}, {d: [{e: []}]}]
+      expect(Brainstem.Utils.wrapObjects(['a', { b: 'c', d: 'e' }])).toEqual [{a: []}, {b: [{c: []}]}, {d: [{e: []}]}]
+      expect(Brainstem.Utils.wrapObjects([{'a': []}, {'b': ['c', d: []]}])).toEqual [{a: []}, {b: [{c: []}, {d: []}]}]

data/spec/helpers/builders.coffee

@@ -25,8 +25,8 @@ spec.defineBuilders = ->
       window.base.data.storage(storageName).add obj if window.base.data.collectionExists(storageName)
       obj
 
-    eval("window.#{"build_#{name.underscore()}".camelize(true)} = builder")
-    eval("window.#{"build_and_cache_#{name.underscore()}".camelize(true)} = creator")
+    window["build_#{name.underscore()}".camelize(true)] = builder
+    window["build_and_cache_#{name.underscore()}".camelize(true)] = creator
 
   isIdAttr = (attrName) ->
     attrName == 'id' || attrName.match(/_id$/) || (attrName.match(/_ids$/))

data/spec/helpers/models/post.coffee

@@ -1,7 +1,7 @@
 class App.Models.Post extends Brainstem.Model
   brainstemKey: "posts"
   paramRoot: 'post'
-  url: '/api/posts'
+  urlRoot: '/api/posts'
 
   @associations:
     replies:            ["posts"]

data/spec/helpers/models/project.coffee

@@ -1,7 +1,7 @@
 class App.Models.Project extends Brainstem.Model
   brainstemKey: "projects"
   paramRoot: 'project'
-  url: '/api/projects'
+  urlRoot: '/api/projects'
 
   @associations:
     tasks: ["tasks"]

data/spec/helpers/models/task.coffee

@@ -1,7 +1,7 @@
 class App.Models.Task extends Brainstem.Model
   brainstemKey: "tasks"
   paramRoot: 'task'
-  url: '/api/tasks.json'
+  urlRoot: '/api/tasks'
 
   @associations:
     project: "projects"
@@ -11,4 +11,4 @@ class App.Models.Task extends Brainstem.Model
 
 class App.Collections.Tasks extends Brainstem.Collection
   model: App.Models.Task
-  url: '/api/tasks.json'
+  url: '/api/tasks'

data/spec/helpers/models/time-entry.coffee

@@ -1,7 +1,7 @@
 class App.Models.TimeEntry extends Brainstem.Model
   brainstemKey: "time_entries"
   paramRoot: 'time_entry'
-  url: '/api/time_entries'
+  urlRoot: '/api/time_entries'
 
   @associations:
     project: "projects"

data/spec/helpers/models/user.coffee

@@ -1,7 +1,7 @@
 class App.Models.User extends Brainstem.Model
   brainstemKey: "users"
   paramRoot: 'user'
-  url: "/api/users"
+  urlRoot: "/api/users"
 
 class App.Collections.Users extends Brainstem.Collection
   model: App.Models.User

data/spec/helpers/spec-helper.coffee

@@ -77,3 +77,24 @@ window.clearLiveEventBindings = ->
 
 window.context = describe
 window.xcontext = xdescribe
+
+# Shared Behaviors
+window.SharedBehaviors ?= {};
+
+window.registerSharedBehavior = (behaviorName, funct) ->
+  if not behaviorName
+    throw "Invalid shared behavior name"
+
+  if typeof funct != 'function'
+    throw "Invalid shared behavior, it must be a function"
+
+  window.SharedBehaviors[behaviorName] = funct
+
+window.itShouldBehaveLike = (behaviorName, context) ->
+  behavior = window.SharedBehaviors[behaviorName];
+  context ?= {}
+
+  if not behavior || typeof behavior != 'function'
+    throw "Shared behavior #{behaviorName} not found."
+  else
+    jasmine.getEnv().describe "#{behaviorName} (shared behavior)", -> behavior.call(this, context)

data/spec/loaders/abstract-loader-shared-behavior.coffee

@@ -0,0 +1,604 @@
+registerSharedBehavior "AbstractLoaderSharedBehavior", (sharedContext) ->
+  loader = loaderClass = null
+
+  beforeEach ->
+    loaderClass = sharedContext.loaderClass
+
+  fakeNestedInclude = ['parent', { project: ['participants'] }, { assignees: ['something_else'] }]
+
+  defaultLoadOptions = ->
+    name: 'tasks'
+
+  createLoader = (opts = {}) ->
+    storageManager = new Brainstem.StorageManager()
+    storageManager.addCollection('tasks', App.Collections.Tasks)
+
+    defaults = 
+      storageManager: storageManager
+
+    loader = new loaderClass(_.extend {}, defaults, opts)
+    loader._getCollectionName = -> 'tasks'
+    loader._createObjects = ->
+      @internalObject = bar: 'foo'
+      @externalObject = foo: 'bar'
+      
+    loader._getModelsForAssociation = -> [{ id: 5 }, { id: 2 }, { id: 1 }, { id: 4 }, { id: 1 }, [{ id: 6 }], { id: null }]
+    loader._getModel = -> App.Collections.Tasks::model
+    loader._updateStorageManagerFromResponse = jasmine.createSpy()
+    loader._updateObjects = (obj, data, silent) ->
+      obj.setLoaded true unless silent
+
+    spyOn(loader, '_updateObjects')
+
+    loader
+
+  describe '#constructor', ->
+    it 'saves off a reference to the passed in StorageManager', ->
+      storageManager = new Brainstem.StorageManager()
+      loader = createLoader(storageManager: storageManager)
+      expect(loader.storageManager).toEqual storageManager
+
+    it 'creates a deferred object and turns the loader into a promise', ->
+      spy = jasmine.createSpy('promise spy')
+
+      loader = createLoader()
+      expect(loader._deferred).not.toBeUndefined()
+      loader.then(spy)
+
+      loader._deferred.resolve()
+      expect(spy).toHaveBeenCalled()
+
+    describe 'options.loadOptions', ->
+      it 'calls #setup with loadOptions if loadOptions were passed in', ->
+        spy = spyOn(loaderClass.prototype, 'setup')
+
+        loader = createLoader(loadOptions: defaultLoadOptions())
+        expect(spy).toHaveBeenCalledWith defaultLoadOptions()
+
+      it 'does not call #setup if loadOptions were not passed in', ->
+        spy = spyOn(loaderClass.prototype, 'setup')
+
+        loader = createLoader()
+        expect(spy).not.toHaveBeenCalled()
+
+  describe '#setup', ->
+    it 'calls #_parseLoadOptions with the loadOptions', ->
+      loader = createLoader()
+      spyOn(loader, '_parseLoadOptions')
+
+      opts = foo: 'bar'
+
+      loader.setup(opts)
+      expect(loader._parseLoadOptions).toHaveBeenCalledWith(opts)
+
+    it 'calls _createObjects', ->
+      loader = createLoader()
+      spyOn(loader, '_createObjects')
+
+      loader.setup()
+      expect(loader._createObjects).toHaveBeenCalled()
+
+    it 'returns the externalObject', ->
+      loader = createLoader()
+      spyOn(loader, '_parseLoadOptions')
+
+      externalObject = loader.setup()
+      expect(externalObject).toEqual(loader.externalObject)
+
+  describe '#load', ->
+    describe 'sanity checking loadOptions', ->
+      funct = null
+
+      beforeEach ->
+        loader = createLoader()
+        spyOn(loader, '_checkCacheForData')
+        spyOn(loader, '_loadFromServer')
+        funct = -> loader.load()
+
+      it 'throws if there are no loadOptions', ->
+        expect(funct).toThrow()
+
+      it 'does not throw if there are loadOptions', ->
+        loader.loadOptions = {}
+        expect(funct).not.toThrow()
+
+    describe 'checking the cache', ->
+      beforeEach ->
+        loader = createLoader()
+        spyOn(loader, '_checkCacheForData')
+        spyOn(loader, '_loadFromServer')
+
+      context 'loadOptions.cache is true', ->
+        it 'calls #_checkCacheForData', ->
+          loader.setup()
+          expect(loader.loadOptions.cache).toEqual(true)
+
+          loader.load()
+          expect(loader._checkCacheForData).toHaveBeenCalled()
+
+        context '#_checkCacheForData returns data', ->
+          it 'returns the data', ->
+            fakeData = ['some', 'stuff']
+            loader._checkCacheForData.andReturn(fakeData)
+
+            loader.setup()
+            expect(loader.load()).toEqual(fakeData)
+
+        context '#_checkCacheForData does not return data', ->
+          it 'calls #_loadFromServer', ->
+            loader.setup()
+            loader.load()
+            expect(loader._loadFromServer).toHaveBeenCalled()
+
+      context 'loadOptions.cache is false', ->
+        it 'does not call #_checkCacheForData', ->
+          loader.setup(cache: false)
+
+          loader.load()
+          expect(loader._checkCacheForData).not.toHaveBeenCalled()
+
+        it 'calls #_loadFromServer', ->
+          loader.setup()
+          loader.load()
+          expect(loader._loadFromServer).toHaveBeenCalled()
+
+  describe '#_parseLoadOptions', ->
+    opts = null
+
+    beforeEach ->
+      loader = createLoader()
+      opts = defaultLoadOptions()
+
+    it 'saves off a reference of the loadOptions as originalOptions', ->
+      loader._parseLoadOptions(defaultLoadOptions())
+      expect(loader.originalOptions).toEqual(defaultLoadOptions())
+
+    it 'parses the include options', ->
+      opts.include = ['foo': ['bar'], 'toad', 'stool']
+      loadOptions = loader._parseLoadOptions(opts)
+
+      expect(loadOptions.include).toEqual [
+        { foo: [{ bar: [ ]}] }
+        { toad: [] }
+        { stool: [] }
+      ]
+
+    describe 'only parsing', ->
+      context 'only is present', ->
+        it 'sets only as an array of strings from the original only', ->
+          opts.only = [1, 2, 3, 4]
+          loadOptions = loader._parseLoadOptions(opts)
+
+          expect(loadOptions.only).toEqual ['1', '2', '3', '4']
+
+      context 'only is not present', ->
+        it 'sets only as null', ->
+          loadOptions = loader._parseLoadOptions(opts)
+          expect(loadOptions.only).toEqual(null)
+
+    it 'defaults filters to an empty object', ->
+      loadOptions = loader._parseLoadOptions(opts)
+      expect(loadOptions.filters).toEqual {}
+
+      # make sure it leaves them alone if they are present
+      opts.filters = filters = foo: 'bar'
+      loadOptions = loader._parseLoadOptions(opts)
+      expect(loadOptions.filters).toEqual filters
+
+    it 'pulls of the top layer of includes and sets them as thisLayerInclude', ->
+      opts.include = ['foo': ['bar'], 'toad': ['stool'], 'mushroom']
+      loadOptions = loader._parseLoadOptions(opts)
+      expect(loadOptions.thisLayerInclude).toEqual ['foo', 'toad', 'mushroom']
+
+    it 'defaults cache to true', ->
+      loadOptions = loader._parseLoadOptions(opts)
+      expect(loadOptions.cache).toEqual true
+
+      # make sure it leaves cache alone if it is present
+      opts.cache = false
+      loadOptions = loader._parseLoadOptions(opts)
+      expect(loadOptions.cache).toEqual false
+
+    it 'sets cache to false if search is present', ->
+      opts = _.extend opts, cache: true, search: 'term'
+
+      loadOptions = loader._parseLoadOptions(opts)
+      expect(loadOptions.cache).toEqual false
+
+    it 'builds a cache key', ->
+      # order, filterKeys, page, perPage, limit, offset
+      myOpts = 
+        order: 'myOrder'
+        filters:
+          key1: 'value1'
+          key2: 'value2'
+        page: 1
+        perPage: 200
+        limit: 50
+        offset: 0
+
+      opts = _.extend(opts, myOpts)
+      loadOptions = loader._parseLoadOptions(opts)
+      expect(loadOptions.cacheKey).toEqual 'myOrder|key1:value1,key2:value2|1|200|50|0'
+
+    it 'sets the cachedCollection on the loader from the storageManager', ->
+      loader._parseLoadOptions(opts)
+      expect(loader.cachedCollection).toEqual loader.storageManager.storage(loader.loadOptions.name)
+
+  describe '#_checkCacheForData', ->
+    opts = null
+    taskOne = taskTwo = null
+
+    beforeEach ->
+      loader = createLoader()
+      opts = defaultLoadOptions()
+      spyOn(loader, '_onLoadSuccess')
+
+      taskOne = buildTask(id: 2)
+      taskTwo = buildTask(id: 3)
+
+    notFound = (loader, opts) ->
+      loader.setup(opts)
+      ret = loader._checkCacheForData()
+
+      expect(ret).toEqual false
+      expect(loader._onLoadSuccess).not.toHaveBeenCalled()
+
+    context 'only query', ->
+      beforeEach ->
+        opts.only = ['2', '3']
+
+      context 'the requested IDs have all been loaded', ->
+        beforeEach ->
+          loader.storageManager.storage('tasks').add([taskOne, taskTwo])
+
+        it 'calls #_onLoadSuccess with the models from the cache', ->
+          loader.setup(opts)
+          loader._checkCacheForData()
+          expect(loader._onLoadSuccess).toHaveBeenCalledWith([taskOne, taskTwo])
+
+      context 'the requested IDs have not all been loaded', ->
+        beforeEach ->
+          loader.storageManager.storage('tasks').add([taskOne])
+
+        it 'returns false and does not call #_onLoadSuccess', ->
+          loader.setup(opts)
+          notFound(loader, opts)
+
+    context 'not an only query', ->
+      context 'there exists a cache with this cacheKey', ->
+        beforeEach ->
+          loader.storageManager.storage('tasks').add taskOne
+          loader.storageManager.getCollectionDetails('tasks').cache['updated_at:desc|||||'] = [key: "tasks", id: taskOne.id]
+
+        context 'all of the cached models have their associations loaded', ->
+          beforeEach ->
+            taskOne.set('project_id', buildAndCacheProject().id)
+
+          it 'calls #_onLoadSuccess with the models from the cache', ->
+            opts.include = ['project']
+            loader.setup(opts)
+            loader._checkCacheForData()
+            expect(loader._onLoadSuccess).toHaveBeenCalledWith([taskOne])
+
+        context 'all of the cached models do not have their associations loaded', ->
+          it 'returns false and does not call #_onLoadSuccess', ->
+            opts.include = ['project']
+            loader.setup(opts)
+            notFound(loader, opts)
+
+      context 'there is no cache with this cacheKey', ->
+        it 'does not call #_onLoadSuccess and returns false', ->
+          loader.setup(opts)
+          notFound(loader, opts)
+
+  describe '#_loadFromServer', ->
+    opts = syncOpts = null
+
+    beforeEach ->
+      loader = createLoader()
+      opts = defaultLoadOptions()
+      syncOpts = data: 'foo'
+
+      spyOn(Backbone, 'sync').andReturn $.ajax()
+      spyOn(loader, '_buildSyncOptions').andReturn(syncOpts)
+
+    it 'calls Backbone.sync with the read, the, internalObject, and #_buildSyncOptions', ->
+      loader.setup(opts)
+      loader._loadFromServer()
+      expect(Backbone.sync).toHaveBeenCalledWith 'read', loader.internalObject, syncOpts
+
+    it 'puts the jqXhr on the returnValues if present', ->
+      opts.returnValues = returnValues = {}
+      loader.setup(opts)
+
+      loader._loadFromServer()
+      expect(returnValues.jqXhr.success).not.toBeUndefined()
+
+    it 'returns the externalObject', ->
+      loader.setup(opts)
+      ret = loader._loadFromServer()
+      expect(ret).toEqual loader.externalObject
+
+  describe '#_shouldUseOnly', ->
+    it 'returns true if internalObject is an instance of a Backbone.Collection', ->
+      loader = createLoader()
+      loader.internalObject = new Backbone.Collection()
+      expect(loader._shouldUseOnly()).toEqual true
+
+    it 'returns false if internalObject is not an instance of a Backbone.Collection', ->
+      loader = createLoader()
+      loader.internalObject = new Backbone.Model()
+      expect(loader._shouldUseOnly()).toEqual false
+
+  describe '#_buildSyncOptions', ->
+    syncOptions = opts = null
+
+    beforeEach ->
+      loader = createLoader()
+      opts = defaultLoadOptions()
+
+    getSyncOptions = (loader, opts) ->
+      loader.setup(opts)
+      loader._buildSyncOptions()
+
+    it 'sets parse to true', ->
+      expect(getSyncOptions(loader, opts).parse).toEqual(true)
+
+    it 'sets error as loadOptions.error', ->
+      opts.error = spy = jasmine.createSpy()
+      expect(getSyncOptions(loader, opts).error).toEqual spy
+
+    it 'sets success as #_onServerLoadSuccess', ->
+      expect(getSyncOptions(loader, opts).success).toEqual(loader._onServerLoadSuccess)
+
+    it 'sets data.include to be the layer of includes that this loader is loading', ->
+      opts.include = [
+        task: [ workspace: ['participants'] ]
+        'time_entries'
+      ]
+
+      expect(getSyncOptions(loader, opts).data.include).toEqual('task,time_entries')
+
+    describe 'data.only', ->
+      context 'this is an only load', ->
+        context '#_shouldUseOnly returns true', ->
+          beforeEach ->
+            spyOn(loader, '_shouldUseOnly').andReturn(true)
+
+          it 'sets data.only to be the difference between the only query and the already loaded ids', ->
+            loader.alreadyLoadedIds = ['1', '2']
+            opts.only = [1, 2, 3, 4]
+            expect(getSyncOptions(loader, opts).data.only).toEqual '3,4'
+
+        context '#_shouldUseOnly returns false', ->
+          beforeEach ->
+            spyOn(loader, '_shouldUseOnly').andReturn(true)
+
+          it 'does not set data.only', ->
+            expect(getSyncOptions(loader, opts).data.only).toBeUndefined()
+
+      context 'this is not an only load', ->
+        it 'does not set data.only', ->
+          expect(getSyncOptions(loader, opts).data.only).toBeUndefined()
+
+    describe 'data.order', ->
+      it 'sets order to be loadOptions.order if present', ->
+        opts.order = 'foo'
+        expect(getSyncOptions(loader, opts).data.order).toEqual 'foo'
+
+    describe 'extending data with filters', ->
+      it 'extends data with anything on filters that does not meet the omit list', ->
+        omitList = ['include', 'only', 'order', 'per_page', 'page', 'limit', 'offset', 'search']
+        opts.filters = {}
+
+        for k in omitList
+          opts.filters[k] = true
+
+        opts.filters.foo = 'bar'
+
+        data = getSyncOptions(loader, opts).data
+
+        for k in omitList
+          expect(data[k]).not.toEqual true
+
+        expect(data.foo).toEqual 'bar'
+
+    describe 'pagination', ->
+      beforeEach ->
+        opts.offset = 0
+        opts.limit = 25
+        opts.perPage = 25
+        opts.page = 1
+
+      context 'not an only request', ->
+        context 'there is a limit and offset', ->
+          it 'adds limit and offset', ->
+            data = getSyncOptions(loader, opts).data
+            expect(data.limit).toEqual 25
+            expect(data.offset).toEqual 0
+
+          it 'does not add per_page and page', ->
+            data = getSyncOptions(loader, opts).data
+            expect(data.per_page).toBeUndefined()
+            expect(data.page).toBeUndefined()
+
+        context 'there is not a limit and offset', ->
+          beforeEach ->
+            delete opts.limit
+            delete opts.offset
+
+          it 'adds per_page and page', ->
+            data = getSyncOptions(loader, opts).data
+            expect(data.per_page).toEqual 25
+            expect(data.page).toEqual 1
+
+          it 'does not add limit and offset', ->
+            data = getSyncOptions(loader, opts).data
+            expect(data.limit).toBeUndefined()
+            expect(data.offset).toBeUndefined()
+
+      context 'only request', ->
+        beforeEach ->
+          opts.only = 1
+
+        it 'does not add limit, offset, per_page, or page', ->
+          data = getSyncOptions(loader, opts).data
+          expect(data.limit).toBeUndefined()
+          expect(data.offset).toBeUndefined()
+          expect(data.per_page).toBeUndefined()
+          expect(data.page).toBeUndefined()
+
+    describe 'data.search', ->
+      it 'sets data.search to be loadOptions.search if present', ->
+        opts.search = 'term'
+        expect(getSyncOptions(loader, opts).data.search).toEqual 'term'
+
+  describe '#_onServerLoadSuccess', ->
+    beforeEach ->
+      loader = createLoader()
+      spyOn(loader, '_onLoadSuccess')
+
+    it 'calls #_updateStorageManagerFromResponse with the response', ->
+      loader._onServerLoadSuccess('response')
+      expect(loader._updateStorageManagerFromResponse).toHaveBeenCalledWith 'response'
+
+    it 'calls #_onServerLoadSuccess with the result from #_updateStorageManagerFromResponse', ->
+      loader._updateStorageManagerFromResponse.andReturn 'data'
+
+      loader._onServerLoadSuccess()
+      expect(loader._onLoadSuccess).toHaveBeenCalledWith 'data'
+
+  describe '#_calculateAdditionalIncludes', ->
+    opts = null
+
+    beforeEach ->
+      loader = createLoader()
+      opts = defaultLoadOptions()
+
+      spyOn(loader, '_getIdsForAssociation').andReturn [1, 2]
+
+    it 'adds each additional (sub) include to the additionalIncludes array', ->
+      opts.include = fakeNestedInclude
+      loader.setup(opts)
+
+      loader._calculateAdditionalIncludes()
+      expect(loader.additionalIncludes.length).toEqual 2
+      expect(loader.additionalIncludes).toEqual [
+        { name: 'project', ids: [1, 2], include: [participants: []] }
+        { name: 'assignees', ids: [1, 2], include: [something_else: []] }
+      ]
+
+  describe '#_onLoadSuccess', ->
+    beforeEach ->
+      loader = createLoader()
+      loader.additionalIncludes = []
+      spyOn(loader, '_onLoadingCompleted')
+      spyOn(loader, '_loadAdditionalIncludes')
+      spyOn(loader, '_calculateAdditionalIncludes')
+
+    it 'calls #_updateObjects with the internalObject, the data, and silent set to true', ->
+      loader._onLoadSuccess('test data')
+      expect(loader._updateObjects).toHaveBeenCalledWith(loader.internalObject, 'test data', true)
+
+    it 'calls #_calculateAdditionalIncludes', ->
+      loader._onLoadSuccess()
+      expect(loader._calculateAdditionalIncludes).toHaveBeenCalled()
+
+    context 'additional includes are needed', ->
+      it 'calls #_loadAdditionalIncludes', ->
+        loader._calculateAdditionalIncludes.andCallFake -> @additionalIncludes = ['foo']
+
+        loader._onLoadSuccess()
+        expect(loader._loadAdditionalIncludes).toHaveBeenCalled()
+        expect(loader._onLoadingCompleted).not.toHaveBeenCalled()
+
+    context 'additional includes are not needed', ->
+      it 'calls #_onLoadingCompleted', ->
+        loader._onLoadSuccess()
+        expect(loader._onLoadingCompleted).toHaveBeenCalled()
+        expect(loader._loadAdditionalIncludes).not.toHaveBeenCalled()
+
+  describe '#_onLoadingCompleted', ->
+    beforeEach ->
+      loader = createLoader()
+
+    it 'calls #_updateObjects with the externalObject and internalObject', ->
+      loader._onLoadingCompleted()
+      expect(loader._updateObjects).toHaveBeenCalledWith(loader.externalObject, loader.internalObject)
+
+    it 'resolves the deferred object with the externalObject', ->
+      spy = jasmine.createSpy()
+      loader.then(spy)
+
+      loader._onLoadingCompleted()
+      expect(spy).toHaveBeenCalledWith(loader.externalObject)
+
+  describe '#_updateObjects', ->
+    fakeObj = null
+
+    beforeEach ->
+      loader = createLoader()
+      fakeObj = setLoaded: jasmine.createSpy()
+      loader._updateObjects.andCallThrough()
+
+    it 'sets the object to loaded if silent is false', ->
+      loader._updateObjects(fakeObj, {})
+      expect(fakeObj.setLoaded).toHaveBeenCalled()
+
+    it 'does not set the object to loaded if silent is true', ->
+      loader._updateObjects(fakeObj, {}, true)
+      expect(fakeObj.setLoaded).not.toHaveBeenCalled()
+
+  describe '#_loadAdditionalIncludes', ->
+    opts = null
+
+    beforeEach ->
+      loader = createLoader()
+      opts = defaultLoadOptions()
+      opts.include = fakeNestedInclude
+
+      loader.setup(opts)
+      loader._calculateAdditionalIncludes()
+
+      spyOn(loader, '_onLoadingCompleted')
+
+    it 'creates a request for each additional include and calls #_onLoadingCompleted when they all are done', ->
+      promises = []
+      spyOn(loader.storageManager, 'loadObject').andCallFake ->
+        promise = $.Deferred()
+        promises.push(promise)
+        promise
+
+      loader._loadAdditionalIncludes()
+      expect(loader.storageManager.loadObject.callCount).toEqual 2
+      expect(promises.length).toEqual 2
+      expect(loader._onLoadingCompleted).not.toHaveBeenCalled()
+
+      for promise in promises
+        promise.resolve()
+
+      expect(loader._onLoadingCompleted).toHaveBeenCalled()
+
+  describe '#_getIdsForAssociation', ->
+    it 'returns the flattened, unique, sorted, and non-null IDs from the models that are returned from #_getModelsForAssociation', ->
+      loader = createLoader()
+      expect(loader._getIdsForAssociation('foo')).toEqual [1, 2, 4, 5, 6]
+
+  describe '#_modelsOrObj', ->
+    beforeEach ->
+      loader = createLoader()
+
+    context 'obj is a Backbone.Collection', ->
+      it 'returns the models from the collection', ->
+        collection = new Backbone.Collection()
+        collection.add([new Backbone.Model(), new Backbone.Model])
+        expect(loader._modelsOrObj(collection)).toEqual(collection.models)
+
+    context 'obj is not a Backbone.Collection', ->
+      it 'returns the obj or an empty array', ->
+        obj = []
+        expect(loader._modelsOrObj(obj)).toEqual(obj)
+
+        obj = null
+        expect(loader._modelsOrObj(obj)).toEqual([])