slender_data 0.5.0 → 0.6.0

data/spec/dummy/spec/javascripts/queries/base_query_spec.coffee

@@ -0,0 +1,41 @@
+#= require spec_helper
+#= require slender_data/queries/base_query
+
+describe 'slender_data.BaseQuery', ->
+
+  beforeEach ->
+    define_test_data this
+
+
+  describe 'selector_name', ->
+
+    it 'returns "id" for id queries', ->
+      query = new slender_data.BaseQuery id: 1, @test_params
+      expect(query.selector_name()).to.equal 'id'
+
+    it 'returns "ids" for ids queries', ->
+      query = new slender_data.BaseQuery ids: [1, 2], @test_params
+      expect(query.selector_name()).to.equal 'ids'
+
+    it 'returns "entry" for entry queries', ->
+      query = new slender_data.BaseQuery entry: {id: 1}, @test_params
+      expect(query.selector_name()).to.equal 'entry'
+
+
+  describe 'selector_value', ->
+
+    it 'returns the given id for id queries', ->
+      query = new slender_data.BaseQuery id: 1, @test_params
+      expect(query.selector_value()).to.eql 1
+
+    it 'returns the given entry for entry queries', ->
+      query = new slender_data.BaseQuery entry: {id: 1}, @test_params
+      expect(query.selector_value()).to.eql {id: 1}
+
+
+  describe 'to_hash', ->
+
+    it 'returns the hash representation of this query', ->
+      query = new slender_data.BaseQuery id: 3, @test_params
+      expect(query.to_hash()).to.eql {id: 3}
+

data/spec/dummy/spec/javascripts/queries/multi_query_spec.coffee

