elasticsearch-persistence 5.0.2 → 6.1.1

data/lib/elasticsearch/persistence/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Persistence
-    VERSION = "5.0.2"
+    VERSION = '6.1.1'
   end
 end

data/spec/repository/find_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe Elasticsearch::Persistence::Repository::Find do
+
+  after do
+    begin; repository.delete_index!; rescue; end
+  end
+
+  let(:repository) do
+    DEFAULT_REPOSITORY
+  end
+
+  describe '#exists?' do
+
+    context 'when the document exists' do
+
+      let(:id) do
+        repository.save(a: 1)['_id']
+      end
+
+      it 'returns true' do
+        expect(repository.exists?(id)).to be(true)
+      end
+    end
+
+    context 'when the document does not exist' do
+
+      it 'returns false' do
+        expect(repository.exists?('1')).to be(false)
+      end
+    end
+
+    context 'when options are provided' do
+
+      let(:id) do
+        repository.save(a: 1)['_id']
+      end
+
+      it 'applies the options' do
+        expect(repository.exists?(id, type: 'other_type')).to be(false)
+      end
+    end
+  end
+
+  describe '#find' do
+
+    context 'when options are not provided' do
+
+      context 'when a single id is provided' do
+
+        let!(:id) do
+          repository.save(a: 1)['_id']
+        end
+
+        it 'retrieves the document' do
+          expect(repository.find(id)).to eq('a' => 1)
+        end
+      end
+
+      context 'when an array of ids is provided' do
+
+        let!(:ids) do
+          3.times.collect do |i|
+            repository.save(a: i)['_id']
+          end
+        end
+
+        it 'retrieves the documents' do
+          expect(repository.find(ids)).to eq([{ 'a' =>0 },
+                                              { 'a' => 1 },
+                                              { 'a' => 2 }])
+        end
+
+        context 'when some documents are found and some are not' do
+
+          before do
+            ids[1] = 22
+            ids
+          end
+
+          it 'returns nil in the result list for the documents not found' do
+            expect(repository.find(ids)).to eq([{ 'a' =>0 },
+                                                 nil,
+                                                 { 'a' => 2 }])
+          end
+        end
+      end
+
+      context 'when multiple ids are provided' do
+
+        let!(:ids) do
+          3.times.collect do |i|
+            repository.save(a: i)['_id']
+          end
+        end
+
+        it 'retrieves the documents' do
+          expect(repository.find(*ids)).to eq([{ 'a' =>0 },
+                                              { 'a' => 1 },
+                                              { 'a' => 2 }])
+        end
+      end
+
+      context 'when the document cannot be found' do
+
+        before do
+          begin; repository.create_index!; rescue; end
+        end
+
+        it 'raises a DocumentNotFound exception' do
+          expect {
+            repository.find(1)
+          }.to raise_exception(Elasticsearch::Persistence::Repository::DocumentNotFound)
+        end
+      end
+    end
+
+    context 'when options are provided' do
+
+      context 'when a single id is passed' do
+
+        let!(:id) do
+          repository.save(a: 1)['_id']
+        end
+
+        it 'applies the options' do
+          expect {
+            repository.find(id, type: 'none')
+          }.to raise_exception(Elasticsearch::Persistence::Repository::DocumentNotFound)
+        end
+      end
+
+      context 'when an array of ids is passed' do
+
+        let!(:ids) do
+          3.times.collect do |i|
+            repository.save(a: i)['_id']
+          end
+        end
+
+        it 'applies the options' do
+          expect(repository.find(ids, type: 'none')).to eq([nil, nil, nil])
+        end
+      end
+
+      context 'when multiple ids are passed' do
+
+        let!(:ids) do
+          3.times.collect do |i|
+            repository.save(a: i)['_id']
+          end
+        end
+
+        it 'applies the options' do
+          expect(repository.find(*ids, type: 'none')).to eq([nil, nil, nil])
+        end
+      end
+    end
+
+    context 'when a document_type is defined on the class' do
+
+      let(:repository) do
+        MyTestRepository.new(document_type:'other_type', client: DEFAULT_CLIENT, index_name: 'test')
+      end
+
+      let!(:ids) do
+        3.times.collect do |i|
+          repository.save(a: i)['_id']
+        end
+      end
+
+      it 'uses the document type in the query' do
+        expect(repository.find(ids)).to eq([{ 'a' =>0 },
+                                            { 'a' => 1 },
+                                            { 'a' => 2 }])
+      end
+    end
+  end
+end

