brainstem-js 0.2.1

data/spec/brainstem-model-spec.coffee

@@ -0,0 +1,283 @@
+describe 'Brainstem.Model', ->
+  model = null
+
+  beforeEach ->
+    model = new App.Models.Task()
+
+  describe 'parse', ->
+    response = null
+
+    beforeEach ->
+      response = count: 1, results: [id: 1, key: 'tasks'], tasks: { 1: { id: 1, title: 'Do Work' } }
+
+    it "extracts object data from JSON with root keys", ->
+      parsed = model.parse(response)
+      expect(parsed.id).toEqual(1)
+
+    it "passes through object data from flat JSON", ->
+      parsed = model.parse({id: 1})
+      expect(parsed.id).toEqual(1)
+
+    it 'should update the storage manager with the new model and its associations', ->
+      response.tasks[1].assignee_ids = [5, 6]
+      response.users = { 5: {id: 5, name: 'Jon'}, 6: {id: 6, name: 'Betty'} }
+
+      model.parse(response)
+
+      expect(base.data.storage('tasks').get(1).attributes).toEqual(response.tasks[1])
+      expect(base.data.storage('users').get(5).attributes).toEqual(response.users[5])
+      expect(base.data.storage('users').get(6).attributes).toEqual(response.users[6])
+
+    it 'should work with an empty response', ->
+      expect( -> model.parse(tasks: {}, results: [], count: 0)).not.toThrow()
+
+    describe 'updateStorageManager', ->
+      it 'should update the associations before the new model', ->
+        response.tasks[1].assignee_ids = [5]
+        response.users = { 5: {id: 5, name: 'Jon'} }
+
+        spy = spyOn(base.data, 'storage').andCallThrough()
+        model.updateStorageManager(response)
+        expect(spy.calls[0].args[0]).toEqual('users')
+        expect(spy.calls[1].args[0]).toEqual('tasks')
+
+      it 'should work with an empty response', ->
+        expect( -> model.updateStorageManager(count: 0, results: [])).not.toThrow()
+
+    it 'should return the first object from the result set', ->
+      response.tasks[2] = (id: 2, title: 'foo')
+      response.results.unshift(id: 2, key: 'tasks')
+      parsed = model.parse(response)
+      expect(parsed.id).toEqual 2
+      expect(parsed.title).toEqual 'foo'
+
+    it 'should not blow up on server side validation error', ->
+      response = errors: ["Invalid task state. Valid states are:'notstarted','started',and'completed'."]
+      expect(-> model.parse(response)).not.toThrow()
+
+    describe 'date handling', ->
+      it "parses ISO 8601 dates into date objects / milliseconds", ->
+        parsed = model.parse({created_at: "2013-01-25T11:25:57-08:00"})
+        expect(parsed.created_at).toEqual(1359141957000)
+
+      it "passes through dates in milliseconds already", ->
+        parsed = model.parse({created_at: 1359142047000})
+        expect(parsed.created_at).toEqual(1359142047000)
+
+      it 'parses dates on associated models', ->
+        response.tasks[1].created_at = "2013-01-25T11:25:57-08:00"
+        response.tasks[1].assignee_ids = [5, 6]
+        response.users = { 5: {id: 5, name: 'John', created_at: "2013-02-25T11:25:57-08:00"}, 6: {id: 6, name: 'Betty', created_at: "2013-01-30T11:25:57-08:00"} }
+
+        parsed = model.parse(response)
+        expect(parsed.created_at).toEqual(1359141957000)
+        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', ->
+
+      class TestClass extends Brainstem.Model
+        @associations:
+          my_users: ["storage_system_collection_name"]
+          my_user: "users"
+          user: "users"
+          users: ["users"]
+
+      it "returns a hash containing the key, type and plural of the association", ->
+        testClass = new TestClass()
+        expect(TestClass.associationDetails('my_users')).toEqual key: "my_user_ids", type: "HasMany",    collectionName: "storage_system_collection_name"
+        expect(TestClass.associationDetails('my_user')).toEqual  key: "my_user_id",  type: "BelongsTo",  collectionName: "users"
+        expect(TestClass.associationDetails('user')).toEqual     key: "user_id",     type: "BelongsTo",  collectionName: "users"
+        expect(TestClass.associationDetails('users')).toEqual    key: "user_ids",    type: "HasMany",    collectionName: "users"
+
+        expect(testClass.constructor.associationDetails('users')).toEqual   key: "user_ids",    type: "HasMany",    collectionName: "users"
+
+      it "is cached on the class for speed", ->
+        original = TestClass.associationDetails('my_users')
+        TestClass.associations.my_users = "something_else"
+        expect(TestClass.associationDetails('my_users')).toEqual original
+
+      it "returns falsy if the association cannot be found", ->
+        expect(TestClass.associationDetails("I'mNotAThing")).toBeFalsy()
+
+    describe 'associationsAreLoaded', ->
+      describe "with BelongsTo associations", ->
+        it "should return true when all provided associations are loaded for the model", ->
+          timeEntry = new App.Models.TimeEntry(id: 5, project_id: 10, task_id: 2)
+          expect(timeEntry.associationsAreLoaded(["project", "task"])).toBeFalsy()
+          buildAndCacheProject( id: 10, title: "a project!")
+          expect(timeEntry.associationsAreLoaded(["project", "task"])).toBeFalsy()
+          expect(timeEntry.associationsAreLoaded(["project"])).toBeTruthy()
+          buildAndCacheTask(id: 2, title: "a task!")
+          expect(timeEntry.associationsAreLoaded(["project", "task"])).toBeTruthy()
+          expect(timeEntry.associationsAreLoaded(["project"])).toBeTruthy()
+          expect(timeEntry.associationsAreLoaded(["task"])).toBeTruthy()
+
+        it "should default to all of the associations defined on the model", ->
+          timeEntry = new App.Models.TimeEntry(id: 5, project_id: 10, task_id: 2, user_id: 666)
+          expect(timeEntry.associationsAreLoaded()).toBeFalsy()
+          buildAndCacheProject(id: 10, title: "a project!")
+          expect(timeEntry.associationsAreLoaded()).toBeFalsy()
+          buildAndCacheTask(id: 2, title: "a task!")
+          expect(timeEntry.associationsAreLoaded()).toBeFalsy()
+          buildAndCacheUser(id:666)
+          expect(timeEntry.associationsAreLoaded()).toBeTruthy()
+
+        it "should appear loaded when an association is null, but not loaded when the key is missing", ->
+          timeEntry = buildAndCacheTimeEntry()
+          delete timeEntry.attributes.project_id
+          expect(timeEntry.associationsAreLoaded(["project"])).toBeFalsy()
+          timeEntry = new App.Models.TimeEntry(id: 5, project_id: null)
+          expect(timeEntry.associationsAreLoaded(["project"])).toBeTruthy()
+          timeEntry = new App.Models.TimeEntry(id: 5, project_id: 2)
+          expect(timeEntry.associationsAreLoaded(["project"])).toBeFalsy()
+
+      describe "with HasMany associations", ->
+        it "should return true when all provided associations are loaded", ->
+          project = new App.Models.Project(id: 5, time_entry_ids: [10, 11], task_ids: [2, 3])
+          expect(project.associationsAreLoaded(["time_entries", "tasks"])).toBeFalsy()
+          buildAndCacheTimeEntry(id: 10)
+          expect(project.associationsAreLoaded(["time_entries"])).toBeFalsy()
+          buildAndCacheTimeEntry(id: 11)
+          expect(project.associationsAreLoaded(["time_entries"])).toBeTruthy()
+          expect(project.associationsAreLoaded(["time_entries", "tasks"])).toBeFalsy()
+          expect(project.associationsAreLoaded(["tasks"])).toBeFalsy()
+          buildAndCacheTask(id: 2)
+          expect(project.associationsAreLoaded(["tasks"])).toBeFalsy()
+          buildAndCacheTask(id: 3)
+          expect(project.associationsAreLoaded(["tasks"])).toBeTruthy()
+          expect(project.associationsAreLoaded(["tasks", "time_entries"])).toBeTruthy()
+
+        it "should appear loaded when an association is an empty array, but not loaded when the key is missing", ->
+          project = new App.Models.Project(id: 5, time_entry_ids: [])
+          expect(project.associationsAreLoaded(["time_entries"])).toBeTruthy()
+          expect(project.associationsAreLoaded(["tasks"])).toBeFalsy()
+
+    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")
+        expect(timeEntry.get("title")).toEqual "foo"
+        expect(timeEntry.get("missing")).toBeUndefined()
+
+      describe "BelongsTo associations", ->
+        it "should return associations", ->
+          timeEntry = new App.Models.TimeEntry(id: 5, project_id: 10, task_id: 2)
+          expect(-> timeEntry.get("project")).toThrow()
+          base.data.storage("projects").add { id: 10, title: "a project!" }
+          expect(timeEntry.get("project").get("title")).toEqual "a project!"
+          expect(timeEntry.get("project")).toEqual base.data.storage("projects").get(10)
+
+        it "should return null when we don't have an association id", ->
+          timeEntry = new App.Models.TimeEntry(id: 5, task_id: 2)
+          expect(timeEntry.get("project")).toBeFalsy()
+
+        it "should throw when we have an association id but it cannot be found", ->
+          timeEntry = new App.Models.TimeEntry(id: 5, task_id: 2)
+          expect(-> timeEntry.get("task")).toThrow()
+
+      describe "HasMany associations", ->
+        it "should return HasMany associations", ->
+          project = new App.Models.Project(id: 5, time_entry_ids: [2, 5])
+          expect(-> project.get("time_entries")).toThrow()
+          base.data.storage("time_entries").add buildTimeEntry(id: 2, project_id: 5, title: "first time entry")
+          base.data.storage("time_entries").add buildTimeEntry(id: 5, project_id: 5, title: "second time entry")
+          expect(project.get("time_entries").get(2).get("title")).toEqual "first time entry"
+          expect(project.get("time_entries").get(5).get("title")).toEqual "second time entry"
+
+        it "should return null when we don't have any association ids", ->
+          project = new App.Models.Project(id: 5)
+          expect(project.get("time_entries").models).toEqual []
+
+        it "should throw when we have an association id but it cannot be found", ->
+          project = new App.Models.Project(id: 5, time_entry_ids: [2, 5])
+          expect(-> project.get("time_entries")).toThrow()
+
+        it "should apply a sort order to has many associations if it is provided at time of get", ->
+          task = buildAndCacheTask(id: 5, sub_task_ids: [103, 77, 99])
+          buildAndCacheTask(id:103 , position: 3, updated_at: 845785)
+          buildAndCacheTask(id:77 , position: 2, updated_at: 995785)
+          buildAndCacheTask(id:99 , position: 1, updated_at: 635785)
+
+          subTasks = task.get("sub_tasks")
+          expect(subTasks.at(0).get('position')).toEqual(3)
+          expect(subTasks.at(1).get('position')).toEqual(2)
+          expect(subTasks.at(2).get('position')).toEqual(1)
+
+          subTasks = task.get("sub_tasks", order: "position:asc")
+          expect(subTasks.at(0).get('position')).toEqual(1)
+          expect(subTasks.at(1).get('position')).toEqual(2)
+          expect(subTasks.at(2).get('position')).toEqual(3)
+
+          subTasks = task.get("sub_tasks", order: "updated_at:desc")
+          expect(subTasks.at(0).get('id')).toEqual("77")
+          expect(subTasks.at(1).get('id')).toEqual("103")
+          expect(subTasks.at(2).get('id')).toEqual("99")
+
+  describe "toServerJSON", ->
+    it "calls toJSON", ->
+      spy = spyOn(model, "toJSON").andCallThrough()
+      model.toServerJSON()
+      expect(spy).toHaveBeenCalled()
+
+    it "always removes default blacklisted keys", ->
+      defaultBlacklistKeys = model.defaultJSONBlacklist()
+      expect(defaultBlacklistKeys.length).toEqual(3)
+
+      model.set('safe', true)
+      for key in defaultBlacklistKeys
+        model.set(key, true)
+
+      json = model.toServerJSON("create")
+      expect(json['safe']).toEqual(true)
+      for key in defaultBlacklistKeys
+        expect(json[key]).toBeUndefined()
+
+    it "removes blacklisted keys for create actions", ->
+      createBlacklist = ['flies', 'ants', 'fire ants']
+      spyOn(model, 'createJSONBlacklist').andReturn(createBlacklist)
+
+      for key in createBlacklist
+        model.set(key, true)
+
+      json = model.toServerJSON("create")
+      for key in createBlacklist
+        expect(json[key]).toBeUndefined()
+
+    it "removes blacklisted keys for update actions", ->
+      updateBlacklist = ['possums', 'racoons', 'potatoes']
+      spyOn(model, 'updateJSONBlacklist').andReturn(updateBlacklist)
+
+      for key in updateBlacklist
+        model.set(key, true)
+
+      json = model.toServerJSON("update")
+      for key in updateBlacklist
+        expect(json[key]).toBeUndefined()

