orchestrate 0.10.0 → 0.11.0

data/lib/orchestrate/search/query_builder.rb

@@ -0,0 +1,83 @@
+module Orchestrate::Search
+  # Query Builder object for constructing search queries
+  class QueryBuilder
+    # @return [Collection] The collection this object will search.
+    attr_reader :collection
+
+    # @return [#to_s] The Lucene Query String given as the search query.
+    attr_reader :query
+
+    # Initialize a new SearchBuilder object
+    # @param collection [Orchestrate::Collection] The collection to search.
+    # @param query [#to_s] The Lucene Query to perform.
+    def initialize(collection, query)
+      @collection = collection
+      @query = query
+    end
+
+    # @return Pretty-Printed string representation of the Search object
+    def to_s
+      "#<Orchestrate::Search::QueryBuilder collection=#{collection.name} query=#{query} options=#{options}>"
+    end
+    alias :inspect :to_s
+
+    # @return [Hash] Optional parameters for the search query.
+    def options
+      @options ||= { limit: 100 }
+    end
+
+    # Sets the sorting parameters for a query's Search Results.
+    # #order takes multiple arguments,
+    # but each even numbered argument must be either :asc or :desc
+    # Odd-numbered arguments defaults to :asc
+    # @example
+    #   @app[:items].search("foo").order(:name, :asc, :rank, :desc, :created_at)
+    def order(*args)
+      options[:sort] = args.each_slice(2).map {|field, dir| dir ||= :asc; "#{field}:#{dir}" }.join(',')
+      self
+    end
+
+    # Sets the limit for the query to Orchestrate, so we don't ask for more than is needed. 
+    # Does not fire a request.
+    # @overload limit
+    #   @return [Integer, nil] The number of items to retrieve.  Nil is equivalent to zero.
+    # @overload limit(count)
+    #   @param count [Integer] The number of items to retrieve.
+    #   @return [Search] self.
+    def limit(count=nil)
+      if count
+        options[:limit] = count > 100 ? 100 : count
+        self
+      else
+        options[:limit]
+      end
+    end
+
+    # Sets the offset for the query to Orchestrate, so you can skip items.  Does not fire a request.
+    # Impelemented as separate method from drop, unlike #take, because take is a more common use case.
+    # @overload offset
+    #   @return [Integer, nil] The number of items to skip.  Nil is equivalent to zero.
+    # @overload offset(count)
+    #   @param count [Integer] The number of items to skip.
+    #   @return [Search] self.
+    def offset(count=nil)
+      if count
+        options[:offset] = count
+        self
+      else
+        options[:offset]
+      end
+    end
+
+    # @return [AggregateBuilder] An AggregateBuilder object to construct aggregate search params
+    def aggregate
+      options[:aggregate] ||= AggregateBuilder.new(self)
+    end
+
+    # @return [Orchestrate::Search::Results] A Results object to enumerate over.
+    def find
+      options[:aggregate] = options[:aggregate].to_param if options[:aggregate]
+      Results.new(collection, query, options)
+    end
+  end
+end

data/lib/orchestrate/search/results.rb

