elasticsearch-model 5.1.0 → 6.1.1

data/spec/elasticsearch/model/response/pagination/will_paginate_spec.rb

@@ -0,0 +1,262 @@
+require 'spec_helper'
+
+describe 'Elasticsearch::Model::Response::Response WillPaginate' do
+
+  before(:all) do
+    class ModelClass
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+
+      def self.per_page
+        33
+      end
+    end
+
+    # Subclass Response so we can include WillPaginate module without conflicts with Kaminari.
+    class WillPaginateResponse < Elasticsearch::Model::Response::Response
+      include Elasticsearch::Model::Response::Pagination::WillPaginate
+    end
+  end
+
+  after(:all) do
+    remove_classes(ModelClass, WillPaginateResponse)
+  end
+
+  let(:response_document) do
+    { 'took' => '5', 'timed_out' => false, '_shards' => {'one' => 'OK'},
+      'hits' => { 'total' => 100, 'hits' => (1..100).to_a.map { |i| { _id: i } } } }
+  end
+
+  let(:search) do
+    Elasticsearch::Model::Searching::SearchRequest.new(model, '*')
+  end
+
+  let(:response) do
+    allow(model).to receive(:client).and_return(client)
+    WillPaginateResponse.new(model, search, response_document).tap do |resp|
+      allow(resp).to receive(:client).and_return(client)
+    end
+  end
+
+  let(:client) do
+    double('client')
+  end
+
+  shared_examples_for 'a search request that can be paginated' do
+
+    describe '#offset' do
+
+      context 'when per_page and page are set' do
+
+        before do
+          response.per_page(3).page(3)
+        end
+
+        it 'sets the correct offset' do
+          expect(response.offset).to eq(6)
+        end
+      end
+    end
+
+    describe '#length' do
+
+      context 'when per_page and page are set' do
+
+        before do
+          response.per_page(3).page(3)
+        end
+
+        it 'sets the correct offset' do
+          expect(response.length).to eq(3)
+        end
+      end
+    end
+
+    describe '#paginate' do
+
+      context 'when there are no settings' do
+
+        context 'when page is set to nil' do
+
+          before do
+            response.paginate(page: nil)
+          end
+
+          it 'uses the defaults' do
+            expect(response.search.definition[:size]).to eq(default_per_page)
+            expect(response.search.definition[:from]).to eq(0)
+          end
+        end
+
+        context 'when page is set to a value' do
+
+          before do
+            response.paginate(page: 2)
+          end
+
+          it 'uses the defaults' do
+            expect(response.search.definition[:size]).to eq(default_per_page)
+            expect(response.search.definition[:from]).to eq(default_per_page)
+          end
+        end
+
+        context 'when a custom page and per_page is set' do
+
+          before do
+            response.paginate(page: 3, per_page: 9)
+          end
+
+          it 'uses the custom values' do
+            expect(response.search.definition[:size]).to eq(9)
+            expect(response.search.definition[:from]).to eq(18)
+          end
+        end
+
+        context 'fall back to first page if invalid value is provided' do
+
+          before do
+            response.paginate(page: -1)
+          end
+
+          it 'uses the custom values' do
+            expect(response.search.definition[:size]).to eq(default_per_page)
+            expect(response.search.definition[:from]).to eq(0)
+          end
+        end
+      end
+    end
+
+    describe '#page' do
+
+      context 'when a value is provided for page' do
+
+        before do
+          response.page(5)
+        end
+
+        it 'calculates the correct :size and :from' do
+          expect(response.search.definition[:size]).to eq(default_per_page)
+          expect(response.search.definition[:from]).to eq(default_per_page * 4)
+        end
+      end
+
+      context 'when a value is provided for page and per_page' do
+
+        before do
+          response.page(5).per_page(3)
+        end
+
+        it 'calculates the correct :size and :from' do
+          expect(response.search.definition[:size]).to eq(3)
+          expect(response.search.definition[:from]).to eq(12)
+        end
+      end
+
+      context 'when a value is provided for per_page and page' do
+
+        before do
+          response.per_page(3).page(5)
+        end
+
+        it 'calculates the correct :size and :from' do
+          expect(response.search.definition[:size]).to eq(3)
+          expect(response.search.definition[:from]).to eq(12)
+        end
+      end
+    end
+
+    describe '#current_page' do
+
+      context 'when no values are set' do
+
+        before do
+          response.paginate({})
+        end
+
+        it 'returns the first page' do
+          expect(response.current_page).to eq(1)
+        end
+      end
+
+      context 'when values are provided for per_page and page' do
+
+        before do
+          response.paginate(page: 3, per_page: 9)
+        end
+
+        it 'calculates the correct current page' do
+          expect(response.current_page).to eq(3)
+        end
+      end
+
+      context 'when #paginate has not been called on the response' do
+
+        it 'returns nil' do
+          expect(response.current_page).to be_nil
+        end
+      end
+    end
+
+    describe '#per_page' do
+
+      context 'when a value is set via the #paginate method' do
+
+        before do
+          response.paginate(per_page: 8)
+        end
+
+        it 'returns the per_page value' do
+          expect(response.per_page).to eq(8)
+        end
+      end
+
+      context 'when a value is set via the #per_page method' do
+
+        before do
+          response.per_page(8)
+        end
+
+        it 'returns the per_page value' do
+          expect(response.per_page).to eq(8)
+        end
+      end
+    end
+
+    describe '#total_entries' do
+
+      before do
+        allow(response).to receive(:results).and_return(double('results', total: 100))
+      end
+
+      it 'returns the total results' do
+        expect(response.total_entries).to eq(100)
+      end
+    end
+  end
+
+  context 'when the model is a single one' do
+
+    let(:model) do
+      ModelClass
+    end
+
+    let(:default_per_page) do
+      33
+    end
+
+    it_behaves_like 'a search request that can be paginated'
+  end
+
+  context 'when the model is a multimodel' do
+
+    let(:model) do
+      Elasticsearch::Model::Multimodel.new(ModelClass)
+    end
+
+    let(:default_per_page) do
+      ::WillPaginate.per_page
+    end
+
+    it_behaves_like 'a search request that can be paginated'
+  end
+end

