elasticsearch-model 0.1.9 → 7.1.1

data/test/integration/active_record_import_test.rb

@@ -1,109 +0,0 @@
-require 'test_helper'
-require 'active_record'
-
-module Elasticsearch
-  module Model
-    class ActiveRecordImportIntegrationTest < Elasticsearch::Test::IntegrationTestCase
-      context "ActiveRecord importing" do
-        setup 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
-
-          class ::ImportArticle < ActiveRecord::Base
-            include Elasticsearch::Model
-
-            scope :popular, -> { where('views >= 50') }
-
-            mapping do
-              indexes :title,      type: 'string'
-              indexes :views,      type: 'integer'
-              indexes :numeric,    type: 'integer'
-              indexes :created_at, type: 'date'
-            end
-          end
-
-          ImportArticle.delete_all
-          ImportArticle.__elasticsearch__.create_index! force: true
-          ImportArticle.__elasticsearch__.client.cluster.health wait_for_status: 'yellow'
-
-          100.times { |i| ImportArticle.create! title: "Test #{i}", views: i }
-        end
-
-        should "import all the documents" do
-          assert_equal 100, ImportArticle.count
-
-          ImportArticle.__elasticsearch__.refresh_index!
-          assert_equal 0, ImportArticle.search('*').results.total
-
-          batches = 0
-          errors  = ImportArticle.import(batch_size: 10) do |response|
-            batches += 1
-          end
-
-          assert_equal 0, errors
-          assert_equal 10, batches
-
-          ImportArticle.__elasticsearch__.refresh_index!
-          assert_equal 100, ImportArticle.search('*').results.total
-        end
-
-        should "import only documents from a specific scope" do
-          assert_equal 100, ImportArticle.count
-
-          assert_equal 0, ImportArticle.import(scope: 'popular')
-
-          ImportArticle.__elasticsearch__.refresh_index!
-          assert_equal 50, ImportArticle.search('*').results.total
-        end
-
-        should "import only documents from a specific query" do
-          assert_equal 100, ImportArticle.count
-
-          assert_equal 0, ImportArticle.import(query: -> { where('views >= 30') })
-
-          ImportArticle.__elasticsearch__.refresh_index!
-          assert_equal 70, ImportArticle.search('*').results.total
-        end
-
-        should "report and not store/index invalid documents" do
-          ImportArticle.create! title: "Test INVALID", numeric: "INVALID"
-
-          assert_equal 101, ImportArticle.count
-
-          ImportArticle.__elasticsearch__.refresh_index!
-          assert_equal 0, ImportArticle.search('*').results.total
-
-          batches = 0
-          errors  = ImportArticle.__elasticsearch__.import(batch_size: 10) do |response|
-            batches += 1
-          end
-
-          assert_equal 1, errors
-          assert_equal 11, batches
-
-          ImportArticle.__elasticsearch__.refresh_index!
-          assert_equal 100, ImportArticle.search('*').results.total
-        end
-
-        should "transform documents with the option" do
-          assert_equal 100, ImportArticle.count
-
-          assert_equal 0, ImportArticle.import( transform: ->(a) {{ index: { data: { name: a.title, foo: 'BAR' } }}} )
-
-          ImportArticle.__elasticsearch__.refresh_index!
-          assert_contains ImportArticle.search('*').results.first._source.keys, 'name'
-          assert_contains ImportArticle.search('*').results.first._source.keys, 'foo'
-          assert_equal 100, ImportArticle.search('test').results.total
-          assert_equal 100, ImportArticle.search('bar').results.total
-        end
-      end
-
-    end
-  end
-end

data/test/integration/active_record_namespaced_model_test.rb

@@ -1,49 +0,0 @@
-require 'test_helper'
-require 'active_record'
-
-module Elasticsearch
-  module Model
-    class ActiveRecordNamespacedModelIntegrationTest < Elasticsearch::Test::IntegrationTestCase
-      context "Namespaced ActiveRecord model integration" do
-        setup do
-          ActiveRecord::Schema.define(:version => 1) do
-            create_table :articles do |t|
-              t.string   :title
-            end
-          end
-
-          module ::MyNamespace
-            class Article < ActiveRecord::Base
-              include Elasticsearch::Model
-              include Elasticsearch::Model::Callbacks
-
-              mapping { indexes :title }
-            end
-          end
-
-          MyNamespace::Article.delete_all
-          MyNamespace::Article.__elasticsearch__.create_index! force: true
-
-          MyNamespace::Article.create! title: 'Test'
-
-          MyNamespace::Article.__elasticsearch__.refresh_index!
-        end
-
-        should "have proper index name and document type" do
-          assert_equal "my_namespace-articles", MyNamespace::Article.index_name
-          assert_equal "article",               MyNamespace::Article.document_type
-        end
-
-        should "save document into index on save and find it" do
-          response = MyNamespace::Article.search 'title:test'
-
-          assert       response.any?, "No results returned: #{response.inspect}"
-          assert_equal 1, response.size
-
-          assert_equal 'Test', response.results.first.title
-        end
-      end
-
-    end
-  end
-end

