slender_data 0.6.0 → 0.7.0

data/spec/dummy/spec/javascripts/brest_loader_spec.coffee

@@ -26,8 +26,7 @@ describe 'BrestLoader', ->
         data: { user: { email: 'one@example.com' }}
 
     it 'returns the entry from the server as a query', ->
-      expect(@callback).to.have.been.calledOnce
-      expect(@callback).to.have.been.calledWith user: @user_1
+      expect(@callback).to.have.been.calledOnceWith user: @user_1
 
 
 
@@ -52,8 +51,7 @@ describe 'BrestLoader', ->
                          { email: 'two@example.com' } ] }
 
     it 'returns the entry from the server as a multi_query', ->
-      expect(@callback).to.have.been.calledOnce
-      expect(@callback).to.have.been.calledWith users: [@user_1, @user_2]
+      expect(@callback).to.have.been.calledOnceWith users: [@user_1, @user_2]
 
 
 
@@ -177,11 +175,8 @@ describe 'BrestLoader', ->
       expect(@server_merge_api).to.have.been.calledWithMatch
         data: old_snippet_ids: [1, 2], merged_snippet_data: @merged_user
 
-    it 'calls the given callback', ->
-      expect(@callback).to.have.been.calledOnce
-
-    it 'provides the server response to the callback', ->
-      expect(@callback).to.have.been.calledWith user: @merged_user
+    it 'calls the given callback with the server response', ->
+      expect(@callback).to.have.been.calledOnceWith user: @merged_user
 
 
   describe 'read', ->
@@ -199,12 +194,10 @@ describe 'BrestLoader', ->
         @brest_loader.read user: {username: 'one'}, @callback
 
       it 'makes an ajax request to the REST read endpoint', ->
-        expect(jQuery.get).to.have.been.calledOnce
-        expect(jQuery.get).to.have.been.calledWith '/users/one.json'
+        expect(jQuery.get).to.have.been.calledOnceWith '/users/one.json'
 
       it 'returns the entry from the server as a query', ->
-        expect(@callback).to.have.been.calledOnce
-        expect(@callback).to.have.been.calledWith user: @user_1
+        expect(@callback).to.have.been.calledOnceWith user: @user_1
 
 
     context 'id query given', ->
@@ -213,12 +206,10 @@ describe 'BrestLoader', ->
         @brest_loader.read username: 'one', @callback
 
       it 'makes an ajax request to the REST read endpoint', ->
-        expect(jQuery.get).to.have.been.calledOnce
-        expect(jQuery.get).to.have.been.calledWith '/users/one.json'
+        expect(jQuery.get).to.have.been.calledOnceWith '/users/one.json'
 
       it 'returns the entry from the server as a query', ->
-        expect(@callback).to.have.been.calledOnce
-        expect(@callback).to.have.been.calledWith user: @user_1
+        expect(@callback).to.have.been.calledOnceWith user: @user_1
 
 
   describe 'read_many', ->
@@ -243,8 +234,7 @@ describe 'BrestLoader', ->
         expect(jQuery.ajax).to.have.been.calledWithMatch data: {usernames: 'one two'}
 
       it 'returns the entry from the server as a multi_query', ->
-        expect(@callback).to.have.been.calledOnce
-        expect(@callback).to.have.been.calledWith users: [@user_1, @user_2]
+        expect(@callback).to.have.been.calledOnceWith users: [@user_1, @user_2]
 
 
     context 'ids multi-query given', ->
@@ -258,8 +248,7 @@ describe 'BrestLoader', ->
         expect(jQuery.ajax).to.have.been.calledWithMatch data: {usernames: 'one two three'}
 
       it 'returns the entry from the server as a multi_query', ->
-        expect(@callback).to.have.been.calledOnce
-        expect(@callback).to.have.been.calledWith users: [@user_1, @user_2]
+        expect(@callback).to.have.been.calledOnceWith users: [@user_1, @user_2]
 
 
 
@@ -283,8 +272,7 @@ describe 'BrestLoader', ->
       expect(jQuery.ajax).to.have.been.calledWithMatch data: { user: { email: 'new@example.com' }}
 
     it 'returns the entry from the server as a query', ->
-      expect(@callback).to.have.been.calledOnce
-      expect(@callback).to.have.been.calledWith user: @user_1
+      expect(@callback).to.have.been.calledOnceWith user: @user_1
 
 
 
