elasticsearch-model 0.1.9 → 7.1.1

data/test/unit/response_pagination_will_paginate_test.rb

@@ -1,398 +0,0 @@
-require 'test_helper'
-require 'will_paginate'
-require 'will_paginate/collection'
-
-class Elasticsearch::Model::ResponsePaginationWillPaginateTest < Test::Unit::TestCase
-  class ModelClass
-    def self.index_name;    'foo'; end
-    def self.document_type; 'bar'; end
-
-    # WillPaginate adds this method to models (see WillPaginate::PerPage module)
-    def self.per_page
-      33
-    end
-  end
-
-  # Subsclass Response so we can include WillPaginate module without conflicts with Kaminari.
-  class WillPaginateResponse < Elasticsearch::Model::Response::Response
-    include Elasticsearch::Model::Response::Pagination::WillPaginate
-  end
-
-  RESPONSE = { 'took' => '5', 'timed_out' => false, '_shards' => {'one' => 'OK'},
-               'hits' => { 'total' => 100, 'hits' => (1..100).to_a.map { |i| { _id: i } } } }
-
-  context "Response pagination" do
-
-    setup do
-      @search   = Elasticsearch::Model::Searching::SearchRequest.new ModelClass, '*'
-      @response = WillPaginateResponse.new ModelClass, @search, RESPONSE
-      @response.klass.stubs(:client).returns mock('client')
-
-      @expected_methods = [
-        # methods needed by WillPaginate::CollectionMethods
-        :current_page,
-        :offset,
-        :per_page,
-        :total_entries,
-        :length,
-
-        # methods defined by WillPaginate::CollectionMethods
-        :total_pages,
-        :previous_page,
-        :next_page,
-        :out_of_bounds?,
-      ]
-    end
-
-    should "have pagination methods" do
-      assert_respond_to @response, :paginate
-
-      @expected_methods.each do |method|
-        assert_respond_to @response, method
-      end
-    end
-
-    context "response.results" do
-      should "have pagination methods" do
-        @expected_methods.each do |method|
-          assert_respond_to @response.results, method
-        end
-      end
-    end
-
-    context "response.records" do
-      should "have pagination methods" do
-        @expected_methods.each do |method|
-          @response.klass.stubs(:find).returns([])
-          assert_respond_to @response.records, method
-        end
-      end
-    end
-
-    context "#offset method" do
-      should "calculate offset using current_page and per_page" do
-        @response.per_page(3).page(3)
-        assert_equal 6, @response.offset
-      end
-    end
-    context "#length method" do
-      should "return count of paginated results" do
-        @response.per_page(3).page(3)
-        assert_equal 3, @response.length
-      end
-    end
-
-    context "#paginate method" do
-      should "set from/size using defaults" do
-        @response.klass.client
-          .expects(:search)
-            .with do |definition|
-              assert_equal 0, definition[:from]
-              assert_equal 33, definition[:size]
-              true
-            end
-          .returns(RESPONSE)
-
-        assert_nil @response.search.definition[:from]
-        assert_nil @response.search.definition[:size]
-
-        @response.paginate(page: nil).to_a
-        assert_equal 0, @response.search.definition[:from]
-        assert_equal 33, @response.search.definition[:size]
-      end
-
-      should "set from/size using default per_page" do
-        @response.klass.client
-          .expects(:search)
-            .with do |definition|
-              assert_equal 33, definition[:from]
-              assert_equal 33, definition[:size]
-              true
-            end
-          .returns(RESPONSE)
-
-        assert_nil @response.search.definition[:from]
-        assert_nil @response.search.definition[:size]
-
-        @response.paginate(page: 2).to_a
-        assert_equal 33, @response.search.definition[:from]
-        assert_equal 33, @response.search.definition[:size]
-      end
-
-      should "set from/size using custom page and per_page" do
-        @response.klass.client
-          .expects(:search)
-            .with do |definition|
-              assert_equal 18, definition[:from]
-              assert_equal 9, definition[:size]
-              true
-            end
-          .returns(RESPONSE)
-
-        assert_nil @response.search.definition[:from]
-        assert_nil @response.search.definition[:size]
-
-        @response.paginate(page: 3, per_page: 9).to_a
-        assert_equal 18, @response.search.definition[:from]
-        assert_equal 9, @response.search.definition[:size]
-      end
-
-      should "search for first page if specified page is < 1" do
-        @response.klass.client
-          .expects(:search)
-            .with do |definition|
-              assert_equal 0, definition[:from]
-              assert_equal 33, definition[:size]
-              true
-            end
-          .returns(RESPONSE)
-
-        assert_nil @response.search.definition[:from]
-        assert_nil @response.search.definition[:size]
-
-        @response.paginate(page: "-1").to_a
-        assert_equal 0, @response.search.definition[:from]
-        assert_equal 33, @response.search.definition[:size]
-      end
-
-      should "use the param_name" do
-        @response.klass.client
-          .expects(:search)
-            .with do |definition|
-              assert_equal 10, definition[:from]
-              true
-            end
-          .returns(RESPONSE)
-
-        @response.paginate(my_page: 2, per_page: 10, param_name: :my_page).to_a
-      end
-    end
-
-    context "#page and #per_page shorthand methods" do
-      should "set from/size using default per_page" do
-        @response.page(5)
-        assert_equal 132, @response.search.definition[:from]
-        assert_equal 33, @response.search.definition[:size]
-      end
-
-      should "set from/size when calling #page then #per_page" do
-        @response.page(5).per_page(3)
-        assert_equal 12, @response.search.definition[:from]
-        assert_equal 3, @response.search.definition[:size]
-      end
-
-      should "set from/size when calling #per_page then #page" do
-        @response.per_page(3).page(5)
-        assert_equal 12, @response.search.definition[:from]
-        assert_equal 3, @response.search.definition[:size]
-      end
-    end
-
-    context "#current_page method" do
-      should "return 1 by default" do
-        @response.paginate({})
-        assert_equal 1, @response.current_page
-      end
-
-      should "return current page number" do
-        @response.paginate(page: 3, per_page: 9)
-        assert_equal 3, @response.current_page
-      end
-
-      should "return nil if not pagination set" do
-        assert_equal nil, @response.current_page
-      end
-    end
-
-    context "#per_page method" do
-      should "return value set in paginate call" do
-        @response.paginate(per_page: 8)
-        assert_equal 8, @response.per_page
-      end
-    end
-
-    context "#total_entries method" do
-      should "return total from response" do
-        @response.expects(:results).returns(mock('results', total: 100))
-        assert_equal 100, @response.total_entries
-      end
-    end
-  end
-
-  context "Multimodel response pagination" do
-    setup do
-      @multimodel = Elasticsearch::Model::Multimodel.new ModelClass
-      @search      = Elasticsearch::Model::Searching::SearchRequest.new @multimodel, '*'
-      @response    = WillPaginateResponse.new @multimodel, @search, RESPONSE
-      @response.klass.stubs(:client).returns mock('client')
-
-      @expected_methods = [
-        # methods needed by WillPaginate::CollectionMethods
-        :current_page,
-        :offset,
-        :per_page,
-        :total_entries,
-        :length,
-
-        # methods defined by WillPaginate::CollectionMethods
-        :total_pages,
-        :previous_page,
-        :next_page,
-        :out_of_bounds?,
-      ]
-    end
-
-    should "have pagination methods" do
-      assert_respond_to @response, :paginate
-
-      @expected_methods.each do |method|
-        assert_respond_to @response, method
-      end
-    end
-
-    context "response.results" do
-      should "have pagination methods" do
-        @expected_methods.each do |method|
-          assert_respond_to @response.results, method
-        end
-      end
-    end
-
-    context "#offset method" do
-      should "calculate offset using current_page and per_page" do
-        @response.per_page(3).page(3)
-        assert_equal 6, @response.offset
-      end
-    end
-    context "#length method" do
-      should "return count of paginated results" do
-        @response.per_page(3).page(3)
-        assert_equal 3, @response.length
-      end
-    end
-
-    context "#paginate method" do
-      should "set from/size using WillPaginate defaults, ignoring aggregated models configuration" do
-        @response.klass.client
-          .expects(:search)
-          .with do |definition|
-          assert_equal 0, definition[:from]
-          assert_equal ::WillPaginate.per_page, definition[:size]
-          true
-        end
-          .returns(RESPONSE)
-
-        assert_nil @response.search.definition[:from]
-        assert_nil @response.search.definition[:size]
-
-        @response.paginate(page: nil).to_a
-        assert_equal 0, @response.search.definition[:from]
-        assert_equal ::WillPaginate.per_page, @response.search.definition[:size]
-      end
-
-      should "set from/size using default per_page, ignoring aggregated models' configuration" do
-        @response.klass.client
-          .expects(:search)
-          .with do |definition|
-          assert_equal ::WillPaginate.per_page, definition[:from]
-          assert_equal ::WillPaginate.per_page, definition[:size]
-          true
-        end
-          .returns(RESPONSE)
-
-        assert_nil @response.search.definition[:from]
-        assert_nil @response.search.definition[:size]
-
-        @response.paginate(page: 2).to_a
-        assert_equal ::WillPaginate.per_page, @response.search.definition[:from]
-        assert_equal ::WillPaginate.per_page, @response.search.definition[:size]
-      end
-
-      should "set from/size using custom page and per_page" do
-        @response.klass.client
-          .expects(:search)
-          .with do |definition|
-          assert_equal 18, definition[:from]
-          assert_equal 9, definition[:size]
-          true
-        end
-          .returns(RESPONSE)
-
-        assert_nil @response.search.definition[:from]
-        assert_nil @response.search.definition[:size]
-
-        @response.paginate(page: 3, per_page: 9).to_a
-        assert_equal 18, @response.search.definition[:from]
-        assert_equal 9, @response.search.definition[:size]
-      end
-
-      should "search for first page if specified page is < 1" do
-        @response.klass.client
-          .expects(:search)
-          .with do |definition|
-          assert_equal 0, definition[:from]
-          assert_equal ::WillPaginate.per_page, definition[:size]
-          true
-        end
-          .returns(RESPONSE)
-
-        assert_nil @response.search.definition[:from]
-        assert_nil @response.search.definition[:size]
-
-        @response.paginate(page: "-1").to_a
-        assert_equal 0, @response.search.definition[:from]
-        assert_equal ::WillPaginate.per_page, @response.search.definition[:size]
-      end
-    end
-
-    context "#page and #per_page shorthand methods" do
-      should "set from/size using default per_page" do
-        @response.page(5)
-        assert_equal 120, @response.search.definition[:from]
-        assert_equal ::WillPaginate.per_page, @response.search.definition[:size]
-      end
-
-      should "set from/size when calling #page then #per_page" do
-        @response.page(5).per_page(3)
-        assert_equal 12, @response.search.definition[:from]
-        assert_equal 3, @response.search.definition[:size]
-      end
-
-      should "set from/size when calling #per_page then #page" do
-        @response.per_page(3).page(5)
-        assert_equal 12, @response.search.definition[:from]
-        assert_equal 3, @response.search.definition[:size]
-      end
-    end
-
-    context "#current_page method" do
-      should "return 1 by default" do
-        @response.paginate({})
-        assert_equal 1, @response.current_page
-      end
-
-      should "return current page number" do
-        @response.paginate(page: 3, per_page: 9)
-        assert_equal 3, @response.current_page
-      end
-
-      should "return nil if not pagination set" do
-        assert_equal nil, @response.current_page
-      end
-    end
-
-    context "#per_page method" do
-      should "return value set in paginate call" do
-        @response.paginate(per_page: 8)
-        assert_equal 8, @response.per_page
-      end
-    end
-
-    context "#total_entries method" do
-      should "return total from response" do
-        @response.expects(:results).returns(mock('results', total: 100))
-        assert_equal 100, @response.total_entries
-      end
-    end
-  end
-end