data/spec/elasticsearch/model/response/records_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Response::Records do
+
+  before(:all) 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
+  end
+
+  after(:all) do
+    remove_classes(DummyCollection, DummyModel)
+  end
+
+  let(:response_document) do
+    { 'hits' => { 'total' => 123, 'max_score' => 456, 'hits' => [{'_id' => '1', 'foo' => 'bar'}] } }
+  end
+
+  let(:results) do
+    Elasticsearch::Model::Response::Results.new(DummyModel, response_document)
+  end
+
+  let(:search) do
+    Elasticsearch::Model::Searching::SearchRequest.new(DummyModel, '*').tap do |request|
+      allow(request).to receive(:execute!).and_return(response_document)
+    end
+  end
+
+  let(:response) do
+    Elasticsearch::Model::Response::Response.new(DummyModel, search)
+  end
+
+  let(:records) do
+    described_class.new(DummyModel, response)
+  end
+
+  context 'when the records are accessed' do
+
+    it 'returns the records' do
+      expect(records.records.size).to eq(1)
+      expect(records.records.first).to eq('FOO')
+    end
+
+    it 'delegates methods to records' do
+      expect(records.foo).to eq('BAR')
+    end
+  end
+
+  describe '#each_with_hit' do
+
+    it 'returns each record with its Elasticsearch hit' do
+      records.each_with_hit do |record, hit|
+        expect(record).to eq('FOO')
+        expect(hit.foo).to eq('bar')
+      end
+    end
+  end
+
+  describe '#map_with_hit' do
+
+    let(:value) do
+      records.map_with_hit { |record, hit| "#{record}---#{hit.foo}" }
+    end
+
+    it 'returns each record with its Elasticsearch hit' do
+      expect(value).to eq(['FOO---bar'])
+    end
+  end
+
+  describe '#ids' do
+
+    it 'returns the ids' do
+      expect(records.ids).to eq(['1'])
+    end
+  end
+
+  context 'when an adapter is used' do
+
+    before do
+      module DummyAdapter
+        module RecordsMixin
+          def records
+            ['FOOBAR']
+          end
+        end
+
+        def records_mixin
+          RecordsMixin
+        end; module_function :records_mixin
+      end
+
+      allow(Elasticsearch::Model::Adapter).to receive(:from_class).and_return(DummyAdapter)
+    end
+
+    after do
+      Elasticsearch::Model::Adapter::Adapter.adapters.delete(DummyAdapter)
+      Object.send(:remove_const, :DummyAdapter) if defined?(DummyAdapter)
+    end
+
+    it 'delegates the records method to the adapter' do
+      expect(records.records).to eq(['FOOBAR'])
+    end
+  end
+end

