lhs 8.0.0 → 9.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e172deae82bb63cb78f7a2d96a261620ecf09af
-  data.tar.gz: b1caad27952e66468718b4f070b125c565fb39cb
+  metadata.gz: a67846d69ae33c0fc39973108dcad1e2b996fd60
+  data.tar.gz: 231e57735eeb0ce6a71a567d311148a69257178a
 SHA512:
-  metadata.gz: d0d4d2fc97519b154413f07dc2f379ca88f3f21dc5fa5b7f87e1354386f725a47edaf20169b88a1a721e8ababd46dfb11bf8d13f057157f8122c39f332af2649
-  data.tar.gz: 354e6e31fc84edc91190a733c9c99a15d0a84be9d003e44ed951df18c70ce911d1380356930d85f8d281c99afeae71068ae9226af554fef0899271c5d73fd22c
+  metadata.gz: 91193cb240275698ce0e2571ff24588cc411f4111260663fce90258c20f2cf9c37b346abcefc40ca91661aeb6b46fff39c6ee4339dcb86e8677c81c605a6db3e
+  data.tar.gz: c13f28d8bea1e6e73dcb0595851195b0c3168eb002268b48b646a636cc52baaf14c0adb8e77708b1b9c6cf1d9416ebd238f4b0b8d71c92d0019ebe39bd672936

data/README.md

@@ -233,7 +233,7 @@ You can apply options to the request chain. Those options will be forwarded to t
 
 **Be careful using methods for batch processing. They could result in a lot of HTTP requests!**
 
-`all` fetches all records from the service by doing multiple requests if necessary.
+`all` fetches all records from the service by doing multiple requests and resolving endpoint pagination if necessary.
 
 ```ruby
 data = Record.all
@@ -241,6 +241,15 @@ data.count # 998
 data.length # 998
 ```
 