data/spec/brainstem-sync-spec.coffee

@@ -0,0 +1,22 @@
+describe "Brainstem.Sync", ->
+  describe "updating models", ->
+    ajaxSpy = null
+
+    beforeEach ->
+      ajaxSpy = spyOn($, 'ajax')
+
+    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", ->
+      model = buildTimeEntry()
+      model.save({}, include: 'creator')
+      expect(ajaxSpy.mostRecentCall.args[0].data).toMatch(/"include":"creator"/)
+
+    it "should setup param roots when models have a paramRoot set", ->
+      model = buildTimeEntry()
+      model.save({})
+      expect(ajaxSpy.mostRecentCall.args[0].data).toMatch(/"time_entry":{/)

data/spec/brainstem-utils-spec.coffee

@@ -0,0 +1,12 @@
+describe 'Brainstem Utils', ->
+  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]'
+      expect(Brainstem.Utils.matches([2, 3], [2])).toBe false
+      expect(Brainstem.Utils.matches([2, 3], [2, 3])).toBe true, '[2, 3], [2, 3]'
+      expect(Brainstem.Utils.matches({ hi: "there" }, { hi: "there" })).toBe true, '{ hi: "there" }, { hi: "there" }'
+      expect(Brainstem.Utils.matches([2, { hi: "there" }], [2, { hi: 2 }])).toBe false
+      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] }]'

