brainstem-js 0.2.1 → 0.3.0

data/.travis.yml

@@ -1,12 +1,9 @@
 language: ruby
-rvm: 1.9.3
+rvm:
+  - 1.9.3
+  - 2.0.0
 
 before_install: gem install bundler
 
-notifications:
-  hipchat: 09a2719b3284ea0d0d247355fa5542@Mavenlink Dev
-
 git:
   depth: 1
-
-source_key: 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

data/Gemfile.lock

@@ -20,7 +20,7 @@ GIT
 PATH
   remote: .
   specs:
-    brainstem-js (0.2.1)
+    brainstem-js (0.3.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,5 +1,7 @@
 # Brainstem.js
 
+[![Build Status](https://travis-ci.org/mavenlink/brainstem-js.png)](https://travis-ci.org/mavenlink/brainstem-js)
+
 [Brainstem](https://github.com/mavenlink/brainstem) is designed to power rich APIs in Rails. The Brainstem gem provides a presenter library that handles converting ActiveRecord objects into structured JSON and a set of API abstractions that allow users to request sorts, filters, and association loads, allowing for simpler implementations, fewer requests, and smaller responses.
 
 The Brainstem.js library is a companion library for Backbone.js that makes integration with Brainstem APIs a breeze.  Brainstem.js adds an identity map and relational models to Backbone.
@@ -23,7 +25,7 @@ What follows is an overview.
 
 ### StorageManager
 
-The `Brianstem.StorageManager` is in charge of loading data over the API, as well as returning already cached data.  We recommend setting one up in a singleton App class.
+The `Brainstem.StorageManager` is in charge of loading data over the API, as well as returning already cached data.  We recommend setting one up in a singleton App class.
 
 	class Application
 	  constructor: ->

data/Rakefile

@@ -9,6 +9,7 @@ task :build do
   sh "rakep build"
 end
 
+desc 'Run jasmine specs with phantomjs'
 task :spec => :build do
   begin
     exec *%w(phantomjs build/headless.js build/headless.html)
@@ -18,6 +19,7 @@ task :spec => :build do
   end
 end
 
+desc 'Start WEBrick server to run jasmine specs in browser'
 task :server => :clean do
   exec "rakep server"
 end

data/lib/brainstem/js/version.rb

@@ -1,5 +1,5 @@
 module Brainstem
   module Js
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/spec/brainstem-collection-spec.coffee

@@ -53,6 +53,31 @@ describe 'Brainstem.Collection', ->
       expect(collection.lastFetchOptions.page).toEqual 3
       expect(collection.length).toEqual 5
 
+    it "fetches based on the last limit and offset if they were the pagination options used", ->
+      respondWith server, "/api/time_entries?limit=2&offset=0", resultsFrom: "time_entries", data: { time_entries: [buildTimeEntry(), buildTimeEntry()] }
+      respondWith server, "/api/time_entries?limit=2&offset=2", resultsFrom: "time_entries", data: { time_entries: [buildTimeEntry(), buildTimeEntry()] }
+      respondWith server, "/api/time_entries?limit=2&offset=4", resultsFrom: "time_entries", data: { time_entries: [buildTimeEntry()] }
+      collection = base.data.loadCollection "time_entries", limit: 2, offset: 0
+      expect(collection.length).toEqual 0
+      server.respond()
+      expect(collection.length).toEqual 2
+      expect(collection.lastFetchOptions.offset).toEqual 0
+
+      spy = jasmine.createSpy()
+      collection.loadNextPage success: spy
+      server.respond()
+      expect(spy).toHaveBeenCalledWith(collection, true)
+      expect(collection.lastFetchOptions.offset).toEqual 2
+      expect(collection.length).toEqual 4
+
+      spy = jasmine.createSpy()
+      collection.loadNextPage success: spy
+      expect(collection.length).toEqual 4
+      server.respond()
+      expect(spy).toHaveBeenCalledWith(collection, false)
+      expect(collection.lastFetchOptions.offset).toEqual 4
+      expect(collection.length).toEqual 5
+
   describe "reload", ->
     it "reloads the collection with the original params", ->
       respondWith server, "/api/posts?include=replies&parents_only=true&per_page=5&page=1", resultsFrom: "posts", data: { posts: [buildPost(message: "old post", reply_ids: [])] }

data/spec/{brianstem-expectation-spec.coffee → brainstem-expectation-spec.coffee}

@@ -63,6 +63,32 @@ describe 'Brainstem Expectations', ->
       expect(collection.get(1).get("tasks").models).toEqual [task1]
       expect(collection.get(2).get("tasks").models).toEqual []
 
+    describe 'recursive loading', ->
+      context 'recursive option is false', ->
+        it "should not try to recursively load includes in an expectation", ->
+          expectation = manager.stub "projects", include: '*', response: (stub) ->
+            stub.results = [project1, project2]
+            stub.associated.projects = [project1, project2]
+            stub.associated.tasks = [task1]
+
+          spy = spyOn(Brainstem.AbstractLoader.prototype, '_loadAdditionalIncludes')
+          collection = manager.loadCollection "projects", include: ["tasks" : ["time_entries"]]
+          expectation.respond()
+          expect(spy).not.toHaveBeenCalled()
+
+      context 'recursive option is true', ->
+        it "should recursively load includes in an expectation", ->
+          expectation = manager.stub "projects", include: '*', response: (stub) ->
+            stub.results = [project1, project2]
+            stub.associated.projects = [project1, project2]
+            stub.associated.tasks = [task1]
+            stub.recursive = true
+
+          spy = spyOn(Brainstem.AbstractLoader.prototype, '_loadAdditionalIncludes')
+          collection = manager.loadCollection "projects", include: ["tasks" : ["time_entries"]]
+          expectation.respond()
+          expect(spy).toHaveBeenCalled()
+
     describe "triggering errors", ->
       it "triggers errors when asked to do so", ->
         errorSpy = jasmine.createSpy()
@@ -80,8 +106,7 @@ describe 'Brainstem Expectations', ->
 
         expectation.respond()
         expect(errorSpy).toHaveBeenCalled()
-        expect(errorSpy.mostRecentCall.args[0] instanceof Brainstem.Collection).toBe true
-        expect(errorSpy.mostRecentCall.args[1]).toEqual resp
+        expect(errorSpy.mostRecentCall.args[0]).toEqual resp
 
       it "does not trigger errors when asked not to", ->
         errorSpy = jasmine.createSpy()
@@ -92,6 +117,10 @@ describe 'Brainstem Expectations', ->
         expectation.respond()
         expect(errorSpy).not.toHaveBeenCalled()
 
+    it "should work without specifying results", ->
+      manager.stubImmediate "projects"
+      expect(-> manager.loadCollection("projects")).not.toThrow()
+
   describe "responding immediately", ->
     it "uses stubImmediate", ->
       expectation = manager.stubImmediate "projects", include: ["tasks"], response: (stub) ->
@@ -133,6 +162,7 @@ describe 'Brainstem Expectations', ->
     it "should allow wildcard params", ->
       manager.stubImmediate "projects", include: '*', response: (stub) ->
         stub.results = [project1, project2]
+        stub.associated.tasks = [task1]
       expect(manager.loadCollection("projects", include: ["tasks"]).models).toEqual [project1, project2]
       expect(manager.loadCollection("projects", include: ["users"]).models).toEqual [project1, project2]
       expect(manager.loadCollection("projects").models).toEqual [project1, project2]
@@ -181,29 +211,114 @@ describe 'Brainstem Expectations', ->
   describe "optionsMatch", ->
     it "should ignore wrapping arrays", ->
       expectation = new Brainstem.Expectation("projects", { include: "workspaces" }, manager)
-      expect(expectation.optionsMatch("projects", { include: "workspaces" })).toBe true
-      expect(expectation.optionsMatch("projects", { include: ["workspaces"] })).toBe true
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+
+      loader.setup(name: "projects", include: "workspaces")
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
+
+      loader.setup(name: "projects", include: ["workspaces"])
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
 
     it "should treat * as an any match", ->
       expectation = new Brainstem.Expectation("projects", { include: "*" }, manager)
-      expect(expectation.optionsMatch("projects", { include: "workspaces" })).toBe true
-      expect(expectation.optionsMatch("projects", { include: ["anything"] })).toBe true
-      expect(expectation.optionsMatch("projects", {})).toBe true
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", include: "workspaces")
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", include: ["anything"])
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", {})
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
 
     it "should treat strings and numbers the same when appropriate", ->
       expectation = new Brainstem.Expectation("projects", { only: "1" }, manager)
-      expect(expectation.optionsMatch("projects", {only: 1})).toBe true
-      expect(expectation.optionsMatch("projects", {only: "1"})).toBe true
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", only: 1)
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", only: "1")
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
 
     it "should treat null, empty array, and empty object the same", ->
       expectation = new Brainstem.Expectation("projects", { filters: {} }, manager)
-      expect(expectation.optionsMatch("projects", { filters: null })).toBe true
-      expect(expectation.optionsMatch("projects", { filters: {} })).toBe true
-      expect(expectation.optionsMatch("projects", { })).toBe true
-      expect(expectation.optionsMatch("projects", { filters: { foo: "bar" } })).toBe false
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", filters: null)
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", filters: {})
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", {})
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", filters: { foo: "bar" })
+      expect(expectation.loaderOptionsMatch(loader)).toBe false
 
       expectation = new Brainstem.Expectation("projects", {}, manager)
-      expect(expectation.optionsMatch("projects", { filters: null })).toBe true
-      expect(expectation.optionsMatch("projects", { filters: {} })).toBe true
-      expect(expectation.optionsMatch("projects", { })).toBe true
-      expect(expectation.optionsMatch("projects", { filters: { foo: "bar" } })).toBe false
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", filters: null)
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", filters: {})
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", {})
+      expect(expectation.loaderOptionsMatch(loader)).toBe true
+
+      loader = new Brainstem.CollectionLoader(storageManager: manager)
+      loader.setup(name: "projects", filters: { foo: "bar" })
+      expect(expectation.loaderOptionsMatch(loader)).toBe false
+
+  describe 'stubbing models', ->
+    context 'a model that matches the load is already in the storage manager', ->
+      it 'updates that model', ->
+        project = buildAndCacheProject()
+
+        expectation = manager.stubModel 'project', project.id, response: (stub) ->
+          stub.result = buildProject(id: project.id, title: 'foobar')
+
+        loaderSpy = jasmine.createSpy('loader').andCallFake (model) ->
+          expect(model).toEqual project
+          expect(model.get('title')).toEqual 'foobar'
+
+        loader = manager.loadModel 'project', project.id
+        loader.done(loaderSpy)
+
+        expectation.respond()
+        expect(loaderSpy).toHaveBeenCalled()
+        expect(manager.storage('projects').length).toEqual 1
+
+    context 'a model is not already in the storage manager', ->
+      it 'adds the model from the loader to the storageManager', ->
+        project = buildProject()
+        stubbedProject = buildProject(id: project.id, title: 'foobar')
+
+        expectation = manager.stubModel 'project', project.id, response: (stub) ->
+          stub.result = stubbedProject
+
+        loader = manager.loadModel 'project', project.id
+
+        loaderSpy = jasmine.createSpy('loader').andCallFake (model) ->
+          expect(model).toEqual loader.getModel()
+          expect(model.attributes).toEqual stubbedProject.attributes
+          expect(manager.storage('projects').get(project.id)).toEqual loader.getModel()
+          expect(model.get('title')).toEqual 'foobar'
+
+        loader.done(loaderSpy)
+
+        expectation.respond()
+        expect(loaderSpy).toHaveBeenCalled()
+        expect(manager.storage('projects').length).toEqual 1

data/spec/brainstem-model-spec.coffee

@@ -28,6 +28,51 @@ describe 'Brainstem.Model', ->
       expect(base.data.storage('users').get(5).attributes).toEqual(response.users[5])
       expect(base.data.storage('users').get(6).attributes).toEqual(response.users[6])
 
+    describe 'adding new models to the storage manager', ->
+      context 'there is an ID on the model already', ->
+        # usually happens when fetching an existing model and not using StorageManager#loadModel
+        # new App.Models.Task(id: 5).fetch()
+
+        beforeEach ->
+          model.set('id', 1)
+
+        context 'model ID matches response ID', ->
+          it 'should add the parsing model to the storage manager', ->
+            response.tasks[1].id = 1
+            expect(base.data.storage('tasks').get(1)).toBeUndefined()
+
+            model.parse(response)
+            expect(base.data.storage('tasks').get(1)).not.toBeUndefined()
+            expect(base.data.storage('tasks').get(1)).toEqual model
+            expect(base.data.storage('tasks').get(1).attributes).toEqual response.tasks[1]
+
+        context 'model ID does not match response ID', ->
+          # this only happens when an association has the same brainstemKey as the parent record
+          # we want to add a new model to the storage manager and not worry about ourself
+
+          it 'should not add the parsing model to the storage manager', ->
+            response.tasks[1].id = 2345
+            expect(base.data.storage('tasks').get(1)).toBeUndefined()
+
+            model.parse(response)
+            expect(base.data.storage('tasks').get(1)).toBeUndefined()
+            expect(base.data.storage('tasks').get(2345)).not.toEqual model
+
+      context 'there is not an ID on the model instance already', ->
+        # usually happens when creating a new model:
+        # new App.Models.Task(title: 'test').save()
+
+        beforeEach ->
+          expect(model.id).toBeUndefined()
+
+        it 'should add the parsing model to the storage manager', ->
+          response.tasks[1].title = 'Hello'
+          expect(base.data.storage('tasks').get(1)).toBeUndefined()
+
+          model.parse(response)
+          expect(base.data.storage('tasks').get(1)).toEqual(model)
+          expect(base.data.storage('tasks').get(1).get('title')).toEqual('Hello')
+
     it 'should work with an empty response', ->
       expect( -> model.parse(tasks: {}, results: [], count: 0)).not.toThrow()
 
@@ -74,33 +119,6 @@ describe 'Brainstem.Model', ->
         expect(base.data.storage('users').get(5).get('created_at')).toEqual(1361820357000)
         expect(base.data.storage('users').get(6).get('created_at')).toEqual(1359573957000)
 
-  describe 'setLoaded', ->
-    it "should set the values of @loaded", ->
-      model.setLoaded true
-      expect(model.loaded).toEqual(true)
-      model.setLoaded false
-      expect(model.loaded).toEqual(false)
-
-    it "triggers 'loaded' when becoming true", ->
-      spy = jasmine.createSpy()
-      model.bind "loaded", spy
-      model.setLoaded false
-      expect(spy).not.toHaveBeenCalled()
-      model.setLoaded true
-      expect(spy).toHaveBeenCalled()
-
-    it "doesn't trigger loaded if trigger: false is provided", ->
-      spy = jasmine.createSpy()
-      model.bind "loaded", spy
-      model.setLoaded true, trigger: false
-      expect(spy).not.toHaveBeenCalled()
-
-    it "returns self", ->
-      spy = jasmine.createSpy()
-      model.bind "loaded", spy
-      model.setLoaded true
-      expect(spy).toHaveBeenCalledWith(model)
-
   describe 'associations', ->
     describe 'associationDetails', ->
 
@@ -181,6 +199,28 @@ describe 'Brainstem.Model', ->
           expect(project.associationsAreLoaded(["time_entries"])).toBeTruthy()
           expect(project.associationsAreLoaded(["tasks"])).toBeFalsy()
 
+      describe "when supplying associations that do not exist", ->
+        class TestClass extends Brainstem.Model
+          @associations:
+            user: "users"
+
+        testClass = null
+
+        beforeEach ->
+          testClass = new TestClass()
+
+        it "returns true when supplying only an association that does not exist", ->
+          expect(testClass.associationsAreLoaded(['foobar'])).toBe true
+          expect(testClass.associationsAreLoaded(['user'])).toBe false
+
+        it "returns false when supplying both a real association that is not loaded and an association that does not exist", ->
+          expect(testClass.associationsAreLoaded(['user', 'foobar'])).toBe false
+
+        it "returns true when supplying a real association that is loaded and an association that does not exist", ->
+          testClass.set('user_id', buildAndCacheUser().id)
+          expect(testClass.associationsAreLoaded(['user'])).toBe true
+          expect(testClass.associationsAreLoaded(['user', 'foobar'])).toBe true
+
     describe "get", ->
       it "should delegate to Backbone.Model#get for anything that is not an association", ->
         timeEntry = new App.Models.TimeEntry(id: 5, project_id: 10, task_id: 2, title: "foo")

data/spec/brainstem-sync-spec.coffee

@@ -1,22 +1,45 @@
 describe "Brainstem.Sync", ->
-  describe "updating models", ->
-    ajaxSpy = null
+  ajaxSpy = null
 
-    beforeEach ->
-      ajaxSpy = spyOn($, 'ajax')
+  beforeEach ->
+    ajaxSpy = spyOn($, 'ajax')
 
+  describe "updating models", ->
     it "should use toServerJSON instead of toJSON", ->
       modelSpy = spyOn(Brainstem.Model.prototype, 'toServerJSON')
       model = buildTimeEntry()
       model.save()
       expect(modelSpy).toHaveBeenCalled()
 
-    it "should pass options.includes through the JSON", ->
+    it "should pass options.include through the JSON", ->
       model = buildTimeEntry()
       model.save({}, include: 'creator')
       expect(ajaxSpy.mostRecentCall.args[0].data).toMatch(/"include":"creator"/)
 
+    it "should accept an array for options.include", ->
+      model = buildTimeEntry()
+      model.save({}, include: ['creator', 'story'])
+      expect(ajaxSpy.mostRecentCall.args[0].data).toMatch(/"include":"creator,story"/)
+
     it "should setup param roots when models have a paramRoot set", ->
       model = buildTimeEntry()
       model.save({})
-      expect(ajaxSpy.mostRecentCall.args[0].data).toMatch(/"time_entry":{/)
+      expect(ajaxSpy.mostRecentCall.args[0].data).toMatch(/"time_entry":{/)
+
+  describe 'error handler', ->
+    it 'wraps the error handler in an errorInterceptor', ->
+      model = buildTimeEntry()
+      base.data.errorInterceptor = jasmine.createSpy('errorInterceptor')
+
+      model.save({})
+      ajaxSpy.mostRecentCall.args[0].error()
+      expect(base.data.errorInterceptor).toHaveBeenCalled()
+
+    it 'only wraps the error handler if base.data.errorInterceptor is defined', ->
+      delete base.data.errorInterceptor
+      model = buildTimeEntry()
+      errorSpy = jasmine.createSpy('error spy')
+
+      model.save({}, error: errorSpy)
+      ajaxSpy.mostRecentCall.args[0].error()
+      expect(errorSpy).toHaveBeenCalled()