backbone-nested-attributes 0.2.2

data/spec/javascripts/backbone-nested-attributes/UndoableSpec.js

@@ -0,0 +1,489 @@
+describe("Backbone.UndoableModel", function() {
+  var model,
+      originalAttributes,
+      afterSyncAttributes,
+      called,
+      post,
+      Post,
+      comments,
+      comment,
+      Comment,
+      author,
+      Person
+
+  beforeEach(function() {
+    jasmine.Ajax.useMock()
+    called = false
+
+    originalAttributes = { title: 'some title', body: 'some body' }
+    model = new Backbone.UndoableModel(originalAttributes)
+    model.url = 'http://someapi.com'
+  })
+
+  function performSync(model) {
+    var request = mostRecentAjaxRequest();
+    request.response({status: 200, responseText: model.toJSON()})
+  }
+
+  it("should be a Backbone.NestedAttributesModel", function() {
+    expect(model).toBeAnInstanceOf(Backbone.NestedAttributesModel)
+  })
+
+  describe("when the initialize method is overriden", function() {
+    var Model
+
+    describe("and the undoable method is not called", function() {
+      beforeEach(function() {
+        Model = Backbone.UndoableModel.extend({
+          initialize: function () {}
+        })
+
+        model = new Model(originalAttributes)
+      })
+
+      it("does not reverts the model own attributes to its original attributes", function() {
+        model.set({ title: 'new title', body: 'new body' })
+        model.undo()
+
+        expect(model.toJSON()).not.toEqual(originalAttributes)
+      })
+    })
+
+    describe("and the undoable method is called", function() {
+      describe("in the initialize method", function() {
+        beforeEach(function() {
+          Model = Backbone.UndoableModel.extend({
+            initialize: function () {
+              this.undoable()
+            }
+          })
+
+          model = new Model(originalAttributes)
+        })
+
+        it("reverts the model own attributes to its original attributes", function() {
+          model.set({ title: 'new title', body: 'new body' })
+          model.undo()
+
+          expect(model.toJSON()).toEqual(originalAttributes)
+        })
+      })
+
+      describe("by calling the super method", function() {
+        beforeEach(function() {
+          Model = Backbone.UndoableModel.extend({
+            initialize: function () {
+              Backbone.UndoableModel.prototype.initialize.apply(this, arguments)
+            }
+          })
+
+          model = new Model(originalAttributes)
+        })
+
+        it("reverts the model own attributes to its original attributes", function() {
+          model.set({ title: 'new title', body: 'new body' })
+          model.undo()
+
+          expect(model.toJSON()).toEqual(originalAttributes)
+        })
+      })
+
+      describe("after it is initialized", function() {
+        beforeEach(function() {
+          Model = Backbone.UndoableModel.extend({})
+
+          model = new Model(originalAttributes)
+        })
+
+        it("reverts the model own attributes to the attributes that the model had before calling undoable", function() {
+          var beforeUndoableAttributes = { title: 'before undoable title', body: 'before undoable body' }
+
+          model.set(beforeUndoableAttributes)
+          model.undoable()
+          model.set({ title: 'new title', body: 'new body' })
+          model.undo()
+
+          expect(model.toJSON()).toEqual(beforeUndoableAttributes)
+        })
+      })
+    })
+  })
+
+  describe("when it is a new model", function() {
+    it("should not have changes since sync", function() {
+      expect(model.hasChangedSinceSync()).toBeFalsy()
+    })
+
+    describe("and it is changed", function() {
+      it("should have changes since sync", function() {
+        model.set({ title: 'new title', body: 'new body' })
+        expect(model.hasChangedSinceSync()).toBeTruthy()
+      })
+
+      describe("and then undo", function() {
+        it("should not have changes since sync", function() {
+          model.set({ title: 'new title', body: 'new body' })
+          model.undo()
+          expect(model.hasChangedSinceSync()).toBeFalsy()
+        })
+
+        it("reverts the model own attributes to its original attributes", function() {
+          model.set({ title: 'new title', body: 'new body' })
+          model.undo()
+
+          expect(model.toJSON()).toEqual(originalAttributes)
+        })
+      })
+
+      describe("and then sync", function() {
+        it("should not have changes since sync", function() {
+          model.set({ title: 'new title', body: 'new body' })
+          model.save()
+          performSync(model)
+          expect(model.hasChangedSinceSync()).toBeFalsy()
+        })
+
+        describe("then undo", function() {
+          it("reverts the model own attributes to their value right after sync", function() {
+            model.set({ title: 'sync title', body: 'sync body' })
+            model.save()
+            performSync(model)
+
+            afterSyncAttributes = model.toJSON()
+
+            model.set({ title: 'new title', body: 'new body' })
+            model.undo()
+
+            expect(model.toJSON()).toEqual(afterSyncAttributes)
+          })
+        })
+      })
+    })
+  })
+
+  describe("when it is an existing model", function() {
+    beforeEach(function() {
+
+      originalAttributes = { id: 123, title: 'some title', body: 'some body' }
+      model = new Backbone.UndoableModel(originalAttributes)
+      model.url = 'http://someapi.com'
+    })
+
+    describe("and it is changed", function() {
+      it("should have changes since sync", function() {
+        model.set({ title: 'new title', body: 'new body' })
+        expect(model.hasChangedSinceSync()).toBeTruthy()
+      })
+
+      describe("and then undo", function() {
+        it("should not have changes since sync", function() {
+          model.set({ title: 'new title', body: 'new body' })
+          model.undo()
+          expect(model.hasChangedSinceSync()).toBeFalsy()
+        })
+
+        it("reverts the model own attributes to its original attributes", function() {
+          model.set({ title: 'new title', body: 'new body' })
+          model.undo()
+
+          expect(model.toJSON()).toEqual(originalAttributes)
+        })
+      })
+
+      describe("and then sync", function() {
+        it("should not have changes since sync", function() {
+          model.set({ title: 'new title', body: 'new body' })
+          model.save()
+          performSync(model)
+          expect(model.hasChangedSinceSync()).toBeFalsy()
+        })
+
+        describe("then undo", function() {
+          it("reverts the model own attributes to their value right after sync", function() {
+            model.set({ title: 'sync title', body: 'sync body' })
+            model.save()
+            performSync(model)
+
+            afterSyncAttributes = model.toJSON()
+
+            model.set({ title: 'new title', body: 'new body' })
+            model.undo()
+
+            expect(model.toJSON()).toEqual(afterSyncAttributes)
+          })
+        })
+      })
+    })
+  })
+
+  describe("state:restore event", function() {
+    var called
+
+    beforeEach(function() {
+      called = false
+    })
+
+    it("is triggered when the model is undo", function() {
+      model.on('state:restore', function () {
+        called = true
+      })
+
+      model.undo()
+      expect(called).toBeTruthy()
+    })
+  })
+
+  describe("state:store event", function() {
+    it("is triggered when the model is saved", function() {
+      model.on('state:store', function () {
+        called = true
+      })
+
+      model.save()
+      performSync(model)
+      expect(called).toBeTruthy()
+    })
+
+    describe("when it is a new model", function() {
+      it("is triggered when the model is saved", function() {
+        model.on('state:store', function () {
+          called = true
+        })
+
+        model.save()
+        performSync(model)
+        expect(called).toBeTruthy()
+      })
+
+      it("is not triggered when the model is destroyed", function() {
+        model.on('state:store', function () {
+          called = true
+        })
+
+        model.destroy()
+        performSync(model)
+        expect(called).toBeFalsy()
+      })
+    })
+
+    describe("when it is not a new model", function() {
+      beforeEach(function() {
+        model.set({ id: 123 })
+      });
+
+      it("is triggered when the model is saved", function() {
+        model.on('state:store', function () {
+          called = true
+        })
+
+        model.save()
+        performSync(model)
+        expect(called).toBeTruthy()
+      })
+
+      it("is triggered when the model is destroyed", function() {
+        model.on('state:store', function () {
+          called = true
+        })
+
+        model.destroy()
+        performSync(model)
+        expect(called).toBeTruthy()
+      })
+    })
+  })
+
+  describe("when it has a has one relationship", function() {
+    beforeEach(function() {
+      Post = Backbone.UndoableModel.extend({
+        relations: [
+          {
+            type: 'one',
+            key:  'author',
+            relatedModel: function () { return Person }
+          }
+        ]
+      })
+
+      Person = Backbone.UndoableModel.extend({})
+
+      originalAttributes = { title: 'some title', author: { name: 'Jon Snow' } }
+      post = new Post(_(originalAttributes).clone())
+      author = post.get('author')
+    })
+
+    describe("and a nested model changes", function() {
+      it("should have changes since sync", function() {
+        author.set({ name: 'Robb Stark' })
+        expect(author.hasChangedSinceSync()).toBeTruthy()
+      })
+
+      it("its parent should have changes since sync", function() {
+        author.set({ name: 'Robb Stark' })
+        expect(post.hasChangedSinceSync()).toBeTruthy()
+      })
+
+      describe("and the nested model state is saved", function() {
+        it("should not have changes since sync", function() {
+          author.set({ name: 'Robb Stark' })
+          author.saveState()
+          expect(author.hasChangedSinceSync()).toBeFalsy()
+        })
+
+        it("its parent should have changes since sync", function() {
+          author.set({ name: 'Robb Stark' })
+          author.saveState()
+          expect(post.hasChangedSinceSync()).toBeTruthy()
+        })
+
+        describe("when undoing changes", function() {
+          it("revert to the last saved state", function() {
+            author.set({ name: 'Robb Stark' })
+            author.saveState()
+            author.set({ name: 'Tyrion Lanninster' })
+            author.undo()
+            expect(author.get('name')).toEqual('Robb Stark')
+          })
+        })
+      })
+    })
+
+    describe("undoing a change", function() {
+      describe("in its own attributes", function() {
+        it("reverts the model own attributes to its original attributes", function() {
+          post.set({ title: 'new title' })
+          post.undo()
+
+          expect(post.toJSON()).toEqual(originalAttributes)
+        })
+      })
+
+      describe("in a nested model", function() {
+        it("reverts the model own attributes as well as the nested ones to its original attributes, creating a new model reference", function() {
+          author.set({ name: 'Robb Stark' })
+          post.undo()
+
+          expect(post.toJSON()).toEqual(originalAttributes)
+          expect(post.get('author')).not.toEqual(author)
+        })
+      })
+    })
+
+    describe("undoing a nested model", function() {
+      it("does not trigger a state:restore event on the parent model", function() {
+        post.on('state:restore', function () {
+          called = true
+        })
+
+        author.undo()
+        expect(called).toBeFalsy()
+      })
+
+      it("trigger a state:restore event on the nested model", function() {
+        author.on('state:restore', function () {
+          called = true
+        })
+
+        author.undo()
+        expect(called).toBeTruthy()
+      })
+    })
+  })
+
+  describe("when it has a has many relationship", function() {
+    beforeEach(function() {
+      Post = Backbone.UndoableModel.extend({
+        relations: [
+          {
+            key:  'comments',
+            relatedModel: function () { return Comment }
+          }
+        ]
+      })
+
+      Comment = Backbone.UndoableModel.extend({})
+
+      originalAttributes = { title: 'some title', comments: [ { body: 'some body' } ] }
+      post = new Post(_(originalAttributes).clone())
+      comments = post.get('comments')
+      comment = comments.at(0)
+    })
+
+    describe("and a nested model changes", function() {
+      it("should have changes since sync", function() {
+        comment.set({ body: 'new body' })
+        expect(comment.hasChangedSinceSync()).toBeTruthy()
+      })
+
+      it("its parent should have changes since sync", function() {
+        comment.set({ body: 'new body' })
+        expect(post.hasChangedSinceSync()).toBeTruthy()
+      })
+
+      describe("and the nested model state is saved", function() {
+        it("should not have changes since sync", function() {
+          comment.set({ body: 'new body' })
+          comment.saveState()
+          expect(comment.hasChangedSinceSync()).toBeFalsy()
+        })
+
+        it("its parent should have changes since sync", function() {
+          comment.set({ body: 'new body' })
+          comment.saveState()
+          expect(post.hasChangedSinceSync()).toBeTruthy()
+        })
+
+        describe("when undoing changes", function() {
+          it("revert to the last saved state", function() {
+            comment.set({ body: 'new body' })
+            comment.saveState()
+            comment.set({ body: 'other body' })
+            comment.undo()
+            expect(comment.get('body')).toEqual('new body')
+          })
+        })
+      })
+    })
+
+    describe("undoing a change", function() {
+      describe("in its own attributes", function() {
+        it("reverts the model own attributes to its original attributes", function() {
+          post.set({ title: 'new title' })
+          post.undo()
+
+          expect(post.toJSON()).toEqual(originalAttributes)
+        })
+      })
+
+      describe("in a nested model", function() {
+        it("reverts the model own attributes as well as the nested ones to its original attributes, keeping the existing collection untouched", function() {
+          comment.set({ body: 'new body' })
+          post.undo()
+
+          expect(post.toJSON()).toEqual(originalAttributes)
+          expect(post.get('comments')).toEqual(comments)
+        })
+      })
+    })
+
+    describe("undoing a nested model", function() {
+      it("does not trigger a state:restore event on the parent model", function() {
+        post.on('state:restore', function () {
+          called = true
+        })
+
+        comment.undo()
+        expect(called).toBeFalsy()
+      })
+
+      it("trigger a state:restore event on the nested model", function() {
+        comment.on('state:restore', function () {
+          called = true
+        })
+
+        comment.undo()
+        expect(called).toBeTruthy()
+      })
+    })
+  })
+})