@@ -309,6 +297,5 @@ describe 'BrestLoader', ->
                          { username: 'two', email: 'two@example.com' } ] }
 
     it 'returns the entry from the server as a multi_query', ->
-      expect(@callback).to.have.been.calledOnce
-      expect(@callback).to.have.been.calledWith users: [@user_1, @user_2]
+      expect(@callback).to.have.been.calledOnceWith users: [@user_1, @user_2]
 

data/spec/dummy/spec/javascripts/entry_store_spec.coffee

@@ -27,40 +27,69 @@ describe 'EntryStore', ->
         result = @entry_store.add server_entry
         expect(@entry_store.get username: 'one').to.eql server_entry
 
-  describe 'partial entries management', ->
+      it 'returns nothing', ->
+        expect(@result).to.be.undefined
 
-    beforeEach ->
-      @test_params.partial_entries = yes
-      @entry_store = new slender_data.EntryStore @test_params
 
-    context 'partial entry cached', ->
+    describe 'partial entries management', ->
 
       beforeEach ->
-        @entry_store.add @partial_user_1
+        @test_params.partial_entries = yes
+        @entry_store = new slender_data.EntryStore @test_params
 
-      it 'replaces the cached entry with the given full entry', ->
-        @entry_store.add @full_user_1
-        expect(@entry_store.get username: 'one').to.eql @full_user_1
+      context 'partial entry cached', ->
 
-    context 'full entry cached', ->
+        beforeEach ->
+          @entry_store.add @partial_user_1
 
-      beforeEach ->
-        @entry_store.add @full_user_1
+        it 'replaces the cached entry with the given full entry', ->
+          @entry_store.add @full_user_1
+          expect(@entry_store.get username: 'one').to.eql @full_user_1
+
+      context 'full entry cached', ->
 
-      it 'does not replace the cached value with the given partial entry', ->
-        @entry_store.add @partial_user_1
-        expect(@entry_store.get username: 'one').to.eql @full_user_1
+        beforeEach ->
+          @entry_store.add @full_user_1
+
+        it 'does not replace the cached value with the given partial entry', ->
+          @entry_store.add @partial_user_1
+          expect(@entry_store.get username: 'one').to.eql @full_user_1
+
+    describe 'return-editables option', ->
+
+      it 'returns editable versions of the option is set', ->
+        result = @entry_store.add @user_1, yes
+        expect(result).to.be.an.editable_version_of @user_1
+
+      it 'returns nothing if the option is not set', ->
+        result = @entry_store.add @user_1, no
+        expect(result).to.be.undefined
 
 
   describe 'add_many', ->
 
-    beforeEach ->
-      @result = @entry_store.add_many [@user_1, @user_2]
+    describe 'default behavior', ->
 
-    it 'adds the given entries the cache', ->
-      expect(@entry_store.get user: @user_1).to.eql @user_1
-      expect(@entry_store.get user: @user_2).to.eql @user_2
+      beforeEach ->
+        @result = @entry_store.add_many [@user_1, @user_2]
 
+      it 'adds the given entries to the cache', ->
+        expect(@entry_store.get user: @user_1).to.eql @user_1
+        expect(@entry_store.get user: @user_2).to.eql @user_2
+
+      it 'returns nothing', ->
+        expect(@result).to.be.undefined
+
+
+    describe 'return_editable_version option', ->
+
+      it 'returns editable versions of the given data if set', ->
+        result = @entry_store.add_many [@user_1, @user_2], yes
+        expect(result[0]).to.be.an.editable_version_of @user_1
+        expect(result[1]).to.be.an.editable_version_of @user_2
+
+      it 'returns nothing if not set', ->
+        expect(@entry_store.add_many [@user_1, @user_2], no).to.be.undefined
 
 
   describe 'delete', ->
@@ -193,8 +222,7 @@ describe 'EntryStore', ->
         @entry_store.add @user_1
 
       it 'returns a modifiable version of existing unmodified entries', ->
-        expect(@entry_store.get user: @user_1).to.eql @user_1
-        expect(@entry_store.get user: @user_1).to.not.equal @user_1
+        expect(@entry_store.get user: @user_1).to.be.an.editable_version_of @user_1
 
       it 'returns modified entries in the modified version', ->
         user = @entry_store.get user: @user_1
@@ -248,8 +276,7 @@ describe 'EntryStore', ->
         expect(@result.found).to.eql [@user_1, @user_2]
 
       it 'returns editable versions of the cached entries', ->
