elasticsearch-model 6.0.0 → 6.1.0

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

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