elasticsearch-model 5.1.0 → 6.1.0

data/test/integration/multiple_models_test.rb

@@ -1,176 +0,0 @@
-require 'test_helper'
-require 'active_record'
-
-# Needed for ActiveRecord 3.x ?
-ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" ) unless ActiveRecord::Base.connected?
-
-::ActiveRecord::Base.raise_in_transactional_callbacks = true if ::ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks) && ::ActiveRecord::VERSION::MAJOR.to_s < '5'
-
-MongoDB.setup!
-
-module Elasticsearch
-  module Model
-    class MultipleModelsIntegration < Elasticsearch::Test::IntegrationTestCase
-      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: 'text', 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
-
-      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
-
-          [::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 MongoDB.available?
-          MongoDB.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: 'text', 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

data/test/support/model.json

@@ -1 +0,0 @@
-{ "baz": "qux" }

data/test/test_helper.rb

@@ -1,92 +0,0 @@
-RUBY_1_8 = defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
-
-exit(0) if RUBY_1_8
-
-require 'simplecov' and SimpleCov.start { add_filter "/test|test_/" } if ENV["COVERAGE"]
-
-# Register `at_exit` handler for integration tests shutdown.
-# MUST be called before requiring `test/unit`.
-at_exit { Elasticsearch::Test::IntegrationTestCase.__run_at_exit_hooks }
-
-puts '-'*80
-
-if defined?(RUBY_VERSION) && RUBY_VERSION > '2.2'
-  require 'test-unit'
-  require 'mocha/test_unit'
-else
-  require 'minitest/autorun'
-  require 'mocha/mini_test'
-end
-
-require 'shoulda-context'
-
-require 'turn' unless ENV["TM_FILEPATH"] || ENV["NOTURN"] || defined?(RUBY_VERSION) && RUBY_VERSION > '2.2'
-
-require 'ansi'
-require 'oj'
-
-require 'active_model'
-
-require 'kaminari'
-
-require 'elasticsearch/model'
-
-require 'elasticsearch/extensions/test/cluster'
-require 'elasticsearch/extensions/test/startup_shutdown'
-
-module Elasticsearch
-  module Test
-    class IntegrationTestCase < ::Test::Unit::TestCase
-      extend Elasticsearch::Extensions::Test::StartupShutdown
-
-      startup  { Elasticsearch::Extensions::Test::Cluster.start(nodes: 1) if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running? }
-      shutdown { Elasticsearch::Extensions::Test::Cluster.stop if ENV['SERVER'] && started? }
-      context "IntegrationTest" do; should "noop on Ruby 1.8" do; end; end if RUBY_1_8
-
-      def setup
-        ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" )
-        logger = ::Logger.new(STDERR)
-        logger.formatter = lambda { |s, d, p, m| "\e[2;36m#{m}\e[0m\n" }
-        ActiveRecord::Base.logger = logger unless ENV['QUIET']
-
-        ActiveRecord::LogSubscriber.colorize_logging = false
-        ActiveRecord::Migration.verbose = false
-
-        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: "localhost:#{(ENV['TEST_CLUSTER_PORT'] || 9250)}",
-                                                                tracer: (ENV['QUIET'] ? nil : tracer)
-      end
-    end
-  end
-end
-
-class MongoDB
-  def self.setup!
-    begin
-      require 'mongoid'
-      Mongo::Client.new(["localhost:27017"])
-      ENV['MONGODB_AVAILABLE'] = 'yes'
-    rescue LoadError, Mongo::Error => e
-      $stderr.puts "MongoDB not installed or running: #{e}"
-    end
-  end
-
-  def self.available?
-    !!ENV['MONGODB_AVAILABLE']
-  end
-
-  def self.connect_to(source)
-    $stderr.puts "Mongoid #{Mongoid::VERSION}", '-'*80
-
-    logger = ::Logger.new($stderr)
-    logger.formatter = lambda { |s, d, p, m| " #{m.ansi(:faint, :cyan)}\n" }
-    logger.level = ::Logger::DEBUG
-
-    Mongoid.logger = logger unless ENV['QUIET']
-    Mongo::Logger.logger   = logger unless ENV['QUIET']
-
-    Mongoid.connect_to source
-  end
-end

data/test/unit/adapter_active_record_test.rb

@@ -1,157 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::AdapterActiveRecordTest < Test::Unit::TestCase
-  context "Adapter ActiveRecord module: " do
-    class ::DummyClassForActiveRecord
-      RESPONSE = Struct.new('DummyActiveRecordResponse') do
-        def response
-          { 'hits' => {'hits' => [ {'_id' => 2}, {'_id' => 1} ]} }
-        end
-      end.new
-
-      def response
-        RESPONSE
-      end
-
-      def ids
-        [2, 1]
-      end
-    end
-
-    RESPONSE = { 'hits' => { 'total' => 123, 'max_score' => 456, 'hits' => [] } }
-
-    setup do
-      @records = [ stub(id: 1, inspect: '<Model-1>'), stub(id: 2, inspect: '<Model-2>') ]
-      @records.stubs(:load).returns(true)
-      @records.stubs(:exec_queries).returns(true)
-    end
-
-    should "have the register condition" do
-      assert_not_nil Elasticsearch::Model::Adapter.adapters[Elasticsearch::Model::Adapter::ActiveRecord]
-      assert_equal false, Elasticsearch::Model::Adapter.adapters[Elasticsearch::Model::Adapter::ActiveRecord].call(DummyClassForActiveRecord)
-    end
-
-    context "Records" do
-      setup do
-        DummyClassForActiveRecord.__send__ :include, Elasticsearch::Model::Adapter::ActiveRecord::Records
-      end
-
-      should "have the implementation" do
-        assert_instance_of Module, Elasticsearch::Model::Adapter::ActiveRecord::Records
-
-        instance = DummyClassForActiveRecord.new
-        instance.expects(:klass).returns(mock('class', primary_key: :some_key, where: @records)).at_least_once
-
-        assert_equal @records, instance.records
-      end
-
-      should "load the records" do
-        instance = DummyClassForActiveRecord.new
-        instance.expects(:records).returns(@records)
-        instance.load
-      end
-
-      should "load the records with its submodels when using :includes" do
-        klass    = mock('class', primary_key: :some_key, where: @records)
-        @records.expects(:includes).with([:submodel]).at_least_once
-
-        instance = DummyClassForActiveRecord.new
-        instance.expects(:klass).returns(klass).at_least_once
-        instance.options[:includes] = [:submodel]
-        instance.records
-      end
-
-      should "reorder the records based on hits order" do
-        @records.instance_variable_set(:@records, @records)
-
-        instance = DummyClassForActiveRecord.new
-        instance.expects(:klass).returns(mock('class', primary_key: :some_key, where: @records)).at_least_once
-
-        assert_equal [1, 2], @records.        to_a.map(&:id)
-        assert_equal [2, 1], instance.records.to_a.map(&:id)
-      end
-
-      should "not reorder records when SQL order is present" do
-        @records.instance_variable_set(:@records, @records)
-
-        instance = DummyClassForActiveRecord.new
-        instance.expects(:klass).returns(stub('class', primary_key: :some_key, where: @records)).at_least_once
-        instance.records.expects(:order).returns(@records)
-
-        assert_equal [2, 1], instance.records.    to_a.map(&:id)
-        assert_equal [1, 2], instance.order(:foo).to_a.map(&:id)
-      end
-    end
-
-    context "Callbacks" do
-      should "register hooks for automatically updating the index" do
-        DummyClassForActiveRecord.expects(:after_commit).times(3)
-
-        Elasticsearch::Model::Adapter::ActiveRecord::Callbacks.included(DummyClassForActiveRecord)
-      end
-    end
-
-    context "Importing" do
-      setup do
-        DummyClassForActiveRecord.__send__ :extend, Elasticsearch::Model::Adapter::ActiveRecord::Importing
-      end
-
-      should "raise an exception when passing an invalid scope" do
-        assert_raise NoMethodError do
-          DummyClassForActiveRecord.__find_in_batches(scope: :not_found_method) do; end
-        end
-      end
-
-      should "implement the __find_in_batches method" do
-        DummyClassForActiveRecord.expects(:find_in_batches).returns([])
-        DummyClassForActiveRecord.__find_in_batches do; end
-      end
-
-      should "limit the relation to a specific scope" do
-        DummyClassForActiveRecord.expects(:find_in_batches).returns([])
-        DummyClassForActiveRecord.expects(:published).returns(DummyClassForActiveRecord)
-
-        DummyClassForActiveRecord.__find_in_batches(scope: :published) do; end
-      end
-
-      should "limit the relation to a specific query" do
-        DummyClassForActiveRecord.expects(:find_in_batches).returns([])
-        DummyClassForActiveRecord.expects(:where).returns(DummyClassForActiveRecord)
-
-        DummyClassForActiveRecord.__find_in_batches(query: -> { where(color: "red") }) do; end
-      end
-
-      should "preprocess the batch if option provided" do
-        class << DummyClassForActiveRecord
-          # Updates/transforms the batch while fetching it from the database
-          # (eg. with information from an external system)
-          #
-          def update_batch(batch)
-            batch.collect { |b| b.to_s + '!' }
-          end
-        end
-
-        DummyClassForActiveRecord.expects(:__find_in_batches).returns( [:a, :b] )
-
-        DummyClassForActiveRecord.__find_in_batches(preprocess: :update_batch) do |batch|
-          assert_same_elements ["a!", "b!"], batch
-        end
-      end
-
-      context "when transforming models" do
-        setup do
-          @transform = DummyClassForActiveRecord.__transform
-        end
-
-        should "provide an object that responds to #call" do
-          assert_respond_to @transform, :call
-        end
-
-        should "provide default transformation" do
-          model = mock("model", id: 1, __elasticsearch__: stub(as_indexed_json: {}))
-          assert_equal @transform.call(model), { index: { _id: 1, data: {} } }
-        end
-      end
-    end
-  end
-end

data/test/unit/adapter_default_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::AdapterDefaultTest < Test::Unit::TestCase
-  context "Adapter default module" do
-    class ::DummyClassForDefaultAdapter; end
-
-    should "have the default Records implementation" do
-      assert_instance_of Module, Elasticsearch::Model::Adapter::Default::Records
-
-      DummyClassForDefaultAdapter.__send__ :include, Elasticsearch::Model::Adapter::Default::Records
-
-      instance = DummyClassForDefaultAdapter.new
-      klass = mock('class', find: [1])
-      instance.expects(:klass).returns(klass)
-      instance.records
-    end
-
-    should "have the default Callbacks implementation" do
-      assert_instance_of Module, Elasticsearch::Model::Adapter::Default::Callbacks
-    end
-
-    context "concerning abstract methods" do
-      setup do
-        DummyClassForDefaultAdapter.__send__ :include, Elasticsearch::Model::Adapter::Default::Importing
-      end
-
-      should "have the default Importing implementation" do
-        assert_raise Elasticsearch::Model::NotImplemented do
-          DummyClassForDefaultAdapter.new.__find_in_batches
-        end
-      end
-
-      should "have the default transform implementation" do
-        assert_raise Elasticsearch::Model::NotImplemented do
-          DummyClassForDefaultAdapter.new.__transform
-        end
-      end
-    end
-
-  end
-end

data/test/unit/adapter_mongoid_test.rb

@@ -1,104 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::AdapterMongoidTest < Test::Unit::TestCase
-  context "Adapter Mongoid module: " do
-    class ::DummyClassForMongoid
-      RESPONSE = Struct.new('DummyMongoidResponse') do
-        def response
-          { 'hits' => {'hits' => [ {'_id' => 2}, {'_id' => 1} ]} }
-        end
-      end.new
-
-      def response
-        RESPONSE
-      end
-
-      def ids
-        [2, 1]
-      end
-    end
-
-    setup do
-      @records = [ stub(id: 1, inspect: '<Model-1>'), stub(id: 2, inspect: '<Model-2>') ]
-      ::Symbol.any_instance.stubs(:in).returns(@records)
-    end
-
-    should "have the register condition" do
-      assert_not_nil Elasticsearch::Model::Adapter.adapters[Elasticsearch::Model::Adapter::Mongoid]
-      assert_equal false, Elasticsearch::Model::Adapter.adapters[Elasticsearch::Model::Adapter::Mongoid].call(DummyClassForMongoid)
-    end
-
-    context "Records" do
-      setup do
-        DummyClassForMongoid.__send__ :include, Elasticsearch::Model::Adapter::Mongoid::Records
-      end
-
-      should "have the implementation" do
-        assert_instance_of Module, Elasticsearch::Model::Adapter::Mongoid::Records
-
-        instance = DummyClassForMongoid.new
-        instance.expects(:klass).returns(mock('class', where: @records))
-
-        assert_equal @records, instance.records
-      end
-
-      should "reorder the records based on hits order" do
-        @records.instance_variable_set(:@records, @records)
-
-        instance = DummyClassForMongoid.new
-        instance.expects(:klass).returns(mock('class', where: @records))
-
-        assert_equal [1, 2], @records.        to_a.map(&:id)
-        assert_equal [2, 1], instance.records.to_a.map(&:id)
-      end
-
-      should "not reorder records when SQL order is present" do
-        @records.instance_variable_set(:@records, @records)
-
-        instance = DummyClassForMongoid.new
-        instance.expects(:klass).returns(stub('class', where: @records)).at_least_once
-        instance.records.expects(:asc).returns(@records)
-
-        assert_equal [2, 1], instance.records.to_a.map(&:id)
-        assert_equal [1, 2], instance.asc.to_a.map(&:id)
-      end
-    end
-
-    context "Callbacks" do
-      should "register hooks for automatically updating the index" do
-        DummyClassForMongoid.expects(:after_create)
-        DummyClassForMongoid.expects(:after_update)
-        DummyClassForMongoid.expects(:after_destroy)
-
-        Elasticsearch::Model::Adapter::Mongoid::Callbacks.included(DummyClassForMongoid)
-      end
-    end
-
-    context "Importing" do
-      should "implement the __find_in_batches method" do
-        relation = mock()
-        relation.stubs(:no_timeout).returns([])
-        DummyClassForMongoid.expects(:all).returns(relation)
-
-        DummyClassForMongoid.__send__ :extend, Elasticsearch::Model::Adapter::Mongoid::Importing
-        DummyClassForMongoid.__find_in_batches do; end
-      end
-
-      context "when transforming models" do
-        setup do
-          @transform = DummyClassForMongoid.__transform
-        end
-
-        should "provide an object that responds to #call" do
-          assert_respond_to @transform, :call
-        end
-
-        should "provide basic transformation" do
-          model = mock("model", id: 1, as_indexed_json: {})
-          assert_equal @transform.call(model), { index: { _id: "1", data: {} } }
-        end
-      end
-    end
-
-  end
-end

data/test/unit/adapter_multiple_test.rb

@@ -1,106 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::MultipleTest < Test::Unit::TestCase
-
-  context "Adapter for multiple models" do
-
-    class ::DummyOne
-      include Elasticsearch::Model
-
-      index_name 'dummy'
-      document_type 'dummy_one'
-
-      def self.find(ids)
-        ids.map { |id| new(id) }
-      end
-
-      attr_reader :id
-
-      def initialize(id)
-        @id = id.to_i
-      end
-    end
-
-    module ::Namespace
-      class DummyTwo
-        include Elasticsearch::Model
-
-        index_name 'dummy'
-        document_type 'dummy_two'
-
-        def self.find(ids)
-          ids.map { |id| new(id) }
-        end
-
-        attr_reader :id
-
-        def initialize(id)
-          @id = id.to_i
-        end
-      end
-    end
-
-    class ::DummyTwo
-      include Elasticsearch::Model
-
-      index_name 'other_index'
-      document_type 'dummy_two'
-
-      def self.find(ids)
-        ids.map { |id| new(id) }
-      end
-
-      attr_reader :id
-
-      def initialize(id)
-        @id = id.to_i
-      end
-    end
-
-    HITS = [{_index: 'dummy',
-             _type: 'dummy_two',
-             _id: '2',
-            }, {
-              _index: 'dummy',
-              _type: 'dummy_one',
-              _id: '2',
-            }, {
-              _index: 'other_index',
-              _type: 'dummy_two',
-              _id: '1',
-            }, {
-              _index: 'dummy',
-              _type: 'dummy_two',
-              _id: '1',
-            }, {
-              _index: 'dummy',
-              _type: 'dummy_one',
-              _id: '3'}]
-
-    setup do
-      @multimodel = Elasticsearch::Model::Multimodel.new(DummyOne, DummyTwo, Namespace::DummyTwo)
-    end
-
-    context "when returning records" do
-      setup do
-        @multimodel.class.send :include, Elasticsearch::Model::Adapter::Multiple::Records
-        @multimodel.expects(:response).at_least_once.returns(stub(response: { 'hits' => { 'hits' => HITS } }))
-      end
-
-      should "keep the order from response" do
-        assert_instance_of Module, Elasticsearch::Model::Adapter::Multiple::Records
-        records = @multimodel.records
-
-        assert_equal 5, records.count
-
-        assert_kind_of ::Namespace::DummyTwo, records[0]
-        assert_kind_of ::DummyOne,            records[1]
-        assert_kind_of ::DummyTwo,            records[2]
-        assert_kind_of ::Namespace::DummyTwo, records[3]
-        assert_kind_of ::DummyOne,            records[4]
-
-        assert_equal [2, 2, 1, 1, 3], records.map(&:id)
-      end
-    end
-  end
-end