@@ -0,0 +1,215 @@
+module Orchestrate::Search
+  # An enumerator for searching an Orchestrate::Collection
+  class Results
+    # @return [Collection] The collection this object will search.
+    attr_reader :collection
+
+    # @return [#to_s] The Lucene Query String given as the search query.
+    attr_reader :query
+
+    # @return [Hash] The query paramaters.
+    attr_reader :options
+
+    # @return [Orchestrate::API::CollectionResponse] The response object
+    attr_reader :response
+
+    # @return [#to_json] The response object's aggregate results
+    attr_reader :aggregates
+
+    # Initialize a new SearchResults object
+    # @param collection [Orchestrate::Collection] The collection searched.
+    # @param query [#to_s] The Lucene Query performed.
+    # @param options [Hash] The query parameters.
+    def initialize(collection, query, options)
+      @collection = collection
+      @query = query
+      @options = options
+      @response = nil
+      @aggregates = nil
+    end
+
+    include Enumerable
+
+    # Iterates over each result from the Search. Used as the basis for Enumerable methods.
+    # Items are provided on the basis of score, with most relevant first.
+    # @overload each
+    #   @return Enumerator
+    # @overload each(&block)
+    #   @yieldparam [Array<(Float, Orchestrate::KeyValue)>] score,key_value  The item's score and the item.
+    # @example
+    #   collection.search("trendy").limit(5).execute.each do |score, item|
+    #     puts "#{item.key} has a trend score of #{score}"
+    #   end
+    def each
+      @response ||= collection.perform(:search, query, options)
+      @aggregates ||= @response.aggregates
+      return enum_for(:each) unless block_given?
+      raise Orchestrate::ResultsNotReady.new if collection.app.inside_parallel?
+      loop do
+        @response.results.each do |listing|
+          yield [ listing['score'], Orchestrate::KeyValue.from_listing(collection, listing, @response) ]
+        end
+        break unless @response.next_link
+        @response = @response.next_results
+      end
+      @response = nil
+    end
+
+    # Iterates over each aggregate result from the Search. Used as the basis for Enumerable methods.  Items are
+    # provided on the basis of score, with most relevant first.
+    # @overload each_aggregate
+    #   @return Enumerator
+    # @overload each_aggregate(&block)
+    #   @yieldparam <(Orchestrate::Collection::AggregateResult)>
+    def each_aggregate
+      @response ||= collection.perform(:search, query, options)
+      @aggregates ||= @response.aggregates
+      return enum_for(:each_aggregate) unless block_given?
+      raise Orchestrate::ResultsNotReady.new if collection.app.inside_parallel?
+      @aggregates.each do |listing|
+        case listing['aggregate_kind']
+        when 'stats'
+          yield StatsResult.new(collection, listing)
+        when 'range'
+          yield RangeResult.new(collection, listing)
+        when 'distance'
+          yield DistanceResult.new(collection, listing)
+        when 'time_series'
+          yield TimeSeriesResult.new(collection, listing)
+        end
+      end
+    end
+
+    # Creates a Lazy Enumerator for the Search Results.  If called inside its
+    # app's `in_parallel` block, will pre-fetch results.
+    def lazy
+      return each.lazy if collection.app.inside_parallel?
+      super
+    end
+  end
+
+  # Base object representing an individual Aggregate result
+  class AggregateResult
+    # @return [Collection] The collection searched.
+    attr_reader :collection
+
+    # @return [#to_s] The aggregate kind/type
+    attr_reader :kind
+
+    # @return [#to_s] The field name the aggregate function operated over.
+    attr_reader :field_name
+
+    # @return [Integer] Number of field values included in the aggregate function.
+    attr_reader :count
+
+    # Initialize a new AggregateResult object
+    # @param collection [Orchestrate::Collection] The collection searched.
+    # @param listing [#to_json] The aggregate result returned from the search.
+    def initialize(collection, listing)
+      @collection = collection
+      @kind = listing['aggregate_kind']
+      @field_name = listing['field_name']
+      @count = listing['value_count']
+    end
+  end
+
+  # Stats Aggregate result object
+  class StatsResult < AggregateResult
+    # @return [Hash] The statistics results
+    attr_reader :statistics
+
+    # @return [Float] Lowest numerical value of the statistics result
+    attr_reader :min
+
+    # @return [Float] Highest numerical value of the statistics result
+    attr_reader :max
+
+    # @return [Float] Average of included numerical values
+    attr_reader :mean
+
+    # @return [Float] Total of included numerical values
+    attr_reader :sum
+
+    # @return [Float]
+    attr_reader :sum_of_squares
+
+    # @return [Float]
+    attr_reader :variance
+
+    # @return [Float]
+    attr_reader :std_dev
+
+    # Initialize a new StatsResult object
+    # @param collection [Orchestrate::Collection] The collection searched.
+    # @param listing [#to_json] The aggregate result returned from the search.
+    def initialize(collection, listing)
+      super(collection, listing)
+      if listing['statistics']
+        @statistics = listing['statistics']
+        @min = @statistics['min']
+        @max = @statistics['max']
+        @mean = @statistics['mean']
+        @sum = @statistics['sum']
+        @sum_of_squares = @statistics['sum_of_squares']
+        @variance = @statistics['variance']
+        @std_dev = @statistics['std_dev']
+      end
+    end
+
+    # @return Pretty-Printed string representation of the StatsResult object
+    def to_s
+      stats = "statistics={\n  min=#{min},\n  max=#{max},\n  mean=#{mean},\n  sum=#{sum},\n  sum_of_squares=#{sum_of_squares},\n  variance=#{variance},\n  std_dev=#{std_dev}\n}"
+      "#<Orchestrate::Search::StatsResult collection=#{collection.name} field_name=#{field_name} count=#{count} #{stats}>"
+    end
+    alias :inspect :to_s
+  end
+
+  # Range Aggregate result object
+  class RangeResult < AggregateResult
+    # @return [Array] Range buckets/sets results
+    attr_reader :buckets
+
+    # Initialize a new RangeResult object
+    # @param collection [Orchestrate::Collection] The collection searched.
+    # @param listing [#to_json] The aggregate result returned from the search.
+    def initialize(collection, listing)
+      super(collection, listing)
+      @buckets = listing['buckets']
+    end
+
+    # @return Pretty-Printed string representation of the RangeResult object
+    def to_s
+      "#<Orchestrate::Search::RangeResult collection=#{collection.name} field_name=#{field_name} buckets=#{buckets}>"
+    end
+    alias :inspect :to_s
+  end
+
+  # Distance Aggregate result object
+  class DistanceResult < RangeResult
+    # @return Pretty-Printed string representation of the DistanceResult object
+    def to_s
+      "#<Orchestrate::Search::DistanceResult collection=#{collection.name} field_name=#{field_name} buckets=#{buckets}>"
+    end
+    alias :inspect :to_s
+  end
+
+  # Time Series Aggregate result object
+  class TimeSeriesResult < RangeResult
+    # @return [#to_s] Time interval
+    attr_reader :interval
+
+    # Initialize a new TimeSeriesResult object
+    # @param collection [Orchestrate::Collection] The collection searched.
+    # @param listing [#to_json] The aggregate result returned from the search.
+    def initialize(collection, listing)
+      super(collection, listing)
+      @interval = listing['interval']
+    end
+
+    # @return Pretty-Printed string representation of the TimeSeriesResult object
+    def to_s
+      "#<Orchestrate::Search::TimeSeriesResult collection=#{collection.name} field_name=#{field_name} interval=#{interval} buckets=#{buckets}>"
+    end
+    alias :inspect :to_s
+  end
+end