data/test/integration/active_record_pagination_test.rb

@@ -1,145 +0,0 @@
-require 'test_helper'
-require 'active_record'
-
-module Elasticsearch
-  module Model
-    class ActiveRecordPaginationTest < Elasticsearch::Test::IntegrationTestCase
-      context "ActiveRecord pagination" do
-        setup do
-          class ::ArticleForPagination < ActiveRecord::Base
-            include Elasticsearch::Model
-
-            scope :published, -> { where(published: true) }
-
-            settings index: { number_of_shards: 1, number_of_replicas: 0 } do
-              mapping do
-                indexes :title,      type: 'string', analyzer: 'snowball'
-                indexes :created_at, type: 'date'
-              end
-            end
-          end
-
-          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
-
-          ArticleForPagination.delete_all
-          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
-
-        should "be on the first page by default" do
-          records = ArticleForPagination.search('title:test').page(1).records
-
-          assert_equal 25, records.size
-          assert_equal 1, records.current_page
-          assert_equal nil, records.prev_page
-          assert_equal 2, records.next_page
-          assert_equal 3, records.total_pages
-
-          assert   records.first_page?,   "Should be the first page"
-          assert ! records.last_page?,    "Should NOT be the last page"
-          assert ! records.out_of_range?, "Should NOT be out of range"
-        end
-
-        should "load next page" do
-          records = ArticleForPagination.search('title:test').page(2).records
-
-          assert_equal 25, records.size
-          assert_equal 2, records.current_page
-          assert_equal 1, records.prev_page
-          assert_equal 3, records.next_page
-          assert_equal 3, records.total_pages
-
-          assert ! records.first_page?,   "Should NOT be the first page"
-          assert ! records.last_page?,    "Should NOT be the last page"
-          assert ! records.out_of_range?, "Should NOT be out of range"
-        end
-
-        should "load last page" do
-          records = ArticleForPagination.search('title:test').page(3).records
-
-          assert_equal 18, records.size
-          assert_equal 3, records.current_page
-          assert_equal 2, records.prev_page
-          assert_equal nil, records.next_page
-          assert_equal 3, records.total_pages
-
-          assert ! records.first_page?,   "Should NOT be the first page"
-          assert   records.last_page?,    "Should be the last page"
-          assert ! records.out_of_range?, "Should NOT be out of range"
-        end
-
-        should "not load invalid page" do
-          records = ArticleForPagination.search('title:test').page(6).records
-
-          assert_equal 0, records.size
-          assert_equal 6, records.current_page
-          assert_equal 5, records.prev_page
-          assert_equal nil, records.next_page
-          assert_equal 3, records.total_pages
-
-          assert ! records.first_page?,   "Should NOT be the first page"
-          assert   records.last_page?,    "Should be the last page"
-          assert   records.out_of_range?, "Should be out of range"
-        end
-
-        should "be combined with scopes" do
-          records = ArticleForPagination.search('title:test').page(2).records.published
-          assert records.all? { |r| r.published? }
-          assert_equal 12, records.size
-        end
-
-        should "respect sort" do
-          search = ArticleForPagination.search({ query: { match: { title: 'test' } }, sort: [ { id: 'desc' } ] })
-
-          records = search.page(2).records
-          assert_equal 43, records.first.id         # 68 - 25 = 42
-
-          records = search.page(3).records
-          assert_equal 18, records.first.id         # 68 - (2 * 25) = 18
-
-          records = search.page(2).per(5).records
-          assert_equal 63, records.first.id         # 68 - 5 = 63
-        end
-
-        should "set the limit per request" do
-          records = ArticleForPagination.search('title:test').limit(50).page(2).records
-
-          assert_equal 18,  records.size
-          assert_equal 2,   records.current_page
-          assert_equal 1,   records.prev_page
-          assert_equal nil, records.next_page
-          assert_equal 2,   records.total_pages
-
-          assert records.last_page?, "Should be the last page"
-        end
-
-        context "with specific model settings" do
-          teardown do
-            ArticleForPagination.instance_variable_set(:@_default_per_page, nil)
-          end
-
-          should "respect paginates_per" do
-            ArticleForPagination.paginates_per 50
-
-            assert_equal 50, ArticleForPagination.search('*').page(1).records.size
-          end
-        end
-      end
-
-    end
-  end
-end

