elasticsearch-model 5.1.0 → 6.1.0

data/spec/elasticsearch/model/searching_search_request_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Serializing do
+
+  before(:all) do
+    class ::DummySearchingModel
+      extend Elasticsearch::Model::Searching::ClassMethods
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+    end
+  end
+
+  after(:all) do
+    remove_classes(DummySearchingModel)
+  end
+
+  before do
+    allow(DummySearchingModel).to receive(:client).and_return(client)
+  end
+
+  let(:client) do
+    double('client')
+  end
+
+  describe '#initialize' do
+
+    context 'when the search definition is a simple query' do
+
+      before do
+        expect(client).to receive(:search).with(index: 'foo', type: 'bar', q: 'foo').and_return({})
+      end
+
+      let(:search) do
+        Elasticsearch::Model::Searching::SearchRequest.new(DummySearchingModel, 'foo')
+      end
+
+      it 'passes the query to the client' do
+        expect(search.execute!).to eq({})
+      end
+    end
+
+    context 'when the search definition is a hash' do
+
+      before do
+        expect(client).to receive(:search).with(index: 'foo', type: 'bar', body: { foo: 'bar' }).and_return({})
+      end
+
+      let(:search) do
+        Elasticsearch::Model::Searching::SearchRequest.new(DummySearchingModel, foo: 'bar')
+      end
+
+      it 'passes the hash to the client' do
+        expect(search.execute!).to eq({})
+      end
+    end
+
+    context 'when the search definition is a json string' do
+
+      before do
+        expect(client).to receive(:search).with(index: 'foo', type: 'bar', body: '{"foo":"bar"}').and_return({})
+      end
+
+      let(:search) do
+        Elasticsearch::Model::Searching::SearchRequest.new(DummySearchingModel, '{"foo":"bar"}')
+      end
+
+      it 'passes the json string to the client' do
+        expect(search.execute!).to eq({})
+      end
+    end
+
+    context 'when the search definition is a custom object' do
+
+      before(:all) do
+        class MySpecialQueryBuilder
+          def to_hash; {foo: 'bar'}; end
+        end
+      end
+
+      after(:all) do
+        Object.send(:remove_const, :MySpecialQueryBuilder) if defined?(MySpecialQueryBuilder)
+      end
+
+      before do
+        expect(client).to receive(:search).with(index: 'foo', type: 'bar', body: {foo: 'bar'}).and_return({})
+      end
+
+      let(:search) do
+        Elasticsearch::Model::Searching::SearchRequest.new(DummySearchingModel, MySpecialQueryBuilder.new)
+      end
+
+      it 'passes the query builder to the client and calls #to_hash on it' do
+        expect(search.execute!).to eq({})
+      end
+    end
+
+    context 'when extra options are specified' do
+
+      before do
+        expect(client).to receive(:search).with(index: 'foo', type: 'bar', q: 'foo', size: 15).and_return({})
+      end
+
+      let(:search) do
+        Elasticsearch::Model::Searching::SearchRequest.new(DummySearchingModel, 'foo', size: 15)
+      end
+
+      it 'passes the extra options to the client as part of the request' do
+        expect(search.execute!).to eq({})
+      end
+    end
+  end
+end

data/spec/elasticsearch/model/searching_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Searching::ClassMethods do
+
+  before(:all) do
+    class ::DummySearchingModel
+      extend Elasticsearch::Model::Searching::ClassMethods
+
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+    end
+  end
+
+  after(:all) do
+    remove_classes(DummySearchingModel)
+  end
+
+  it 'has the search method' do
+    expect(DummySearchingModel).to respond_to(:search)
+  end
+
+  describe '#search' do
+
+    let(:response) do
+      double('search', execute!: { 'hits' => {'hits' => [ {'_id' => 2 }, {'_id' => 1 } ]} })
+    end
+
+    before do
+      expect(Elasticsearch::Model::Searching::SearchRequest).to receive(:new).with(DummySearchingModel, 'foo', { default_operator: 'AND' }).and_return(response)
+    end
+
+    it 'creates a search object' do
+      expect(DummySearchingModel.search('foo', default_operator: 'AND')).to be_a(Elasticsearch::Model::Response::Response)
+    end
+  end
+
+  describe 'lazy execution' do
+
+    let(:response) do
+      double('search').tap do |r|
+        expect(r).to receive(:execute!).never
+      end
+    end
+
+    it 'does not execute the search until the results are accessed' do
+      DummySearchingModel.search('foo')
+    end
+  end
+end