data/lib/orchestrate/search.rb

@@ -0,0 +1,10 @@
+module Orchestrate
+  # Namespace for concerns related to the Orchestrate API
+  module Search
+  end
+
+end
+
+require_relative 'search/query_builder.rb'
+require_relative 'search/aggregate_builder.rb'
+require_relative 'search/results.rb'

data/lib/orchestrate/version.rb

@@ -1,4 +1,4 @@
 module Orchestrate
   # @return [String] The version number of the Orchestrate Gem
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/lib/orchestrate.rb

@@ -2,6 +2,7 @@ require "orchestrate/api"
 require "orchestrate/client"
 require "orchestrate/application"
 require "orchestrate/collection"
+require "orchestrate/search"
 require "orchestrate/key_value"
 require "orchestrate/refs"
 require "orchestrate/event"

data/orchestrate.gemspec

@@ -3,25 +3,25 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'orchestrate/version'
 
 Gem::Specification.new do |s|
-	s.name          = 'orchestrate'
-	s.version       = Orchestrate::VERSION
-	s.authors       = ['Matthew Lyon', 'Justin Mecham', 'James Carrasquer']
-	s.email         = ['matthew@lyonheart.us', 'justin@mecham.me', 'jimcar@aracnet.com']
-	s.summary       = 'Ruby client for Orchestrate.io'
-	s.description   = 'Client for the Orchestrate REST API'
-	s.homepage      = 'https://github.com/orchestrate-io/orchestrate-ruby'
-	s.license       = 'MIT'
+  s.name          = 'orchestrate'
+  s.version       = Orchestrate::VERSION
+  s.authors       = ['Matthew Lyon', 'Justin Mecham', 'James Carrasquer', 'Eric Johnson']
+  s.email         = ['matthew@lyonheart.us', 'justin@mecham.me', 'jimcar@aracnet.com', 'erjohnson.pdx@gmail.com']
+  s.summary       = 'Ruby client for Orchestrate.io'
+  s.description   = 'Client for the Orchestrate REST API'
+  s.homepage      = 'https://github.com/orchestrate-io/orchestrate-ruby'
+  s.license       = 'MIT'
 