data/test/integration/dynamic_index_name_test.rb

@@ -1,47 +0,0 @@
-require 'test_helper'
-require 'active_record'
-
-module Elasticsearch
-  module Model
-    class DynamicIndexNameTest < Elasticsearch::Test::IntegrationTestCase
-      context "Dynamic index name" do
-        setup do
-          class ::ArticleWithDynamicIndexName < ActiveRecord::Base
-            include Elasticsearch::Model
-            include Elasticsearch::Model::Callbacks
-
-            def self.counter=(value)
-              @counter = 0
-            end
-
-            def self.counter
-              (@counter ||= 0) && @counter += 1
-            end
-
-            mapping    { indexes :title }
-            index_name { "articles-#{counter}" }
-          end
-
-          ::ActiveRecord::Schema.define(:version => 1) do
-            create_table ::ArticleWithDynamicIndexName.table_name do |t|
-              t.string :title
-            end
-          end
-
-          ::ArticleWithDynamicIndexName.counter = 0
-        end
-
-        should 'evaluate the index_name value' do
-          assert_equal ArticleWithDynamicIndexName.index_name, "articles-1"
-        end
-
-        should 're-evaluate the index_name value each time' do
-          assert_equal ArticleWithDynamicIndexName.index_name, "articles-1"
-          assert_equal ArticleWithDynamicIndexName.index_name, "articles-2"
-          assert_equal ArticleWithDynamicIndexName.index_name, "articles-3"
-        end
-      end
-
-    end
-  end
-end

data/test/integration/mongoid_basic_test.rb