@@ -0,0 +1,143 @@
+#= require spec_helper
+#= require slender_data/queries/multi_query
+
+
+describe 'slender_data.MultiQuery', ->
+
+  beforeEach ->
+    define_test_data this
+
+
+  describe 'constructor', ->
+
+    it 'allows to provide ids using their generic name "ids"', ->
+      multi_query = new slender_data.MultiQuery ids: [1, 2], @test_params
+      expect(multi_query.ids()).to.eql [1, 2]
+
+    it 'allows to provide ids using their domain specific name (i.e. "usernames")', ->
+      multi_query = new slender_data.MultiQuery usernames: [1, 2], @test_params
+      expect(multi_query.ids()).to.eql [1, 2]
+
+    it 'allows to provide entries using their generic name "entries"', ->
+      multi_query = new slender_data.MultiQuery entries: [ {username: 'one'},
+                                                           {username: 'two'} ],
+                                                @test_params
+      expect(multi_query.entries()).to.eql [ {username: 'one'},
+                                             {username: 'two'} ]
+
+    it 'allows to provide entries using their domain specific name (i.e. "users")', ->
+      multi_query = new slender_data.MultiQuery users: [ {username: 'one'},
+                                                         {username: 'two'} ],
+                                                @test_params
+      expect(multi_query.entries()).to.eql [ {username: 'one'},
+                                             {username: 'two'} ]
+
+    it 'throws an exception for unknown query selectors', ->
+      expect(-> new slender_data.MultiQuery [1,2]).to.throw()
+      expect(-> new slender_data.MultiQuery zonk: [1,2]).to.throw()
+
+
+
+  describe 'empty', ->
+
+    it 'returns true if the multi-query describes no entries', ->
+      multi_query = new slender_data.MultiQuery ids: [], @test_params
+      expect(multi_query.empty()).to.be.true
+
+    it 'returns false if the multi-query describes at least one snippet', ->
+      multi_query = new slender_data.MultiQuery ids: [1], @test_params
+      expect(multi_query.empty()).to.be.false
+
+
+
+  describe 'entries', ->
+
+    it 'throws an exception for an ids query', ->
+      query = new slender_data.MultiQuery usernames: ['one'], @test_params
+      expect(-> query.entries()).to.throw()
+
+    it 'returns the entries for the given entries query', ->
+      users = [{username: 'one'}]
+      query = new slender_data.MultiQuery users: users, @test_params
+      result = query.users()
+      expect(result).to.eql users
+
+
+
+  describe 'ids', ->
+
+    it 'returns the ids of the given ids query', ->
+      query = new slender_data.MultiQuery usernames: ['one', 'two'], @test_params
+      expect(query.usernames()).to.eql ['one', 'two']
+
+    it 'returns the id of the given entry query', ->
+      query = new slender_data.MultiQuery users: [ {username: 'one'}
+                                                   {username: 'two'} ],
+                                          @test_params
+      expect(query.ids()).to.eql ['one', 'two']
+
+
+
+  describe 'replicate', ->
+
+    beforeEach ->
+      @test_params.versioning = yes
+      @test_params.partial_entries = yes
+      multi_query = new slender_data.MultiQuery users: [@user_1], full: yes,
+                                                @test_params
+      @result = multi_query.replicate [@user_2]
+
+    it 'creates a new MultiQuery', ->
+      expect(@result).to.be.an.instanceof slender_data.MultiQuery
+
+    it 'makes the new MultiQuery have the same selector name', ->
+      expect(@result.selector_name()).to.eql 'users'
+
+    it 'makes the new MultiQuery have the given selector values', ->
+      expect(@result.selector_value()).to.eql [@user_2]
+
+    it 'copies the "partial_entries" configuration setting to the new MultiQuery', ->
+      expect(@result.partial_entries).to.be.true
+
+    it 'copies the "versioning" configuration setting to the new MultiQuery', ->
+      expect(@result.versioning).to.be.true
+
+    it 'copies the "full" query parameter to the new MultiQuery', ->
+      expect(@result.full).to.be.true
+
+
+
+  describe 'single_selector_name', ->
+
+    it 'returns the custom entry name if the custom entries name is given', ->
+      @test_params.entry_name = 'entry'
+      @test_params.entries_name = 'entries'
+      multi_query = new slender_data.MultiQuery entries: [{id: 1}], @test_params
+      expect(multi_query.single_selector_name()).to.equal 'entry'
+
+    it 'it truncates the last character for any other selector name', ->
+      multi_query = new slender_data.MultiQuery ids: [1], @test_params
+      expect(multi_query.single_selector_name()).to.equal 'id'
+
+
+
+  describe 'transpose', ->
+
+    it 'converts the given ids MultiQuery into an array of id Queries', ->
+      multi_query = new slender_data.MultiQuery usernames: ['one', 'two', 'three'],
+                                                @test_params
+      result = multi_query.transpose()
+      expect(result[0].to_hash()).to.eql username: 'one'
+      expect(result[1].to_hash()).to.eql username: 'two'
+      expect(result[2].to_hash()).to.eql username: 'three'
+
+    it 'converts the given entries MultiQuery into an array of entry Queries', ->
+      multi_query = new slender_data.MultiQuery
+        users: [{username: 'one'}, {username: 'two'}, {username: 'three'}],
+        @test_params
+      result = multi_query.transpose()
+      expect(result.length).to.eql 3
+      expect(result[0].to_hash()).to.eql user: {username: 'one'}
+      expect(result[1].to_hash()).to.eql user: {username: 'two'}
+      expect(result[2].to_hash()).to.eql user: {username: 'three'}
+

data/spec/dummy/spec/javascripts/queries/single_query_spec.coffee