-        expect(@result.found[0]).to.eql @user_1
-        expect(@result.found[0]).to.not.equal @user_1
+        expect(@result.found[0]).to.be.an.editable_version_of @user_1
 
       it 'returns the missing entries as a MultiQuery', ->
         expect(@result.missing).to.be.an.instanceof slender_data.MultiQuery
@@ -311,5 +338,5 @@ describe 'EntryStore', ->
         expect(@result.found).to.eql [@user_2]
 
       it 'reports outdated entries as missing', ->
-        expect(@result.missing.to_hash()).to.eql users: [@user_1]
+        expect(@result.missing).to.eql_query users: [@user_1]
 

data/spec/dummy/spec/javascripts/loading_tracker_spec.coffee

@@ -1,95 +1,126 @@
 #= require spec_helper
+#= require slender_data/loading_tracker
 
 
-# Domain-specifc matcher for checking if the given snippet is currently loading.
-chai.Assertion.addMethod 'have_loading_id', (snippet_id) ->
-  @assert @_obj.is_loading(id: snippet_id),
-          """expected snippet '#{snippet_id}' to be loading,
+# Domain-specifc matcher for checking if the given entry is currently loading.
+chai.Assertion.addMethod 'loading', (query) ->
+  @assert @_obj.is_loading(query),
+          """expected entry '#{query.username}' to be loading,
              but it was not""",
-          """expected snippet '#{snippet_id}' to not be loading,
+          """expected entry '#{query.username}' to not be loading,
              but it is"""
 