@@ -1,177 +0,0 @@
-require 'test_helper'
-
-Mongo.setup!
-
-if Mongo.available?
-  Mongo.connect_to 'mongoid_articles'
-
-  module Elasticsearch
-    module Model
-      class MongoidBasicIntegrationTest < Elasticsearch::Test::IntegrationTestCase
-
-        class ::MongoidArticle
-          include Mongoid::Document
-          include Elasticsearch::Model
-          include Elasticsearch::Model::Callbacks
-
-          field :id, type: String
-          field :title, type: String
-          attr_accessible :title if respond_to? :attr_accessible
-
-          settings index: { number_of_shards: 1, number_of_replicas: 0 } do
-            mapping do
-              indexes :title,      type: 'string', analyzer: 'snowball'
-              indexes :created_at, type: 'date'
-            end
-          end
-
-          def as_indexed_json(options={})
-            as_json(except: [:id, :_id])
-          end
-        end
-
-        context "Mongoid integration" do
-          setup do
-            Elasticsearch::Model::Adapter.register \
-              Elasticsearch::Model::Adapter::Mongoid,
-              lambda { |klass| !!defined?(::Mongoid::Document) && klass.respond_to?(:ancestors) && klass.ancestors.include?(::Mongoid::Document) }
-
-            MongoidArticle.__elasticsearch__.create_index! force: true
-
-            MongoidArticle.delete_all
-
-            MongoidArticle.create! title: 'Test'
-            MongoidArticle.create! title: 'Testing Coding'
-            MongoidArticle.create! title: 'Coding'
-
-            MongoidArticle.__elasticsearch__.refresh_index!
-            MongoidArticle.__elasticsearch__.client.cluster.health wait_for_status: 'yellow'
-          end
-
-          should "index and find a document" do
-            response = MongoidArticle.search('title:test')
-
-            assert response.any?
-
-            assert_equal 2, response.results.size
-            assert_equal 2, response.records.size
-
-            assert_instance_of Elasticsearch::Model::Response::Result, response.results.first
-            assert_instance_of MongoidArticle, response.records.first
-
-            assert_equal 'Test', response.results.first.title
-            assert_equal 'Test', response.records.first.title
-          end
-
-          should "iterate over results" do
-            response = MongoidArticle.search('title:test')
-
-            assert_equal ['Test', 'Testing Coding'], response.results.map(&:title)
-            assert_equal ['Test', 'Testing Coding'], response.records.map(&:title)
-          end
-
-          should "access results from records" do
-            response = MongoidArticle.search('title:test')
-
-            response.records.each_with_hit do |r, h|
-              assert_not_nil h._score
-              assert_not_nil h._source.title
-            end
-          end
-
-          should "preserve the search results order for records" do
-            response = MongoidArticle.search('title:code')
-
-            response.records.each_with_hit do |r, h|
-              assert_equal h._id, r.id.to_s
-            end
-
-            response.records.map_with_hit do |r, h|
-              assert_equal h._id, r.id.to_s
-            end
-          end
-
-          should "remove document from index on destroy" do
-            article = MongoidArticle.first
-
-            article.destroy
-            assert_equal 2, MongoidArticle.count
-
-            MongoidArticle.__elasticsearch__.refresh_index!
-
-            response = MongoidArticle.search 'title:test'
-
-            assert_equal 1, response.results.size
-            assert_equal 1, response.records.size
-          end
-
-          should "index updates to the document" do
-            article = MongoidArticle.first
-
-            article.title = 'Writing'
-            article.save
-
-            MongoidArticle.__elasticsearch__.refresh_index!
-
-            response = MongoidArticle.search 'title:write'
-
-            assert_equal 1, response.results.size
-            assert_equal 1, response.records.size
-          end
-
-          should "return results for a DSL search" do
-            response = MongoidArticle.search query: { match: { title: { query: 'test' } } }
-
-            assert_equal 2, response.results.size
-            assert_equal 2, response.records.size
-          end
-
-          should "return a paged collection" do
-            response = MongoidArticle.search query: { match: { title: { query: 'test' } } },
-                                      size: 2,
-                                      from: 1
-
-            assert_equal 1, response.results.size
-            assert_equal 1, response.records.size
-
-            assert_equal 'Testing Coding', response.results.first.title
-            assert_equal 'Testing Coding', response.records.first.title
-          end
-
-
-          context "importing" do
-            setup do
-              MongoidArticle.delete_all
-              97.times { |i| MongoidArticle.create! title: "Test #{i}" }
-              MongoidArticle.__elasticsearch__.create_index! force: true
-              MongoidArticle.__elasticsearch__.client.cluster.health wait_for_status: 'yellow'
-            end
-
-            should "import all the documents" do
-              assert_equal 97, MongoidArticle.count
-
-              MongoidArticle.__elasticsearch__.refresh_index!
-              assert_equal 0, MongoidArticle.search('*').results.total
-
-              batches = 0
-              errors  = MongoidArticle.import(batch_size: 10) do |response|
-                batches += 1
-              end
-
-              assert_equal 0, errors
-              assert_equal 10, batches
-
-              MongoidArticle.__elasticsearch__.refresh_index!
-              assert_equal 97, MongoidArticle.search('*').results.total
-
-              response = MongoidArticle.search('test')
-              assert response.results.any?, "Search has not returned results: #{response.to_a}"
-            end
-          end
-        end
-
-      end
-    end
-  end
-
-end

data/test/integration/multiple_models_test.rb