data/test/unit/response_records_test.rb

@@ -1,91 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::RecordsTest < Test::Unit::TestCase
-  context "Response records" do
-    class DummyCollection
-      include Enumerable
-
-      def each(&block); ['FOO'].each(&block); end
-      def size;         ['FOO'].size;         end
-      def empty?;       ['FOO'].empty?;       end
-      def foo;          'BAR';                end
-    end
-
-    class DummyModel
-      def self.index_name;    'foo'; end
-      def self.document_type; 'bar'; end
-
-      def self.find(*args)
-        DummyCollection.new
-      end
-    end
-
-    RESPONSE = { 'hits' => { 'total' => 123, 'max_score' => 456, 'hits' => [{'_id' => '1', 'foo' => 'bar'}] } }
-    RESULTS  = Elasticsearch::Model::Response::Results.new DummyModel, RESPONSE
-
-    setup do
-      search   = Elasticsearch::Model::Searching::SearchRequest.new DummyModel, '*'
-      search.stubs(:execute!).returns RESPONSE
-
-      response = Elasticsearch::Model::Response::Response.new DummyModel, search
-      @records = Elasticsearch::Model::Response::Records.new  DummyModel, response
-    end
-
-    should "access the records" do
-      assert_respond_to @records, :records
-      assert_equal 1, @records.records.size
-      assert_equal 'FOO', @records.records.first
-    end
-
-    should "delegate Enumerable methods to records" do
-      assert ! @records.empty?
-      assert_equal 'FOO', @records.first
-    end
-
-    should "delegate methods to records" do
-      assert_respond_to   @records, :foo
-      assert_equal 'BAR', @records.foo
-    end
-
-    should "have each_with_hit method" do
-      @records.each_with_hit do |record, hit|
-        assert_equal 'FOO', record
-        assert_equal 'bar', hit.foo
-      end
-    end
-
-    should "have map_with_hit method" do
-      assert_equal ['FOO---bar'], @records.map_with_hit { |record, hit| "#{record}---#{hit.foo}" }
-    end
-
-    should "return the IDs" do
-      assert_equal ['1'], @records.ids
-    end
-
-    context "with adapter" do
-      module DummyAdapter
-        module RecordsMixin
-          def records
-            ['FOOBAR']
-          end
-        end
-
-        def records_mixin
-          RecordsMixin
-        end; module_function :records_mixin
-      end
-
-      should "delegate the records method to the adapter" do
-        Elasticsearch::Model::Adapter.expects(:from_class)
-                                     .with(DummyModel)
-                                     .returns(DummyAdapter)
-
-        @records = Elasticsearch::Model::Response::Records.new DummyModel,
-                                                               RESPONSE
-
-        assert_equal ['FOOBAR'], @records.records
-      end
-    end
-
-  end
-end

