hoodoo 1.10.0 → 1.11.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YjU2MjRlMTgwYjU3ZDdhOTBhZjk4M2E5NGEwZjk5Mjg4MDM0YjMyMw==
+    Y2FmMmNkOGIxNmI3Yjc3Njk2ZGU4MmJlMzVkZDkyYWQ2ZGI2NGNiNQ==
   data.tar.gz: !binary |-
-    YWFhZjNkZGJkNDMyZDI1NmE4NDk0NGQyMzAxNGFkMDZlMWU0NzRkMw==
+    YWNkMjFhNmMwODQ2OGYxYjZmNDI1ZGIxZGJmNzg3YjQyY2I5ZDMxYw==
 SHA512:
   metadata.gz: !binary |-
-    ZDBiYjhmNDc5OTQ2ODAyNjI5NzU3YzY0YjE4MmQzYTRiMjRkY2NmYjdkZDJl
-    N2UxYThkMDhiMzBjMmQ4YWQ1YjcyMDhlMjM2ZDVjNjhiNGJhMTg4ZjgzZTg1
-    MDA0NWQ1OWZmMWM0MzhlNDkzZmNjODM4ZTdkOTUxMTQzYmFmNGY=
+    ZWJjN2JjMjA3Zjc1YTRmMzYwN2ZkODYyMzE4M2I2N2VkOTg4M2I1MDBjMDhj
+    ZGE3N2RhNWZlOGMwMDQ2MWVmNzNhMzQ3MWEwZTRiZDhjMjBkMDNjNDdhZjdh
+    ZjYxOGUwYTk1NDFlYTJmY2VhNGYxYWI5ODk5YzdmNDNkOThjYTE=
   data.tar.gz: !binary |-
-    Y2UyY2ZhMDM1YTRlOTg5ODlmNzYwZDMyNGQyMTRiNjY1NmY3ZDdhYjAwN2Y1
-    NmQxNDQ0NmQ1ZDUxZDA4YzgzZGI1YjdkODY4YTViZjc4MWMwNzVlZmNhM2E4
-    MmY3MDlmZTFhZTBhZTAxYWVkODQ4NWFmYTJkOGQwOWMzNDIzMTE=
+    MmQzNzQxZWI0OTQ2YjI2Nzg1ODAxMzA0ODVlNmM0ODRmMTE2YTY0YmEwYzA2
+    YTdjMzZkMTY4NWRlNjlmMzdhNTc1NDdiYWM4OTQ1YjNkNzQzNjYzZTlmNDFl
+    Nzc3Mzk5ZmFhMDIxOTk0NmY2MzIyMTc2MGQ2YjFlYWQ5MDQxMGQ=

data/lib/hoodoo/client.rb

@@ -10,6 +10,7 @@
 require 'hoodoo/client/headers'
 
 require 'hoodoo/client/augmented_base'
+require 'hoodoo/client/paginated_enumeration'
 require 'hoodoo/client/augmented_hash'
 require 'hoodoo/client/augmented_array'
 

data/lib/hoodoo/client/augmented_array.rb

@@ -17,6 +17,7 @@ module Hoodoo
     #
     class AugmentedArray < ::Array
       include Hoodoo::Client::AugmentedBase
+      include Hoodoo::Client::PaginatedEnumeration
 
       # For lists, the (optional) total size of the data set, of which
       # the contents of this Array will often only represent a single

data/lib/hoodoo/client/endpoint/endpoint.rb

@@ -314,6 +314,35 @@ module Hoodoo
           end
         end
 
+        # Set the +augmented_array+'s +next_page_proc+ attribute to a Proc that
+        # will call the list endpoint to retrieve the next batch of of Resources
+        # using the same query parameters.
+        #
+        # +augmented_array+:: The Hoodoo::Client::AugmentedArray instance
+        #                     containing the initial set of Resources to
+        #                     be enumerated through.
+        #
+        # +query_hash+::      The query parameters to be used for this
+        #                     enumeration. See the constructor for more.
+        #
+        # Returns the +augmented_array+ passed in, with the +next_page_proc+
+        # value set.
+        #
+        def inject_enumeration_state ( augmented_array, query_hash )
+
+          endpoint                       = self
+          query_hash                     = query_hash.nil? ? {} : query_hash.dup
+          batch_size                     = [ 1, augmented_array.size ].max
+          augmented_array.next_page_proc = Proc.new do
+            query_hash[ :offset ] = ( query_hash[ :offset ] || 0 ) + batch_size
+            endpoint.list( query_hash )
+          end
+
+          return augmented_array
+
+        end
+
+
       public
 
         # Obtain a list of resource instance representations.