-#
-# describe 'slender_data.LoadingTracker', ->
-#
-#   beforeEach ->
-#     @loading_tracker = new slender_data.LoadingTracker()
-#
-#
-#   describe 'is_loading', ->
-#
-#     describe 'snippet is not loading', ->
-#
-#       it 'returns false', ->
-#         expect(@loading_tracker.is_loading id: 3).to.be.false
-#
-#     describe 'snippet is currently loading', ->
-#
-#       it 'returns true', ->
-#         @loading_tracker.start_loading id: 3
-#         expect(@loading_tracker.is_loading id: 3).to.be.true
-#
-#
-#   describe 'matching_loading_ids', ->
-#
-#     it 'returns the ids that are currently loading', ->
-#       @loading_tracker.start_loadings ids: [1, 2, 3]
-#       expect(@loading_tracker.matching_loading_ids [1, 3, 4]).to.eql [1, 3]
-#
-#
-#   describe 'snippet_arrived', ->
-#
-#     beforeEach ->
-#       @loading_tracker.start_loadings ids: [1, 3]
-#
-#     it 'calls the queued callback', (done) ->
-#       @loading_tracker.wait_for_loading_finished id: 3, done
-#       @loading_tracker.snippet_arrived id: 3
-#
-#     it 'unregisters the arrived snippets from the loading list', ->
-#       @loading_tracker.snippet_arrived id: 1
-#       expect(@loading_tracker).to.not.have_loading_id 1
-#
-#     it 'does not unregister other loading snippets', ->
-#       @loading_tracker.snippet_arrived 1
-#       expect(@loading_tracker).to.have_loading_id 3
-#
-#
-#   describe 'start_loading', ->
-#
-#     it 'stores the id of the loading query', ->
-#       @loading_tracker.start_loading key: '3_2'
-#       expect(@loading_tracker).to.have_loading_id 3
-#
-#
-#   describe 'start_loadings', ->
-#
-#     it 'stores the ids of the loading snippets', ->
-#       @loading_tracker.start_loadings ids: [1, 3]
-#       expect(@loading_tracker).to.have_loading_id 1
-#       expect(@loading_tracker).to.not.have_loading_id 2
-#       expect(@loading_tracker).to.have_loading_id 3
-#
-#
-#   describe 'wait_for_loading_finished', ->
-#
-#     describe 'without a request running', ->
-#
-#       it 'calls the given callback immediately', (done) ->
-#         @loading_tracker.wait_for_loading_finished id: 3, done
-#
-#     describe 'while a request is running', ->
-#
-#       beforeEach ->
-#         @loading_tracker.start_loading id: 3
-#
-#       it 'does not call the given callback', ->
-#         callback = sinon.spy()
-#         @loading_tracker.wait_for_loading_finished id: 3, callback
-#         expect(callback.called).to.be.false
-#
-#       it 'queues the given callback', ->
-#         @loading_tracker.wait_for_loading_finished id: 3, 'callback method'
-#         expect(@loading_tracker.loading_snippets[3]).to.eql ['callback method']
-#
-#
+
+describe 'slender_data.LoadingTracker', ->
+
+  beforeEach ->
+    define_test_data this
+    @loading_tracker = new slender_data.LoadingTracker @test_params
+
+
+  describe 'entry_arrived', ->
+
+    beforeEach ->
+      @loading_tracker.start_loadings users: [@user_1, @user_2]
+
+    it 'calls the queued callback with the loaded entry', (done) ->
+      @loading_tracker.wait_for_entry_loaded user: @user_1, (entry) =>
+        expect(entry).to.equal @user_1
+        done()
+      @loading_tracker.entry_arrived @user_1
+
+    it 'unregisters the arrived entrys from the loading list', ->
+      @loading_tracker.entry_arrived @user_1
+      expect(@loading_tracker).to.not.have.loading user: @user_1
+
+    it 'does not unregister other loading entries', ->
+      @loading_tracker.entry_arrived @user_1
+      expect(@loading_tracker).to.have.loading user: @user_2
+
+
+  describe 'is_loading', ->
+
+    it 'returns false if the entry is not loading', ->
+      expect(@loading_tracker.is_loading id: 3).to.be.false
+
+    it 'returns true if the entry is currently loading', ->
+      @loading_tracker.start_loading id: 3
+      expect(@loading_tracker.is_loading id: 3).to.be.true
+
+
+  describe 'start_loading', ->
+
+    it 'stores the id of the loading query', ->
+      @loading_tracker.start_loading @user_1
+      expect(@loading_tracker).to.have.loading user: @user_1
+
+
+  describe 'start_loadings', ->
+
+    it 'stores the ids of the loading entries', ->
+      @loading_tracker.start_loadings users: [@user_1, @user_3]
+      expect(@loading_tracker).to.have.loading user: @user_1
+      expect(@loading_tracker).to.not.have.loading user: @user_2
+      expect(@loading_tracker).to.have.loading user: @user_3
+
+
+  describe 'wait_for_entry_loaded', ->
+
+    describe 'without a request running', ->
+
+      beforeEach ->
+        @callback = sinon.stub()
+        @result = @loading_tracker.wait_for_entry_loaded user: @user_1,
+                                                         @callback
+
+      it 'returns the given query as the function result', ->
+        expect(@result).to.eql_query user: @user_1
+
+      it 'does not call the given callback', ->
+        expect(@callback).to.not.have.been.called
+
+      it 'does not call the given callback when the entry gets loaded later', ->
+        @loading_tracker.entry_arrived @user_1
+        expect(@callback).to.not.have.been.called
+
+
+    describe 'while a request is running', ->
+
+      beforeEach ->
+        @loading_tracker.start_loading user: @user_1
+        @callback = sinon.stub()
+        @result = @loading_tracker.wait_for_entry_loaded user: @user_1,
+                                                         @callback
+
+      it 'returns nothing', ->
+        expect(@result).to.be.undefined
+
+      it 'does not call the given callback', ->
+        expect(@callback).to.not.have.been.called
+
+      it 'calls the given callback when the entry is loaded later', ->
+        @loading_tracker.entry_arrived @user_1
+        expect(@callback).to.have.been.calledOnce
+
+
+  describe 'wait_for_entries_loaded', ->
+
+    beforeEach ->
+      @loading_tracker.start_loadings users: [@user_1, @user_2]
+      @callback = sinon.stub()
+      @result = @loading_tracker.wait_for_entries_loaded users: [@user_1, @user_2, @user_3],
+                                                         @callback
+
+    it 'returns a multiquery describing the entries that are not currently loading', ->
+      expect(@result).to.eql_query users: [@user_3]
+
+    it 'does not call the callback if not all entries have been loaded yet', ->
+      expect(@callback).to.not.have.been.called
+      @loading_tracker.entry_arrived @user_1
+      expect(@callback).to.not.have.been.called
+
+    it 'calls the given callback with the loaded entries when they all have loaded', ->
+      @loading_tracker.entry_arrived @user_1
+      @loading_tracker.entry_arrived @user_2
+      expect(@callback).to.have.been.calledOnceWith [@user_1, @user_2]
+

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

@@ -84,7 +84,7 @@ describe 'Parameterizable', ->
 
       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