data/spec/brianstem-expectation-spec.coffee

@@ -0,0 +1,209 @@
+describe 'Brainstem Expectations', ->
+  manager = project1 = project2 = task1 = null
+
+  beforeEach ->
+    manager = base.data
+    manager.enableExpectations()
+
+    project1 = buildProject(id: 1, task_ids: [1])
+    project2 = buildProject(id: 2)
+    task1 = buildTask(id: 1, project_id: project1.id)
+
+  describe "stubbing responses", ->
+    it "should update returned collections", ->
+      expectation = manager.stub "projects", response: (stub) ->
+        stub.results = [project1, project2]
+      collection = manager.loadCollection "projects"
+      expect(collection.length).toEqual 0
+      expectation.respond()
+      expect(collection.length).toEqual 2
+      expect(collection.get(1)).toEqual project1
+      expect(collection.get(2)).toEqual project2
+
+    it "should call callbacks", ->
+      expectation = manager.stub "projects", response: (stub) ->
+        stub.results = [project1, project2]
+      collection = null
+      manager.loadCollection "projects", success: (c) -> collection = c
+      expect(collection).toBeNull()
+      expectation.respond()
+      expect(collection.length).toEqual 2
+      expect(collection.get(1)).toEqual project1
+      expect(collection.get(2)).toEqual project2
+
+    it "should add to passed-in collections", ->
+      expectation = manager.stub "projects", response: (stub) ->
+        stub.results = [project1, project2]
+      collection = new Brainstem.Collection()
+      manager.loadCollection "projects", collection: collection
+      expect(collection.length).toEqual 0
+      expectation.respond()
+      expect(collection.length).toEqual 2
+      expect(collection.get(1)).toEqual project1
+      expect(collection.get(2)).toEqual project2
+
+    it "should work with results hashes", ->
+      expectation = manager.stub "projects", response: (stub) ->
+        stub.results = [{ key: "projects", id: 2 }, { key: "projects", id: 1 }]
+        stub.associated.projects = [project1, project2]
+      collection = manager.loadCollection "projects"
+      expectation.respond()
+      expect(collection.length).toEqual 2
+      expect(collection.models[0]).toEqual project2
+      expect(collection.models[1]).toEqual project1
+
+    it "can populate associated objects", ->
+      expectation = manager.stub "projects", include: ["tasks"], response: (stub) ->
+        stub.results = [project1, project2]
+        stub.associated.projects = [project1, project2]
+        stub.associated.tasks = [task1]
+      collection = new Brainstem.Collection()
+      manager.loadCollection "projects", collection: collection, include: ["tasks"]
+      expectation.respond()
+      expect(collection.get(1).get("tasks").models).toEqual [task1]
+      expect(collection.get(2).get("tasks").models).toEqual []
+
+    describe "triggering errors", ->
+      it "triggers errors when asked to do so", ->
+        errorSpy = jasmine.createSpy()
+
+        collection = new Brainstem.Collection()
+
+        resp =
+          readyState: 4
+          status: 401
+          responseText: ""
+
+        expectation = manager.stub "projects", collection: collection, triggerError: resp
+
+        manager.loadCollection "projects", error: errorSpy
+
+        expectation.respond()
+        expect(errorSpy).toHaveBeenCalled()
+        expect(errorSpy.mostRecentCall.args[0] instanceof Brainstem.Collection).toBe true
+        expect(errorSpy.mostRecentCall.args[1]).toEqual resp
+
+      it "does not trigger errors when asked not to", ->
+        errorSpy = jasmine.createSpy()
+        expectation = manager.stub "projects", response: (exp) -> exp.results = [project1, project2]
+
+        manager.loadCollection "projects", error: errorSpy
+
+        expectation.respond()
+        expect(errorSpy).not.toHaveBeenCalled()
+
+  describe "responding immediately", ->
+    it "uses stubImmediate", ->
+      expectation = manager.stubImmediate "projects", include: ["tasks"], response: (stub) ->
+        stub.results = [project1, project2]
+        stub.associated.tasks = [task1]
+      collection = manager.loadCollection "projects", include: ["tasks"]
+      expect(collection.get(1).get("tasks").models).toEqual [task1]
+
+  describe "multiple stubs", ->
+    it "should match the first valid expectation", ->
+      manager.stubImmediate "projects", only: [1], response: (stub) ->
+        stub.results = [project1]
+      manager.stubImmediate "projects", response: (stub) ->
+        stub.results = [project1, project2]
+      manager.stubImmediate "projects", only: [2], response: (stub) ->
+        stub.results = [project2]
+      expect(manager.loadCollection("projects", only: 1).models).toEqual [project1]
+      expect(manager.loadCollection("projects").models).toEqual [project1, project2]
+      expect(manager.loadCollection("projects", only: 2).models).toEqual [project2]
+
+    it "should fail if it cannot find a specific match", ->
+      manager.stubImmediate "projects", response: (stub) ->
+        stub.results = [project1]
+      manager.stubImmediate "projects", include: ["tasks"], filters: { something: "else" }, response: (stub) ->
+        stub.results = [project1, project2]
+        stub.associated.tasks = [task1]
+      expect(manager.loadCollection("projects", include: ["tasks"], filters: { something: "else" }).models).toEqual [project1, project2]
+      expect(-> manager.loadCollection("projects", include: ["tasks"], filters: { something: "wrong" })).toThrow()
+      expect(-> manager.loadCollection("projects", include: ["users"], filters: { something: "else" })).toThrow()
+      expect(-> manager.loadCollection("projects", filters: { something: "else" })).toThrow()
+      expect(-> manager.loadCollection("projects", include: ["users"])).toThrow()
+      expect(manager.loadCollection("projects").models).toEqual [project1]
+
+    it "should ignore empty arrays", ->
+      manager.stubImmediate "projects", response: (stub) ->
+        stub.results = [project1, project2]
+      expect(manager.loadCollection("projects", include: []).models).toEqual [project1, project2]
+
+    it "should allow wildcard params", ->
+      manager.stubImmediate "projects", include: '*', response: (stub) ->
+        stub.results = [project1, project2]
+      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]
+
+  describe "recording", ->
+    it "should record options", ->
+      expectation = manager.stubImmediate "projects", filters: { something: "else" }, response: (stub) ->
+        stub.results = [project1, project2]
+      manager.loadCollection("projects", filters: { something: "else" })
+      expect(expectation.matches[0].filters).toEqual { something: "else" }
+
+  describe "clearing expectations", ->
+    it "expectations can be removed", ->
+      expectation = manager.stub "projects", include: ["tasks"], response: (stub) ->
+        stub.results = [project1, project2]
+        stub.associated.tasks = [task1]
+
+      collection = manager.loadCollection "projects", include: ["tasks"]
+      expectation.respond()
+      expect(collection.get(1).get("tasks").models).toEqual [task1]
+
+      collection2 = manager.loadCollection "projects", include: ["tasks"]
+      expect(collection2.get(1)).toBeFalsy()
+      expectation.respond()
+      expect(collection2.get(1).get("tasks").models).toEqual [task1]
+
+      expectation.remove()
+      expect(-> manager.loadCollection "projects").toThrow()
+
+  describe "lastMatch", ->
+    it "retrives the last match object", ->
+      expectation = manager.stubImmediate "projects", include: "*", response: (stub) ->
+        stub.results = []
+
+      manager.loadCollection("projects", include: ["tasks"])
+      manager.loadCollection("projects", include: ["users"])
+
+      expect(expectation.matches.length).toEqual(2)
+      expect(expectation.lastMatch().include).toEqual(["users"])
+
+    it "returns undefined if no matches exist", ->
+      expectation = manager.stub "projects", response: (stub) ->
+        stub.results = []
+      expect(expectation.lastMatch()).toBeUndefined()
+
+  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
+
+    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
+
+    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
+
+    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
+
+      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