@@ -337,6 +366,9 @@ module Hoodoo
         # satisfying the list conditions were found. The array contents
         # are undefined in the case of errors.
         #
+        # Call Hoodoo::Client::PaginatedEnumeration#enumerate_all to enumerate
+        # over the list of resource instances with automatic pagination.
+        #
         def list( query_hash = nil )
           raise "Subclasses must implement Hoodoo::Client::Endpoint\#list"
         end

data/lib/hoodoo/client/endpoint/endpoints/http.rb

@@ -50,7 +50,7 @@ module Hoodoo
             d.action     = :list
             d.query_hash = query_hash
 
-            return do_http( d )
+            return inject_enumeration_state( do_http( d ), query_hash )
           end
 
           # See Hoodoo::Client::Endpoint#show.

data/lib/hoodoo/client/paginated_enumeration.rb

@@ -0,0 +1,94 @@
+########################################################################
+# File::    paginated_enumeration.rb
+# (C)::     Loyalty New Zealand 2016
+#
+# Purpose:: A module that adds support for enumeration over paginated
+#           resources.
+# ----------------------------------------------------------------------
+#           29-Sep-2016 (DJO): Created.
+########################################################################
+
+module Hoodoo
+  class Client # Just used as a namespace here
+
+    # Ruby mixin providing an enumeration mechanism, allowing the
+    # caller to iterate over all the resource instances in the list,
+    # automatically performing the necessary pagination behind the scenes.
+    #
+    module PaginatedEnumeration
+
+      # Proc called by enumerate_all to provide the next 'page' of values
+      # to be enumerated through. Returns an Hoodoo::Client::AugmentedArray.
+      #
+      attr_accessor :next_page_proc
+
+      # Yields each resource instance, automatically paginating
+      # through the entire set of resources.
+      #
+      # Provide a block to process each resource instance. For example:
+      #
+      #     results = members.list(:search => { :surname => 'Smith' } ).enumerate_all do | member |
+      #       if member.platform_errors.has_errors?
+      #         .. deal with error ...
+      #         break
+      #       else
+      #         .. process member ...
+      #       end
+      #     end
+      #
+      # Each iteration yields a Hoodoo::Client::AugmentedHash representation of
+      # the requested resource instance. The caller must check for errors on
+      # the value yielded with each iteration, as per the example above.
+      #
+      def enumerate_all
+
+        raise "Must provide a block to enumerate_all" unless block_given?
+
+        # The first set of results is in 'this' AugmentedArray
+        results = self
+
+        loop do
+
+          if results.size > 0
+
+            if results.platform_errors.has_errors?
+              raise "Hoodoo::Client:: PaginatedEnumeration#enumerate_all: Unexpected internal state combination of results set and results error indication"
+            end
+
+            # Yield a resource at a time to the caller
+            #
+            # Note: An inter-resource call in a single service returns each
+            #       resource as a Hash, which must be converted to AugmentedHash
+            results.each do | result |
+              yield to_augmented_hash(result)
+            end
+            results = next_page_proc.call()
+          else
+            # Return errors in an (empty) AugmentedHash
+            if results.platform_errors.has_errors?
+              yield copy_hash_errors_and_options( Hoodoo::Client::AugmentedHash.new, results )
+            end
+            break
+          end
+
+        end
+
+      end
+
+      private
+
+      # Convert a Hash to an AugmentedHash
+      def to_augmented_hash( src )
+        src.is_a?( Hoodoo::Client::AugmentedHash ) ? src : Hoodoo::Client::AugmentedHash[ src ]
+      end
+
+      # Copy the platform_errors and response_options from src -> dest
+      def copy_hash_errors_and_options( dest, src )
+        dest.set_platform_errors( src.platform_errors )
+        dest.response_options = src.response_options.dup if src.response_options
+        dest
+      end
+
+    end
+  end
+end

data/lib/hoodoo/services/middleware/endpoints/inter_resource_local.rb

@@ -53,7 +53,7 @@ module Hoodoo; module Services
         # See Hoodoo::Client::Endpoint#list.
         #
         def list( query_hash = nil )
