elasticsearch-model 5.1.0 → 6.1.0

data/spec/elasticsearch/model/adapters/active_record/import_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe 'Elasticsearch::Model::Adapter::ActiveRecord Importing' do
+
+  before(:all) do
+    ActiveRecord::Schema.define(:version => 1) do
+      create_table :import_articles do |t|
+        t.string   :title
+        t.integer  :views
+        t.string   :numeric # For the sake of invalid data sent to Elasticsearch
+        t.datetime :created_at, :default => 'NOW()'
+      end
+    end
+
+    ImportArticle.delete_all
+    ImportArticle.__elasticsearch__.client.cluster.health(wait_for_status: 'yellow')
+  end
+
+  before do
+    ImportArticle.__elasticsearch__.create_index!
+  end
+
+  after do
+    clear_indices(ImportArticle)
+    clear_tables(ImportArticle)
+  end
+
+  describe '#import' do
+
+    context 'when no search criteria is specified' do
+
+      before do
+        10.times { |i| ImportArticle.create! title: 'Test', views: "#{i}" }
+        ImportArticle.import
+        ImportArticle.__elasticsearch__.refresh_index!
+      end
+
+      it 'imports all documents' do
+        expect(ImportArticle.search('*').results.total).to eq(10)
+      end
+    end
+
+    context 'when batch size is specified' do
+
+      before do
+        10.times { |i| ImportArticle.create! title: 'Test', views: "#{i}" }
+      end
+
+      let!(:batch_count) do
+        batches = 0
+        errors  = ImportArticle.import(batch_size: 5) do |response|
+          batches += 1
+        end
+        ImportArticle.__elasticsearch__.refresh_index!
+        batches
+      end
+
+      it 'imports using the batch size' do
+        expect(batch_count).to eq(2)
+      end
+
+      it 'imports all the documents' do
+        expect(ImportArticle.search('*').results.total).to eq(10)
+      end
+    end
+
+    context 'when a scope is specified' do
+
+      before do
+        10.times { |i| ImportArticle.create! title: 'Test', views: "#{i}" }
+        ImportArticle.import(scope: 'popular', force: true)
+        ImportArticle.__elasticsearch__.refresh_index!
+      end
+
+      it 'applies the scope' do
+        expect(ImportArticle.search('*').results.total).to eq(5)
+      end
+    end
+
+    context 'when a query is specified' do
+
+      before do
+        10.times { |i| ImportArticle.create! title: 'Test', views: "#{i}" }
+        ImportArticle.import(query: -> { where('views >= 3') })
+        ImportArticle.__elasticsearch__.refresh_index!
+      end
+
+      it 'applies the query' do
+        expect(ImportArticle.search('*').results.total).to eq(7)
+      end
+    end
+
+    context 'when there are invalid documents' do
+
+      let!(:result) do
+        10.times { |i| ImportArticle.create! title: 'Test', views: "#{i}" }
+        new_article
+        batches = 0
+        errors  = ImportArticle.__elasticsearch__.import(batch_size: 5) do |response|
+          batches += 1
+        end
+        ImportArticle.__elasticsearch__.refresh_index!
+        { batch_size: batches, errors: errors}
+      end
+
+      let(:new_article) do
+        ImportArticle.create!(title: "Test INVALID", numeric: "INVALID")
+      end
+
+      it 'does not import them' do
+        expect(ImportArticle.search('*').results.total).to eq(10)
+        expect(result[:batch_size]).to eq(3)
+        expect(result[:errors]).to eq(1)
+      end
+    end
+
+    context 'when a transform proc is specified' do
+
+      before do
+        10.times { |i| ImportArticle.create! title: 'Test', views: "#{i}" }
+        ImportArticle.import( transform: ->(a) {{ index: { data: { name: a.title, foo: 'BAR' } }}} )
+        ImportArticle.__elasticsearch__.refresh_index!
+      end
+
+      it 'transforms the documents' do
+        expect(ImportArticle.search('*').results.first._source.keys).to include('name')
+        expect(ImportArticle.search('*').results.first._source.keys).to include('foo')
+      end
+
+      it 'imports all documents' do
+        expect(ImportArticle.search('test').results.total).to eq(10)
+        expect(ImportArticle.search('bar').results.total).to eq(10)
+      end
+    end
+
+    context 'when the model has a default scope' do
+
+      around(:all) do |example|
+        10.times { |i| ImportArticle.create! title: 'Test', views: "#{i}" }
+        ImportArticle.instance_eval { default_scope { where('views > 3') } }
+        example.run
+        ImportArticle.default_scopes.pop
+      end
+
+      before do
+        ImportArticle.__elasticsearch__.import
+        ImportArticle.__elasticsearch__.refresh_index!
+      end
+
+      it 'uses the default scope' do
+        expect(ImportArticle.search('*').results.total).to eq(6)
+      end
+    end
+
+    context 'when there is a default scope and a query specified' do
+
+      around(:all) do |example|
+        10.times { |i| ImportArticle.create! title: 'Test', views: "#{i}" }
+        ImportArticle.instance_eval { default_scope { where('views > 3') } }
+        example.run
+        ImportArticle.default_scopes.pop
+      end
+
+      before do
+        ImportArticle.import(query: -> { where('views <= 4') })
+        ImportArticle.__elasticsearch__.refresh_index!
+      end
+
+      it 'combines the query and the default scope' do
+        expect(ImportArticle.search('*').results.total).to eq(1)
+      end
+    end
+
+    context 'when the batch is empty' do
+
+      before do
+        ImportArticle.delete_all
+        ImportArticle.import
+        ImportArticle.__elasticsearch__.refresh_index!
+      end
+
+      it 'does not make any requests to create documents' do
+        expect(ImportArticle.search('*').results.total).to eq(0)
+      end
+    end
+  end
+end