data/spec/elasticsearch/model/response/response_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Response::Response do
+
+  before(:all) do
+    class OriginClass
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+    end
+  end
+
+  after(:all) do
+    remove_classes(OriginClass)
+  end
+
+  let(:response_document) do
+    { 'took' => '5', 'timed_out' => false, '_shards' => {'one' => 'OK'}, 'hits' => { 'hits' => [] },
+      'aggregations' => {'foo' => {'bar' => 10}},
+      'suggest' => {'my_suggest' => [ { 'text' => 'foo', 'options' => [ { 'text' => 'Foo', 'score' => 2.0 },
+                                                                        { 'text' => 'Bar', 'score' => 1.0 } ] } ]}}
+
+  end
+
+  let(:search) do
+    Elasticsearch::Model::Searching::SearchRequest.new(OriginClass, '*').tap do |request|
+      allow(request).to receive(:execute!).and_return(response_document)
+    end
+  end
+
+  let(:response) do
+    Elasticsearch::Model::Response::Response.new(OriginClass, search)
+  end
+
+  it 'performs the Elasticsearch request lazily' do
+    expect(search).not_to receive(:execute!)
+    response
+  end
+
+  describe '#klass' do
+
+    it 'returns the class' do
+      expect(response.klass).to be(OriginClass)
+    end
+  end
+
+  describe '#search' do
+
+    it 'returns the search object' do
+      expect(response.search).to eq(search)
+    end
+  end
+
+  describe '#took' do
+
+    it 'returns the took field' do
+      expect(response.took).to eq('5')
+    end
+  end
+
+  describe '#timed_out' do
+
+    it 'returns the timed_out field' do
+      expect(response.timed_out).to eq(false)
+    end
+  end
+
+  describe '#shards' do
+
+    it 'returns a Hashie::Mash' do
+      expect(response.shards.one).to eq('OK')
+    end
+  end
+
+  describe '#response' do
+
+    it 'returns the response document' do
+      expect(response.response).to eq(response_document)
+    end
+  end
+
+  describe '#results' do
+
+    it 'provides access to the results' do
+      expect(response.results).to be_a(Elasticsearch::Model::Response::Results)
+      expect(response.size).to be(0)
+    end
+  end
+
+  describe '#records' do
+
+    it 'provides access to the records' do
+      expect(response.records).to be_a(Elasticsearch::Model::Response::Records)
+      expect(response.size).to be(0)
+    end
+  end
+
+  describe 'enumerable methods' do
+
+    it 'delegates the methods to the results' do
+      expect(response.empty?).to be(true)
+    end
+  end
+
+  describe 'aggregations' do
+
+    it 'provides access to the aggregations' do
+      expect(response.aggregations).to be_a(Hashie::Mash)
+      expect(response.aggregations.foo.bar).to eq(10)
+    end
+  end
+
+  describe 'suggestions' do
+
+    it 'provides access to the suggestions' do
+      expect(response.suggestions).to be_a(Hashie::Mash)
+      expect(response.suggestions.my_suggest.first.options.first.text).to eq('Foo')
+      expect(response.suggestions.terms).to eq([ 'Foo', 'Bar' ])
+    end
+
+    context 'when there are no suggestions' do
+
+      let(:response_document) do
+        { }
+      end
+
+      it 'returns an empty list' do
+        expect(response.suggestions.terms).to eq([ ])
+      end
+    end
+  end
+end

