slender_data 0.5.0 → 0.6.0

data/spec/dummy/spec/javascripts/parameterizable_spec.coffee

@@ -0,0 +1,138 @@
+#= require spec_helper
+
+
+describe 'Parameterizable', ->
+
+  beforeEach ->
+    define_test_data this
+
+
+  describe 'constructor', ->
+
+    it 'stores the given parameters for later use', ->
+      @parameterizable = new slender_data.Parameterizable @test_params
+      expect(@parameterizable.params).to.not.be.undefined
+
+    it 'allows to configure the name of data models', ->
+      @parameterizable = new slender_data.Parameterizable @test_params
+      expect(@parameterizable.entry_name).to.equal 'user'
+
+    it 'defaults the name for a collection of data models to the plural version of the name of a single data model', ->
+      @parameterizable = new slender_data.Parameterizable @test_params
+      expect(@parameterizable.entries_name).to.equal 'users'
+
+    it 'allows to configure the name for a collection of data models', ->
+      @test_params.entries_name = 'humans'
+      @parameterizable = new slender_data.Parameterizable @test_params
+      expect(@parameterizable.entries_name).to.equal 'humans'
+
+    it 'uses the "id" attribute as an identifier by default', ->
+      @test_params.id_name = undefined
+      @parameterizable = new slender_data.Parameterizable @test_params
+      expect(@parameterizable.id_name).to.equal 'id'
+
+    it 'allows to configure which attribute is used as the indentifier', ->
+      @test_params.id_name = 'foo'
+      @parameterizable = new slender_data.Parameterizable @test_params
+      expect(@parameterizable.id_name).to.equal 'foo'
+
+    it 'defaults the name of a collection of identifiers to "ids"', ->
+      @test_params.id_name = undefined
+      @test_params.ids_name = undefined
+      @parameterizable = new slender_data.Parameterizable @test_params
+      expect(@parameterizable.ids_name).to.equal 'ids'
+
+    it 'allows to configure the name of a collection of identifiers', ->
+      @test_params.ids_name = 'foo'
+      @parameterizable = new slender_data.Parameterizable @test_params
+      expect(@parameterizable.ids_name).to.equal 'foo'
+
+    it 'uses the "version" attribute for versioning by default', ->
+      @test_params.version_name = undefined
+      @parameterizable = new slender_data.Parameterizable @test_params
+      expect(@parameterizable.version_name).to.equal 'version'
+
+    it 'allows to configure which attribute is used for versioning', ->
+      @test_params.version_name = 'foo'
+      @parameterizable = new slender_data.Parameterizable @test_params
+      expect(@parameterizable.version_name).to.equal 'foo'
+
+    it 'does not perform versioning by default', ->
+      @test_params.versioning = undefined
+      @parameterizable = new slender_data.Parameterizable @test_params
+      expect(@parameterizable.versioning).to.be.false
+
+    it 'allows to enable versioning', ->
+      @test_params.versioning = yes
+      @parameterizable = new slender_data.Parameterizable @test_params
+      expect(@parameterizable.versioning).to.be.true
+
+
+
+  describe 'querify_single', ->
+
+    beforeEach ->
+      @test_params.versioning = yes
+      @test_params.partial_entries = yes
+      @parameterizable = new slender_data.Parameterizable @test_params
+      @query_hash = id: 3, full: yes
+
+    context 'given a query hash', ->
+
+      beforeEach ->
+        @result = @parameterizable._querify_single @query_hash
+
+      it 'returns a query instance for the given hash', ->
+        expect(@result).to.be.an.instanceof slender_data.SingleQuery
+        expect(@result.to_hash()).to.eql @query_hash
+
+      it 'configures the created query with the default configuration values of the current query', ->
+        expect(@result.versioning).to.be.true
+        expect(@result.partial_entries).to.be.true
+
+      it 'configures the created query with teh query parameters of the current query', ->
+        expect(@result.full).to.be.true
+
+    context 'given a query object', ->
+
+      beforeEach ->
+        @query = new slender_data.SingleQuery @query_hash, @test_params
+        @result = @parameterizable._querify_single @query
+
+      it 'returns a given query directly', ->
+        expect(@result).to.equal @query
+
+
+  describe 'querify_multi', ->
+
+    beforeEach ->
+      @test_params.versioning = yes
+      @test_params.partial_entries = yes
+      @parameterizable = new slender_data.Parameterizable @test_params
+      @query_hash = ids: [3, 4], full: yes
+
+    context 'given a query hash', ->
+
+      beforeEach ->
+        @result = @parameterizable._querify_multi @query_hash
+
+      it 'returns a query instance for the given hash', ->
+        expect(@result).to.be.an.instanceof slender_data.MultiQuery
+        expect(@result.to_hash()).to.eql @query_hash
+
+      it 'configures the created query with the default configuration values of the current query', ->
+        expect(@result.versioning).to.be.true
+        expect(@result.partial_entries).to.be.true
+
+      it 'configures the created query with teh query parameters of the current query', ->
+        expect(@result.full).to.be.true
+
+    context 'given a query object', ->
+
+      beforeEach ->
+        @query = new slender_data.MultiQuery @query_hash, @test_params
+        @result = @parameterizable._querify_multi @query
+
+      it 'returns a given query directly', ->
+        expect(@result).to.equal @query
+