+        expect(@result).to.eql_query @query_hash
 
       it 'configures the created query with the default configuration values of the current query', ->
         expect(@result.versioning).to.be.true
@@ -118,7 +118,7 @@ describe 'Parameterizable', ->
 
       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
+        expect(@result).to.eql_query @query_hash
 
       it 'configures the created query with the default configuration values of the current query', ->
         expect(@result.versioning).to.be.true

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

@@ -1,6 +1,31 @@
 #= require spec_helper
 
 
+# Domain-specifc matcher for checking if the PersistenceManager
+# has the given user in the cache (or not).
+chai.Assertion.addMethod 'cached_user', (user) ->
+  cached_user = @_obj.get user: user
+  if @__flags.negate
+    # No cached user expected.
+    new chai.Assertion(cached_user,
+                       'Should not have cached user').to.be.undefined
+  else
+    # The given cached user expected.
+    new chai.Assertion(cached_user,
+                       'Should have cached user').to.be.eql user
+    new chai.Assertion(cached_user,
+                       'Should have cached user').to.not.be.equal user
+
+
+# Domain-specifc matcher for checking if the tested object is an array
+# of elements with at least the given properties.
+chai.Assertion.addMethod 'entries_with_matching_properties', (attr_name, expected_values) ->
+  expect(@_obj).to.have.length expected_values.length
+  obj_values = (obj[attr_name] for obj in @_obj)
+  for expected_value in expected_values
+    expect(obj_values).to.include expected_value
+
+
 describe 'PersistenceManager', ->
 
   beforeEach ->
@@ -10,28 +35,53 @@ describe 'PersistenceManager', ->
 
   describe 'add_to_cache', ->
 
-    beforeEach ->
-      @result = @persistence_manager.add_to_cache @user_1
+    describe 'normal behavior', ->
 
-    it 'adds the described entry to the serverside cache', ->
-      expect(@persistence_manager.get user: @user_1).to.eql @user_1
+      beforeEach ->
+        @result = @persistence_manager.add_to_cache @user_1
 
-    it 'returns nothing', ->
-      expect(@result).to.be.undefined
+      it 'adds the described entry to the serverside cache', ->
+        expect(@persistence_manager).to.have.cached_user @user_1
 
+      it 'returns nothing', ->
+        expect(@result).to.be.undefined
+
+    describe 'return_editable_version option', ->
+
+      it 'returns an editable version of the given entry when set', ->
+        result = @persistence_manager.add_to_cache @user_1, yes
+        expect(result).to.be.an.editable_version_of @user_1
+
+      it 'returns nothing if not set', ->
+        result = @persistence_manager.add_to_cache @user_1, no
+        expect(result).to.be.undefined
 
 
   describe 'add_many_to_cache', ->
 
-    beforeEach ->
-      @result = @persistence_manager.add_many_to_cache [ @user_1, @user_2 ]
+    describe 'normal behavior', ->
 
-    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
+      beforeEach ->
+        @result = @persistence_manager.add_many_to_cache [@user_1, @user_2]
 
-    it 'returns nothing', ->
-      expect(@result).to.be.undefined
+      it 'adds all described entries to the chache', ->
+        expect(@persistence_manager).to.have.cached_user @user_1
+        expect(@persistence_manager).to.have.cached_user @user_2
+
+      it 'returns nothing', ->
+        expect(@result).to.be.undefined
+
+
+    describe 'return_editable_version option', ->
+
+      it 'returns editable versions of the given entries when set', ->
+        result = @persistence_manager.add_many_to_cache [@user_1, @user_2], yes
+        expect(result[0]).to.be.an.editable_version_of @user_1
+        expect(result[1]).to.be.an.editable_version_of @user_2
+
+      it 'returns nothing if not set', ->
+        result = @persistence_manager.add_many_to_cache [@user_1, @user_2], no
+        expect(result).to.be.undefined
 
 
 
@@ -43,19 +93,17 @@ describe 'PersistenceManager', ->
       @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
+      expect(@server_create_api).to.have.been.calledOnceWith @user_1
 
     it 'adds the server response to the cache', ->
-      expect(@persistence_manager.get user: @user_1).to.eql @user_1
+      expect(@persistence_manager).to.have.cached_user @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
+        expect(result).to.be.an.editable_version_of @user_1
         done()
 
 
@@ -67,12 +115,11 @@ describe 'PersistenceManager', ->
       @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]