data/spec/elasticsearch/model/serializing_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Serializing do
+
+  before(:all) do
+    class DummyClass
+      include Elasticsearch::Model::Serializing::InstanceMethods
+
+      def as_json(options={})
+        'HASH'
+      end
+    end
+  end
+
+  after(:all) do
+    remove_classes(DummyClass)
+  end
+
+  it 'delegates to #as_json by default' do
+    expect(DummyClass.new.as_indexed_json).to eq('HASH')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,161 @@
+require 'pry-nav'
+require 'kaminari'
+require 'kaminari/version'
+require 'will_paginate'
+require 'will_paginate/collection'
+require 'elasticsearch/model'
+require 'hashie/version'
+require 'active_model'
+require 'mongoid'
+require 'yaml'
+require 'active_record'
+
+unless defined?(ELASTICSEARCH_URL)
+  ELASTICSEARCH_URL = ENV['ELASTICSEARCH_URL'] || "localhost:#{(ENV['TEST_CLUSTER_PORT'] || 9200)}"
+end
+
+RSpec.configure do |config|
+  config.formatter = 'documentation'
+  config.color = true
+
+  config.before(:suite) do
+    require 'ansi'
+    tracer = ::Logger.new(STDERR)
+    tracer.formatter = lambda { |s, d, p, m| "#{m.gsub(/^.*$/) { |n| '   ' + n }.ansi(:faint)}\n" }
+    Elasticsearch::Model.client = Elasticsearch::Client.new host: ELASTICSEARCH_URL,
+                                                            tracer: (ENV['QUIET'] ? nil : tracer)
+
+    unless ActiveRecord::Base.connected?
+      ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" )
+    end
+    require 'support/app'
+
+    if ::ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks) && ::ActiveRecord::VERSION::MAJOR.to_s < '5'
+      ::ActiveRecord::Base.raise_in_transactional_callbacks = true
+    end
+  end
+
+  config.after(:all) do
+    drop_all_tables!
+    delete_all_indices!
+  end
+end
+
+# Is the ActiveRecord version at least 4.0?
+#
+# @return [ true, false ] Whether the ActiveRecord version is at least 4.0.
+#
+# @since 6.0.1
+def active_record_at_least_4?
+  defined?(::ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 4
+end
+
+# Delete all documents from the indices of the provided list of models.
+#
+# @param [ Array<ActiveRecord::Base> ] models The list of models.
+#
+# @return [ true ]
+#
+# @since 6.0.1
+def clear_indices(*models)
+  models.each do |model|
+    begin; Elasticsearch::Model.client.delete_by_query(index: model.index_name, q: '*'); rescue; end
+  end and true
+end
+
+# Delete all documents from the tables of the provided list of models.
+#
+# @param [ Array<ActiveRecord::Base> ] models The list of models.
+#
+# @return [ true ]
+#
+# @since 6.0.1
+def clear_tables(*models)
+  begin; models.map(&:delete_all); rescue; end and true
+end
+
+# Drop all tables of models registered as subclasses of ActiveRecord::Base.
+#
+# @return [ true ]
+#
+# @since 6.0.1
+def drop_all_tables!
+  ActiveRecord::Base.descendants.each do |model|
+    begin
+      ActiveRecord::Schema.define do
+        drop_table model
+      end if model.table_exists?
+    rescue
+    end
+  end and true
+end
+
+# Drop all indices of models registered as subclasses of ActiveRecord::Base.
+#
+# @return [ true ]
+#
+# @since 6.0.1
+def delete_all_indices!
+  client = Elasticsearch::Model.client
+  ActiveRecord::Base.descendants.each do |model|
+    begin
+      client.indices.delete(index: model.index_name) if model.__elasticsearch__.index_exists?
+    rescue
+    end
+  end and true
+end
+
+# Remove all classes.
+#
+# @param [ Array<Class> ] classes The list of classes to remove.
+#
+# @return [ true ]
+#
+# @since 6.0.1
+def remove_classes(*classes)
+  classes.each do |_class|
+    Object.send(:remove_const, _class.name.to_sym) if defined?(_class)
+  end and true
+end
+
+# Determine whether the tests with Mongoid should be run.
+# Depends on whether MongoDB is running on the default host and port, `localhost:27017`.
+#
+# @return [ true, false ]
+#
+# @since 6.0.1
+def test_mongoid?
+  $mongoid_available ||= begin
+    require 'mongoid'
+    if defined?(Mongo) # older versions of Mongoid use the driver, Moped
+      client = Mongo::Client.new(['localhost:27017'])
+      Timeout.timeout(1) do
+        client.database.command(ping: 1) && true
+      end
+    end and true
+  rescue Timeout::Error, LoadError, Mongo::Error => e
+    client.close
+    $stderr.puts("MongoDB not installed or running: #{e}")
+  end
+end
+
+# Connect Mongoid and set up its Logger if Mongoid tests should be run.
+#
+# @since 6.0.1
+def connect_mongoid(source)
+  if test_mongoid?
+    $stderr.puts "Mongoid #{Mongoid::VERSION}", '-'*80
+
+    if !ENV['QUIET'] == 'true'
+      logger = ::Logger.new($stderr)
+      logger.formatter = lambda { |s, d, p, m| " #{m.ansi(:faint, :cyan)}\n" }
+      logger.level = ::Logger::DEBUG
+      Mongoid.logger = logger
+      Mongo::Logger.logger = logger
+    else
+      Mongo::Logger.logger.level = ::Logger::WARN
+    end
+
+    Mongoid.connect_to(source)
+  end
+end

data/spec/support/app/answer.rb

@@ -0,0 +1,33 @@
+class Answer < ActiveRecord::Base
+  include Elasticsearch::Model
+
+  belongs_to :question
+
+  JOIN_TYPE = 'answer'.freeze
+
+  index_name 'questions_and_answers'.freeze
+  document_type 'doc'.freeze
+
+  before_create :randomize_id
+
+  def randomize_id
+    begin
+      self.id = SecureRandom.random_number(1_000_000)
+    end while Answer.where(id: self.id).exists?
+  end
+
+  mapping do
+    indexes :text
+    indexes :author
+  end
+
+  def as_indexed_json(options={})
+    # This line is necessary for differences between ActiveModel::Serializers::JSON#as_json versions
+    json = as_json(options)[JOIN_TYPE] || as_json(options)
+    json.merge(join_field: { name: JOIN_TYPE, parent: question_id })
+  end
+
+  after_commit lambda { __elasticsearch__.index_document(routing: (question_id || 1))  },  on: :create
+  after_commit lambda { __elasticsearch__.update_document(routing: (question_id || 1)) },  on: :update
+  after_commit lambda {__elasticsearch__.delete_document(routing: (question_id || 1)) },  on: :destroy
+end

data/spec/support/app/article.rb

@@ -0,0 +1,22 @@
+class ::Article < ActiveRecord::Base
+  include Elasticsearch::Model
+  include Elasticsearch::Model::Callbacks
+
+  document_type 'article'
+
+  settings index: {number_of_shards: 1, number_of_replicas: 0} do
+    mapping do
+      indexes :title, type: 'text', analyzer: 'snowball'
+      indexes :body, type: 'text'
+      indexes :clicks, type: 'integer'
+      indexes :created_at, type: 'date'
+    end
+  end
+
+  def as_indexed_json(options = {})
+    attributes
+        .symbolize_keys
+        .slice(:title, :body, :clicks, :created_at)
+        .merge(suggest_title: title)
+  end
+end

data/spec/support/app/article_for_pagination.rb

@@ -0,0 +1,12 @@
+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: 'text', analyzer: 'snowball'
+      indexes :created_at, type: 'date'
+    end
+  end
+end

data/spec/support/app/article_with_custom_serialization.rb

@@ -0,0 +1,13 @@
+class ::ArticleWithCustomSerialization < ActiveRecord::Base
+  include Elasticsearch::Model
+  include Elasticsearch::Model::Callbacks
+
+  mapping do
+    indexes :title
+  end
+
+  def as_indexed_json(options={})
+    # as_json(options.merge root: false).slice('title')
+    { title: self.title }
+  end
+end

data/spec/support/app/article_with_dynamic_index_name.rb

@@ -0,0 +1,15 @@
+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

data/spec/support/app/author.rb

@@ -0,0 +1,9 @@
+class Author < ActiveRecord::Base
+  has_many :authorships
+
+  after_update { self.authorships.each(&:touch) }
+
+  def full_name
+    [first_name, last_name].compact.join(' ')
+  end
+end

data/spec/support/app/authorship.rb

@@ -0,0 +1,4 @@
+class Authorship < ActiveRecord::Base
+  belongs_to :author
+  belongs_to :post, touch: true
+end

data/spec/support/app/category.rb

@@ -0,0 +1,3 @@
+class Category < ActiveRecord::Base
+  has_and_belongs_to_many :posts
+end

data/spec/support/app/comment.rb

@@ -0,0 +1,3 @@
+class Comment < ActiveRecord::Base
+  belongs_to :post, touch: true
+end

data/spec/support/app/episode.rb

@@ -0,0 +1,11 @@
+class Episode < ActiveRecord::Base
+  include Elasticsearch::Model
+  include Elasticsearch::Model::Callbacks
+
+  settings index: {number_of_shards: 1, number_of_replicas: 0} do
+    mapping do
+      indexes :name, type: 'text', analyzer: 'snowball'
+      indexes :created_at, type: 'date'
+    end
+  end
+end

data/spec/support/app/image.rb

@@ -0,0 +1,19 @@
+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: 'text', analyzer: 'snowball'
+      indexes :created_at, type: 'date'
+    end
+  end
+
+  def as_indexed_json(options={})
+    as_json(except: [:_id])
+  end
+end

data/spec/support/app/import_article.rb

@@ -0,0 +1,12 @@
+class ImportArticle < ActiveRecord::Base
+  include Elasticsearch::Model
+
+  scope :popular, -> { where('views >= 5') }
+
+  mapping do
+    indexes :title,      type: 'text'
+    indexes :views,      type: 'integer'
+    indexes :numeric,    type: 'integer'
+    indexes :created_at, type: 'date'
+  end
+end

data/spec/support/app/mongoid_article.rb

@@ -0,0 +1,21 @@
+class ::MongoidArticle
+  include Mongoid::Document
+  include Elasticsearch::Model
+  include Elasticsearch::Model::Callbacks
+
+  field :id, type: String
+  field :title, type: String
+  field :views, type: Integer
+  attr_accessible :title if respond_to? :attr_accessible
+
+  settings index: { number_of_shards: 1, number_of_replicas: 0 } do
+    mapping do
+      indexes :title,      type: 'text', analyzer: 'snowball'
+      indexes :created_at, type: 'date'
+    end
+  end
+
+  def as_indexed_json(options={})
+    as_json(except: [:id, :_id])
+  end
+end

data/spec/support/app/namespaced_book.rb

@@ -0,0 +1,10 @@
+module MyNamespace
+  class Book < ActiveRecord::Base
+    include Elasticsearch::Model
+    include Elasticsearch::Model::Callbacks
+
+    document_type 'book'
+
+    mapping { indexes :title }
+  end
+end

data/spec/support/app/parent_and_child_searchable.rb

@@ -0,0 +1,24 @@
+module ParentChildSearchable
+  INDEX_NAME = 'questions_and_answers'.freeze
+  JOIN = 'join'.freeze
+
+  def create_index!(options={})
+    client = Question.__elasticsearch__.client
+    client.indices.delete index: INDEX_NAME rescue nil if options[:force]
+
+    settings = Question.settings.to_hash.merge Answer.settings.to_hash
+    mapping_properties = { join_field: { type: JOIN,
+                                         relations: { Question::JOIN_TYPE => Answer::JOIN_TYPE } } }
+
+    merged_properties = mapping_properties.merge(Question.mappings.to_hash[:doc][:properties]).merge(
+        Answer.mappings.to_hash[:doc][:properties])
+    mappings = { doc: { properties: merged_properties }}
+
+    client.indices.create index: INDEX_NAME,
+                          body: {
+                              settings: settings.to_hash,
+                              mappings: mappings }
+  end
+
+  extend self
+end

data/spec/support/app/post.rb

@@ -0,0 +1,14 @@
+class Post < ActiveRecord::Base
+  include Searchable
+
+  has_and_belongs_to_many :categories, after_add:    [ lambda { |a,c| a.__elasticsearch__.index_document } ],
+                          after_remove: [ lambda { |a,c| a.__elasticsearch__.index_document } ]
+  has_many                :authorships
+  has_many                :authors, through: :authorships,
+                          after_add: [ lambda { |a,c| a.__elasticsearch__.index_document } ],
+                          after_remove: [ lambda { |a,c| a.__elasticsearch__.index_document } ]
+  has_many                :comments, after_add:    [ lambda { |a,c| a.__elasticsearch__.index_document } ],
+                          after_remove: [ lambda { |a,c| a.__elasticsearch__.index_document } ]
+
+  after_touch() { __elasticsearch__.index_document }
+end

data/spec/support/app/question.rb

@@ -0,0 +1,27 @@
+class Question < ActiveRecord::Base
+  include Elasticsearch::Model
+
+  has_many :answers, dependent: :destroy
+
+  JOIN_TYPE = 'question'.freeze
+  JOIN_METADATA = { join_field: JOIN_TYPE}.freeze
+
+  index_name 'questions_and_answers'.freeze
+  document_type 'doc'.freeze
+
+  mapping do
+    indexes :title
+    indexes :text
+    indexes :author
+  end
+
+  def as_indexed_json(options={})
+    # This line is necessary for differences between ActiveModel::Serializers::JSON#as_json versions
+    json = as_json(options)[JOIN_TYPE] || as_json(options)
+    json.merge(JOIN_METADATA)
+  end
+
+  after_commit lambda { __elasticsearch__.index_document  },  on: :create
+  after_commit lambda { __elasticsearch__.update_document },  on: :update
+  after_commit lambda { __elasticsearch__.delete_document },  on: :destroy
+end

data/spec/support/app/searchable.rb

@@ -0,0 +1,48 @@
+module Searchable
+  extend ActiveSupport::Concern
+
+  included do
+    include Elasticsearch::Model
+    include Elasticsearch::Model::Callbacks
+
+    # Set up the mapping
+    #
+    settings index: { number_of_shards: 1, number_of_replicas: 0 } do
+      mapping do
+        indexes :title,      analyzer: 'snowball'
+        indexes :created_at, type: 'date'
+
+        indexes :authors do
+          indexes :first_name
+          indexes :last_name
+            indexes :full_name, type: 'text' do
+            indexes :raw, type: 'keyword'
+          end
+        end
+
+        indexes :categories, type: 'keyword'
+
+        indexes :comments, type: 'nested' do
+          indexes :text
+          indexes :author
+        end
+      end
+    end
+
+    # Customize the JSON serialization for Elasticsearch
+    #
+    def as_indexed_json(options={})
+      {
+          title: title,
+          text:  text,
+          categories: categories.map(&:title),
+          authors:    authors.as_json(methods: [:full_name], only: [:full_name, :first_name, :last_name]),
+          comments:   comments.as_json(only: [:text, :author])
+      }
+    end
+
+    # Update document in the index after touch
+    #
+    after_touch() { __elasticsearch__.index_document }
+  end
+end

data/spec/support/app/series.rb

@@ -0,0 +1,11 @@
+class Series < ActiveRecord::Base
+  include Elasticsearch::Model
+  include Elasticsearch::Model::Callbacks
+
+  settings index: {number_of_shards: 1, number_of_replicas: 0} do
+    mapping do
+      indexes :name, type: 'text', analyzer: 'snowball'
+      indexes :created_at, type: 'date'
+    end
+  end
+end