data/spec/elasticsearch/model/adapters/active_record/multi_model_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe 'Elasticsearch::Model::Adapter::ActiveRecord MultiModel' do
+
+  before(:all) do
+    ActiveRecord::Schema.define do
+      create_table Episode.table_name do |t|
+        t.string :name
+        t.datetime :created_at, :default => 'NOW()'
+      end
+
+      create_table Series.table_name do |t|
+        t.string :name
+        t.datetime :created_at, :default => 'NOW()'
+      end
+    end
+  end
+
+  before do
+    models = [ Episode, Series ]
+    clear_tables(models)
+    models.each do |model|
+      model.__elasticsearch__.create_index! force: true
+      model.create name: "The #{model.name}"
+      model.create name: "A great #{model.name}"
+      model.create name: "The greatest #{model.name}"
+      model.__elasticsearch__.refresh_index!
+    end
+  end
+
+  after do
+    clear_indices(Episode, Series)
+    clear_tables(Episode, Series)
+  end
+
+  context 'when the search is across multimodels' do
+
+    let(:search_result) do
+      Elasticsearch::Model.search(%q<"The greatest Episode"^2 OR "The greatest Series">, [Series, Episode])
+    end
+
+    it 'executes the search across models' do
+      expect(search_result.results.size).to eq(2)
+      expect(search_result.records.size).to eq(2)
+    end
+
+    describe '#results' do
+
+      it 'returns an instance of Elasticsearch::Model::Response::Result' do
+        expect(search_result.results[0]).to be_a(Elasticsearch::Model::Response::Result)
+        expect(search_result.results[1]).to be_a(Elasticsearch::Model::Response::Result)
+      end
+
+      it 'returns the correct model instance' do
+        expect(search_result.results[0].name).to eq('The greatest Episode')
+        expect(search_result.results[1].name).to eq('The greatest Series')
+      end
+
+      it 'provides access to the results' do
+        expect(search_result.results[0].name).to eq('The greatest Episode')
+        expect(search_result.results[0].name?).to be(true)
+        expect(search_result.results[0].boo?).to be(false)
+
+        expect(search_result.results[1].name).to eq('The greatest Series')
+        expect(search_result.results[1].name?).to be(true)
+        expect(search_result.results[1].boo?).to be(false)
+      end
+    end
+
+    describe '#records' do
+
+      it 'returns an instance of Elasticsearch::Model::Response::Result' do
+        expect(search_result.records[0]).to be_a(Episode)
+        expect(search_result.records[1]).to be_a(Series)
+      end
+
+      it 'returns the correct model instance' do
+        expect(search_result.records[0].name).to eq('The greatest Episode')
+        expect(search_result.records[1].name).to eq('The greatest Series')
+      end
+
+      context 'when the data store is changed' do
+
+        before do
+          Series.find_by_name("The greatest Series").delete
+          Series.__elasticsearch__.refresh_index!
+        end
+
+        it 'only returns matching records' do
+          expect(search_result.results.size).to eq(2)
+          expect(search_result.records.size).to eq(1  )
+          expect(search_result.records[0].name).to eq('The greatest Episode')
+        end
+      end
+    end
+
+    describe 'pagination' do
+
+      let(:search_result) do
+        Elasticsearch::Model.search('series OR episode', [Series, Episode])
+      end
+
+      it 'properly paginates the results' do
+        expect(search_result.page(1).per(3).results.size).to eq(3)
+        expect(search_result.page(2).per(3).results.size).to eq(3)
+        expect(search_result.page(3).per(3).results.size).to eq(0)
+      end
+    end
+  end
+end