+      expect(@server_create_many_api).to.have.been.calledOnceWith [@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
+      expect(@persistence_manager).to.have.cached_user @user_1
+      expect(@persistence_manager).to.have.cached_user @user_2
 
     it 'returns nothing', ->
       expect(@result).to.be.undefined
@@ -92,11 +139,10 @@ describe 'PersistenceManager', ->
         done()
 
     it 'removes the given entry from the cache', ->
-        expect(@persistence_manager.get user: @user_1).to.be.undefined
+      expect(@persistence_manager).to.not.have.cached_user @user_1
 
     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
+      expect(@server_delete_api).to.have.been.calledOnceWith @user_1
 
     it 'calls the given callback with a description of the deleted entry', ->
       expect(@result).to.eql username: 'one'
@@ -111,12 +157,11 @@ describe 'PersistenceManager', ->
       @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
+      expect(@persistence_manager).to.not.have.cached_user @user_1
+      expect(@persistence_manager).to.not.have.cached_user @user_2
 
     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]
+      expect(@server_delete_many_api).to.have.been.calledOnceWith [@user_1, @user_2]
 
     it 'calls the given callback with a description of the deleted entries', ->
       expect(@result).to.eql usernames: ['one', 'two']
@@ -131,7 +176,7 @@ describe 'PersistenceManager', ->
         @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
+        expect(@persistence_manager).to.have.cached_user @user_1
 
       it 'returns undefined if the described entry is not cached', ->
         expect(@persistence_manager.get user: @user_2).to.be.undefined
@@ -213,7 +258,7 @@ describe 'PersistenceManager', ->
           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
+          expect(@result.missing).to.eql_query usernames: ['three'], full: no
 
       context 'full entries requested', ->
 
@@ -225,7 +270,7 @@ describe 'PersistenceManager', ->
           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
+          expect(@result.missing).to.eql_query usernames: ['one', 'three'], full: yes
 
 
     describe 'versioning', ->
@@ -238,7 +283,7 @@ describe 'PersistenceManager', ->
 
         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]
+          expect(@result.missing).to.eql_query users: [@user_1]
 
 
   describe 'load', ->
@@ -262,6 +307,26 @@ describe 'PersistenceManager', ->
         it 'does not query the server', ->
           expect(@persistence_manager.server_api.read).to.not.have.been.called
 
+      context 'described entry is currently loading', ->
+
+        beforeEach ->
+          @persistence_manager.loading_tracker.start_loading @user_1
+          @callback = sinon.stub()
+          @persistence_manager.load user: @user_1, @callback
+
+        it 'does not make another load operation to the server', ->
+          expect(@server_read_api).to.not.have.been.called
+
+        it 'calls the callback with the entry when the entry returns from the server', ->
+          expect(@callback).to.not.have.been.called
+          @persistence_manager.loading_tracker.entry_arrived @user_1
+          expect(@callback).to.have.been.calledOnceWith @user_1
+
+        it 'adds the loaded entry to the clientside cache', ->
+          @persistence_manager.loading_tracker.entry_arrived @user_1
+          expect(@persistence_manager).to.have.cached_user @user_1
+
+
       context 'described entry is not in the cache', ->
 
         beforeEach (done) ->
@@ -271,15 +336,13 @@ describe 'PersistenceManager', ->
 
         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
+          expect(server_read_api).to.have.been.calledOnceWithQuery user: @user_1
 
         it 'adds the loaded entry to the cache', ->
-          expect(@persistence_manager.get user: @user_1).to.eql @user_1
+          expect(@persistence_manager).to.have.cached_user @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
+          expect(@result).to.be.an.editable_version_of @user_1
 
 
     describe 'partial entry functionality', ->
@@ -387,16 +450,17 @@ describe 'PersistenceManager', ->
           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
+          expect(@persistence_manager).to.have.cached_user @user_1
 
 
 
   describe 'load_many', ->
 
-    describe 'normal functionality', ->
+    beforeEach ->
+      @server_read_many_api = sinon.stub @persistence_manager.server_api, 'read_many'
 
-      beforeEach ->
-        @server_read_many_api = sinon.stub(@persistence_manager.server_api, 'read_many')
+
+    describe 'normal functionality', ->
 
       context 'all snippets are in the cache', ->
 
@@ -422,18 +486,18 @@ describe 'PersistenceManager', ->
           @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()