data/test/unit/response_result_test.rb

@@ -1,90 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::ResultTest < Test::Unit::TestCase
-  context "Response result" do
-
-    should "have method access to properties" do
-      result = Elasticsearch::Model::Response::Result.new foo: 'bar', bar: { bam: 'baz' }
-
-      assert_respond_to result, :foo
-      assert_respond_to result, :bar
-
-      assert_equal 'bar', result.foo
-      assert_equal 'baz', result.bar.bam
-
-      assert_raise(NoMethodError) { result.xoxo }
-    end
-
-    should "return _id as #id" do
-      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _id: 42, _source: { id: 12 }
-
-      assert_equal 42, result.id
-      assert_equal 12, result._source.id
-    end
-
-    should "return _type as #type" do
-      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _type: 'baz', _source: { type: 'BAM' }
-
-      assert_equal 'baz', result.type
-      assert_equal 'BAM', result._source.type
-    end
-
-    should "delegate method calls to `_source` when available" do
-      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _source: { bar: 'baz' }
-
-      assert_respond_to result, :foo
-      assert_respond_to result, :_source
-      assert_respond_to result, :bar
-
-      assert_equal 'bar', result.foo
-      assert_equal 'baz', result._source.bar
-      assert_equal 'baz', result.bar
-    end
-
-    should "delegate existence method calls to `_source`" do
-      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _source: { bar: { bam: 'baz' } }
-
-      assert_respond_to result._source, :bar?
-      assert_respond_to result, :bar?
-
-      assert_equal true,  result._source.bar?
-      assert_equal true,  result.bar?
-      assert_equal false, result.boo?
-
-      assert_equal true,  result.bar.bam?
-      assert_equal false, result.bar.boo?
-    end
-
-    should "delegate methods to @result" do
-      result = Elasticsearch::Model::Response::Result.new foo: 'bar'
-
-      assert_equal 'bar',   result.foo
-      assert_equal 'bar',   result.fetch('foo')
-      assert_equal 'moo',   result.fetch('NOT_EXIST', 'moo')
-      assert_equal ['foo'], result.keys
-
-      assert_respond_to result, :to_hash
-      assert_equal({'foo' => 'bar'}, result.to_hash)
-
-      assert_raise(NoMethodError) { result.does_not_exist }
-    end
-
-    should "delegate existence method calls to @result" do
-      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _source: { bar: 'bam' }
-      assert_respond_to result, :foo?
-
-      assert_equal true,  result.foo?
-      assert_equal false, result.boo?
-      assert_equal false, result._source.foo?
-      assert_equal false, result._source.boo?
-    end
-
-    should "delegate as_json to @result even when ActiveSupport changed half of Ruby" do
-      require 'active_support/json/encoding'
-      result = Elasticsearch::Model::Response::Result.new foo: 'bar'
-
-      result.instance_variable_get(:@result).expects(:as_json)
-      result.as_json(except: 'foo')
-    end
-  end
-end

data/test/unit/response_results_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::ResultsTest < Test::Unit::TestCase
-  context "Response results" do
-    class OriginClass
-      def self.index_name;    'foo'; end
-      def self.document_type; 'bar'; end
-    end
-
-    RESPONSE = { 'hits' => { 'total' => 123, 'max_score' => 456, 'hits' => [{'foo' => 'bar'}] } }
-
-    setup do
-      @search   = Elasticsearch::Model::Searching::SearchRequest.new OriginClass, '*'
-      @response = Elasticsearch::Model::Response::Response.new OriginClass, @search
-      @results  = Elasticsearch::Model::Response::Results.new  OriginClass, @response
-      @search.stubs(:execute!).returns(RESPONSE)
-    end
-
-    should "access the results" do
-      assert_respond_to @results, :results
-      assert_equal 1, @results.results.size
-      assert_equal 'bar', @results.results.first.foo
-    end
-
-    should "delegate Enumerable methods to results" do
-      assert ! @results.empty?
-      assert_equal 'bar', @results.first.foo
-    end
-
-  end
-end