-	s.files         = `git ls-files -z`.split("\x0")
-	s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
-	s.test_files    = s.files.grep(%r{^(test|spec|features)/})
-	s.require_paths = ["lib"]
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
 
-  s.add_dependency "faraday", "~> 0.9"
+  s.add_dependency "faraday", "0.9.0"
   s.add_dependency "net-http-persistent", "~> 2.9"
   s.add_development_dependency "bundler", "~> 1.6"
   s.add_development_dependency "rake"
   s.add_development_dependency "typhoeus"
   s.add_development_dependency "em-http-request"
   s.add_development_dependency "em-synchrony"
-end
+end

data/test/orchestrate/collection_aggregates_test.rb

@@ -0,0 +1,118 @@
+require "test_helper"
+
+class CollectionAggregates < MiniTest::Unit::TestCase
+  def setup
+    @app, @stubs = make_application({parallel:true})
+    @items = @app[:items]
+
+    @query = "foo"
+    @stats = [{
+      "aggregate_kind" => "stats",
+      "field_name" => "value.bar",
+      "value_count" => 100,
+      "statistics" => {
+        "min" => 2.99,
+        "max" => 29.99,
+        "mean" => 11.779370,
+        "sum" => 1495.98,
+        "sum_of_squares" => 32740.05,
+        "variance" => 119.986850,
+        "std_dev" => 10.953851
+      }
+    }]
+    @range = [{
+      "aggregate_kind" => "range",
+      "field_name" => "value.bar",
+      "value_count" => 100,
+      "buckets" => [{
+        "max" => 40,
+        "count" => 42
+      }]
+    }]
+    @distance = [{
+      "aggregate_kind" => "distance",
+      "field_name" => "value.bar",
+      "value_count" => 100,
+      "buckets" => [{
+        "min" => 0,
+        "max" => 1,
+        "count" => 42
+      }]
+    }]
+    @time_series = [{
+      "aggregate_kind" => "time_series",
+      "field_name" => "value.bar",
+      "interval" => "day",
+      "value_count" => 100,
+      "buckets" => [{
+        "bucket" => "2014-11-01",
+        "count" => 17
+      }]
+    }]
+    @limit = 100
+    @total = 110
+
+    @make_listing = lambda{|i| make_kv_listing(:items, key: "item-#{i}", reftime: nil, score: @total-i/@total*5.0) }
+    @handle_aggregate = lambda do |aggregate|
+      case aggregate
+      when 'bar:stats'
+        { "results" => 100.times.map{|i| @make_listing.call(i)}, "count" => 100, "total_count" => @total,
+          "aggregates" => @stats }
+      when 'bar:range:*~40:'
+        { "results" => 100.times.map{|i| @make_listing.call(i)}, "count" => 100, "total_count" => @total,
+          "aggregates" => @range }
+      when 'bar:distance:0~1:'
+        { "results" => 100.times.map{|i| @make_listing.call(i)}, "count" => 100, "total_count" => @total,
+          "aggregates" => @distance }
+      when 'bar:time_series:day'
+        { "results" => 100.times.map{|i| @make_listing.call(i)}, "count" => 100, "total_count" => @total,
+          "aggregates" => @time_series }
+      else
+        raise ArgumentError.new("unexpected aggregate: #{aggregate}")
+      end
+    end
+
+    @called = false
+    @stubs.get("/v0/items") do |env|
+      @called = true
+      assert_equal @query, env.params['query']
+      assert_equal @limit, env.params['limit'].to_i
+      body = @handle_aggregate.call(env.params['aggregate'])
+      [ 200, response_headers, body.to_json ]
+    end
+  end
+
+  def test_basic_stats_aggregate
+    results = @items.search("foo").aggregate.stats("bar").find
+    results.each_aggregate
+    assert_equal @stats, results.aggregates
+  end
+
+  def test_basic_range_aggregate
+    results = @items.search("foo").aggregate.range("bar").below(40).find
+    results.each_aggregate
+    assert_equal @range, results.aggregates
+  end
+
+  def test_basic_distance_aggregate
+    @query = "foo:NEAR:{lat:12.3 lon:56.7 dist:100km}"
+    results = @items.near("foo", 12.3, 56.7, 100).aggregate.distance("bar").between(0,1).find
+    results.each_aggregate
+    assert_equal @distance, results.aggregates
+  end
+
+  def test_basic_time_series_aggregate
+    results = @items.search("foo").aggregate.time_series("bar").day.find
+    results.each_aggregate
+    assert_equal @time_series, results.aggregates
+  end
+
+  def test_each_aggregate_enum
+    results = @items.search("foo").aggregate.time_series("bar").day.find
+    enum = results.each_aggregate
+    aggregates = enum.to_a
+    assert_equal 1, aggregates.size
+    assert aggregates.first.is_a?(Orchestrate::Search::TimeSeriesResult)
+    assert_equal "day", aggregates.first.interval
+  end
+end