@@ -0,0 +1,112 @@
+#= require spec_helper
+#= require slender_data/queries/single_query
+
+
+describe 'slender_data.SingleQuery', ->
+
+  beforeEach ->
+    define_test_data this
+    @entry_query = new slender_data.SingleQuery user: @user_1, @test_params
+    @id_query = new slender_data.SingleQuery username: 'one', @test_params
+
+
+  describe 'constructor', ->
+
+    it 'allows to provide an id using its generic name "id"', ->
+      query = new slender_data.SingleQuery id: 'one', @test_params
+      expect(query.id()).to.eql 'one'
+
+    it 'allows to provide an id using its domain specific name (i.e. "username")', ->
+      query = new slender_data.SingleQuery username: 'one', @test_params
+      expect(query.id()).to.eql 'one'
+
+    it 'allows to provide an entry using its generic name "entry"', ->
+      query = new slender_data.SingleQuery entry: {username: 'one'}, @test_params
+      expect(query.entry()).to.eql username: 'one'
+
+    it 'allows to provide an entry using its domain specific name (i.e. "user")', ->
+      query = new slender_data.SingleQuery user: {username: 'one'}, @test_params
+      expect(query.entry()).to.eql username: 'one'
+
+    it 'allows to provide the version using its generic name "version"', ->
+      query = new slender_data.SingleQuery entry: {username: 'foo', version: 2}, @test_params
+      expect(query.version()).to.eql 2
+
+    it 'allows to provide an entry using its domain specific name (i.e. "timestamp")', ->
+      query = new slender_data.SingleQuery user: {username: 'foo', timestamp: 2}, @test_params
+      expect(query.version()).to.eql 2
+
+    it 'throws an exception for missing query selectors', ->
+      expect(=> new slender_data.SingleQuery 'one', @test_params).to.throw()
+
+    it 'throws an exception for unknown query selectors', ->
+      expect(=> new slender_data.SingleQuery zonk: 'one', @test_params).to.throw()
+
+
+
+  describe 'entry getter', ->
+
+    context 'entry query', ->
+
+      it 'allows access through the entry() function', ->
+        expect(@entry_query.entry()).to.eql @user_1
+
+      it 'allows access through the domain-specific name', ->
+        expect(@entry_query.user()).to.eql @user_1
+
+
+    context 'id query', ->
+
+      it 'throws an exception', ->
+        expect(-> @id_query.user()).to.throw()
+
+
+
+  describe 'id getter', ->
+
+    context 'entry query', ->
+
+      it 'returns the id through the id() function', ->
+        expect(@entry_query.id()).to.equal 'one'
+
+      it 'returns the id through its domain-specific name', ->
+        expect(@entry_query.username()).to.equal 'one'
+
+
+    context 'id query', ->
+
+      it 'returns the id through the id() function', ->
+        expect(@id_query.id()).to.equal 'one'
+
+      it 'returns the id through its domain-specific name', ->
+        expect(@id_query.username()).to.equal 'one'
+
+
+
+  describe 'version getter', ->
+
+    context 'entry query', ->
+
+      it 'returns the version through the version() function', ->
+        expect(@entry_query.version()).to.equal 2
+
+      it 'returns the version through its domain-specific name', ->
+        expect(@entry_query.timestamp()).to.equal 2
+
+
+    context 'id query', ->
+
+      it 'throws an exception because id queries can not contain versions', ->
+        expect(-> @id_query.version).to.throw()
+        expect(-> @id_query.timestamp).to.throw()
+
+
+
+  describe 'to_hash', ->
+
+    it 'returns the hash versions of id queries', ->
+      expect(@id_query.to_hash()).to.eql username: 'one'
+
+    it 'returns the hash versions of entry queries', ->
+      expect(@entry_query.to_hash()).to.eql user: @user_1
+

data/spec/dummy/spec/javascripts/query_cache_spec.coffee