+          @persistence_manager.load_many users: [@user_1,
+                                                 @user_2,
+                                                 @user_3], (users) =>
+            expect(users).to.have.entries_with_matching_properties 'username',
+                                                                   [ 'one',
+                                                                     'two',
+                                                                     '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]
+            expect(@server_read_many_api).to.have.been.calledOnceWithQuery users: [@user_2]
             done()
 
         it 'adds the loaded entries to the cache', ->
@@ -442,7 +506,6 @@ describe 'PersistenceManager', ->
             expect(users[0]).to.not.equal @user_2_from_server
 
 
-
     describe 'partial entry functionality', ->
 
       beforeEach ->
@@ -468,12 +531,10 @@ describe 'PersistenceManager', ->
           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'
-
+          expect(@result).to.have.entries_with_matching_properties 'email',
+                                                                   [ 'one@example.com',
+                                                                     'two@example.com',
+                                                                     'three@example.com' ]
 
       context 'partial entries requested', ->
 
@@ -504,13 +565,59 @@ describe 'PersistenceManager', ->
         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]
+        expect(@server_read_many_api).to.have.been.calledOnceWithQuery users: [@user_1]
 
       it 'adds the loaded entries to the cache', ->
         expect(@persistence_manager.get username: 'one').to.eql @user_1
 
 
+    describe 'loading tracking', ->
+
+      context 'some entries are currently loading', ->
+
+        beforeEach ->
+          @persistence_manager.loading_tracker.start_loadings users: [@user_1, @user_2]
+          @callback = sinon.stub()
+          @persistence_manager.load_many users: [@user_1, @user_2], @callback
+
+        it 'does not make another load operation to the server', ->
+          expect(@server_read_many_api).to.not.have.been.called
+
+        it 'calls the callback with the entries when they arrive', ->
+          expect(@callback).to.not.have.been.called
+          @persistence_manager.loading_tracker.entries_arrived [@user_1, @user_2]
+          expect(@callback).to.have.been.calledOnceWith [@user_1, @user_2]
+
+        it 'adds the loaded result to the cache', ->
+          @persistence_manager.loading_tracker.entries_arrived [@user_1, @user_2]
+          expect(@persistence_manager).to.have.cached_user @user_1
+          expect(@persistence_manager).to.have.cached_user @user_2
+
+
+      describe 'all options working together', ->
+
+        beforeEach ->
+          @persistence_manager.add_to_cache @user_1
+          @persistence_manager.loading_tracker.start_loadings users: [@user_2]
+          @callback = sinon.stub()
+          @server_read_many_api.yields users: [@user_3]
+          @persistence_manager.load_many users: [@user_1, @user_2, @user_3],
+                                         @callback
+          @persistence_manager.loading_tracker.entries_arrived [@user_2]
+
+        it 'returns all requested entries', ->
+          expect(@callback).to.have.been.calledOnce
+          callback_args = @callback.args[0][0]
+          expect(callback_args).to.be.entries_with_matching_properties 'username',
+                                                                       [ 'one',
+                                                                         'two',
+                                                                         'three' ]
+
+        it 'loads only the not currently loading entries from the server', ->
+          expect(@server_read_many_api).to.have.been.calledOnceWithQuery users: [@user_3]
+
+
+
   describe 'merge', ->
 
     beforeEach ->
@@ -528,9 +635,9 @@ describe 'PersistenceManager', ->
       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
+      expect(@persistence_manager).to.not.have.cached_user @user_1
+      expect(@persistence_manager).to.not.have.cached_user @user_2
+      expect(@persistence_manager).to.have.cached_user @user_3
 
     it 'adds the user provided by the server to the client cache', ->
       cached_user = @persistence_manager.get user: @merged_user_server_response
@@ -541,8 +648,7 @@ describe 'PersistenceManager', ->
 
     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
+      expect(callback_args).to.be.an.editable_version_of @merged_user_server_response
 
 
 
@@ -577,12 +683,11 @@ describe 'PersistenceManager', ->
         @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
+        expect(@server_update_api).to.have.been.calledOnceWith
           username: 'one', email: 'new_one@example.com'
 
-      it 'calls the callback with the server response when done', ->
-        expect(@result).to.eql user: @user
+      it 'calls the callback with the editable version of the updated entry', ->
+        expect(@result).to.be.an.editable_version_of @user
 
       it 'stores the now persisted changes on the client', (done) ->
         @persistence_manager.update @user, =>