data/test/orchestrate/collection_geo_queries_test.rb

@@ -34,7 +34,7 @@ class CollectionGeoQueriesTest < MiniTest::Unit::TestCase
 
   def test_near_search_without_units
     @query = @near_query
-    results = @items.near("location", 12, 56, 1).map{|i| i }
+    results = @items.near("location", 12, 56, 1).find.each.map{|i| i }
     assert_equal 10, results.length
     results.each_with_index do |item, idx|
       assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
@@ -45,7 +45,7 @@ class CollectionGeoQueriesTest < MiniTest::Unit::TestCase
 
   def test_near_search_with_units
     @query = @near_query
-    results = @items.near("location", 12, 56, 1, 'km').map{|i| i }
+    results = @items.near("location", 12, 56, 1, 'km').find.each.map{|i| i }
     assert_equal 10, results.length
     results.each_with_index do |item, idx|
       assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
@@ -56,7 +56,7 @@ class CollectionGeoQueriesTest < MiniTest::Unit::TestCase
 
   def test_near_search_with_sort
     @query = @near_query
-    results = @items.near("location", 12, 56, 1, 'km').order(:location).map{|i| i }
+    results = @items.near("location", 12, 56, 1, 'km').order(:location).find.each.map{|i| i }
     assert_equal 10, results.length
     results.each_with_index do |item, idx|
       assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
@@ -67,7 +67,7 @@ class CollectionGeoQueriesTest < MiniTest::Unit::TestCase
 
   def test_in_bounding_box
     @query = @in_query
-    results = @items.in("location", {north:12, east:57, south:12, west:56}).map{|i| i }
+    results = @items.in("location", {north:12, east:57, south:12, west:56}).find.each.map{|i| i }
     assert_equal 12, results.length
     results.each_with_index do |item, idx|
       assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
@@ -78,7 +78,7 @@ class CollectionGeoQueriesTest < MiniTest::Unit::TestCase
 
   def test_in_bounding_box_with_sort
     @query = @in_query
-    results = @items.in("location", {north:12, east:57, south:12, west:56}).order(:location).map{|i| i }
+    results = @items.in("location", {north:12, east:57, south:12, west:56}).order(:location).find.each.map{|i| i }
     assert_equal 12, results.length
     results.each_with_index do |item, idx|
       assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005

data/test/orchestrate/collection_searching_test.rb

@@ -33,7 +33,7 @@ class CollectionSearchingTest < MiniTest::Unit::TestCase
   end
 
   def test_basic_search
-    results = @items.search("foo").map{|i| i }
+    results = @items.search("foo").find.each.map{|i| i }
     assert_equal 110, results.length
     results.each_with_index do |item, idx|
       assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
@@ -48,14 +48,13 @@ class CollectionSearchingTest < MiniTest::Unit::TestCase
     @handle_offset = lambda do |o|
       case o
       when "10"
-        { "results" => 50.times.map{|i| @make_listing.call(i+offset) }, "count" => @limit, "total_count" => @total,
-          "next" => "/v0/items?query=foo&offset=#{offset+@limit}&limit=#{@limit}"}
+        { "results" => 50.times.map{|i| @make_listing.call(i+offset) }, "count" => @limit, "total_count" => @total }
       else
         raise ArgumentError.new("unexpected offset: #{o}")
       end
     end