@@ -0,0 +1,347 @@
+#= require spec_helper
+
+
+describe 'QueryCache', ->
+
+  beforeEach ->
+    define_test_data this
+    @query_cache = new slender_data.QueryCache @test_params
+
+
+  describe 'add', ->
+
+    describe 'normal behavior', ->
+
+      beforeEach ->
+        @result = @query_cache.add @user_1
+
+      it 'adds the given entry', ->
+        expect(@query_cache.cache.length()).to.equal 1
+        expect(@query_cache.get username: 'one').to.equal @user_1
+
+      it 'returns nothing', ->
+        expect(@result).to.be.undefined
+
+
+    describe 'partial/full behavior', ->
+
+      beforeEach ->
+        @test_params.partial_entries = yes
+        @query_cache = new slender_data.QueryCache @test_params
+
+      it 'replaces an existing partial entry with the given full entry', ->
+        @query_cache.add @partial_user_1
+        @query_cache.add @full_user_1
+        expect(@query_cache.get username: 'one').to.eql @full_user_1
+
+      it 'does not replace an existing full entry with the given partial entry', ->
+        @query_cache.add @full_user_1
+        @query_cache.add @partial_user_1
+        expect(@query_cache.get username: 'one').to.eql @full_user_1
+
+
+
+  describe 'add_clone', ->
+
+    describe 'normal behavior', ->
+
+      beforeEach ->
+        @result = @query_cache.add_clone @user_1
+
+      it 'adds a copy of the given entry', ->
+        expect(@query_cache.length()).to.equal 1
+        expect(@query_cache.get user: @user_1).to.eql @user_1
+        expect(@query_cache.get user: @user_1).to.not.equal @user_1
+
+      it 'returns a copy of the added entry', ->
+        expect(@result).to.eql @user_1
+        expect(@result).to.not.equal @user_1
+
+
+    describe 'partial/full behavior', ->
+
+      beforeEach ->
+        @test_params.partial_entries = yes
+        @query_cache = new slender_data.QueryCache @test_params
+
+      it 'replaces an existing partial entry with the given full entry', ->
+        @query_cache.add @partial_user_1
+        @query_cache.add_clone @full_user_1
+        expect(@query_cache.get username: 'one').to.eql @full_user_1
+
+      it 'does not replace an existing full entry with the given partial entry', ->
+        @query_cache.add @full_user_1
+        @query_cache.add_clone @partial_user_1
+        expect(@query_cache.get username: 'one').to.eql @full_user_1
+
+
+
+    describe 'add_clones', ->
+
+      beforeEach ->
+        @result = @query_cache.add_clones [@user_1, @user_2]
+
+      it 'adds copies of the given entries to the chache', ->
+        expect(@query_cache.length()).to.equal 2
+        cache_content = @query_cache.get_many users: [@user_1, @user_2]
+        expect(cache_content.found[0]).to.eql @user_1
+        expect(cache_content.found[0]).to.not.equal @user_1
+        expect(cache_content.found[1]).to.eql @user_2
+        expect(cache_content.found[1]).to.not.equal @user_2
+
+      it 'returns copies of the added entries', ->
+        expect(@result).to.eql [@user_1, @user_2]
+
+
+
+  describe 'add_many', ->
+
+    describe 'normal behavior', ->
+
+      beforeEach ->
+        @result = @query_cache.add_many [@user_1, @user_2]
+
+      it 'adds the given entries', ->
+        expect(@query_cache.length()).to.equal 2
+        expect(@query_cache.get user: @user_1).to.equal @user_1
+        expect(@query_cache.get user: @user_2).to.equal @user_2
+
+      it 'returns undefined', ->
+        expect(@result).to.be.undefined
+
+
+    describe 'partial/full behavior', ->
+
+      beforeEach ->
+        @test_params.partial_entries = yes
+        @query_cache = new slender_data.QueryCache @test_params
+        @query_cache.add_many [@partial_user_1, @full_user_2]
+        @query_cache.add_many [@full_user_1, @partial_user_2]
+
+      it 'replaces an existing partial entry with the given full entry', ->
+        expect(@query_cache.get username: 'one').to.eql @full_user_1
+
+      it 'does not replace an existing full entry with the given partial entry', ->
+        expect(@query_cache.get username: 'two').to.eql @full_user_2
+
+
+
+  describe 'add_many_as_clones', ->
+
+    describe 'normal behavior', ->
+
+      beforeEach ->
+        @result = @query_cache.add_many_as_clones [@user_1, @user_2]
+
+      it 'adds clones of the given entries', ->
+        expect(@query_cache.length()).to.equal 2
+        expect(@query_cache.get user: @user_1).to.eql @user_1
+        expect(@query_cache.get user: @user_1).to.not.equal @user_1
+        expect(@query_cache.get user: @user_2).to.eql @user_2
+        expect(@query_cache.get user: @user_2).to.not.equal @user_2
+
+      it 'returns the added entries', ->
+        expect(@result.length).to.equal 2
+        expect(@result[0]).to.eql @user_1
+        expect(@result[0]).to.not.equal @user_1
+        expect(@result[1]).to.eql @user_2
+        expect(@result[1]).to.not.equal @user_2
+
+
+    describe 'partial/full behavior', ->
+
+      beforeEach ->
+        @test_params.partial_entries = yes
+        @query_cache = new slender_data.QueryCache @test_params
+        @query_cache.add_many [@partial_user_1, @full_user_2]
+        @query_cache.add_many_as_clones [@full_user_1, @partial_user_2]
+
+      it 'replaces an existing partial entry with the given full entry', ->
+        expect(@query_cache.get username: 'one').to.eql @full_user_1
+
+      it 'does not replace an existing full entry with the given partial entry', ->
+        expect(@query_cache.get username: 'two').to.eql @full_user_2
+
+
+
+  describe 'get', ->
+
+    describe 'normal behavior', ->
+
+      beforeEach ->
+        @query_cache.add @user_1
+
+      it 'returns the entry described by the given entry', ->
+        expect(@query_cache.get user: @user_1).to.equal @user_1
+
+      it 'returns the entry described by the given id', ->
+        expect(@query_cache.get username: @user_1.username).to.equal @user_1
+
+      it 'returns undefined if the entry does not exist', ->
+        expect(@query_cache.get id: 99).to.be.undefined
+
+
+    describe 'partial entries enabled', ->
+
+      beforeEach ->
+        @test_params.partial_entries = yes
+        @query_cache = new slender_data.QueryCache @test_params
+
+      context 'partial entry cached', ->
+
+        beforeEach ->
+          @query_cache.add @partial_user_1
+
+        it 'returns the partial entry if a partial entry is requested', ->
+          @result = @query_cache.get username: 'one'
+          expect(@result).to.eql @partial_user_1
+
+        it 'returns nothing if a full entry is requested', ->
+          @result = @query_cache.get username: 'one', full: yes
+          expect(@result).to.be.undefined
+
+      context 'full entry cached', ->
+
+        beforeEach ->
+          @query_cache.add @full_user_1
+
+        it 'returns the full entry if a partial entry is requested', ->
+          @result = @query_cache.get username: 'one'
+          expect(@result).to.eql @full_user_1
+
+        it 'returns the full entry if a full entry is requested', ->
+          @result = @query_cache.get username: 'one', full: yes
+          expect(@result).to.eql @full_user_1
+
+
+    describe 'versioning', ->
+
+      beforeEach ->
+        @test_params.versioning = yes
+        @query_cache = new slender_data.QueryCache @test_params
+
+      it 'returns the cached entry if it is fresh', ->
+        @query_cache.add @user_1
+        @result = @query_cache.get user: @user_1
+        expect(@result).to.eql @user_1
+
+      it 'returns nothing if the cached entry is stale', ->
+        @result = @query_cache.add @user_1_outdated
+        expect(@result).to.be.undefined
+
+
+  describe 'get_many', ->
+
+    describe 'normal behavior', ->
+
+      beforeEach ->
+        @query_cache.add_many [@user_1, @user_2]
+
+      it 'returns the entries described by the given entry multi-query', ->
+        result = @query_cache.get_many users: [@user_1, @user_2]
+        expect(result.found).to.eql [@user_1, @user_2]
+        expect(result.missing.empty()).to.be.true
+
+      it 'returns the entries described by the given id multi-query', ->
+        result = @query_cache.get_many usernames: ['one', 'two']
+        expect(result.found).to.eql [@user_1, @user_2]
+        expect(result.missing.empty()).to.be.true
+
+      it "reports non-existing entries as a MultiQuery in the 'missing' result portion", ->
+        result = @query_cache.get_many usernames: ['one', 99]
+        expect(result.missing).to.be.an.instanceof slender_data.MultiQuery
+        expect(result.missing.to_hash()).to.eql usernames: [99]
+
+
+    describe 'with partial entries enabled', ->
+
+      beforeEach ->
+        @test_params.partial_entries = yes
+        @query_cache = new slender_data.QueryCache @test_params
+        @query_cache.add_many [@partial_user_1, @full_user_2]
+
+      context 'partial entries are allowed', ->
+
+        beforeEach ->
+          @result = @query_cache.get_many usernames: ['one', 'two', 'three']
+
+        it 'returns partial and full entries', ->
+          expect(@result.found).to.eql [@partial_user_1, @full_user_2]
+
+        it 'reports missing entries', ->
+          expect(@result.missing.to_hash()).to.eql usernames: ['three']
+
+        it 'configures the missing entries multi_query to allow partial entries as well', ->
+          expect(@result.missing.full).to.be.falsy
+
+
+      context 'full entries requested', ->
+
+        beforeEach ->
+          @result = @query_cache.get_many usernames: ['one', 'two'], full: yes
+
+        it 'returns only full entries', ->
+          expect(@result.found).to.eql [@full_user_2]
+
+        it 'reports missing entries', ->
+          expect(@result.missing.to_hash().usernames).to.eql ['one']
+
+        it 'configures the missing entries multi-query to also request only full entries', ->
+          expect(@result.missing.full).to.be.true
+
+
+    describe 'versioning', ->
+
+      beforeEach ->
+        @test_params.versioning = yes
+        @query_cache = new slender_data.QueryCache @test_params
+        @query_cache.add_many [@user_1_outdated, @user_2]
+        @result = @query_cache.get_many users: [@user_1, @user_2]
+
+      it 'returns only cached entries with the right version from the cache', ->
+        expect(@result.found).to.eql [@user_2]
+
+      it 'reports outdated cached entries as missing', ->
+        expect(@result.missing.to_hash()).to.eql users: [@user_1]
+
+
+
+  describe 'length', ->
+
+    it 'returns the number of stored entries', ->
+      expect(@query_cache.length()).to.equal 0
+      @query_cache.add @user_1
+      expect(@query_cache.length()).to.equal 1
+      @query_cache.add @user_2
+      expect(@query_cache.length()).to.equal 2
+      @query_cache.remove user: @user_1
+      expect(@query_cache.length()).to.equal 1
+
+
+  describe 'remove', ->
+
+    beforeEach ->
+      @query_cache.add @user_1
+
+    it 'removes the given entry from the cache', ->
+      @query_cache.remove user: @user_1
+      expect(@query_cache.length()).to.equal 0
+
+    it 'removes the entry with the given id from the cache', ->
+      @query_cache.remove username: 'one'
+      expect(@query_cache.length()).to.equal 0
+
+
+  describe 'remove_many', ->
+
+    beforeEach ->
+      @query_cache.add_many [@user_1, @user_2]
+
+    it 'removes the given entries from the server', ->
+      @query_cache.remove_many users: [@user_1, @user_2]
+      expect(@query_cache.length()).to.equal 0
+
+    it 'removes the entries with the given ids from the server', ->
+      @query_cache.remove_many usernames: ['one', 'two']
+      expect(@query_cache.length()).to.equal 0
+