+`all` is chainable and has the same interface like `where` (See: [Find multiple records](https://github.com/local-ch/lhs#find-multiple-records))
+
+```ruby
+Record.where(color: 'blue').all
+Record.all.where(color: 'blue')
+Record.all(color: 'blue')
+# All three are doing the same thing: fetching all records with the color 'blue' from the endpoint while resolving pagingation if endpoint is paginated
+```
+
 [Count vs. Length](#count-vs-length)
 
 `find_each` is a more fine grained way to process single records that are fetched in batches.
@@ -844,6 +853,62 @@ end
 Example.find(1) # GET records/1
 ```
 
+## Testing: How to write tests when using LHS
+
+[WebMock](https://github.com/bblimke/webmock)! 
+
+Best practice is to let LHS fetch your records and Webmock to stub/mock endpoints responses. 
+This follows the [Black Box Testing](https://en.wikipedia.org/wiki/Black-box_testing) approach and prevents you from building up constraints to LHS' internal structures/mechanisms, which will break when we change internal things.
+LHS provides interfaces that result in HTTP requests, this is what you should test.
+
+```ruby
+let(:contracts) do
+  [
+    {number: '1'},
+    {number: '2'},
+    {number: '3'}
+  ]
+end
+
+before(:each) do
+  stub_request(:get, "http://datastore/user/:id/contracts")
+    .to_return(
+      body: {
+        items: contracts,
+        limit: 10,
+        total: contracts.length,
+        offset: 0
+      }.to_json
+    )
+end
+
+it 'displays contracts' do
+  visit 'contracts'
+  contracts.each do |contract|
+    expect(page).to have_content(contract[:number])
+  end
+end
+```
+
+## Where values hash
+
+Returns a hash of where conditions.
+Common to use in tests, as where queries are not performing any HTTP-requests when no data is accessed.
+
+```ruby
+records = Record.where(color: 'blue').where(available: true).where(color: 'red')
+
+expect(
+  records
+).to have_requested(:get, %r{records/})
+  .with(query: hash_including(color: 'blue', available: true))
+# will fail as no http request is made (no data requested)
+
+expect(
+  records.where_values_hash
+).to eq {color: 'red', available: true}
+```
+
 ## License
 
 [GNU Affero General Public License Version 3.](https://www.gnu.org/licenses/agpl-3.0.en.html)

data/lib/lhs/collection.rb

@@ -34,6 +34,14 @@ class LHS::Collection < LHS::Proxy
     false
   end
 
+  def raw_items
+    if _raw.is_a?(Array)
+      _raw
+    else
+      _raw[items_key]
+    end
+  end
+
   protected
 
   def method_missing(name, *args, &block)

data/lib/lhs/concerns/record/chainable.rb

@@ -15,6 +15,12 @@ class LHS::Record
         Chain.new(self, Parameter.new(hash))
       end
 
+      def all(hash = nil)
+        chain = Chain.new(self, Parameter.new(hash))
+        chain._links.push(Option.new(all: true))
+        chain
+      end
+
       def options(hash = nil)
         Chain.new(self, Option.new(hash))
       end
@@ -171,6 +177,10 @@ class LHS::Record
         push(Parameter.new(hash))
       end
 
+      def all(hash = nil)
+        push([Parameter.new(hash), Option.new(all: true)])
+      end
+
       def options(hash = nil)
         push(Option.new(hash))
       end
@@ -323,7 +333,7 @@ class LHS::Record
 
       def push(link)
         clone = self.clone
-        clone._links = _links + [link].compact
+        clone._links = _links + [link].flatten.compact
         clone
       end
 

data/lib/lhs/concerns/record/request.rb

@@ -18,6 +18,14 @@ class LHS::Record
 
       private
 
+      # Applies limit to the first request of an all request chain
+      # Tries to apply an high value for limit and reacts on the limit
+      # returned by the endpoint to make further requests
+      def apply_limit!(options)
+        options[:params] ||= {}
+        options[:params] = options[:params].merge(limit_key => options[:params][limit_key] || LHS::Pagination::Base::DEFAULT_LIMIT)
+      end
+
       # Convert URLs in options to endpoint templates
       def convert_options_to_endpoints(options)
         if options.is_a?(Array)
@@ -160,6 +168,42 @@ class LHS::Record
         end
       end
 
+      # After fetching the first page,
+      # we can evaluate if there are further remote objects remaining
+      # and after preparing all the requests that have to be made in order to fetch all
+      # remote items during this batch, they are fetched in parallel
+      def load_and_merge_remaining_objects!(data, options)
+        if paginated?(data._raw)
+          load_and_merge_paginated_collection!(data, options)
+        elsif data.collection? && paginated?(data.first._raw)
+          load_and_merge_set_of_paginated_collections!(data, options)
+        end
+      end
+
+      def load_and_merge_paginated_collection!(data, options)
+        pagination = data._record.pagination(data)
+        return data if pagination.pages_left.zero?
+        record = data._record
+        record.request(
+          options_for_next_batch(record, pagination, options)
+        ).each do |batch_data|
+          merge_batch_data_with_parent!(batch_data, data)
+        end
+      end
+
+      def load_and_merge_set_of_paginated_collections!(data, options)
+        options_for_this_batch = []
+        options.each_with_index do |_, index|
+          record = data[index]._record
+          pagination = record.pagination(data[index])
+          next if pagination.pages_left.zero?
+          options_for_this_batch.push(options_for_next_batch(record, pagination, options[index], data[index]))
+        end
+        data._record.request(options_for_this_batch.flatten).each do |batch_data|
+          merge_batch_data_with_parent!(batch_data, batch_data._request.options[:parent_data])
+        end
+      end
+
       # Load additional resources that are requested with include
       def load_include(options, data, sub_includes, references)
         record = record_for_options(options) || self
@@ -191,10 +235,15 @@ class LHS::Record
       # paginates itself to ensure all records are fetched
       def load_all_included!(record, options)
         data = record.request(options)
-        load_and_merge_all_the_rest!(data, options)
+        load_and_merge_remaining_objects!(data, options)
         data
       end
 
+      # Checks if given raw is paginated or not
+      def paginated?(raw)
+        !!(raw.is_a?(Hash) && raw[total_key] && raw[pagination_key])
+      end
+
       def prepare_options_for_include_all_request!(options)
         if options.is_a?(Array)
           options.each do |option|
@@ -225,6 +274,13 @@ class LHS::Record
         options || {}
       end
 
+      def merge_batch_data_with_parent!(batch_data, parent_data)
+        parent_data._raw[items_key].concat batch_data.raw_items
+        parent_data._raw[limit_key] = batch_data._raw[limit_key]
+        parent_data._raw[total_key] = batch_data._raw[total_key]
+        parent_data._raw[pagination_key] = batch_data._raw[pagination_key]
+      end
+
       # Merge explicit params nested in 'params' namespace with original hash.
       def merge_explicit_params!(params)
         return true unless params
@@ -273,8 +329,26 @@ class LHS::Record
         end
       end
 
+      def options_for_next_batch(record, pagination, options, parent_data = nil)
+        batch_options = []
+        pagination.pages_left.times do |index|
+          page_options = {
+            params: {
+              record.limit_key => pagination.limit,
+              record.pagination_key => pagination.next_offset(index + 1)
+            }
+          }
+          page_options[:parent_data] = parent_data if parent_data
+          batch_options.push(
+            options.deep_dup.deep_merge(page_options)
+          )
+        end
+        batch_options
+      end
+
       # Merge explicit params and take configured endpoints options as base
       def process_options(options, endpoint)
+        options = options.deep_dup
         options[:params].deep_symbolize_keys! if options[:params]
         options[:error_handler] = merge_error_handlers(options[:error_handler]) if options[:error_handler]
         options = (endpoint.options || {}).merge(options)
@@ -318,12 +392,14 @@ class LHS::Record
 
       def single_request(options)
         options ||= {}
+        options = options.dup
         including = options.delete(:including)
         referencing = options.delete(:referencing)
-        options = options.dup
         endpoint = find_endpoint(options[:params])
+        apply_limit!(options) if options[:all]
         response = LHC.request(process_options(options, endpoint))
         data = LHS::Data.new(response.body, nil, self, response.request, endpoint)
+        load_and_merge_remaining_objects!(data, process_options(options, endpoint)) if paginated?(data._raw) && options[:all]
         handle_includes(including, data, referencing) if including.present? && data.present?
         data
       end

data/lib/lhs/record.rb

@@ -1,7 +1,6 @@
 Dir[File.dirname(__FILE__) + '/concerns/record/*.rb'].each { |file| require file }
 
 class LHS::Record
-  include All
   include Batch
   include Chainable
   include Configuration

data/lib/lhs/version.rb

@@ -1,3 +1,3 @@
 module LHS
-  VERSION = "8.0.0"
+  VERSION = "9.0.0"
 end

data/spec/collection/configurable_spec.rb

@@ -31,7 +31,7 @@ describe LHS::Collection do
 
   context 'lets you configure how to deal with collections' do
     it 'initalises and gives access to collections according to configuration' do
-      results = Search.all(params: { type: :phonebook, size: 10 })
+      results = Search.all(type: :phonebook, size: 10)
       expect(results.count).to eq total
       expect(results.total).to eq total
       expect(results.limit).to eq limit

data/spec/record/all_spec.rb

@@ -1,23 +1,61 @@
 require 'rails_helper'
 
 describe LHS::Record do
-  let(:datastore) do
-    'http://datastore/v2'
-  end
-
   before(:each) do
-    LHC.config.placeholder('datastore', datastore)
     class Record < LHS::Record
-      endpoint ':datastore/feedbacks'
+      endpoint 'http://datastore/feedbacks'
     end
   end
 
   context 'all' do
     it 'is querying endpoint without pagination when using all' do
-      stub_request(:get, "#{datastore}/feedbacks?limit=100").to_return(status: 200, body: { items: 300.times.map { { foo: 'bar' } }, total: 300 }.to_json)
+      stub_request(:get, "http://datastore/feedbacks?limit=100").to_return(body: { items: 300.times.map { { foo: 'bar' } }, total: 300 }.to_json)
       records = Record.all
       expect(records).to be_kind_of Record
       expect(records.size).to eq(300)
     end
+
+    context 'is chainable with where and works like where' do
+      let(:total) { 22 }
+      let(:limit) { 10 }
+      let!(:first_page_request) do
+        stub_request(:get, "http://datastore/feedbacks?color=blue&limit=100")
+          .to_return(body: { items: 10.times.map { { foo: 'bar' } }, total: total, limit: limit, offset: 0 }.to_json)
+      end
+      let!(:second_page_request) do
+        stub_request(:get, "http://datastore/feedbacks?color=blue&limit=#{limit}&offset=10")
+          .to_return(body: { items: 10.times.map { { foo: 'bar' } }, total: total, limit: limit, offset: 10 }.to_json)
+      end
+      let!(:third_page_request) do
+        stub_request(:get, "http://datastore/feedbacks?color=blue&limit=#{limit}&offset=20")
+          .to_return(body: { items: 2.times.map { { foo: 'bar' } }, total: total, limit: limit, offset: 20 }.to_json)
+      end
+
+      it 'fetches all remote objects' do
+        records = Record.where(color: 'blue').all
+        expect(records.length).to eq total
+        expect(first_page_request).to have_been_requested.times(1)
+        expect(second_page_request).to have_been_requested.times(1)
+        expect(third_page_request).to have_been_requested.times(1)
+        records = Record.all.where(color: 'blue')
+        expect(records.length).to eq total
+        expect(first_page_request).to have_been_requested.times(2)
+        expect(second_page_request).to have_been_requested.times(2)
+        expect(third_page_request).to have_been_requested.times(2)
+        records = Record.all(color: 'blue')
+        expect(records.length).to eq total
+        expect(first_page_request).to have_been_requested.times(3)
+        expect(second_page_request).to have_been_requested.times(3)
+        expect(third_page_request).to have_been_requested.times(3)
+      end
+
+      it 'works in combination with include and includes' do
+        records = Record.includes(:product).includes_all(:options).all(color: 'blue')
+        expect(records.length).to eq total
+        expect(first_page_request).to have_been_requested.times(1)
+        expect(second_page_request).to have_been_requested.times(1)
+        expect(third_page_request).to have_been_requested.times(1)
+      end
+    end
   end
 end

data/spec/record/endpoint_inheritance_spec.rb

@@ -34,7 +34,7 @@ describe LHS::Record do
       stub_request(:get, 'http://records?color=blue').to_return(body: [].to_json)
       Example.where(color: 'blue')
       expect(
-        -> { Base.all }
+        -> { Base.all.first }
       ).to raise_error(RuntimeError, 'Compilation incomplete. Unable to find value for id.')
     end
   end
@@ -52,7 +52,7 @@ describe LHS::Record do
 
     it 'inherits endpoints based on ruby class_attribute behaviour' do
       request = stub_request(:get, 'http://records?limit=100').to_return(body: [].to_json)
-      Base.all
+      Base.all.first
       assert_requested(request)
 
       request = stub_request(:get, 'http://examples/1').to_return(body: {}.to_json)

data/spec/record/paginatable_collection_spec.rb

@@ -71,6 +71,7 @@ describe LHS::Record do
           body: { items: (201..300).to_a, limit: 100, total: 300, offset: 200 }.to_json
         )
       all = Record.all
+      all.first # fetch/resolve
       assert_requested last_request
       expect(all).to be_kind_of Record
       expect(all._data._proxy).to be_kind_of LHS::Collection

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhs
 version: !ruby/object:Gem::Version
-  version: 8.0.0
+  version: 9.0.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhs/graphs/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-31 00:00:00.000000000 Z
+date: 2017-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lhc
@@ -205,7 +205,6 @@ files:
 - lib/lhs/concerns/proxy/accessors.rb
 - lib/lhs/concerns/proxy/create.rb
 - lib/lhs/concerns/proxy/link.rb
-- lib/lhs/concerns/record/all.rb
 - lib/lhs/concerns/record/batch.rb
 - lib/lhs/concerns/record/chainable.rb
 - lib/lhs/concerns/record/configuration.rb

data/lib/lhs/concerns/record/all.rb

@@ -1,98 +0,0 @@
-require 'active_support'
-
-class LHS::Record
-
-  module All
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      # Should be an edge case but sometimes all objects from a certain resource
-      # are required. In this case we load the first page with the default max limit,
-      # compute the amount of left over requests, do all the the left over requests
-      # for the following pages and concatenate all the results in order to return
-      # all the objects for a given resource.
-      def all(options = {})
-        options ||= {}
-        options[:params] ||= {}
-        options[:params] = options[:params].merge(limit_key => options[:params][limit_key] || LHS::Pagination::Base::DEFAULT_LIMIT)
-        data = request(options)
-        load_and_merge_all_the_rest!(data, options) if paginated?(data._raw)
-        data._record.new(LHS::Data.new(data, nil, self))
-      end
-
-      private
-
-      def paginated?(raw)
-        raw.is_a?(Hash) && raw[total_key] && raw[pagination_key]
-      end
-
-      def all_items_from(data)
-        if data._raw.is_a?(Array)
-          data._raw
-        else
-          data._raw[items_key]
-        end
-      end
-
-      # After fetching the first page,
-      # we can evaluate if there are further remote objects remaining
-      # and after preparing all the requests that have to be made in order to fetch all
-      # remote items during this batch, they are fetched in parallel
-      def load_and_merge_all_the_rest!(data, options)
-        if paginated?(data._raw)
-          load_and_merge_paginated_collection!(data, options)
-        elsif data.collection? && paginated?(data.first._raw)
-          load_and_merge_set_of_paginated_collections!(data, options)
-        end
-      end
-
-      def load_and_merge_paginated_collection!(data, options)
-        pagination = data._record.pagination(data)
-        return data if pagination.pages_left.zero?
-        record = data._record
-        record.request(
-          options_for_next_batch(record, pagination, options)
-        ).each do |batch_data|
-          merge_batch_data_with_parent!(batch_data, data)
-        end
-      end
-
-      def load_and_merge_set_of_paginated_collections!(data, options)
-        options_for_this_batch = []
-        options.each_with_index do |_, index|
-          record = data[index]._record
-          pagination = record.pagination(data[index])
-          next if pagination.pages_left.zero?
-          options_for_this_batch.push(options_for_next_batch(record, pagination, options[index], data[index]))
-        end
-        data._record.request(options_for_this_batch.flatten).each do |batch_data|
-          merge_batch_data_with_parent!(batch_data, batch_data._request.options[:parent_data])
-        end
-      end
-
-      def merge_batch_data_with_parent!(batch_data, parent_data)
-        parent_data._raw[items_key].concat all_items_from batch_data
-        parent_data._raw[limit_key] = batch_data._raw[limit_key]
-        parent_data._raw[total_key] = batch_data._raw[total_key]
-        parent_data._raw[pagination_key] = batch_data._raw[pagination_key]
-      end
-
-      def options_for_next_batch(record, pagination, options, parent_data = nil)
-        batch_options = []
-        pagination.pages_left.times do |index|
-          page_options = {
-            params: {
-              record.limit_key => pagination.limit,
-              record.pagination_key => pagination.next_offset(index + 1)
-            }
-          }
-          page_options[:parent_data] = parent_data if parent_data
-          batch_options.push(
-            options.deep_dup.deep_merge(page_options)
-          )
-        end
-        batch_options
-      end
-    end
-  end
-end