data/spec/elasticsearch/model/adapters/active_record/namespaced_model_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe 'Elasticsearch::Model::Adapter::ActiveRecord Namespaced Model' do
+
+  before(:all) do
+    ActiveRecord::Schema.define(:version => 1) do
+      create_table :books do |t|
+        t.string   :title
+      end
+    end
+
+    MyNamespace::Book.delete_all
+    MyNamespace::Book.__elasticsearch__.create_index!(force: true)
+    MyNamespace::Book.create!(title: 'Test')
+    MyNamespace::Book.__elasticsearch__.refresh_index!
+  end
+
+  after do
+    clear_indices(MyNamespace::Book)
+    clear_tables(MyNamespace::Book)
+  end
+
+  context 'when the model is namespaced' do
+
+    it 'has the proper index name' do
+      expect(MyNamespace::Book.index_name).to eq('my_namespace-books')
+    end
+
+    it 'has the proper document type' do
+      expect(MyNamespace::Book.document_type).to eq('book')
+    end
+
+    it 'saves the document into the index' do
+      expect(MyNamespace::Book.search('title:test').results.size).to eq(1)
+      expect(MyNamespace::Book.search('title:test').results.first.title).to eq('Test')
+    end
+  end
+end

data/spec/elasticsearch/model/adapters/active_record/pagination_spec.rb