-          return @middleware.inter_resource_local(
+          result =  @middleware.inter_resource_local(
             :source_interaction => self.interaction(),
             :discovery_result   => @discovery_result,
             :endpoint           => self,
@@ -62,6 +62,7 @@ module Hoodoo; module Services
 
             :query_hash         => query_hash
           )
+          return inject_enumeration_state( result, query_hash )
         end
 
         # See Hoodoo::Client::Endpoint#show.

data/lib/hoodoo/services/middleware/endpoints/inter_resource_remote.rb

@@ -71,7 +71,7 @@ module Hoodoo
           def list( query_hash = nil )
             result = preprocess( :list )
             result = @wrapped_endpoint.list( query_hash ) if result.nil?
-            return postprocess( result )
+            return inject_enumeration_state( postprocess( result ), query_hash )
           end
 
           # See Hoodoo::Client::Endpoint#show.

data/lib/hoodoo/version.rb

@@ -12,6 +12,6 @@ module Hoodoo
   # The Hoodoo gem version. If this changes, ensure that the date in
   # "hoodoo.gemspec" is correct and run "bundle install" (or "update").
   #
-  VERSION = '1.10.0'
+  VERSION = '1.11.0'
 
 end

data/spec/active/active_record/manually_dated_spec.rb

@@ -927,9 +927,21 @@ describe Hoodoo::ActiveRecord::ManuallyDated do
     #   history entries
     #
     it 'updates work' do
-      values  = ( '1'..'9' ).to_a
+      values  = ( '1'..'5' ).to_a
       threads = []
 
+      # The loop below creates a Thread for each 'value', and each Thread
+      # consumes a db connection, so we have to check that the pool is big enough
+      # to ensure that each thread gets a connection.
+      #
+      # A better solution would be to temporarily create a connection pool with
+      # more connections in it, but attempts to do that broke other parts of this
+      # spec :-(
+      #
+      expect( ActiveRecord::Base.connection_pool.size ).to be >= values.size
+      # Reclaim old, unused connections
+      ActiveRecord::Base.connection_pool.reap()
+
       @uuids.each do | uuid |
         values.each do | value |
           threads << Thread.new do
@@ -946,9 +958,9 @@ describe Hoodoo::ActiveRecord::ManuallyDated do
             end
           end
         end
+        threads.each { | thread | thread.join() }
       end
 
-      threads.each { | thread | thread.join() }
 
       @uuids.each do | uuid |
         contemporary = RSpecModelManualDateTest.manually_dated_contemporary.where( :uuid => uuid ).to_a

data/spec/client/endpoint/endpoints/http_spec.rb

@@ -32,7 +32,7 @@ describe Hoodoo::Client::Endpoint::HTTP do
     it 'should successfuly connect with valid certificate chain' do
       endpoint = connect_to_real_https_endpoint('127.0.0.1', 'spec/files/ca/ca-cert.pem')
       response = endpoint.list()
-      expect(response["message"]).to eq("This data is a secret")
+      expect(response[0]["message"]).to eq("This data is a secret")
     end
 
     it "should fail when certificate doesn't match the hostname" do
@@ -51,7 +51,8 @@ describe Hoodoo::Client::Endpoint::HTTP do
 
     class SslSelfSignedApp
       def call(env)
-        return [200, {'Content-Type' => 'application/json'}, ['{"message": "This data is a secret"}'] ]
+        # Note: Respond to 'list' calls with correct Hoodoo semantics
+        return [200, {'Content-Type' => 'application/json'}, ['{ "_data" : [ { "message": "This data is a secret" } ] }'] ]
       end
     end
 

data/spec/client/paginated_enumeration_spec.rb

@@ -0,0 +1,434 @@
+require 'securerandom'
+require 'spec_helper.rb'
+
+#
+# These tests define the following Services.
+#
+# Clients can call into any of them to invoke the different calling semantics
+# between them.
+#
+#
+# ┌──────────────────────────────────────────────┐ ┌──────────────────────────┐
+# │                                              │ │                          │
+# │               RSpecNumberService             │ │ RSpecRemoteNumberService │
+# │                                              │ │                          │
+# │                                              │ │                          │
+# │ ┌──────────────┐           ┌────────────────┐│ │  ┌───────────────────┐   │
+# │ │              │  inter    │                ││ │  │                   │   │
+# │ │ RSpecNumber  │◀resource ─│RSpecEvenNumber ││ │  │  RSpecOddNumber   │   │
+# │ │              │  local    │                ││ │  │                   │   │
+# │ └──────────────┘           └────────────────┘│ │  └───────────────────┘   │
+# │         ▲                                    │ │            │             │
+# │         │                            inter   │ │            │             │
+# │         └───────────────────────────resource ┼─┼────────────┘             │
+# │                                      remote  │ │                          │
+# └──────────────────────────────────────────────┘ └──────────────────────────┘
+#
+# To start the services in your specs do:
+#
+#     spec_helper_start_svc_app_in_thread_for( RSpecNumberService )
+#     spec_helper_start_svc_app_in_thread_for( RSpecRemoteNumberService)
+#
+
+################################################################################
+#
+# Create a 'RSpecNumber' Resource with the following properties:
+#
+# - manages 'Number' resources ie: { 'number': 3 }, for numbers between 0 & 999
+# - provides a public 'list' endpoint (no session needed)
+# - pagination
+# - will generate an error when asked to retrieve any 'Number' resource with a
+#   number value >= 500 && filter_data['force_error'] is set (to anything)
+#
+class RSpecNumberImplementation < Hoodoo::Services::Implementation
+
+  public
+
+  # Number resources are all in this range
+  NUMBER_RANGE = 0..999
+
+  # Number resources that generate errors are all in this range
+  ERROR_RANGE  = 500..999
+
+  def list( context )
+    request  = context.request
+
+    resources = []
+    implode = false
+    0.upto( request.list.limit - 1 ) do |i|
+      num = request.list.offset + i
+      implode = implode || ERROR_RANGE.include?( num )
+      if NUMBER_RANGE.include?( num )
+        resources << { 'number' => num }
+      else
+        break
+      end
+    end
+
+    context.response.set_resources( resources, resources.count )
+    if implode && request.list.filter_data[ 'force_error' ]
+      context.response.add_error( 'platform.malformed' )
+    end
+  end
+
+end
+
+#
+# Interface for our implementation
+#
+class RSpecNumberInterface < Hoodoo::Services::Interface
+  interface :RSpecNumber do
+    endpoint       :numbers, RSpecNumberImplementation
+    to_list do
+      filter :force_error
+    end
+    public_actions :list
+  end
+end
+
+
+################################################################################
+#
+# Create a 'RSpecEvenNumber' Resource with the following properties:
+#
+# - Calls RSpecNumber via the 'inter_resource_local' calling mechanism
+# - Only returns 'even' numbers, 0, 2, 4... for numbers between 0 & 999
+# - provides a public 'list' endpoint (no session needed)
+#
+# See RSpecNumberImplementation for error handling etc
+#
+class RSpecEvenNumberImplementation < Hoodoo::Services::Implementation
+
+  public
+
+  def list( context )
+    request   = context.request
+    endpoint  = context.resource( :RSpecNumber, 1 )
+    resources = []
+    limit     = request.list.limit  ? request.list.limit  : 50
+    offset    = request.list.offset ? request.list.offset : 0
+
+    # We always iterate through every Number resource - yeah its dumb
+    endpoint.list( { :filter => request.list.filter_data } ).enumerate_all do | number_res |
+
+      if number_res.platform_errors.has_errors?
+        context.response.add_errors( number_res.platform_errors )
+        break
+      end
+
+      number = number_res['number']
+
+      # Number in the correct range & is 'even'
+      resources << number_res if number >= ( offset * 2 ) && number.even?
+      break if resources.size >= limit
+
+    end
+
+    context.response.set_resources( resources, resources.count )
+  end
+
+end
+
+#
+# Interface for our implementation
+#
+class RSpecEvenNumberInterface < Hoodoo::Services::Interface
+  interface :RSpecEvenNumber do
+    endpoint       :even_numbers, RSpecEvenNumberImplementation
+    to_list do
+      filter :force_error
+    end
+    public_actions :list
+  end
+end
+
+################################################################################
+#
+# Define our service, that implements both resources
+#
+class RSpecNumberService < Hoodoo::Services::Service
+  comprised_of RSpecNumberInterface,
+               RSpecEvenNumberInterface
+end
+
+
+################################################################################
+#
+# Create a 'RSpecOddNumber' Resource with the following properties:
+#
+# - Calls RSpecNumber via the 'inter_resource_remote' calling mechanism
+# - Only returns 'odd' numbers, 1, 3, 5 ... for numbers between 0 & 999
+# - provides a public 'list' endpoint (no session needed)
+#
+# See RSpecNumberImplementation for error handling etc
+#
+class RSpecOddNumberImplementation < Hoodoo::Services::Implementation
+
+  public
+
+  def list( context )
+    request   = context.request
+    endpoint  = context.resource( :RSpecNumber, 1 )
+    resources = []
+    limit     = request.list.limit  ? request.list.limit  : 50
+    offset    = request.list.offset ? request.list.offset : 0
+
+    # We always iterate through every Number resource - yeah its dumb
+    endpoint.list( { :filter => request.list.filter_data } ).enumerate_all do | number_res |
+
+      if number_res.platform_errors.has_errors?
+        context.response.add_errors( number_res.platform_errors )
+        break
+      end
+
+      number = number_res['number']
+
+      # Number in the correct range & is 'odd'
+      resources << number_res if number >= ( offset * 2 ) && number.odd?
+      break if resources.size >= limit
+
+    end
+
+    context.response.set_resources( resources, resources.count )
+  end
+
+end
+
+#
+# Interface for our implementation
+#
+class RSpecOddNumberInterface < Hoodoo::Services::Interface
+  interface :RSpecOddNumber do
+    endpoint       :odd_numbers, RSpecOddNumberImplementation
+    to_list do
+      filter :force_error
+    end
+    public_actions :list
+  end
+end
+
+################################################################################
+#
+# Define our service, that implements both resources
+#
+class RSpecRemoteNumberService < Hoodoo::Services::Service
+  comprised_of RSpecOddNumberInterface
+end
+
+
+
+##############################################################################
+# Tests
+##############################################################################
+
+describe Hoodoo::Client do
+
+  before :all do
+
+    # Start our services in background threads
+    spec_helper_start_svc_app_in_thread_for( RSpecNumberService )
+    spec_helper_start_svc_app_in_thread_for( RSpecRemoteNumberService )
+
+  end
+
+  before :each do
+
+    @client = Hoodoo::Client.new({
+      drb_port:     URI.parse( Hoodoo::Services::Discovery::ByDRb::DRbServer.uri() ).port,
+      auto_session: false
+    })
+
+  end
+
+  context 'happy path behaviour' do
+
+    let( :resources ) { [
+      {
+        endpoint:     @client.resource( :RSpecNumber, 1 ),
+        data:         (0..999).to_a
+      },
+      {
+        endpoint:     @client.resource( :RSpecEvenNumber, 1 ),
+        data:         (0..999).step(2).to_a
+      },
+      {
+        endpoint:     @client.resource( :RSpecOddNumber, 1 ),
+        data:         (1..999).step(2).to_a
+      },
+    ] }
+
+    it 'returns every single result with the correct value' do
+
+      resources.each do | resource |
+        numbers = []
+
+        resource[ :endpoint ].list.enumerate_all do | result |
+          expect( result.platform_errors.errors ).to eq( [] )
+          break if result.platform_errors.has_errors?
+          numbers << result[ 'number' ]
+        end
+
+        expect( numbers ).to eq( resource[ :data ] )
+      end
+
+    end
+
+    context 'different "limit" sizes' do
+
+      let(:limits) {
+        # Note: Smaller limits will make the tests very slow
+        [ 250, 500, 750, 999, 1000, 1001 ]
+      }
+
+      it 'enumerates correctly with different batch sizes' do
+
+        resources.each do | resource |
+          limits.each do | limit |
+            numbers = []
+
+            resource[ :endpoint ].list( { 'limit' => limit } ).enumerate_all do | result |
+              expect( result.platform_errors.errors ).to eq( [] )
+              break if result.platform_errors.has_errors?
+              numbers << result[ 'number' ]
+            end
+
+            expect( numbers ).to eq( resource[ :data ] )
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+  context 'error handling behaviour' do
+
+    let( :resources ) { [
+      {
+        endpoint:         @client.resource( :RSpecNumber, 1 ),
+        expected_results: [
+                            {
+                              limit:  10,
+                              data:   ( 0..499 ).to_a,
+                            },
+                            {
+                              limit:  250,
+                              data:   ( 0..499 ).to_a,
+                            },
+                            {
+                              limit:  499,
+                              data:   ( 0..498 ).to_a,
+                            },
+                            {
+                              limit:  500,
+                              data:   ( 0..499 ).to_a,
+                            },
+                            {
+                              limit:  501,
+                              data:   [],
+                            },
+                          ]
+      },
+      {
+        endpoint:         @client.resource( :RSpecEvenNumber, 1 ),
+        expected_results: [
+                            {
+                              limit:  10,
+                              data:   ( 0..498 ).step(2).to_a
+                            },
+                            {
+                              limit:  249,
+                              data:   ( 0..496 ).step(2).to_a
+                            },
+                            {
+                              limit:  250,
+                              data:   ( 0..498 ).step(2).to_a
+                            },
+                            {
+                              limit:  251,
+                              data:   []
+                            },
+                          ]
+      },
+      {
+        endpoint:         @client.resource( :RSpecOddNumber, 1 ),
+        expected_results: [
+                            {
+                              limit:  10,
+                              data:   ( 1..499 ).step(2).to_a
+                            },
+                            {
+                              limit:  249,
+                              data:   ( 1..497 ).step(2).to_a
+                            },
+                            {
+                              limit:  250,
+                              data:   ( 1..499 ).step(2).to_a
+                            },
+                            {
+                              limit:  251,
+                              data:   []
+                            },
+                          ]
+      },
+    ] }
+
+    it 'returns values until an error occurs in the "list" call' do
+
+      resources.each do | resource |
+        resource[ :expected_results ].each do | expected |
+
+          numbers    = []
+          errors     = 0
+          query_hash = {
+            'limit'   => expected[ :limit ],
+            'filter'  => {
+              'force_error' => 'true'
+            }
+          }
+
+          resource[ :endpoint ].list( query_hash ).enumerate_all do | result |
+            numbers << result[ 'number' ] if result.has_key? 'number'
+            errors  += 1 if result.platform_errors.has_errors?
+          end
+
+          # The number of valid resources that you recieve is dependent on
+          # the 'limit' size that is passed through on the 'list' call
+          #
+          # Thats because the system will enumerate through an entire batch of
+          # resources (of size limit), OR return an error.
+          #
+          # So the underlying service retrieves 50 valid resources and returns
+          # then the caller will enumerate through those 50. On the other hand if
+          # the service reads 50 resources, and then detects an error on the 51st
+          # then 0 resources are retuned, only an error!
+          #
+          expect( numbers ).to eq( expected[ :data ] )
+          # Check that an error is returned
+          expect( errors ).to eq( 1 )
+        end
+      end
+
+    end
+
+
+    it 'raises an exception if no block supplied' do
+
+      endpoints = [
+          @client.resource( :RSpecNumber, 1 ),
+          @client.resource( :RSpecEvenNumber, 1 ),
+          @client.resource( :RSpecOddNumber, 1 ),
+      ]
+
+      endpoints.each do | endpoint |
+        expect {
+          endpoint.list.enumerate_all
+        }.to raise_exception( RuntimeError, 'Must provide a block to enumerate_all' )
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hoodoo
 version: !ruby/object:Gem::Version
-  version: 1.10.0
+  version: 1.11.0
 platform: ruby
 authors:
 - Loyalty New Zealand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-23 00:00:00.000000000 Z
+date: 2016-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kgio
@@ -285,6 +285,7 @@ files:
 - lib/hoodoo/client/endpoint/endpoints/http_based.rb
 - lib/hoodoo/client/endpoint/endpoints/not_found.rb
 - lib/hoodoo/client/headers.rb
+- lib/hoodoo/client/paginated_enumeration.rb
 - lib/hoodoo/communicators.rb
 - lib/hoodoo/communicators/fast.rb
 - lib/hoodoo/communicators/pool.rb
@@ -395,6 +396,7 @@ files:
 - spec/client/endpoint/endpoints/http_spec.rb
 - spec/client/endpoint/endpoints/not_found_spec.rb
 - spec/client/headers_spec.rb
+- spec/client/paginated_enumeration_spec.rb
 - spec/communicators/fast_spec.rb
 - spec/communicators/pool_spec.rb
 - spec/communicators/slow_spec.rb
@@ -528,6 +530,7 @@ test_files:
 - spec/client/endpoint/endpoints/http_spec.rb
 - spec/client/endpoint/endpoints/not_found_spec.rb
 - spec/client/headers_spec.rb
+- spec/client/paginated_enumeration_spec.rb
 - spec/communicators/fast_spec.rb
 - spec/communicators/pool_spec.rb
 - spec/communicators/slow_spec.rb