data/spec/elasticsearch/model/response/result_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+require 'active_support/json/encoding'
+
+describe Elasticsearch::Model::Response::Result do
+
+  let(:result) do
+    described_class.new(foo: 'bar', bar: { bam: 'baz' })
+  end
+
+  it 'provides access to the properties' do
+    expect(result.foo).to eq('bar')
+    expect(result.bar.bam).to eq('baz')
+    expect { result.xoxo }.to raise_exception(NoMethodError)
+  end
+
+  describe '#id' do
+
+    let(:result) do
+      described_class.new(foo: 'bar', _id: 42, _source: { id: 12 })
+    end
+
+    it 'returns the _id field' do
+      expect(result.id).to eq(42)
+    end
+
+    it 'provides access to the source id field' do
+      expect(result._source.id).to eq(12)
+    end
+  end
+
+  describe '#type' do
+
+    let(:result) do
+      described_class.new(foo: 'bar', _type: 'baz', _source: { type: 'BAM' })
+    end
+
+    it 'returns the _type field' do
+      expect(result.type).to eq('baz')
+    end
+
+    it 'provides access to the source type field' do
+      expect(result._source.type).to eq('BAM')
+    end
+  end
+
+  describe 'method delegation' do
+
+    let(:result) do
+      described_class.new(foo: 'bar', _source: { bar: { bam: 'baz' } })
+    end
+
+    it 'provides access to the _source field via a method' do
+      expect(result._source).to eq('bar' => { 'bam' => 'baz' })
+    end
+
+    it 'is recognized by #method' do
+      expect(result.method :bar).to be_a Method
+    end
+
+    it 'respond_to? still works' do
+      expect(result.respond_to? :bar).to be true
+    end
+
+    context 'when methods map to keys in subdocuments of the response from Elasticsearch' do
+
+      it 'provides access to top level fields via a method' do
+        expect(result.foo).to eq('bar')
+        expect(result.fetch(:foo)).to eq('bar')
+        expect(result.fetch(:does_not_exist, 'moo')).to eq('moo')
+      end
+
+      it 'responds to hash methods' do
+        expect(result.keys).to eq(['foo', '_source'])
+        expect(result.to_hash).to eq('foo' => 'bar', '_source' => { 'bar' => { 'bam' => 'baz' } })
+      end
+
+      it 'provides access to fields in the _source subdocument via a method' do
+        expect(result.bar).to eq('bam' => 'baz')
+        expect(result.bar.bam).to eq('baz')
+        expect(result._source.bar).to eq('bam' => 'baz')
+        expect(result._source.bar.bam).to eq('baz')
+      end
+
+      context 'when boolean methods are called' do
+
+        it 'provides access to top level fields via a method' do
+          expect(result.foo?).to eq(true)
+          expect(result.boo?).to eq(false)
+        end
+
+        it 'delegates to fields in the _source subdocument via a method' do
+          expect(result.bar?).to eq(true)
+          expect(result.bar.bam?).to eq(true)
+          expect(result.boo?).to eq(false)
+          expect(result.bar.boo?).to eq(false)
+          expect(result._source.bar?).to eq(true)
+          expect(result._source.bar.bam?).to eq(true)
+          expect(result._source.boo?).to eq(false)
+          expect(result._source.bar.boo?).to eq(false)
+        end
+      end
+    end
+
+    context 'when methods do not map to keys in subdocuments of the response from Elasticsearch' do
+
+      it 'raises a NoMethodError' do
+        expect { result.does_not_exist }.to raise_exception(NoMethodError)
+      end
+    end
+  end
+
+  describe '#as_json' do
+
+    let(:result) do
+      described_class.new(foo: 'bar', _source: { bar: { bam: 'baz' } })
+    end
+
+    it 'returns a json string' do
+      expect(result.as_json(except: 'foo')).to eq({'_source'=>{'bar'=>{'bam'=>'baz'}}})
+    end
+  end
+end

data/spec/elasticsearch/model/response/results_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Response::Results do
+
+  before(:all) do
+    class OriginClass
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+    end
+  end
+
+  after(:all) do
+    remove_classes(OriginClass)
+  end
+
+  let(:response_document) do
+    { 'hits' => { 'total' => 123, 'max_score' => 456, 'hits' => [{'foo' => 'bar'}] } }
+  end
+
+  let(:search) do
+    Elasticsearch::Model::Searching::SearchRequest.new(OriginClass, '*').tap do |request|
+      allow(request).to receive(:execute!).and_return(response_document)
+    end
+  end
+
+  let(:response) do
+    Elasticsearch::Model::Response::Response.new(OriginClass, search)
+  end
+
+  let(:results) do
+    response.results
+  end
+
+  describe '#results' do
+
+    it 'provides access to the results' do
+      expect(results.results.size).to be(1)
+      expect(results.results.first.foo).to eq('bar')
+    end
+  end
+
+  describe 'Enumerable' do
+
+    it 'deletebates enumerable methods to the results' do
+      expect(results.empty?).to be(false)
+      expect(results.first.foo).to eq('bar')
+    end
+  end
+
+  describe '#raw_response' do
+
+    it 'returns the raw response document' do
+      expect(response.raw_response).to eq(response_document)
+    end
+  end
+end