data/spec/helpers/builders.coffee

@@ -0,0 +1,80 @@
+window.spec ?= {}
+
+spec.defineBuilders = ->
+  window.defineBuilder = (name, klass, defaultOptions) ->
+    class_defaults = {}
+
+    for key, value of defaultOptions
+      if typeof(value) == "function"
+        do ->
+          seq_name = name + "_" + key
+          BackboneFactory.define_sequence(seq_name, value)
+          class_defaults[key] = ->
+            next = BackboneFactory.next(seq_name)
+            if isIdAttr(seq_name) then arrayPreservedToString(next) else next
+      else
+        class_defaults[key] = if isIdAttr(key) then arrayPreservedToString(value) else value
+
+    factory = BackboneFactory.define(name, klass, -> return class_defaults)
+    builder = (opts) ->
+      BackboneFactory.create(name, $.extend({}, class_defaults, idsToStrings(opts)))
+
+    creator = (opts) ->
+      obj = builder(idsToStrings(opts))
+      storageName = name.underscore().pluralize()
+      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")
+
+  isIdAttr = (attrName) ->
+    attrName == 'id' || attrName.match(/_id$/) || (attrName.match(/_ids$/))
+
+  arrayPreservedToString = (value) ->
+    if _.isArray(value)
+      _.map(value, (v) -> arrayPreservedToString(v))
+    else if value? && !$.isPlainObject(value)
+      String(value)
+    else
+      value
+
+  idsToStrings = (builderOpts) ->
+    for key, value of builderOpts
+      if isIdAttr(key)
+        builderOpts[key] = arrayPreservedToString(value)
+
+    builderOpts
+
+  window.defineBuilder "user", App.Models.User, {
+    id: (n) -> return n
+  }
+
+  window.defineBuilder "project", App.Models.Project, {
+    id: (n) -> return n
+    title: "new project"
+  }
+
+  getTimeEntryDefaults = ->
+    project = buildProject()
+
+    return {
+      id: (n)-> return n
+      project_id: project.get("id")
+    }
+  window.defineBuilder "timeEntry", App.Models.TimeEntry, getTimeEntryDefaults()
+
+  getTaskDefaults = ->
+    project = buildProject()
+
+    return {
+      id: (n) -> n
+      project_id: project.get("id")
+      description: "a very interesting task"
+      title: (n) -> "new Task#{n}"
+      archived: false
+      parent_id: null
+    }
+  window.defineBuilder "task", App.Models.Task, getTaskDefaults()
+
+  window.defineBuilder "post", App.Models.Post, {}