-    results = @items.search("foo").offset(offset).take(@limit)
-    assert_equal 50, results.length
+    results = @items.search("foo").offset(offset).limit(@limit).find
+    assert_equal 10, results.options[:offset]
     results.each_with_index do |item, idx|
       assert_in_delta (@total-(idx+10)/@total * 5.0), item[0], 0.005
       assert_equal "item-#{idx+10}", item[1].key
@@ -65,7 +64,7 @@ class CollectionSearchingTest < MiniTest::Unit::TestCase
 
   def test_in_parallel_prefetches_enums
     items = nil
-    @app.in_parallel { items = @app[:items].search("foo").each }
+    @app.in_parallel { items = @app[:items].search("foo").find.each }
     assert @called, "enum wasn't prefetched inside in_parallel"
     assert_equal @total, items.to_a.size
   end
@@ -73,27 +72,27 @@ class CollectionSearchingTest < MiniTest::Unit::TestCase
   def test_in_parallel_prefetches_lazy_enums
     return unless [].respond_to?(:lazy)
     items = nil
-    @app.in_parallel { items = @app[:items].search("foo").lazy.map{|d| d } }
+    @app.in_parallel { items = @app[:items].search("foo").find.lazy.map{|d| d } }
     assert @called, "lazy wasn't prefetched from in_parallel"
     assert_equal @total, items.force.size
   end
 
   def test_in_parallel_raises_if_forced
     assert_raises Orchestrate::ResultsNotReady do
-      @app.in_parallel { @app[:items].search("foo").to_a }
+      @app.in_parallel { @app[:items].search("foo").find.each.to_a }
     end
   end
 
   def test_enums_prefetch
     items = nil
-    @app.in_parallel { items = @app[:items].search("foo").each }
+    @app.in_parallel { items = @app[:items].search("foo").find.each }
     assert @called, "enum wasn't prefetched"
     assert_equal @total, items.to_a.size
   end
 
   def test_lazy_enums_dont_prefetch
     return unless [].respond_to?(:lazy)
-    items = @app[:items].search("foo").lazy.map{|d| d }
+    items = @app[:items].search("foo").find.lazy.map{|d| d }
     refute @called, "lazy was prefetched outside in_parallel"
     assert_equal @total, items.force.size
   end

data/test/orchestrate/collection_sorting_test.rb

@@ -33,7 +33,7 @@ class CollectionSortingTest < MiniTest::Unit::TestCase
   end
 
   def test_basic_sort_ascending
-    results = @items.search("foo").order(:score, :asc).map{|i| i }
+    results = @items.search("foo").order(:score, :asc).find.each.map{|i| i }
     assert_equal 110, results.length
     results.each_with_index do |item, idx|
       assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
@@ -44,7 +44,7 @@ class CollectionSortingTest < MiniTest::Unit::TestCase
   end
 
   def test_basic_sort_descending
-    results = @items.search("foo").order(:score, :desc).map{|i| i }
+    results = @items.search("foo").order(:score, :desc).find.each.map{|i| i }
     assert_equal 110, results.length
     results.each_with_index do |item, idx|
       assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
@@ -55,7 +55,7 @@ class CollectionSortingTest < MiniTest::Unit::TestCase
   end
 
   def test_basic_multiple_fields_sort_ascending
-    results = @items.search("foo").order(:score, :asc, :rank, :asc).map{|i| i }
+    results = @items.search("foo").order(:score, :asc, :rank, :asc).find.each.map{|i| i }
     assert_equal 110, results.length
     results.each_with_index do |item, idx|
       assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
@@ -67,7 +67,7 @@ class CollectionSortingTest < MiniTest::Unit::TestCase
   end
 
   def test_basic_multiple_fields_sort_descending
-    results = @items.search("foo").order(:score, :asc, :rank, :desc).map{|i| i }
+    results = @items.search("foo").order(:score, :asc, :rank, :desc).find.each.map{|i| i }
     assert_equal 110, results.length
     results.each_with_index do |item, idx|
       assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005