data/spec/dummy/spec/javascripts/persistence_manager_spec.coffee

@@ -0,0 +1,659 @@
+#= require spec_helper
+
+
+describe 'PersistenceManager', ->
+
+  beforeEach ->
+    define_test_data this
+    @persistence_manager = new slender_data.PersistenceManager @test_params
+
+
+  describe 'add_to_cache', ->
+
+    beforeEach ->
+      @result = @persistence_manager.add_to_cache @user_1
+
+    it 'adds the described entry to the serverside cache', ->
+      expect(@persistence_manager.get user: @user_1).to.eql @user_1
+
+    it 'returns nothing', ->
+      expect(@result).to.be.undefined
+
+
+
+  describe 'add_many_to_cache', ->
+
+    beforeEach ->
+      @result = @persistence_manager.add_many_to_cache [ @user_1, @user_2 ]
+
+    it 'adds all described entries to the chache', ->
+      expect(@persistence_manager.get user: @user_1).to.eql @user_1
+      expect(@persistence_manager.get user: @user_2).to.eql @user_2
+
+    it 'returns nothing', ->
+      expect(@result).to.be.undefined
+
+
+
+  describe 'create', ->
+
+    beforeEach ->
+      @server_create_api = sinon.stub(@persistence_manager.server_api, 'create')
+                                .yields user: @user_1
+      @result = @persistence_manager.create @user_1
+
+    it 'creates the entry on the server', ->
+      expect(@server_create_api).to.have.been.calledOnce
+      expect(@server_create_api).to.have.been.calledWith @user_1
+
+    it 'adds the server response to the cache', ->
+      expect(@persistence_manager.get user: @user_1).to.eql @user_1
+
+    it 'returns nothing', ->
+      expect(@result).to.be.undefined
+
+    it 'calls the given callback with an editable version of the created entry when done', (done) ->
+      @persistence_manager.create @user_1, (result) =>
+        expect(result).to.eql @user_1
+        expect(result).to.not.equal @user_1
+        done()
+
+
+  describe 'create_many', ->
+
+    beforeEach ->
+      @server_create_many_api = sinon.stub(@persistence_manager.server_api, 'create_many')
+                                     .yields users: [@user_1, @user_2]
+      @result = @persistence_manager.create_many [@user_1, @user_2]
+
+    it 'creates the entries on the server', ->
+      expect(@server_create_many_api).to.have.been.calledOnce
+      expect(@server_create_many_api).to.have.been.calledWith [@user_1, @user_2]
+
+    it 'adds the server response to the cache', ->
+      expect(@persistence_manager.get user: @user_1).to.eql @user_1
+      expect(@persistence_manager.get user: @user_2).to.eql @user_2
+
+    it 'returns nothing', ->
+      expect(@result).to.be.undefined
+
+    it 'calls the given callback when done', (done) ->
+      @persistence_manager.create_many [@user_1], done
+
+
+
+  describe 'delete', ->
+
+    beforeEach (done) ->
+      @persistence_manager.add_to_cache @user_1
+      @server_delete_api = sinon.stub(@persistence_manager.server_api, 'delete')
+                                .yields username: 'one'
+      @persistence_manager.delete @user_1, (@result) =>
+        done()
+
+    it 'removes the given entry from the cache', ->
+        expect(@persistence_manager.get user: @user_1).to.be.undefined
+
+    it 'removes the given entry from the server', ->
+      expect(@server_delete_api).to.have.been.calledOnce
+      expect(@server_delete_api).to.have.been.calledWith @user_1
+
+    it 'calls the given callback with a description of the deleted entry', ->
+      expect(@result).to.eql username: 'one'
+
+
+  describe 'delete_many', ->
+
+    beforeEach (done) ->
+      @persistence_manager.add_many_to_cache [@user_1, @user_2]
+      @server_delete_many_api = sinon.stub(@persistence_manager.server_api, 'delete_many')
+                                     .yields usernames: ['one', 'two']
+      @persistence_manager.delete_many [@user_1, @user_2], (@result) => done()
+
+    it 'removes the given entries from the cache', ->
+      expect(@persistence_manager.get user: @user_1).to.be.undefined
+      expect(@persistence_manager.get user: @user_2).to.be.undefined
+
+    it 'removes the given entry from the server', ->
+      expect(@server_delete_many_api).to.have.been.calledOnce
+      expect(@server_delete_many_api).to.have.been.calledWith [@user_1, @user_2]
+
+    it 'calls the given callback with a description of the deleted entries', ->
+      expect(@result).to.eql usernames: ['one', 'two']
+
+
+
+  describe 'get', ->
+
+    describe 'normal functionality', ->
+
+      beforeEach ->
+        @persistence_manager.add_to_cache @user_1
+
+      it 'returns the described entry from the cache if it exists there', ->
+        expect(@persistence_manager.get user: @user_1).to.eql @user_1
+
+      it 'returns undefined if the described entry is not cached', ->
+        expect(@persistence_manager.get user: @user_2).to.be.undefined
+
+
+    describe 'partial/full functionality', ->
+
+      beforeEach ->
+        @test_params.partial_entries = yes
+        @persistence_manager = new slender_data.PersistenceManager @test_params
+
+      context 'partial entry in cache', ->
+
+        beforeEach ->
+          @persistence_manager.add_to_cache @partial_user_1
+
+        it 'returns the cached partial entry when partial entries are allowed', ->
+          result = @persistence_manager.get username: 'one', full: no
+          expect(result).to.eql @partial_user_1
+
+        it 'returns undefined when full entries are requested', ->
+          result = @persistence_manager.get username: 'one', full: yes
+          expect(result).to.be.undefined
+
+
+      context 'full entry in the cache', ->
+
+        beforeEach ->
+          @persistence_manager.add_to_cache @full_user_1
+
+        context 'partial entry requested', ->
+
+          beforeEach ->
+            @result = @persistence_manager.get username: 'one', full: no
+
+          it 'returns the cached full entry', ->
+            expect(@result).to.eql @full_user_1
+
+        context 'full entry requested', ->
+
+          beforeEach ->
+            @result = @persistence_manager.get username: 'one', full: yes
+
+          it 'returns the cached full entry', ->
+            expect(@result).to.eql @full_user_1
+
+
+
+  describe 'get_many', ->
+
+    describe 'normal functionality', ->
+
+      beforeEach ->
+        @persistence_manager.add_many_to_cache [@user_1, @user_3]
+        @result = @persistence_manager.get_many users: [@user_1, @user_2, @user_3]
+
+      it 'returns the cached entries', ->
+        expect(@result.found).to.eql [@user_1, @user_3]
+
+      it 'returns the ids of the missing entries', ->
+        expect(@result.missing).to.be.an.instanceof slender_data.MultiQuery
+        expect(@result.missing.ids()).to.eql ['two']
+
+
+    describe 'partial/full functionality', ->
+
+      beforeEach ->
+        @test_params.partial_entries = yes
+        @persistence_manager = new slender_data.PersistenceManager @test_params
+        @persistence_manager.add_many_to_cache [@partial_user_1, @full_user_2]
+
+      context 'partial entries requested', ->
+
+        beforeEach ->
+          @result = @persistence_manager.get_many
+            usernames: ['one', 'two', 'three'], full: no
+
+        it 'returns all matching cached entries as found', ->
+          expect(@result.found).to.eql [@partial_user_1, @full_user_2]
+
+        it 'returns the ids of missing entries as missing', ->
+          expect(@result.missing.to_hash()).to.eql usernames: ['three'], full: no
+
+      context 'full entries requested', ->
+
+        beforeEach ->
+          @result = @persistence_manager.get_many
+            usernames: ['one', 'two', 'three'], full: yes
+
+        it 'returns only full entries as found', ->
+          expect(@result.found).to.eql [@full_user_2]
+
+        it 'returns partial and missing entries as missing', ->
+          expect(@result.missing.to_hash()).to.eql usernames: ['one', 'three'], full: yes
+
+
+    describe 'versioning', ->
+
+       beforeEach ->
+         @test_params.versioning = yes
+         @persistence_manager = new slender_data.PersistenceManager @test_params
+         @persistence_manager.add_many_to_cache [@user_1_outdated, @user_2]
+         @result = @persistence_manager.get_many users: [@user_1, @user_2]
+
+        it 'returns only results of the right version', ->
+          expect(@result.found).to.eql [@user_2]
+          expect(@result.missing.to_hash()).to.eql users: [@user_1]
+
+
+  describe 'load', ->
+
+    beforeEach ->
+      @server_read_api = sinon.stub @persistence_manager.server_api, 'read'
+
+
+    describe 'normal behavior', ->
+
+      context 'described entry is in the cache', ->
+
+        beforeEach (done) ->
+          @persistence_manager.add_to_cache @user_1
+          @persistence_manager.load user: @user_1, (@result) =>
+            done()
+
+        it 'returns the entry directly from the cache', ->
+          expect(@result).to.eql @user_1
+
+        it 'does not query the server', ->
+          expect(@persistence_manager.server_api.read).to.not.have.been.called
+
+      context 'described entry is not in the cache', ->
+
+        beforeEach (done) ->
+          @server_read_api.yields(user: @user_1)
+          @persistence_manager.load user: @user_1, (@result) =>
+            done()
+
+        it 'loads the entry from the server', ->
+          server_read_api = @persistence_manager.server_api.read
+          expect(server_read_api).to.have.been.calledOnce
+          expect(server_read_api.args[0][0].to_hash()).to.eql user: @user_1
+
+        it 'adds the loaded entry to the cache', ->
+          expect(@persistence_manager.get user: @user_1).to.eql @user_1
+
+        it 'returns an editable copy of the entry loaded from the server', ->
+          expect(@result).to.eql @user_1
+          expect(@result).to.not.equal @user_1
+
+
+    describe 'partial entry functionality', ->
+
+      beforeEach ->
+        @test_params.partial_entries = yes
+        @persistence_manager = new slender_data.PersistenceManager @test_params
+        @server_read_api = sinon.stub(@persistence_manager.server_api, 'read')
+                                .yields(user: @full_user_1)
+
+      context 'cache contains partial entry', ->
+
+        beforeEach ->
+          @persistence_manager.add_to_cache @partial_user_1
+
+        context 'full entry requested', (done) ->
+
+          beforeEach (done) ->
+            @persistence_manager.load {username: 'one', full: yes}, (@result) =>
+              done()
+
+          it 'loads the requested entry from the server', ->
+              expect(@server_read_api).to.have.been.calledOnce
+              expect(@server_read_api.args[0][0].to_hash()).to.have.property 'username',
+                                                                             'one'
+
+          it 'replaces the cached partial entry with the loaded full entry', ->
+            expect(@persistence_manager.get username: 'one').to.eql @full_user_1
+
+        context 'partial entry requested', ->
+
+          beforeEach (done) ->
+            @persistence_manager.load {username: 'one', full: no}, (@result) =>
+              done()
+
+          it 'returns the entry from the cache', ->
+            expect(@result).to.eql @partial_user_1
+
+          it 'does not load data from the server', ->
+            expect(@server_read_api).to.not.have.been.called
+
+      context 'cache contains full entry', ->
+
+        beforeEach ->
+          @persistence_manager.add_to_cache @full_user_1
+
+        context 'full entry requested', ->
+
+          beforeEach (done) ->
+            @persistence_manager.load {username: 'one', full: yes}, (@result) =>
+              done()
+
+          it 'returns the entry from the cache', ->
+            expect(@result).to.eql @full_user_1
+
+          it 'does not load data from the server', ->
+            expect(@server_read_api).to.not.have.been.called
+
+        context 'partial entry requested', ->
+
+          beforeEach (done) ->
+            @persistence_manager.load {username: 'one', full: no}, (@result) =>
+              done()
+
+          it 'returns the full entry from the cache', ->
+            expect(@result).to.eql @full_user_1
+
+          it 'does not load data from the server', ->
+            expect(@server_read_api).to.not.have.been.called
+
+
+    describe 'versioning', ->
+
+      beforeEach ->
+        @test_params.versioning = yes
+        @persistence_manager = new slender_data.PersistenceManager @test_params
+        @server_read_api = sinon.stub(@persistence_manager.server_api, 'read')
+
+      context 'cache contains current entry', ->
+
+        beforeEach (done) ->
+          @persistence_manager.add_to_cache @user_1
+          @persistence_manager.load user: @user_1, (@result) => done()
+
+        it 'returns the cached entry', ->
+          expect(@result).to.eql @user_1
+
+        it 'does not load anything from the server', ->
+          expect(@server_read_api).to.not.have.been.called
+
+      context 'cache contains outdated entry', ->
+
+        beforeEach (done) ->
+          @persistence_manager.add_to_cache @user_1_outdated
+          @server_read_api.yields user: @user_1
+          @persistence_manager.load user: @user_1, (@result) => done()
+
+        it 'does not return the cached entry', ->
+          expect(@result).to.not.eql @user_1_outdated
+
+        it 'loads the current entry from the server', ->
+          expect(@server_read_api).to.have.been.calledOnce
+
+        it 'returns the current entry loaded from the server', ->
+          expect(@result).to.eql @user_1
+
+        it 'updates the cache with the newly loaded entry version', ->
+          expect(@persistence_manager.get user: @user_1).to.eql @user_1
+
+
+
+  describe 'load_many', ->
+
+    describe 'normal functionality', ->
+
+      beforeEach ->
+        @server_read_many_api = sinon.stub(@persistence_manager.server_api, 'read_many')
+
+      context 'all snippets are in the cache', ->
+
+        beforeEach ->
+          @persistence_manager.add_many_to_cache [@user_1, @user_2]
+
+        it 'returns all requested snippets', (done) ->
+          @persistence_manager.load_many users: [@user_1, @user_2], (users) =>
+            expect(users).to.eql [@user_1, @user_2]
+            done()
+
+        it 'does not query the server', (done) ->
+          @persistence_manager.load_many users: [@user_1, @user_2], =>
+            expect(@server_read_many_api).to.not.have.been.called
+            done()
+
+
+      context 'some snippets are not cached', ->
+
+        beforeEach ->
+          @persistence_manager.add_many_to_cache [@user_1, @user_3]
+          @user_2_from_server = slender_data.clone_hash @user_2
+          @server_read_many_api.yields users: [@user_2_from_server]
+
+        it 'returns all requested snippets', (done) ->
+          @persistence_manager.load_many users: [@user_1, @user_2, @user_3], (users) =>
+            expect(users).to.have.length 3
+            user_ids = (user.username for user in users)
+            expect(user_ids).to.include 'one'
+            expect(user_ids).to.include 'two'
+            expect(user_ids).to.include 'three'
+            done()
+
+        it 'loads the missing snippets from the server', (done) ->
+          @persistence_manager.load_many users: [@user_1, @user_2, @user_3], (users) =>
+            server_args = @server_read_many_api.args[0][0].to_hash()
+            expect(server_args).to.eql users: [@user_2]
+            done()
+
+        it 'adds the loaded entries to the cache', ->
+          @persistence_manager.load_many users: [@user_2], (users) =>
+            expect(users[0]).to.eql @user_2
+            expect(users[0]).to.not.equal @user_2_from_server
+
+
+
+    describe 'partial entry functionality', ->
+
+      beforeEach ->
+        @test_params.partial_entries = yes
+        @persistence_manager = new slender_data.PersistenceManager @test_params
+        @persistence_manager.add_many_to_cache [@partial_user_1, @full_user_2]
+        @server_read_many_api = sinon.stub(@persistence_manager.server_api, 'read_many')
+                                     .yields(users: [ @full_user_1, @full_user_3 ])
+
+      context 'full entries requested', (done) ->
+
+        beforeEach (done) ->
+          @persistence_manager.load_many {usernames: ['one', 'two', 'three'], full: yes},
+                                         (@result) => done()
+
+        it 'loads the partial entries from the server', ->
+          expect(@server_read_many_api).to.have.been.calledOnce
+          server_args = @server_read_many_api.args[0][0]
+          expect(server_args.to_hash().usernames).to.eql ['one', 'three']
+
+        it 'replaces the cached partial entries with the loaded full entries', ->
+          expect(@persistence_manager.get username: 'one').to.eql @full_user_1
+          expect(@persistence_manager.get username: 'two').to.eql @full_user_2
+
+        it 'returns the full entries', ->
+          expect(@result).to.have.length 3
+          emails = (entry.email for entry in @result)
+          expect(emails).to.include 'one@example.com'
+          expect(emails).to.include 'two@example.com'
+          expect(emails).to.include 'three@example.com'
+
+
+      context 'partial entries requested', ->
+
+        beforeEach (done) ->
+          @persistence_manager.load_many {usernames: ['one', 'two'], full: no},
+                                         (@result) => done()
+
+        it 'returns the entries from the cache', ->
+          expect(@result).to.eql [@partial_user_1, @full_user_2]
+
+        it 'does not load data from the server', ->
+          expect(@server_read_many_api).to.not.have.been.called
+
+
+    describe 'versioning', ->
+
+      beforeEach (done) ->
+        @test_params.versioning = yes
+        @persistence_manager = new slender_data.PersistenceManager @test_params
+        @persistence_manager.add_many_to_cache [@user_1_outdated, @user_2]
+        @server_read_many_api = sinon.stub(@persistence_manager.server_api,
+                                           'read_many')
+                                     .yields(users: [@user_1])
+        @persistence_manager.load_many users: [@user_1, @user_2],
+                                       (@result) => done()
+
+      it 'returns all requested entries', ->
+        expect(@result).to.eql [@user_2, @user_1]
+
+      it 'loads only outdated entries from the server', ->
+        expect(@server_read_many_api).to.have.been.calledOnce
+        expect(@server_read_many_api.args[0][0].to_hash()).to.eql users: [@user_1]
+
+      it 'adds the loaded entries to the cache', ->
+        expect(@persistence_manager.get username: 'one').to.eql @user_1
+
+
+  describe 'merge', ->
+
+    beforeEach ->
+      @merged_user_data = email: 'merged@example.com'
+      @merged_user_server_response = username: 'merged server', timestamp: 1
+      @persistence_manager.add_many_to_cache [@user_1, @user_2, @user_3]
+      @callback = sinon.stub()
+      @server_merge_api = sinon.stub(@persistence_manager.server_api, 'merge')
+                               .yields(user: @merged_user_server_response)
+      @persistence_manager.merge [@user_1.username, @user_2.username],
+                                 @merged_user_data,
+                                 @callback
+
+    it 'performes the merge on the server', ->
+      expect(@server_merge_api).to.have.been.calledOnce
+
+    it 'removes the old users from the client cache', ->
+      expect(@persistence_manager.get user: @user_1).to.be.undefined
+      expect(@persistence_manager.get user: @user_2).to.be.undefined
+      expect(@persistence_manager.get user: @user_3).to.eql @user_3
+
+    it 'adds the user provided by the server to the client cache', ->
+      cached_user = @persistence_manager.get user: @merged_user_server_response
+      expect(cached_user).to.eql @merged_user_server_response
+
+    it 'calls the given callback when done', ->
+      expect(@callback).to.have.been.calledOnce
+
+    it 'returns the editable user in the callback', ->
+      callback_args = @callback.args[0][0]
+      expect(callback_args).to.eql @merged_user_server_response
+      expect(callback_args).to.not.equal @merged_user_server_response
+
+
+
+  describe 'update', ->
+
+    beforeEach ->
+      @persistence_manager.add_to_cache @user_1
+      @user = @persistence_manager.get user: @user_1
+      @server_update_api = sinon.stub(@persistence_manager.server_api, 'update')
+                                                          .yields user: @user
+
+
+    context 'nothing is changed', ->
+
+      beforeEach (done) ->
+        @persistence_manager.update @user, (@result) => done()
+
+      it 'does not make a call to the server', ->
+        expect(@server_update_api).to.not.have.been.called
+
+      it 'calls the callback with the given entry', ->
+        expect(@result).to.eql user: @user_1
+
+      it 'works without a callback provided', ->
+        @persistence_manager.update @user
+
+
+    context 'entry is changed', ->
+
+      beforeEach (done) ->
+        @user.email = 'new_one@example.com'
+        @persistence_manager.update @user, (@result) => done()
+
+      it 'calls the server with only the changed attributes as payload', ->
+        expect(@server_update_api).to.have.been.calledOnce
+        expect(@server_update_api).to.have.been.calledWith
+          username: 'one', email: 'new_one@example.com'
+
+      it 'calls the callback with the server response when done', ->
+        expect(@result).to.eql user: @user
+
+      it 'stores the now persisted changes on the client', (done) ->
+        @persistence_manager.update @user, =>
+          @persistence_manager.update @user, =>
+            expect(@persistence_manager.server_api.update).to.have.been.calledOnce
+            done()
+
+      it 'works without a given callback', ->
+        @persistence_manager.update @user
+
+
+
+  describe 'update_many', ->
+
+    beforeEach ->
+      @persistence_manager.add_many_to_cache [@user_1, @user_2, @user_3]
+      @user_1_changed = @persistence_manager.get user: @user_1
+      @user_2_changed = @persistence_manager.get user: @user_2
+      @user_3_changed = @persistence_manager.get user: @user_3
+      @server_update_many_api = sinon.stub @persistence_manager.server_api,
+                                           'update_many'
+
+    context 'nothing is changed', ->
+
+      beforeEach (done) ->
+        @server_update_many_api.yields users: [ @user_1_changed,
+                                                @user_2_changed ]
+        @persistence_manager.update_many [@user_1_changed, @user_2_changed],
+                                         (@result) => done()
+
+      it 'does not call the server', ->
+        expect(@server_update_many_api).to.not.have.been.called
+
+      it 'calls the callback with the server response', ->
+        expect(@result).to.eql users: [@user_1_changed, @user_2_changed]
+
+      it 'works without a given callback', ->
+        @persistence_manager.update_many [@user_1_changed]
+
+
+    context 'some entries are changed', ->
+
+      beforeEach (done) ->
+        @user_1_changed.email = 'new_one@example.com'
+        @user_3_changed.timestamp = 3
+        @server_update_many_api.yields users: [ @user_1_changed,
+                                                @user_3_changed  ]
+        @persistence_manager.update_many [ @user_1_changed
+                                           @user_2_changed
+                                           @user_3_changed ],
+                                         (@result) => done()
+
+      it 'calls the server with only the changed attributes as payload', ->
+          expect(@server_update_many_api).to.have.been.calledOnce
+          update_args = @server_update_many_api.args[0][0]
+          expect(update_args[0]).to.eql username: 'one', email: 'new_one@example.com'
+          expect(update_args[1]).to.eql username: 'three', timestamp: 3
+
+      it 'calls the callback with the server response', ->
+        expect(@result).to.eql users: [@user_1_changed, @user_3_changed]
+
+      it 'stores the now persisted changes on the client', (done) ->
+        @persistence_manager.update_many [ @user_1_changed
+                                           @user_2_changed
+                                           @user_3_changed ], =>
+          @persistence_manager.update_many [ @user_1_changed
+                                             @user_2_changed
+                                             @user_3_changed ], =>
+            expect(@server_update_many_api).to.have.been.calledOnce
+            done()
+
+      it 'works without a given callback', ->
+        @persistence_manager.update_many [@user_1]
+