@@ -1,172 +0,0 @@
-require 'test_helper'
-require 'active_record'
-
-Mongo.setup!
-
-module Elasticsearch
-  module Model
-    class MultipleModelsIntegration < Elasticsearch::Test::IntegrationTestCase
-      context "Multiple models" do
-        setup do
-          ActiveRecord::Schema.define(:version => 1) do
-            create_table :episodes do |t|
-              t.string :name
-              t.datetime :created_at, :default => 'NOW()'
-            end
-
-            create_table :series do |t|
-              t.string :name
-              t.datetime :created_at, :default => 'NOW()'
-            end
-          end
-
-          module ::NameSearch
-            extend ActiveSupport::Concern
-
-            included do
-              include Elasticsearch::Model
-              include Elasticsearch::Model::Callbacks
-
-              settings index: {number_of_shards: 1, number_of_replicas: 0} do
-                mapping do
-                  indexes :name, type: 'string', analyzer: 'snowball'
-                  indexes :created_at, type: 'date'
-                end
-              end
-            end
-          end
-
-          class ::Episode < ActiveRecord::Base
-            include NameSearch
-          end
-
-          class ::Series < ActiveRecord::Base
-            include NameSearch
-          end
-
-          [::Episode, ::Series].each do |model|
-            model.delete_all
-            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
-
-        should "find matching documents across multiple models" do
-          response = Elasticsearch::Model.search(%q<"The greatest Episode"^2 OR "The greatest Series">, [Series, Episode])
-
-          assert response.any?, "Response should not be empty: #{response.to_a.inspect}"
-
-          assert_equal 2, response.results.size
-          assert_equal 2, response.records.size
-
-          assert_instance_of Elasticsearch::Model::Response::Result, response.results.first
-          assert_instance_of Episode, response.records.first
-          assert_instance_of Series, response.records.last
-
-          assert_equal 'The greatest Episode', response.results[0].name
-          assert_equal 'The greatest Episode', response.records[0].name
-
-          assert_equal 'The greatest Series', response.results[1].name
-          assert_equal 'The greatest Series', response.records[1].name
-        end
-
-        should "provide access to results" do
-          response = Elasticsearch::Model.search(%q<"A great Episode"^2 OR "A great Series">, [Series, Episode])
-
-          assert_equal 'A great Episode', response.results[0].name
-          assert_equal true,              response.results[0].name?
-          assert_equal false,             response.results[0].boo?
-
-          assert_equal 'A great Series', response.results[1].name
-          assert_equal true,             response.results[1].name?
-          assert_equal false,            response.results[1].boo?
-        end
-
-        should "only retrieve records for existing results" do
-          ::Series.find_by_name("The greatest Series").delete
-          ::Series.__elasticsearch__.refresh_index!
-          response = Elasticsearch::Model.search(%q<"The greatest Episode"^2 OR "The greatest Series">, [Series, Episode])
-
-          assert response.any?, "Response should not be empty: #{response.to_a.inspect}"
-
-          assert_equal 2, response.results.size
-          assert_equal 1, response.records.size
-
-          assert_instance_of Elasticsearch::Model::Response::Result, response.results.first
-          assert_instance_of Episode, response.records.first
-
-          assert_equal 'The greatest Episode', response.results[0].name
-          assert_equal 'The greatest Episode', response.records[0].name
-        end
-
-        should "paginate the results" do
-          response = Elasticsearch::Model.search('series OR episode', [Series, Episode])
-
-          assert_equal 3, response.page(1).per(3).results.size
-          assert_equal 3, response.page(2).per(3).results.size
-          assert_equal 0, response.page(3).per(3).results.size
-        end
-
-        if Mongo.available?
-          Mongo.connect_to 'mongoid_collections'
-
-          context "Across mongoid models" do
-            setup do
-              class ::Image
-                include Mongoid::Document
-                include Elasticsearch::Model
-                include Elasticsearch::Model::Callbacks
-
-                field :name, type: String
-                attr_accessible :name if respond_to? :attr_accessible
-
-                settings index: {number_of_shards: 1, number_of_replicas: 0} do
-                  mapping do
-                    indexes :name, type: 'string', analyzer: 'snowball'
-                    indexes :created_at, type: 'date'
-                  end
-                end
-
-                def as_indexed_json(options={})
-                  as_json(except: [:_id])
-                end
-              end
-
-              Image.delete_all
-              Image.__elasticsearch__.create_index! force: true
-              Image.create! name: "The Image"
-              Image.create! name: "A great Image"
-              Image.create! name: "The greatest Image"
-              Image.__elasticsearch__.refresh_index!
-              Image.__elasticsearch__.client.cluster.health wait_for_status: 'yellow'
-            end
-
-            should "find matching documents across multiple models" do
-              response = Elasticsearch::Model.search(%q<"greatest Episode" OR "greatest Image"^2>, [Episode, Image])
-
-              assert response.any?, "Response should not be empty: #{response.to_a.inspect}"
-
-              assert_equal 2, response.results.size
-              assert_equal 2, response.records.size
-
-              assert_instance_of Elasticsearch::Model::Response::Result, response.results.first
-              assert_instance_of Image, response.records.first
-              assert_instance_of Episode, response.records.last
-
-              assert_equal 'The greatest Image', response.results[0].name
-              assert_equal 'The greatest Image', response.records[0].name
-
-              assert_equal 'The greatest Episode', response.results[1].name
-              assert_equal 'The greatest Episode', response.records[1].name
-            end
-          end
-        end
-
-      end
-    end
-  end
-end