data/spec/repository/response/results_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Elasticsearch::Persistence::Repository::Response::Results do
+
+  before(:all) do
+    class MyRepository
+      include Elasticsearch::Persistence::Repository
+
+      def deserialize(document)
+        'Object'
+      end
+    end
+  end
+
+  let(:repository) do
+    MyRepository.new
+  end
+
+  after(:all) do
+    if defined?(MyRepository)
+      Object.send(:remove_const, MyRepository.name)
+    end
+  end
+
+  let(:response) do
+    { "took" => 2,
+      "timed_out" => false,
+      "_shards" => {"total" => 5, "successful" => 5, "failed" => 0},
+      "hits" =>
+               { "total" => 2,
+                 "max_score" => 0.19,
+                 "hits" =>
+                           [{"_index" => "my_index",
+                             "_type" => "note",
+                             "_id" => "1",
+                             "_score" => 0.19,
+                             "_source" => {"id" => 1, "title" => "Test 1"}},
+
+                            {"_index" => "my_index",
+                             "_type" => "note",
+                             "_id" => "2",
+                             "_score" => 0.19,
+                             "_source" => {"id" => 2, "title" => "Test 2"}}
+                            ]
+               }
+    }
+  end
+
+  let(:results) do
+    described_class.new(repository, response)
+  end
+
+  describe '#repository' do
+
+    it 'should return the repository' do
+      expect(results.repository).to be(repository)
+    end
+  end
+
+  describe '#response' do
+
+    it 'returns the response' do
+      expect(results.response).to eq(response)
+    end
+
+    it 'wraps the response in a HashWrapper' do
+      expect(results.response._shards.total).to eq(5)
+    end
+
+    context 'when the response method is not called' do
+
+      it 'does not create an instance of HashWrapper' do
+        expect(Elasticsearch::Model::HashWrapper).not_to receive(:new)
+        results
+      end
+    end
+
+    context 'when the response method is called' do
+
+      it 'does create an instance of HashWrapper' do
+        expect(Elasticsearch::Model::HashWrapper).to receive(:new)
+        results.response
+      end
+    end
+  end
+
+  describe '#total' do
+
+    it 'returns the total' do
+      expect(results.total).to eq(2)
+    end
+  end
+
+  describe '#max_score' do
+
+    it 'returns the max score' do
+      expect(results.max_score).to eq(0.19)
+    end
+  end
+
+  describe '#each' do
+
+    it 'delegates the method to the results' do
+      expect(results.size).to eq(2)
+    end
+  end
+
+  describe '#each_with_hit' do
+
+    it 'returns each deserialized object with the raw document' do
+      expect(results.each_with_hit { |pair| pair[0] = 'Obj'}).to eq(['Obj', 'Obj'].zip(response['hits']['hits']))
+    end
+  end
+
+  describe '#map_with_hit' do
+
+    it 'returns the result of the block called on a pair of each raw document and the deserialized object' do
+      expect(results.map_with_hit { |pair| pair[0] }).to eq(['Object', 'Object'])
+    end
+  end
+
+  describe '#raw_response' do
+
+    it 'returns the raw response from Elasticsearch' do
+      expect(results.raw_response).to eq(response)
+    end
+  end
+end