@@ -0,0 +1,315 @@
+require 'spec_helper'
+
+describe 'Elasticsearch::Model::Adapter::ActiveRecord Pagination' do
+
+  before(:all) do
+    ActiveRecord::Schema.define(:version => 1) do
+      create_table ArticleForPagination.table_name do |t|
+        t.string   :title
+        t.datetime :created_at, :default => 'NOW()'
+        t.boolean  :published
+      end
+    end
+
+    Kaminari::Hooks.init if defined?(Kaminari::Hooks)
+
+    ArticleForPagination.__elasticsearch__.create_index! force: true
+
+    68.times do |i|
+      ArticleForPagination.create! title: "Test #{i}", published: (i % 2 == 0)
+    end
+
+    ArticleForPagination.import
+    ArticleForPagination.__elasticsearch__.refresh_index!
+  end
+
+  context 'when no other page is specified' do
+
+    let(:records) do
+      ArticleForPagination.search('title:test').page(1).records
+    end
+
+    describe '#size' do
+
+      it 'returns the correct size' do
+        expect(records.size).to eq(25)
+      end
+    end
+
+    describe '#current_page' do
+
+      it 'returns the correct current page' do
+        expect(records.current_page).to eq(1)
+      end
+    end
+
+    describe '#prev_page' do
+
+      it 'returns the correct previous page' do
+        expect(records.prev_page).to be_nil
+      end
+    end
+
+    describe '#next_page' do
+
+      it 'returns the correct next page' do
+        expect(records.next_page).to eq(2)
+      end
+    end
+
+    describe '#total_pages' do
+
+      it 'returns the correct total pages' do
+        expect(records.total_pages).to eq(3)
+      end
+    end
+
+    describe '#first_page?' do
+
+      it 'returns the correct first page' do
+        expect(records.first_page?).to be(true)
+      end
+    end
+
+    describe '#last_page?' do
+
+      it 'returns the correct last page' do
+        expect(records.last_page?).to be(false)
+      end
+    end
+
+    describe '#out_of_range?' do
+
+      it 'returns whether the pagination is out of range' do
+        expect(records.out_of_range?).to be(false)
+      end
+    end
+  end
+
+  context 'when a specific page is specified' do
+
+    let(:records) do
+      ArticleForPagination.search('title:test').page(2).records
+    end
+
+    describe '#size' do
+
+      it 'returns the correct size' do
+        expect(records.size).to eq(25)
+      end
+    end
+
+    describe '#current_page' do
+
+      it 'returns the correct current page' do
+        expect(records.current_page).to eq(2)
+      end
+    end
+
+    describe '#prev_page' do
+
+      it 'returns the correct previous page' do
+        expect(records.prev_page).to eq(1)
+      end
+    end
+
+    describe '#next_page' do
+
+      it 'returns the correct next page' do
+        expect(records.next_page).to eq(3)
+      end
+    end
+
+    describe '#total_pages' do
+
+      it 'returns the correct total pages' do
+        expect(records.total_pages).to eq(3)
+      end
+    end
+
+    describe '#first_page?' do
+
+      it 'returns the correct first page' do
+        expect(records.first_page?).to be(false)
+      end
+    end
+
+    describe '#last_page?' do
+
+      it 'returns the correct last page' do
+        expect(records.last_page?).to be(false)
+      end
+    end
+
+    describe '#out_of_range?' do
+
+      it 'returns whether the pagination is out of range' do
+        expect(records.out_of_range?).to be(false)
+      end
+    end
+  end
+
+  context 'when a the last page is specified' do
+
+    let(:records) do
+      ArticleForPagination.search('title:test').page(3).records
+    end
+
+    describe '#size' do
+
+      it 'returns the correct size' do
+        expect(records.size).to eq(18)
+      end
+    end
+
+    describe '#current_page' do
+
+      it 'returns the correct current page' do
+        expect(records.current_page).to eq(3)
+      end
+    end
+
+    describe '#prev_page' do
+
+      it 'returns the correct previous page' do
+        expect(records.prev_page).to eq(2)
+      end
+    end
+
+    describe '#next_page' do
+
+      it 'returns the correct next page' do
+        expect(records.next_page).to be_nil
+      end
+    end
+
+    describe '#total_pages' do
+
+      it 'returns the correct total pages' do
+        expect(records.total_pages).to eq(3)
+      end
+    end
+
+    describe '#first_page?' do
+
+      it 'returns the correct first page' do
+        expect(records.first_page?).to be(false)
+      end
+    end
+
+    describe '#last_page?' do
+
+      it 'returns the correct last page' do
+        expect(records.last_page?).to be(true)
+      end
+    end
+
+    describe '#out_of_range?' do
+
+      it 'returns whether the pagination is out of range' do
+        expect(records.out_of_range?).to be(false)
+      end
+    end
+  end
+
+  context 'when an invalid page is specified' do
+
+    let(:records) do
+      ArticleForPagination.search('title:test').page(6).records
+    end
+
+    describe '#size' do
+
+      it 'returns the correct size' do
+        expect(records.size).to eq(0)
+      end
+    end
+
+    describe '#current_page' do
+
+      it 'returns the correct current page' do
+        expect(records.current_page).to eq(6)
+      end
+    end
+
+    describe '#next_page' do
+
+      it 'returns the correct next page' do
+        expect(records.next_page).to be_nil
+      end
+    end
+
+    describe '#total_pages' do
+
+      it 'returns the correct total pages' do
+        expect(records.total_pages).to eq(3)
+      end
+    end
+
+    describe '#first_page?' do
+
+      it 'returns the correct first page' do
+        expect(records.first_page?).to be(false)
+      end
+    end
+
+    describe '#last_page?' do
+
+      it 'returns whether it is the last page', if: !(Kaminari::VERSION < '1') do
+        expect(records.last_page?).to be(false)
+      end
+
+      it 'returns whether it is the last page', if: Kaminari::VERSION < '1' do
+        expect(records.last_page?).to be(true) # Kaminari returns current_page >= total_pages in version < 1.0
+      end
+    end
+
+    describe '#out_of_range?' do
+
+      it 'returns whether the pagination is out of range' do
+        expect(records.out_of_range?).to be(true)
+      end
+    end
+  end
+
+  context 'when a scope is also specified' do
+
+    let(:records) do
+      ArticleForPagination.search('title:test').page(2).records.published
+    end
+
+    describe '#size' do
+
+      it 'returns the correct size' do
+        expect(records.size).to eq(12)
+      end
+    end
+  end
+
+  context 'when a sorting is specified' do
+
+    let(:search) do
+      ArticleForPagination.search({ query: { match: { title: 'test' } }, sort: [ { id: 'desc' } ] })
+    end
+
+    it 'applies the sort' do
+      expect(search.page(2).records.first.id).to eq(43)
+      expect(search.page(3).records.first.id).to eq(18)
+      expect(search.page(2).per(5).records.first.id).to eq(63)
+    end
+  end
+
+  context 'when the model has a specific default per page set' do
+
+    around do |example|
+      original_default = ArticleForPagination.instance_variable_get(:@_default_per_page)
+      ArticleForPagination.paginates_per 50
+      example.run
+      ArticleForPagination.paginates_per original_default
+    end
+
+    it 'uses the default per page setting' do
+      expect(ArticleForPagination.search('*').page(1).records.size).to eq(50)
+    end
+  end
+end