data/spec/repository/search_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+describe Elasticsearch::Persistence::Repository::Search do
+
+  after do
+    begin; repository.delete_index!; rescue; end
+  end
+
+  describe '#search' do
+
+    let(:repository) do
+      DEFAULT_REPOSITORY
+    end
+
+    context 'when the repository does not have a type set' do
+
+      before do
+        repository.save({ name: 'user' }, refresh: true)
+      end
+
+      context 'when a query definition is provided as a hash' do
+
+        it 'uses the default document type' do
+          expect(repository.search({ query: { match: { name: 'user' } } }).first).to eq('name' => 'user')
+        end
+      end
+
+      context 'when a query definition is provided as a string' do
+
+        it 'uses the default document type' do
+          expect(repository.search('user').first).to eq('name' => 'user')
+        end
+      end
+
+      context 'when the query definition is neither a String nor a Hash' do
+
+        it 'raises an ArgumentError' do
+          expect {
+            repository.search(1)
+          }.to raise_exception(ArgumentError)
+        end
+      end
+
+      context 'when options are provided' do
+
+        context 'when a query definition is provided as a hash' do
+
+          it 'uses the default document type' do
+            expect(repository.search({ query: { match: { name: 'user' } } }, type: 'other').first).to be_nil
+          end
+        end
+
+        context 'when a query definition is provided as a string' do
+
+          it 'uses the default document type' do
+            expect(repository.search('user', type: 'other').first).to be_nil
+          end
+        end
+
+        context 'when the query definition is neither a String nor a Hash' do
+
+          it 'raises an ArgumentError' do
+            expect {
+              repository.search(1)
+            }.to raise_exception(ArgumentError)
+          end
+        end
+      end
+    end
+
+    context 'when the repository does have a type set' do
+
+      let(:repository) do
+        MyTestRepository.new(document_type: 'other_note')
+      end
+
+      before do
+        repository.save({ name: 'user' }, refresh: true)
+      end
+
+      context 'when options are provided' do
+
+        context 'when a query definition is provided as a hash' do
+
+          it 'uses the options' do
+            expect(repository.search({ query: { match: { name: 'user' } } }, type: 'other').first).to be_nil
+          end
+        end
+
+        context 'when a query definition is provided as a string' do
+
+          it 'uses the options' do
+            expect(repository.search('user', type: 'other').first).to be_nil
+          end
+        end
+
+        context 'when the query definition is neither a String nor a Hash' do
+
+          it 'raises an ArgumentError' do
+            expect {
+              repository.search(1)
+            }.to raise_exception(ArgumentError)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#count' do
+
+    context 'when the repository does not have a type set' do
+
+      let(:repository) do
+        DEFAULT_REPOSITORY
+      end
+
+      before do
+        repository.save({ name: 'user' }, refresh: true)
+      end
+
+      context 'when a query definition is provided as a hash' do
+
+        it 'uses the default document type' do
+          expect(repository.count({ query: { match: { name: 'user' } } })).to eq(1)
+        end
+      end
+
+      context 'when a query definition is provided as a string' do
+
+        it 'uses the default document type' do
+          expect(repository.count('user')).to eq(1)
+        end
+      end
+
+      context 'when options are provided' do
+
+        context 'when a query definition is provided as a hash' do
+
+          it 'uses the options' do
+            expect(repository.count({ query: { match: { name: 'user' } } }, type: 'other')).to eq(0)
+          end
+        end
+
+        context 'when a query definition is provided as a string' do
+
+          it 'uses the options' do
+            expect(repository.count('user', type: 'other')).to eq(0)
+          end
+        end
+      end
+    end
+
+    context 'when the repository does have a type set' do
+
+      let(:repository) do
+        MyTestRepository.new(document_type: 'other_note')
+      end
+
+      before do
+        repository.save({ name: 'user' }, refresh: true)
+      end
+
+      context 'when options are provided' do
+
+        context 'when a query definition is provided as a hash' do
+
+          it 'uses the options' do
+            expect(repository.count({ query: { match: { name: 'user' } } }, type: 'other')).to eq(0)
+          end
+        end
+
+        context 'when a query definition is provided as a string' do
+
+          it 'uses the options' do
+            expect(repository.count('user', type: 'other')).to eq(0)
+          end
+        end
+      end
+    end
+  end
+end